Klassenvererbung

Hallo zusammen,

Ich brauche hilfe bei einer Laboraufgabe. Die Aufgabenstellung hat keinen Sinn, ich weiß nicht warum unser Prof. so was fragt. Ich würde mich freuen wenn jemand mir schon bisschen weiterhelfen könnte:

Aufgabe:

Einfach Vererbung
Definieren Sie eine Klasse Alpha mit
einem privaten int-Datenelement x
einem Standardkonstruktor
einem Konstruktor mit 1 Parameter
einer Methode print()

Leiten Sie von dieser Klasse public eine Klasse Beta ab mit
einem weiteren int-Datenelement y
einem Standardkonstruktor
einem Konstruktor mit 2 Parametern
einer Methode print()

Der erste Parameter des Konstruktors von Beta soll zum Aufruf des Konstruktors von Alpha verwendet werden, um die geerbten Daten zu initialisieren.
Die Methode print() in Beta soll x und y anzeigen. Dies geschieht durch einen Aufruf der geerbten print()-Funktion Alpha::print() und nachfolgender Ausgabe des neuen Datenelements y.
Anmerkung: Wäre x in Alpha public, könnte auch direkt zugegriffen werden.
Dies wäre aber nicht sinnvoll, da es zu einer verstärkten Kopplung der beiden Klassen führt. Zum Zugriff auf geerbte Daten sind also vorzugsweise geerbte Methoden zu verwenden.

2.1 Ermitteln Sie im Hauptprogramm mit Hilfe des sizeof-Operators die Größe von Objekten der Klassen Alpha und Beta und rufen Sie deren print()- Methoden auf.

2.2 Fügen Sie in die Klasse Beta ein weiteres Datenelement x beliebigen Typs ein (z.B. int), erweitern Sie die Konstruktoren entsprechend und ermitteln Sie erneut die Größe von Objekten der Klasse Beta.
Was schließen Sie aus dem Ergebnis?

Machen Sie nun x in alpha public und versuchen Sie von Beta::print() darauf zuzugreifen.

Ich kam nur so weit:

#include <iostream>
using namespace std;

class Alpha
{

private:
	int x;

public:
	Alpha();
	Alpha(int n);

	void print()
	{
		cout << x;
	}
};

class Beta : public Alpha
{
private:
	int y;
public:
	Beta();
	Beta(int m, int k);

	void print()
	{
		cout <<  "x: " << Alpha::print << endl;
		cout <<  "y: " << y << endl;
	}

};

int main()
{
	Alpha a(3);
	cout << sizeof(a) ;

	return 0;
}

GPC

Als Einstieg:

class Beta : public Alpha {
private:
    int y;
public:
    Beta(int y_=0, int x=0) : y(y_), Alpha(x) {}  //Nennt sich Elementinitialiser, schließlich musst du die Basisklasse noch initialisieren

    void print() const {
        cout <<  "x: " << Alpha::print();
        cout <<  "y: " << y << endl;
    }

};

du hast Recht. Aber ich habe mir schon Gedanken gemacht. Du kannst ja trotzdem mir helfen oder

PRIEST

yeah kennste den >> ~

http://www.fun-soft.de/Download/ebooks/c%2B%2Bin21tagen/kap11.html

les dir des ma durch danach kannst es!!! Die seite bzw. das Buch is eh goiL!

GPC

Hatte ich vergessen:

class Alpha {
private:
    int x;

public:
    Alpha(int n=0) : x(n) {}  //gleiches Spiel

    void print() const {
        cout << x;
    }
};

Das mit dem sizeof - Operator machst du ja richtig, der Rest dürfte kein Problem sein.

CStoll

kannst du lesen? wenn ja, lies dir einfach mal die Aufgabe durch und mach' Schritt für Schritt das, was dort verlangt wurde. (aktuell geht deine Lösung bis zum ersten "und" in Teilaufgabe 2.1 ;))

OK. Danke ich werde es jetzt durchlesen. Wenn ich fragen habe komme ich nochmal:

Ich habe die Vererbungsgeschichte durchgelesen, aber ich habe eins nicht verstanden:

