class Person{

    public:
	Person();
        Person(string vn,string nn, int geb);
        ~Person();

        string getVname();
        string getNname();
        int getGebdate();

        void setVname(string v);
        void setNname(string n);
        void setGebdate(int g);

    private:
        string vname;
        string nname;
        int gebdate;
};

Dann möcht ich noch die parents haben die aus 3 Personen besteht:

class Parents{
    public:
        Parents(Person s, Person v, Person m);
        ~Parents();

	Person getSohn();
	Person getVater(); 
	Person getMutter(); 

	void setSohn(Person S);
	void setVater(Person V); 
	void setMutter(Person M);

    private:
        Person sohn;
        Person vater;
        Person mutter;
};

Wenn ich dann in der Main folgendes teste, bekomm ich einen Fehler, wieso?
Muss ich mit Pointern arbeiten oder wie funktioniert das?

int main() {
Person p("Hubert","Mueller",23);
Person p1("Sepp","Humanig",63);
Person p2("Sabine","Mueller",33);

Parents(p,p1,p2);

}

Fehler ist:

/tmp/ccxgayKD.o: In function `main':
programm.cpp:(.text+0x421): undefined reference to `Parents::Parents(Person, Person, Person)'
programm.cpp:(.text+0x42f): undefined reference to `Parents::~Parents()'
collect2: ld returned 1 exit status

vielen Dank
mfg
1metal3

Was meinst du mit linken?
Ich verwende gar keine Ide nur editor und shell.

Das ist aber egal glaub ich.

konstruktor und destruktor sind doch da:

Parents(Person s, Person v, Person m);
~Parents();

class Person
{
public:
	Person(void) : m_nAge(0) { m_sFirstName = ""; m_sName = ""; }
	Person(const std::string& sFirstName, const std::string& sName, unsigned short nAge) : m_nAge(nAge) { m_sFirstName = sFirstName; m_sName = sName; }
	Person(const Person& person) : m_nAge(person.get_age()) { m_sFirstName = person.get_first_name(); m_sName = person.get_name();
	~Person(void);

public:
	const std::string& get_first_name(void)		{	return m_sFirstName;	}
	const std::string& get_name(void)			{	return m_sName;			}
	unsigned short get_age(void)				{	return m_nAge;			}

public:
	void set_first_name(const std::string& sFirstName)		{ m_sFirstName = sFirstName;	}
	void set_name(const std::string& sName)					{ m_sName = sName;				}
	void set_age(unsigned short nAge)						{ m_nAge = nAge;				}

private:
	std::string		m_sFirstName;
	std::string		m_sName;
	unsigned short	m_nAge;
};

class Parents 
{
public:
	Parents(const Person& personChild, const Person& personFather, const Person& personMother) : m_personChild(personChild), m_personFather(personFather), m_personMother(personMother) { }
	~Parents(void);

public:
	const Person&	get_child(void)				{ return m_personChild;		}
	const Person&	get_father(void)			{ return m_personFather;	}
	const Person&	get_mother(void)			{ return m_personMother;	}

public:
	void set_child(const Person& person)		{ m_personChild = person;	}
	void set_father(const Person& person)		{ m_personFather = person;	}
	void set_mother(const Person& person)		{ m_personMother = person;	}

private:
	Person	m_personChild;
	Person	m_personFather;
	Person	m_personMother;
};

Was meinst du mit linken?
Ich verwende gar keine Ide nur editor und shell.

Naja, die Übersetzungseinheiten musste noch verlinken. (Wobei es eh so aussieht, als hättest du keine eigenen .cpp Files für die Klassen.)
Für gcc sieht das so aus:

gcc -o Person.o -c Person.cpp
gcc -o Parents.o -c Parents.cpp
gcc -o Main.o -c Main.cpp
gcc -o Programm Main.o Person.o Parents.o // So linkst du die Objekte

Oder schau dich mal nach makefiles und autotools um, erleichtert die Arbeit ungemein.

Makefile hab ich schon das linken geht natürlich.

Ich habe zu den header files auch die cpps hab sie nur vergessen reinzutun: schaun so aus:

#include "person.h"
#include <string>
using namespace std;

	Person::Person(){}

	Person::Person(string vn,string nn,int geb){
		Person::vname = vn; 
		Person::nname = nn; 
		Person::gebdate = geb;
	}
        Person::~Person(){}

        string Person::getVname(){
            return Person::vname;
        }

        string Person::getNname(){
            return Person::nname;
        }

        int Person::getGebdate(){
            return Person::gebdate;
        }

        void Person::setVname(string v){
            Person::vname=v;
        }

        void Person::setNname(string n){
            Person::nname=n;
        }

        void Person::setGebdate(int g){
            Person::gebdate=g;
        }

#include "parents.h"
#include <string>
using namespace std;

        Parents::Parents(Person s, Person v, Person m){
		Parents::sohn = s; 
		Parents::vater= v;
		Paretns::mutter=m;
	}

	~Parents(){}

	Person getSohn(){
		return Parents::sohn;
	}	
	Person getVater(){
		return Parents::vater;
	} 
	Person getMutter(){
		return Parents::mutter;
	} 

	void setSohn(Person S){
		Parents::sohn=S;
	}
	void setVater(Person V){
		Parents::vater=V;
	} 
	void setMutter(Person M){
		Parents::mutter=M;
	}

Der Fehler ist irgendwas mit Referenzen oder so glaub ich, Ich werds heut testen - danke erstmal

Was anderes noch: Der Grund wieso ich 2 Header files und 2 cpps mache ist weil ich die klassen ohne Header files nicht der anderen bekannt machen kann oder? ich will ja das in der parents.cpp die person.h bekannt ist, das geht über inkludieren oder gibt es eine andere Möglichkeit?

danke

1metal3 schrieb:

int main() {
Person p("Hubert","Mueller",23);
Person p1("Sepp","Humanig",63);
Person p2("Sabine","Mueller",33);

Parents(p,p1,p2); //<---------
   
}

Du rufst zwar den Konstruktor auf aber hast kein Objekt, das erstellt werden kann.
Ich würde es so machen (ungetestet):

int main() {
Person p("Hubert","Mueller",23);
Person p1("Sepp","Humanig",63);
Person p2("Sabine","Mueller",33);

Parents Eltern(p,p1,p2); 
// oder:
Parents Eltern2 = new Parents(p,p1,p2);
// und bei Eltern2 natürlich mit delete Eltern2; den Destruktor aufrufen
}

void setSohn(Person S){
        Parents::sohn=S;
}

gehört ersetzt durch: (&)

void setSohn(Person &S){
        Parents::sohn=S;
}

danke für die Hilfe

@(D)Evil: danke für das prima Beispiel