Undefinierter Verweis auf statisches Klassenmitglied

Kann jemand erklären, warum der folgende Code nicht kompiliert wird? Zumindest unter g ++ 4.2.4.

Und interessanter, warum wird es kompiliert, wenn ich MEMBER auf int umsetze?

#include <vector>

class Foo {  
public:  
    static const int MEMBER = 1;  
};

int main(){  
    vector<int> v;  
    v.push_back( Foo::MEMBER );       // undefined reference to `Foo::MEMBER'
    v.push_back( (int) Foo::MEMBER ); // OK  
    return 0;
}

Sie müssen das statische Element tatsächlich irgendwo definieren (nach der Klassendefinition). Versuche dies:

class Foo { /* ... */ };

const int Foo::MEMBER;

int main() { /* ... */ }

Das sollte die undefinierte Referenz loswerden.

Das Problem ergibt sich aus einem interessanten Zusammenprall neuer C ++ - Funktionen und dem, was Sie versuchen zu tun. Schauen wir uns zunächst die push_backSignatur an:

void push_back(const T&)

Es wird ein Verweis auf ein Objekt vom Typ erwartet T. Nach dem alten Initialisierungssystem existiert ein solches Mitglied. Der folgende Code wird beispielsweise problemlos kompiliert:

#include <vector>

class Foo {
public:
    static const int MEMBER;
};

const int Foo::MEMBER = 1; 

int main(){
    std::vector<int> v;
    v.push_back( Foo::MEMBER );       // undefined reference to `Foo::MEMBER'
    v.push_back( (int) Foo::MEMBER ); // OK  
    return 0;
}

Dies liegt daran, dass sich irgendwo ein tatsächliches Objekt befindet, in dem dieser Wert gespeichert ist. Wenn Sie jedoch zu der neuen Methode zum Festlegen statischer const-Elemente wechseln, wie oben beschrieben, Foo::MEMBERhandelt es sich nicht mehr um ein Objekt. Es ist eine Konstante, ähnlich wie:

#define MEMBER 1

Aber ohne die Kopfschmerzen eines Präprozessor-Makros (und mit Typensicherheit). Das bedeutet, dass der Vektor, der eine Referenz erwartet, keine bekommen kann.

Der C ++ - Standard erfordert eine Definition für Ihr statisches const-Mitglied, wenn die Definition irgendwie benötigt wird.

Die Definition ist beispielsweise erforderlich, wenn die Adresse verwendet wird. push_backNimmt seinen Parameter als const-Referenz und so benötigt der Compiler unbedingt die Adresse Ihres Mitglieds und Sie müssen sie im Namespace definieren.

Wenn Sie die Konstante explizit umwandeln, erstellen Sie eine temporäre Konstante, und diese temporäre Konstante ist an die Referenz gebunden (gemäß speziellen Regeln im Standard).

Dies ist ein wirklich interessanter Fall, und ich denke tatsächlich, dass es sich lohnt, ein Problem anzusprechen, damit der Standard geändert wird, um das gleiche Verhalten für Ihr ständiges Mitglied zu haben!

Obwohl dies auf seltsame Weise als legitime Verwendung des unären '+' - Operators angesehen werden könnte. Grundsätzlich ist das Ergebnis von unary +ein r-Wert, daher gelten die Regeln für die Bindung von r-Werten an const-Referenzen, und wir verwenden nicht die Adresse unseres statischen const-Elements:

v.push_back( +Foo::MEMBER );

Aaa.h

class Aaa {

protected:

    static Aaa *defaultAaa;

};

Aaa.cpp

// You must define an actual variable in your program for the static members of the classes

static Aaa *Aaa::defaultAaa;

Keine Ahnung, warum die Besetzung funktioniert, aber Foo :: MEMBER wird erst beim ersten Laden von Foo zugewiesen. Da Sie es nie laden, wird es nie zugewiesen. Wenn Sie irgendwo einen Verweis auf ein Foo hätten, würde es wahrscheinlich funktionieren.

Mit C ++ 11 wäre das Obige für Basistypen wie möglich

class Foo {
public:  
  static constexpr int MEMBER = 1;  
};

Der constexprTeil erstellt einen statischen Ausdruck im Gegensatz zu einer statischen Variablen - und das verhält sich wie eine extrem einfache Inline-Methodendefinition. Der Ansatz erwies sich jedoch mit C-String-Kontexten innerhalb von Template-Klassen als etwas wackelig.

In Bezug auf die zweite Frage: push_ref verwendet die Referenz als Parameter, und Sie können keine Referenz auf das statische Konstantenmitglied einer Klasse / Struktur haben. Sobald Sie static_cast aufrufen, wird eine temporäre Variable erstellt. Und ein Verweis auf dieses Objekt kann übergeben werden, alles funktioniert einwandfrei.

Oder zumindest mein Kollege, der das gelöst hat, hat es gesagt.