"Eine protected abgeleitete Klasse unterscheidet sich in den
Zugriffsrechten von außen nicht von einer privat abgeleiteten Klasse.
Eine Konvertierung ist allerdings innerhalb einer Elementfunktion noch möglich. "

Kann mir das mal einer erklären.Vorallem den letzten Satz ?

class A {
protected:
        int a;
};

class B : private A{};

class C : protected A{};

class D : public B{
public:
        void test(){
                a = 0; // hier kannst du nicht drauf zugreifen, da A nur in B sichtbar
        }
};

class E : public C{
public:
        void test(){
                a = 0; // hier kannst du drauf zugreifen, da alle erbenden Klassen diese sehen
        }
};

int main() {
        return 0;
}

So verstehe ich den Satz jedenfalls bzw. glaube, dass dies gemeint ist

Gruß,
CSpille

class A{};

int main()
{
A objekt;

}

//Hier wird Destruktor für A aufgerufen.

WAnn macht es Sinn den Destruktor selbst zu definieren. ABgesehen von virtual destruktor ?

A* ptr=new A;

delete ptr;  // wird hier der Destuktor von A aufgerufen ? nein würd ich sagen

was passiert überhaupt hier

A* ptr=new A;

delete ptr;  // wird hier der Destuktor von A aufgerufen ? nein würd ich sagen

Yup

Was ich immer noch nicht versteh welchen Sinn macht es,
einen Basisklassen Zeiger auf eine abgeleitete Klasse zeigen zu lassen.
Nur dann kommt ja auch der virtual Destruktor ins Spiel.
Warum nicht einen abgeleiteten Zeiger auch auf eine abgeleitete Klasse zeigen lassen. Kostet das mehr oder wo liegt das Problem. Es kostet insofern mehr
dass ich ja dann auch die Methoden von B selber zur Verfügung habe.
Will man das wohl nicht ?

WAnn macht es Sinn den Destruktor selbst zu definieren. ABgesehen von virtual destruktor ?

Es gibt einige Fälle, wo es sinnvoll ist.
Häufig braucht man ihn um Resourcem freizugeben, die im Konstrukor (auf dem Heap)
angelegt wurden. (RAII)
http://de.wikipedia.org/wiki/RAII

oki

Was ich immer noch nicht versteh welchen Sinn macht es,
einen Basisklassen Zeiger auf eine abgeleitete Klasse zeigen zu lassen.
Nur dann kommt ja auch der virtual Destruktor ins Spiel.
Warum nicht einen abgeleiteten Zeiger auch auf eine abgeleitete Klasse zeigen lassen. Kostet das mehr oder wo liegt das Problem. Es kostet insofern mehr
dass ich ja dann auch die Methoden von B selber zur Verfügung habe.
Will man das wohl nicht ?

Da kommt das mit dem virtual in's Spiel. Das kann man ja nicht nur mit dem Destruktor machen sondern auch mit allen anderen Methoden. Und das ist sehr oft erwünscht. Zum Nachschlagen: Das nennt sich Polymorphie.

oki
Was ich immer noch nicht versteh welchen Sinn macht es,
einen Basisklassen Zeiger auf eine abgeleitete Klasse zeigen zu lassen.
Nur dann kommt ja auch der virtual Destruktor ins Spiel.

Ich hab gerade Bananen im Supermarkt gekauft, jetzt lege ich sie in einen
(selbstentsorgenden) Obstkorb. Wenn die Früchte darin verfault sind, werden
sie weggeworfen (gelöscht). Jetzt interessiert den Obstkorb nicht, ob ne Banane oder
nen Apfel verfault ist, sondern er wirft das Obst einfach weg (delete obst)

EDIT: Obst hat natürlich ne Funktion getVerfallsdatum()

Vielleicht etwas albern, aber evtl hilft es

sizeof(Point2D) ergibt 24 Byte

wenn ich aber im private statt double 2 int deklariere bekomme ich 12 Byte.

Wie gibts das ?

Obst *liste[3];

Dann kannst du das hier machen:

liste[0] = new Apfel();
liste[1] = new Birne();
liste[2] = new Banane();

double ist kleiner als int, deswegen.

Geh ins Bett o.O

Double hat die Große 8
Int hat die Größe 4
Pointer ist ebenfalls 4.

2x Double + virtual Pointer ergibt 20 angezeigt 24, da werden 4 Bytes als Padding verwendet.
http://msdn.microsoft.com/en-us/library/ms253935.aspx

2x Int + virtual Pointer ergibt 12 angezeigt 12

Wahrscheinlich um auf eine gerade Speicheradresse zu kommen.

