class Person
{
private:
	string name; 
	int age; 
public:
	Person(string n, int a):name(n), age(a) {};

	const string name2() { return name; }
	const int age2() { return age; }
};

istream& operator>>(istream& is, Person& P)
{
	is>>P.name2(),P.age2();  // Fehler
	if(!is) return is;

	return is;
}

ostream& operator<<(ostream& os, Person& P)
{
	return os << P.name2() << " " << P.age2() << endl;
}

int main()
{
	Person P1("Goofy",63);
	ostream& os(cout<<P1);

	istream& is(Person& P);

	keep_window_open();
}

is >> P.name2() >> P.age2();

3 IntelliSense: Kein ">>"-Operator stimmt mit diesen Operanden überein.

istream& operator>>(istream& is, Person& P)
{
    std::string name;
    int age;
    is >> name >> age;

    P = Person(name, age);

    return is;
}

Die Klasse hat leider keine Setter, daher musst du folgendes machen oder die Klasse abändern:

istream& operator>>(istream& is, Person& P)
{
    std::string name;
    int age;
    is >> name >> age;

    P = Person(name, age);

    return is;
}

Das habe ich hinzugefügt, nur es will keine Eingabe annehmen, obwohl es doch aufgerufen wird.

istream& is(Person& P);

#include <iostream>

class Person
{
    std::string name;
    int alter;
public:
    Person(const std::string& n, int a) :
    alter(a), name(n) {}
    Person() : name("Unbekannt"), alter(0) {}
    std::string Name() const { return name; }
    int Alter() const { return alter; }
    friend std::istream& operator>>(std::istream& in, Person& p);
};

std::ostream& operator<<(std::ostream& out, const Person& p)
{
    return out << p.Name() << ", " << p.Alter() << " Jahre alt.";
}

std::istream& operator>>(std::istream& in, Person& p)
{
    std::cout << "Name: ";
    std::getline(in, p.name);
    std::cout << "Alter: ";
    return in >> p.alter;
}

int main()
{
    Person p;
    std::cin >> p;
    std::cout << p;
    return 0;
}

Mit friend erlaubst du dem Operator >>, auf private Member von Person zuzugreifen.
Sollte man aber sparsam mit umgehen, da es ja die ganze Datenkapselung durchlöchert. Aber bei nem Operator >> kann man das ruhig machen, denke ich.

@winux: Was bedeutet der unkommentierte Code? Kannst du uns mal bitte deinen Code zeigen?

Das die Funktion aufgerufen wird.

istream& is(Person& P);

Doch es sollte dann hierher Springen:

istream& operator>>(istream& is, Person& P)
{
	string name;
	int age;
	is>>name>>age;
	P = Person(name, age);
	if(!is) return is;

	return is;
}

Und wenn das Programm läuft sollte es doch nach einer Eingabe fragen. Doch das macht es nicht.

class Person
{
private:
	string name; 
	int age; 
public:
	Person(string n, int a):name(n), age(a) 
	{
		if(a < 0 || a > 150)
			error("Alter ist ungueltige!");
	}
	Person() : name("Unbekannt"), age(0) {} 

	const string name2() { return name; }
	const int age2() { return age; }

	friend istream& operator>>(istream& is, Person& P);
};

Und was ist jetzt deine Frage?

Die frage wenn ich denn Namen eingebe und danach das alter eingebe, und bei alter eine negative Zahl oder größer als 150 eingebe müsste es doch die error Funktion ausführen weil ich ja im Konstruktor das ja definiert habe. Doch es kommt nicht. Wenn ich 789 oder -6 eingebe wird das auch ausgegeben, obwohl es ja abgefangen werden sollte.

Vermutlich rufst du in deinem Stream-Operator den Konstruktor nicht auf oder nur den Kopierkonstruktor...

Problem gelöst, habe die Prüfung auch in dem >> Stream geschrieben. Und jetzt funktioniert die Überprüfung auch. Ist das so gut oder gibt es eine besser Lösung dafür?

istream& operator>>(istream& is, Person& P)
{
	cout << "Person und Alter eingeben" << endl;
	is>>P.name>>P.age;

	if(P.age < 0 || P.age > 150)
			error ("Alter ist ungueltige!\n");

	if(!is) return is;

	return is;
}

ostream& operator<<(ostream& os, Person& P)
{
	return os << P.name2() << " " << P.age2() << endl;
}

int main()
try{
	Person P1("Goofy",63);
	ostream& os(cout<<P1);

	Person P;
	istream& is(cin>>P);
	operator<<(os,P);

	keep_window_open();
}
catch (runtime_error e) {	
	cout << e.what() << '\n';
	keep_window_open("~");	
}

