#include <iostream>
using namespace std;

class Basis
{
      protected:
           int a;

      public:
           Basis(int m) : a(m) {}
           int getWert() { return a; }
};

class Abgeleitet : public Basis
{
      private:
           int b;
      public:
           Abgeleitet(int v, int w) : Basis(v), b(w) {}
           int getWert() { return a + b; }
};

int main()
{
    Basis eins(11);
    Abgeleitet zwei(7,9);

    cout << eins.getWert() << endl;          // 11
    cout << zwei.getWert() << endl;          // 16
    cout << zwei.Basis::getWert() << endl;   // 7
    eins = zwei;                            
    cout << eins.getWert() << endl;          // 7                    ???
    zwei = eins;                             // Compilerfehler       ???
    cout << zwei.getWert() << endl;
    cout << zwei.a << endl;                  // Compilerfehler       ???

    char dummy;
    cin >> dummy;
    return 0;
}

Kurt

1. ausgabe:

Ist 11 weil beim ctor der basis 11 als parameter übergeben wurde. Und getWert liefert nur den wert des members wieder zurück.

2. ausgabe:

Ist 11 weil 7 und 9 als parameter für den ctor von abgeleitet übergeben werden. Der ctor von abgeleitet wiederum ruft den ctor von basis mit dem parameter 7 auf. Der protected member a ist nun mit 7 initialisiert. Dann wird b mit 9 initialisiert. getWert() von abgeleitet gibt die summe von a und b zurück. a ist deswegen verfügbar in abgeleitet weil abgeleitet von basis erbt und damit auf protected-member von basis zugriff hat. Die summe von 9 und 7 ist 16. Stimmt also.

3. ausgabe:
Da wird explizt die getWert methode von basis aufgerufen die wiederum den wert von a zurück gibt, der in der instanz von abgeleitet die du "zwei" nennst 7 ist. Es wird deswegen explizit qualifiziert weil abgeleitet getWert() überschreibt und ohne diese qualifizierung die getWert-methode von abgeleitet aufgerufen werden würde. Dann wäre die ausgabe wieder 16.

4. compilefehler eins = zwei
basis hat den ctor nicht explicit gemacht. Das bedeuted dass basis implicit in int convertiert werden kann. Zwei ist eine instanz von abgeleit. Abgeleitet wiederum IST EINE basis. Als solche also implizit in int convertierbar. Da basis keinen assignment-op implementiert baut der compiler eine standardimplementierung selbes gilt auch für den copy-ctor. Beim zuweisen werden die werte von abgeleitet, also b, abgetrennt. Das ist als slicing bekannt. Der wert von a ist immer noch 7. Dieser wird "eins" zugewiesen. Das geht aus den eben genannten gründen.

5. ausgabe
Der neue wert von a wird ausgegeben der ist wegen 4. nun 7.

6. compilefehler
"abgleitet" IST zwar eine "basis" aber "basis" IST KEIN "abgeleitet". Hier müsste abgeleitet einen op= für basis implementieren weil der standard op= nicht ausreicht. abgeleitet kann nicht implizit in int convertiert werden.
Deswegen meckert der compiler, weil er nicht weiss wie er die zuweisung machen soll.

7. compilefehler
a ist zwar in abgeleitet verfügbar, aber bleibt nach aussen hin weiter protected. Das heisst der op<< hat kein recht darauf zuzugreifen. Das seigt einem der compiler aber auch.

Hmm garnich so einfach..... ich hoffe man versteht das

//EDIT ok man kanns auch kürzer machen ...