Das Padding kann ja ganz schön speicher kosten

class B
{
public:
	B(void);
	~B(void);
private:
	char m_1;
	double m_3;
	char m_2;
	double m_4;
};

Double hat die Große 8
Int hat die Größe 4
Pointer ist ebenfalls 4.

Diese Größen sind (strenggenommen) Compiler- und System-abhängig.
Bei meinem 64-bit System ist ein Pointer z. B. 8 Byte.
-> Ich vermute du hast (noch) ein 32-bit System?

Diese Klasse hat die unglaubliche Größe von 32 Byte.
Wie gibts das. char sagen wir mal 4 Byte *2 + 2*double = 24 Byte

Wahrscheinlich um auf eine gerade Speicheradresse zu kommen.

Das Padding kann ja ganz schön speicher kosten

class B
{
public:
	B(void);
	~B(void);
private:
	char m_1;
	double m_3;
	char m_2;
	double m_4;
};

Änder einfach mal die Reihenfolge in char, char, double, double oder
in double, double, char, char und du hast (wahrscheinlich) nur noch 24 Byte

Nö, 64 bit, heisst aber nicht, dass ich auch in 64-Bit Mode kompiliere *gg*

Mir war klar, dass du nur die Größenangaben begründen wolltest.
Die 32-bit Aussage ging Richtung blurry333

Hast du wirklich im 32bit Modus kompiliert? Ich hätte gesagt, du hast gar nichts kompiliert

Zeus schrieb:

Double hat die Große 8
Int hat die Größe 4
Pointer ist ebenfalls 4.

Diese Größen sind (strenggenommen) Compiler- und System-abhängig.
Bei meinem 64-bit System ist ein Pointer z. B. 8 Byte.
-> Ich vermute du hast (noch) ein 32-bit System?

Ups ich hab ja auch ein 64 Bit Windows 7 Betriebssystem.

int main()
{
int y=7;
int *x=&y;	

cout<<sizeof(x);  // Ausgabe 4 Byte !!!
}

WAnn macht es Sinn den Destruktor selbst zu definieren. ABgesehen von virtual destruktor ?

Einen eigenen Destruktor brauchst Du immer dann, wenn der Defaultdestruktor nicht alles abräumen kann. Der Defaultdestruktor ruft einfach die Destruktoren aller Membervariablen auf. Sonst macht der nichts. Wenn eine Deiner Membervariablen z.B. ein Pointer ist, mußt Du einen eigenen Destruktor erzeugen, der den Speicher eventuell frei gibt:

class x
{
    TYPE *pointer;
    x() { pointer=NULL }
    ~x() { if( pointer ) free(pointer); }    // oder delete pointer;

    ....
};

Der Default destruktor würde den Speicher nicht freigeben. Gleiches gilt auch für Filehandles, Fensterhandles und ähnliches.

mfg Martin

~x() { if( pointer ) free(pointer); }    // oder delete pointer;

mgaeckler meinte natürlich:

~x() { if( pointer ) delete pointer; }    // oder (in Ausnahmen) free(pointer);

Jetzt verführ keinen Neuling dazu malloc und free zu benutzen

@blurry333: In C++ verwendet man i. d. R. new und delete

oki

Was ich immer noch nicht versteh welchen Sinn macht es,
einen Basisklassen Zeiger auf eine abgeleitete Klasse zeigen zu lassen.

Ich habe beispielsweise eine Klassenbibliothek für die Windows API.

Die Basisklasse kapselt das Fensterhandle. Abgeleitete Klassen spezialisieren sich dann immer mehr:

Selbstdefinierte Windowsklassen,
Edit Controls, Comboboxen, Listboxen, MDI-Fenster, MDI-Childs usw. usf.

Einer meiner Container enthält eine Liste aller Fenster mit selbst definierten Klassen. Der Container selber kennt aber nur die BASIS-Klasse aller selbst defnierten Fenster. Applikationsspezifische Klassen kann er gar nicht kennen, da er Teil der Bibliothek ist.

Er liefert daher immer nur einen Zeiger auf die Basisklasse zurück. Wenn der Anwendung in dem Kontext das auch genügt, wird sie das auch so lassen. Ansonsten muß halt gecastet werden.

Der Container ist auch dafür verantworlich, Windows Messages an die Instanzen der Fensterklassen zu verteilen. Dafür sind dann die virtuellen Funktionen zwingend erforderlich, da er applikationsspezifische Messagehandler gar nicht kennen kann.

Generel brauchst Du das, wenn ein Container Zeiger auf Instanzen von Klassen speichern muß, bei denen er nur die Basisklasse kennt.

mfg Martin