class Person
{
private:
	string name; 
	int age; 
public:
	Person(string n, int a):name(n), age(a) 
	{
		if(age < 0 || age > 150)
			error ("Alter ist ungueltige!");
	}
	Person() : name("Unbekannt"), age(0) {}

	const string name2() { return name; }
	const int age2() { return age; }

	friend istream& operator>>(istream& is, Person& P);
};

Ich denke, das ist OK so.

OK

#include <iostream>
#include <exception>
#include <locale>
#include <vector>
#include <algorithm>

class AlterFalsch : public std::exception
{
    public:
    const char* what() const throw()
    {
        return "Alter in einem ungueltigen Bereich!\n";
    }
};

class NameFalsch : public std::exception
{
    public:
    const char* what() const throw()
    {
        return "Ein vollstaendiger Name muss\n-Aus Vor- und Nachnahmen bestehen\n"
               "-Laenger als 3 Zeichen sein\n"
               "-Darf keine Sonderzeichen enthalten\n";
    }
};

bool istUmlaut(char c)
{
    const char ae = 132, oe = 148, ue = 129,
               UE = 220, OE = 214, AE = 196;
    std::vector<char> sonderzeichen { ae, oe, ue, AE, OE, UE };
    return std::find(sonderzeichen.begin(), sonderzeichen.end(), c) != sonderzeichen.end();
}

bool nameInOrdnung(const std::string& name)
{
    if(name.size() < 3)
        return false;
    unsigned anzahlLeerzeichen = 0; //Ein vollstaendiger Name hat genau 1 Leerzeichen.
    for(auto i : name)
        if(!std::isalpha(i, std::locale("")) && !istUmlaut(i))
        {
            if(i == ' ')
                ++anzahlLeerzeichen;
            else
                return false;
        }
    if(anzahlLeerzeichen != 1)
        return false;
    return true;
}

bool alterInOrdnung(const int& alter)
{
    return alter <= 150 && alter >= 0;
}

class Person
{
    int alter;
    std::string name;
public:
    Person(const std::string& n, int a) :
    alter(a), name(n) {}
    Person() : alter(0), name("Unbekannt") {}
    std::string Name() const { return name; }
    int Alter() const { return alter; }
    friend std::istream& operator>>(std::istream& in, Person& p) throw(AlterFalsch);
};

std::ostream& operator<<(std::ostream& out, const Person& p)
{
    return out << p.Name() << ", " << p.Alter() << " Jahre alt.";
}

template<typename typ>
void in(typ& para, std::istream& is = std::cin) //wrapper um cin fuer sichere Eingabe
{
    while(!(is >> para))
    {
        std::cerr << "Fehler bei der Eingabe!\n";
        is.clear();
        is.ignore(1000, '\n');
    }
}

std::istream& operator>>(std::istream& is, Person& p) throw(AlterFalsch)
{
    std::cout << "Name: ";
    std::getline(is, p.name);
    if(!nameInOrdnung(p.Name()))
        throw NameFalsch();
    std::cout << "Alter: ";
    in(p.alter, is);
    if(!alterInOrdnung(p.Alter()))
        throw AlterFalsch();
    return is;
}

int main()
{
    Person p;
    try
    {
        std::cin >> p;
        std::cout << p;
    }
    catch(const std::exception& a)
    {
        throw;
    }
    return 0;
}

Aber jetzt ernstgemeinte Fragen:

Ist das gut so? (Ich bring mir das selbst nur zum Spaß bei und andere Menschen sehen selten Code von mir, daher die Frage, kann ja sein, dass ich da was falsch gelernt hab vom Stil her). Und ich hab' festgestellt, dass bei

std::isalpha(char, std::locale)

mit der Systemlocale auch Umlaute wie ö, ä und ü als false ausgewertet werden und musste mir dann diese blöde istUmlaut schreiben. Warum ist das so, ich dachte die locale wär extra für sowas da?

Sollte man aber sparsam mit umgehen, da es ja die ganze Datenkapselung durchlöchert.

friend stärkt die Kapslung. Es vermeidet, Member oder Memberfunktionen komplett public zu machen, nur damit irgendeine andere Funktion darauf Zugriff hat.

In diesem Fall wäre es vllt. besser, der Klasse Person eine Funktion wie toString() const zu verpassen, und der Operator << ruft die dann einfach auf und gibt's aus.

Warum muss ich ein XYZ-Objekt erst in einen String umwandeln, um es ausgeben zu können? Ineffizient.

Da ihr mich ja scheinbar überlesen habt, wie wär's denn so?

#include <iostream>
#include <exception>
#include <locale>
#include <vector>
#include <algorithm>

class AlterFalsch : public std::exception
{
    public:
    const char* what() const throw()
    {
        return "Alter in einem ungueltigen Bereich!\n";
    }
};

