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.

#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;
}

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;
    }

};

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!

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.

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; 
    } 
};

oder net ^^

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.

//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.

#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?

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

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;
}

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;
}

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

#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;
}