Geht, trotz unpassendem Ctor

Hallo,

ich habe folgenden Code:

D3DXCOLOR g_color1(1, 1, 1, 1);

D3DXCOLOR fooColor(g_color1);

D3DXCOLOR hat folgende Ctor:

D3DXCOLOR() {}
D3DXCOLOR( DWORD argb );
D3DXCOLOR( CONST FLOAT * );
D3DXCOLOR( CONST D3DXFLOAT16 * );
D3DXCOLOR( CONST D3DCOLORVALUE& );
D3DXCOLOR( FLOAT r, FLOAT g, FLOAT b, FLOAT a );

Unsinnigerweise also keinen Ctor für einen Parameter vom Typ D3DXCOLOR.
Meine Frage: Wieso geht der Code dennoch? (D3DCOLORVALUE ist ein struct mit 4 floats - aber der kann doch net einfach so das struct D3DXCOLOR in ein D3DCOLORVALUE casten, oder? oO )

Mario Sandler

Der Compiler erstellt dir automatisch einen Kopierkonstruktor der eine Referenz auf ein Objekt desselben Typs entgegennimmmt.
Auch erstellt der Compiler automatisch eine überladene Version des = Operators.

Der "Konstruktor" den du suchst ist der Copy Konstruktur oder cctor mit folgender Signatur:

Class Klasse
{
   Klasse(const Klasse& other);
}

Dieser wird wie der default ctor oder der dtor standardmäßig vom Compiler angelegt, sofern er nicht vom Benutzer deklariert wurde.

Ah ok, Danke.

Ich dachte da gibts ne Regel wie: "sobald ich einen Ctor selber schreibe, erstellt mir der Compiler NICHT mehr diese paar Standard Ctor".

pumuckl

nur der Default-Ctor wird nichtmehr erzeugt bei eigenen Ctoren. Der Copy-Ctor wird immer erzeugt, wenn du ihn nicht deklarierst/definierst.

asc

CtorFrage schrieb:

Ich dachte da gibts ne Regel wie: "sobald ich einen Ctor selber schreibe, erstellt mir der Compiler NICHT mehr diese paar Standard Ctor".

Wenn du einen eigenen Konstruktor schreibst wird nur der Standardkonstruktor nicht erzeugt.

Wenn du eine Klasse A hast:

class A
{
};

Wird daraus implizit folgendes generiert:

class A
{
    public:
        A();
        ~A();
        A(A const &);
        A& operator=(A const &);
}

Wenn du etwas davon nicht erzeugt bekommen willst, deklariere es in dem private-Bereich und Implementiere es nicht. Beispiel:

class A
{
    private:
        A(A const &); // Keine Implementierung!
        A& operator=(A const &); // Keine Implementierung!
};

Dies würde den Compiler dazu bringen nur noch den Standardkonstruktor und Destruktor zu generieren.

cu André

CStoll

asc schrieb:

Dies würde den Compiler dazu bringen nur noch den Standardkonstruktor und Destruktor zu generieren.

Genau genommen nur den Dtor - die Klasse hat jetzt einen selbstdefinierten Konstruktor (selbst wenn er nicht implementiert ist) und damit wird (afair) auch der Default-Ctor wegrationalisiert.

Nexus

asc schrieb:

[...] Wird daraus implizit folgendes generiert: [...]

Der Adressoperator wird auch noch automatisch generiert.

Der Komma-Operator glaube ich auch, aber der ist dann nicht mehr klassenspezifisch. Oder es wird einfach der Standard-Komma-Operator angewandt, bis man einen eigenen definiert, ganz sicher bin ich mir da nicht.