PDA

Archiv verlassen und diese Seite im Standarddesign anzeigen : [C++] Standard-Konstruktor von speziellem Konstruktor aus aufrufen?


Nasenbaer
2008-12-23, 18:28:34
Hallo,
ich habe 2 Konstruktoren: den Standardkonstruktor und einen, der zusätzliche Parameter engegen nimmt:

class bla
{
bla();
bla(int a);
}

bla::bla()
{
// allgemeine Initialisierungen
}



bla::bla(int a)
{
// spezieller Kram
}


Ich möchte jetzt erreichen, dass ich allgemeine Initialisierungen, die in jedem Falle gemacht werden müssen in bla() ausgelagert werden und das beim Erstellen einer Insanz mittels bla(int a) zuvor in Inhalt von bla() aufgeführt wird.
Wie mache ich das?

Achso und wenn jemand weiß wie man das gleiche bei Java erreicht wäre ich auch dankbar. :D

robobimbo
2008-12-23, 19:17:12
öhm, lager das allgemeine doch in eine private methode aus und ruf die von den verschiedenen konstruktoren aus auf

Nasenbaer
2008-12-23, 19:20:46
öhm, lager das allgemeine doch in eine private methode aus und ruf die von den verschiedenen konstruktoren aus auf
Ja das ginge natürlich aber ich dachte da gibts irgendwie ne Möglichkeit das so zu machen wie ich dachte.
Ich fänd das eleganter. :)

Nasenbaer
2008-12-23, 19:36:26
Hab da gerade was gefunden: http://www.parashift.com/c++-faq-lite/ctors.html#faq-10.3

Du hattest Recht. Er empfiehlt auch eine private init() Funktion.

instinct
2008-12-23, 19:42:52
In JAVA machst du es so:


bla()
{
...
}

bla(int a)
{
this(); // Hier rufst du den Standardkonstruktor auf
...
}


In C++ geht das nicht. Da musst du es in eine private init()-Methode auslagern.

Nasenbaer
2008-12-23, 19:46:16
Danke für den Tipp.

pest
2008-12-23, 20:09:40
class bla
{
bla();
bla(int a);
}

bla::bla()
{
// allgemeine Initialisierungen
}



bla::bla(int a)
{
bla();
// spezieller Kram
}

Nasenbaer
2008-12-23, 20:12:55
@pest

Nein das klappt nicht. Da wird eine bla Instanz im lokalen Scope von bla(int a) angelegt und wieder zerstört, wenn bla(int a) verlassen wird.

pest
2008-12-23, 20:19:45
Nein das klappt nicht. Da wird eine bla Instanz im lokalen Scope von bla(int a) angelegt und wieder zerstört, wenn bla(int a) verlassen wird.

kann sein, hab's nich ausprobiert...würde aber so oder so über ne init-methode gehn

The_Invisible
2008-12-23, 21:10:52
würde mich auch interessieren, habs auch immer in ner privaten methode gemacht. habe dazu aber weder im web noch in meinem 1200 seiten c++ schinken was gefunden.

mfg

Coda
2008-12-23, 22:35:03
Das ist auch die einzige Möglichkeit.

ScottManDeath
2008-12-24, 00:48:12
C++ 0x unterstuetzt das chaining von Konstruktoren der selben Klasses aehnlich wie in C#.

pest
2008-12-24, 09:56:28
Nein das klappt nicht. Da wird eine bla Instanz im lokalen Scope von bla(int a) angelegt und wieder zerstört, wenn bla(int a) verlassen wird.

ist es eigentlich zwingend das du die selbe Klasse benutzt?
formell schöner und flexibler wäre doch sowas, benutze ich auch oft


class bla
{
public:
bla();
};

class bla_ext : public bla
{
public:
bla_ext(int a);
};

bla::bla()
{
}

bla_ext::bla_ext(int a)
:bla()
{
}

Monger
2008-12-24, 10:14:52
...
Du hattest Recht. Er empfiehlt auch eine private init() Funktion.
Ich hab von C++ keine Ahnung, aber unter Java und C# kannst du finale Attribute nur im Konstruktor initialisieren. Da hast du also gar keine andere Wahl - außer, du machst deine Attribute nicht final, aber dann weichst du dein Design nunmal auf.

Wenn tatsächlich zwei Konstruktoren etliches an Code teilen, bietet es sich dann an, einen dritten Konstruktor als private zu deklarieren, den dann beide aufrufen.

instinct
2008-12-24, 10:24:58
Bei C++ müssen const-Attribute schon VOR Eintritt in den Konstruktor initialisiert sein. Deshalb muss man dies in der Elementinitalisierungsliste tun, von daher ist auch nicht vorgesehen einen anderen Konstruktor zusätzlich aufzurufen.

Nasenbaer
2008-12-24, 14:50:25
ist es eigentlich zwingend das du die selbe Klasse benutzt?
formell schöner und flexibler wäre doch sowas, benutze ich auch oft


class bla
{
public:
bla();
};

class bla_ext : public bla
{
public:
bla_ext(int a);
};

bla::bla()
{
}

bla_ext::bla_ext(int a)
:bla()
{
}


Dazu müsste ich dann künstlich eine weiter Hierarchie-Ebene einfügen. Der Code der für Init-Code der für alle abgeleiteten Klassen gleich ist, der ist schon im Konstruktor der abtrakten Super-Klasse.