class Alpha { 
private: 
    int x; 

public: 
    Alpha(int n=0) : x(n) {}  //<= Wozu :x(n), vertsehe ich nicht so ganz

    void print() const { 
        cout << x; 
    } 
};

PRIEST

n wird ja mit 0 init. und isses wie x(0)

oder net ^^

jippi schrieb:

Ich habe die Vererbungsgeschichte durchgelesen, aber ich habe eins nicht verstanden:
class Alpha { 
private: 
    int x; 

public: 
    Alpha(int n=0) : x(n) {}  //<= Wozu :x(n), vertsehe ich nicht so ganz
    
    
    void print() const { 
        cout << x; 
    } 
};

also ich habe die Beta Klasse bisschen geändert, weil er noch eine Fehlermeldung brachte.

class Alpha { 
private: 
    int x; 

public: 
    Alpha(int n=0) : x(n) {}  

    int print() const { 
        cout << x; 
	return x;
    } 
};

class Beta : public Alpha { 
private: 
    int y; 
public: 
    Beta(int y_=0, int x=0) : y(y_), Alpha(x) {}  //Nennt sich Elementinitialiser, schließlich musst du die Basisklasse noch initialisieren 

    void print() const { 
        cout <<  "x: " << Alpha::print(); 
        cout <<  "y: " << y << endl; 
    } 

}; 

int main()
{
	Alpha a(4);
	cout << sizeof(a) ;

	return 0;
}

Als ausgabe kommt jetzt 4 raus.Und Ein Integer wert ist ja 4 - byte groß. Es sollte stimmen. Aber wie gesagt musste ich die printfunktion in der Klasse Alpha ändern.

GPC

Du hast sie falsch geändert, entweder du machst es so:

//Alpha print   
void print() const {
  cout <<  "x: " << x;
}

//Beta print
void print() const {
  Alpha::print();
  cout <<  "y: " << y << endl;
}

oder so:

//Alpha print   
int print() const {
  return x;
}

//Beta print
void print() const {
  cout <<  "x: " << Alpha::print() << endl;
  cout <<  "y: " << y << endl;
}

Zu deiner Frage: Das ist ein Elementinitializer, der initialisert x mit n.

Es sieht jetzt so aus:

#include <iostream>
using namespace std;

class Alpha { 
private: 
    int x; 

public: 
    Alpha(int n=0) : x(n) {}  

    int print() const {  
		return x;
    } 
};

class Beta : public Alpha { 
private: 
    int y; 
public: 
    Beta(int y_=0, int x=0) : y(y_), Alpha(x) {}  //Nennt sich Elementinitialiser, schließlich musst du die Basisklasse noch initialisieren 

    void print() const { 
        cout <<  "x: " << Alpha::print() << endl; 
        cout <<  "y: " << y << endl; 
    } 

}; 

int main()
{
	Alpha a(0);
	cout << "Sizeof Alpha: " << sizeof(a) << endl;
	Beta b(0);
	cout << "Sizeof Beta: " << sizeof(b) << endl;

	a.print();
	b.print();

	return 0;
}

Als Ausgabe bekomme ich:

Sizeof Alpha: 4
Sizeof Beta: 8
x: 0
y: 0
Press any key to continue

Wie kann ich jetzt die Werte von x und y ändern?

Diesen Elementinitialiser verstehe ich einfach nicht.
Ich vermute mal:

Beta(int y_=0, int x=0) : y(y_), Alpha(x) {}  //y(y_) sorgt dafür, dass das erste element y ist und Alpha(x) sorgt dafür dass das zweite element x ist oder?

GPC

Wie kann ich jetzt die Werte von x und y ändern?

Indem du folgendes einbaust:

//das muss in Alpha rein:
void setX(int x_) { x = x_; }
int getX() const { return x; }

//das muss in Beta rein:
void setY(int y_) { y = y_; }
int getY() const { return y; }

Zu deiner main Methode