class NameFalsch : public std::exception
{
    public:
    const char* what() const throw()
    {
        return "Ein vollstaendiger Name muss\n-Aus Vor- und Nachnahmen bestehen\n"
               "-Laenger als 3 Zeichen sein\n"
               "-Darf keine Sonderzeichen enthalten\n";
    }
};

bool istUmlaut(char c)
{
    const char ae = 132, oe = 148, ue = 129,
               UE = 220, OE = 214, AE = 196;
    std::vector<char> sonderzeichen { ae, oe, ue, AE, OE, UE };
    return std::find(sonderzeichen.begin(), sonderzeichen.end(), c) != sonderzeichen.end();
}

bool nameInOrdnung(const std::string& name)
{
    if(name.size() < 3)
        return false;
    unsigned anzahlLeerzeichen = 0; //Ein vollstaendiger Name hat genau 1 Leerzeichen.
    for(auto i : name)
        if(!std::isalpha(i, std::locale("")) && !istUmlaut(i))
        {
            if(i == ' ')
                ++anzahlLeerzeichen;
            else
                return false;
        }
    if(anzahlLeerzeichen != 1)
        return false;
    return true;
}

bool alterInOrdnung(const int& alter)
{
    return alter <= 150 && alter >= 0;
}

class Person
{
    int alter;
    std::string name;
public:
    Person(const std::string& n, int a) :
    alter(a), name(n) {}
    Person() : alter(0), name("Unbekannt") {}
    std::string Name() const { return name; }
    int Alter() const { return alter; }
    friend std::istream& operator>>(std::istream& in, Person& p) throw(AlterFalsch);
};

std::ostream& operator<<(std::ostream& out, const Person& p)
{
    return out << p.Name() << ", " << p.Alter() << " Jahre alt.";
}

template<typename typ>
void in(typ& para, std::istream& is = std::cin) //wrapper um cin fuer sichere Eingabe
{
    while(!(is >> para))
    {
        std::cerr << "Fehler bei der Eingabe!\n";
        is.clear();
        is.ignore(1000, '\n');
    }
}

std::istream& operator>>(std::istream& is, Person& p) throw(AlterFalsch)
{
    std::cout << "Name: ";
    std::getline(is, p.name);
    if(!nameInOrdnung(p.Name()))
        throw NameFalsch();
    std::cout << "Alter: ";
    in(p.alter, is);
    if(!alterInOrdnung(p.Alter()))
        throw AlterFalsch();
    return is;
}

int main()
{
    Person p;
    try
    {
        std::cin >> p;
        std::cout << p;
    }
    catch(const std::exception& a)
    {
        throw;
    }
    return 0;
}

Aber jetzt ernstgemeinte Fragen:

Ist das gut so? (Ich bring mir das selbst nur zum Spaß bei und andere Menschen sehen selten Code von mir, daher die Frage, kann ja sein, dass ich da was falsch gelernt hab vom Stil her). Und ich hab' festgestellt, dass bei

std::isalpha(char, std::locale)

mit der Systemlocale auch Umlaute wie ö, ä und ü als false ausgewertet werden und musste mir dann diese blöde istUmlaut schreiben. Warum ist das so, ich dachte die locale wär extra für sowas da?

Danke für deine Hilfe, nur bin ich noch nicht mit dem Lernen bei template angekommen.

vector <Person> ps;

istream& operator>>(istream& is, Person& P)
{
	cout << "Person und Alter eingeben" << endl;
	while (is>>P.name>>P.age)
	ps.push_back(P.name,P.age);   // Fehler
	{
	if(P.age < 0 || P.age > 150)
		   error ("Alter ist ungueltige!\n");
	if(!is) return is;

	for(int i = 0;i<P.name.size();++i)
		switch(P.name[i])
	    {
		case ';': case ':': case '"': case '\'': case '[': case ']':
		case '*': case '&': case '^': case '%': case '$': case '#': 
		case '@': case '!':
			error ("Ungueltiger Name!");
	    }  
	}
	return is;
}

ostream& operator<<(ostream& os, Person& P)
{
	return os << P.name2() << " " << P.age2() << endl;
}

int main()
try{
	Person P1("Goofy",63);
	ostream& os(cout<<P1);

	Person P;
	istream& is(cin>>P);
	operator<<(os,P);

	keep_window_open();
}
catch (runtime_error e) {	
	cout << e.what() << '\n';
	keep_window_open("~");	
}

Zeile 7 error C2661: 'std::vector<_Ty>::push_back': Keine überladene Funktion akzeptiert 2 Argumente
Zeile 7 IntelliSense: Keine Instanz von Überladene Funktion "Vector<T>::push_back [mit T=Person]" stimmt mit der Argumentliste überein.

Das muss so aussehen:

ps.push_back(P);