# Struktur
Es gibt die Klasse A.
Es gibt die Klasse B, die von A erbt (public).
Es gibt eine Klasse C, die von B erbt (public).
Klasse A, B und C haben eine Funktion void a().
Klasse B und C haben eine Funktion void b().
# Klasse A
Klasse A hat nur void a(), nicht mal ein Konstrutor
void A::a(): macht nichts
# Klasse B
hat
## Public
- Konstruktor
- virtual Destruktor
- void a()
- virtual void b()
- void b() const
- static inst liefereIdStat()
## protected
- string s
- void info(const string& text) const
## private
- int id;
- static int idStat = 0
## Wie so Sachen funktionieren
idStat started mit Null, und für jedes B Object wird die aktuelle idStat um eins addiert gegeben.
info wird von jeder Funktion zurückgegeben und gibt:
"id: *Name der Funktion* s"
aus
void B::a(): s += 1 (s ist ein String), info das B::a() aufgerufen wurde
void B::b() hat zwei Versionen, *virtual void ()* und *void b() const*
    - virtual b(): s +=2 , info B::b()
    - b() const: info B::b() const
static int liefereIdStat() gibt idStat aus
Konstruktor:
- s fängt immer als leerer string an ""
- id wird wie oben erwähnt gemacht
- info das B() ausgeführt wurde
Destruktor:
- info mit "~B()"
# Klasse C
## public
- Konstruktor
- virtual destuktor
- void a()
- void b()
## Wie so funktioniert
- Konstruktor ruft Konstruktor von B auf, mit "C" (bin mir aber nicht ganz sicher ob das das in B Konstuktor überschreibt, wahrscheinlich ja), dannach noch info mit "C()"
- Destruktor ruft nur info mit "~C()" auf
- void C::a(): s += 3 , info C::a()
- void b(): s += 3, info "C::a()"

# Ablauf inf main()
erzeugt ein A object und ruft a() (sollte nichts passieren)
gibt vvv aus und holt sich IdStat
erzeugt b, ruft b() auf (hätte auf virtual getippt)
gitb www aus, liefert IdStat
Erzeugt ein Array von C zeigern der Größe 2
beide werden mit neuen C gefüllt (erhöht idStat)
c[0] ruft a() auf
c[1] ruft b() auf
beide Objecte werden gelöscht
ein const c object wird erstell (++idStat)
gibt xxx + IdStat aus
Zeiger auf ein A object wird einen neuen C object zugeordnet
a() wird aufgerufen
object wird gelöscht
gibt yyy + IdStat aus
Zeiger auf ein B object wird mit neuen C object gefüllt
a() wird aufgerufen
b() wird aufgerufen
object wird gelöscht
gibt zzz + IdStat aus

# Ausgabe
**Was ich denke:**
```
vvv 0
1: B::b() 2
www 1
2: C() C
3: C() C
2: C::a() C3
3: C::b() C4
2: ~C() C3
3: ~C() C4
4: C() C
xxx 4
5: C() C
5: ~C() C
yyy 5
6: C() C
6: B::a() C1
6: C::b() C14
6: ~C() C14
zzz 5
1: ~B() 2
4: ~C() C
```
**Was rauskommt:**
```
vvv 0
1: B()
1: B::b() 2
www 1
2: B() C
2: C() C
3: B() C
3: C() C
2: C::a() C3
3: C::b() C4
2: ~C() C3
2: ~B() C3
3: ~C() C4
3: ~B() C4
4: B() C
4: C() C
xxx 4
5: B() C
5: C() C
yyy 5
6: B() C
6: C() C
6: B::a() C1
6: C::b() C14
6: ~C() C14
6: ~B() C14
zzz 6
4: ~C() C
4: ~B() C
1: ~B() 2
```
# Was waren meine Fehler?
Ich hab vergessen, das mit jeden C Objekt auch den B Konstruktor aufgerufen wird
Nach xxx 4 hatte ich gedacht, der Destuktor von C wird aufgerufen, aber eigentlich wird der Destuktor von A aufgerufen.
Ich hab die Reihenfolge, mit der die Objekte nach zzz 6 gelöscht werden vertauscht.
