3. Klasse mit Member Klassen?

Klasse mit Member Klassen?

  • B

    Hast du Konstruktor und Destruktor von Parents auch definiert?
    Du kannst die Dsestruktoren in beiden Klassen auch weglassen. Hier reichen die per default erzeugten.

    0
  • 1

    in der main ist die parents.h und die person.h includet.

    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();
    0
  • L

    Nö, Du deklarierst sie nur. "Da" wären sie wenn irgendwas mit {} dabei (oder in einem externen File) steht.

    0
  • *

    Machs irgendwie so ... ist wohl mal wieder net getestet ...

    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;
};
    0
  • T

    1metal3 schrieb:

    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.

    0
  • 1

    Danke werd das heut mal testen.

    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

    0
  • 1

    Ich schau mir das heute mal an dann stell ich morgen wieder Fragen vielen Dank für die prompte und gute Hilfe hier.

    0
  • C

    Man könnte doch theoretisch anstatt unsigned short (für das Alter) auch unsigned char nehme, oder? Ist doch effizienter 😉 .

    0
  • ?

    ich bin mir nicht sicher aber könnte der Fehler nicht in der main liegen:

    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
}
    0
  • 1

    Vielen Dank euch allen, habs jetzt geschafft. Das Problem das ich hatte ich habe nicht mit Referenzen gearbeitet.

    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

    0
Anmelden zum Antworten