int main() {
    Alpha a(1); //x wird hiermit 1
    cout << "Sizeof Alpha: " << sizeof(a) << endl;
    //Beta b(0);  //y gibst du mit 0 an, und x ist defaultmäßig 0
    Beta b(5,4);  //y=5 und x=4
    cout << "Sizeof Beta: " << sizeof(b) << endl;

    b.setY(7);  // jetzt ist y 7 
    a.print();
    b.print();

    return 0;
}

Elementinitializer: http://tutorial.schornboeck.net/initliste.htm

Ok Danke, dass du mir weitergeholfen hast. Ich melde mich wieder wenn ich fragen habe

Soweit klappt alles ganz gut. Aber bei der Teilaufgabe 2.2 verlangt er, dass ich den Datenelement x "public" machen soll und über Beta::print() darauf zuzugreifen. Ich habe es nicht so ganz verstanden wie ich es realisieren soll.

class Alpha {    

public:
	int x; //<= ist jetzt public

    Alpha(int n=0) : x(n) {}  //Initialisierungsliste von Alpha

    int print() const {  
		return x;
    } 

};

class Beta : public Alpha { 
private: 
    int y; 
	int x; //Teilaufgabe 2.2 Ergänzung von Klasse Beta um Datenelement x.
public: 
    Beta(int y_=0, int x=0) : y(y_), Alpha(x) {}  //Initialisierungsliste von Beta

    void print() const { 
        cout <<  "x: " << Alpha::print() << endl; //<= ????und hier????
        cout <<  "y: " << y << endl; 
    } 
}; 

int main()
{
	Alpha a(1);
	cout << "Sizeof Alpha: " << sizeof(a) << endl;
	Beta b(5,3);
	cout << "Sizeof Beta: " << sizeof(b) << endl;
	a.print();
	b.print();

	return 0;
}

CStoll

Ich wußte gar nicht, daß man eine Membervariable so überladen kann
Egal - auf das Element aus der Basisklasse greifst du mit Alpha::x zu:

void Beta::print() const
{
  cout<<"Alpha-Anteil:"<<endl;
  cout<<"x:"<<Alpha::x<<endl;

  cout<<"Beta-Anteil:"<<endl;
  cout<<"x:"<<x<<endl<<"y:"<<y<<endl;
}

PS: Die Umdefinition des Rückgabewertes von print() ist übrigens ganz schlechtes Design - die erstgenannte Variante von GPC ist wohl besser:

//Alpha print   
void print() const {
  cout <<  "x: " << x << endl;
}

//Beta print
void print() const {
  Alpha::print();
  cout <<  "y: " << y << endl;
}

GPC

@CStoll: Wenigstens du hast's gemerkt Sonst hat keiner meinen faux pas moniert...

@Jippi: Du solltest dir mal folgendes durchlesen: http://tutorial.schornboeck.net/oop.htm
Dire fehlt viel Stoff aus dem Bereich.

Ok. Es hat geklappt. Danke an euch vielmals. Das Code sieht jetzt so aus und sollte jetzt stimmen. Jetzt kann ich die Aufgabe 3 machen:)

#include <iostream>
using namespace std;

class Alpha {    

public:

	int x;
    Alpha(int n=0) : x(n) {}  //Initialisierungsliste von Alpha

    void print() const { 
		cout <<  "x: " << x << endl; 
	} 
};

class Beta : public Alpha { 
private: 
    int y; 
	int x; //Teilaufgabe 2.2 Ergänzung von Klasse Beta um Datenelement x.
public: 
    Beta(int y_=0, int x=0, int x_=0) : y(y_), Alpha(x),x(x_) {}  //Initialisierungsliste von Beta

    /*void print() const { 
		Alpha::print(); 
		cout <<  "y: " << y << endl; 
	} */
	void Beta::print() const { 
	cout<<"Alpha-Anteil:"<<endl; 
	cout<<"x:"<<Alpha::x<<endl; 

	cout<<"Beta-Anteil:"<<endl; 
	cout<<"x:"<<x<<endl<<"y:"<<y<<endl;
	}
}; 

int main()
{
	Alpha a(1);
	cout << "Sizeof Alpha: " << sizeof(a) << endl;
	Beta b(5,3,8);
	cout << "Sizeof Beta: " << sizeof(b) << endl;

	b.print();

	return 0;
}