Riferimento indefinito al membro di classe statico

Qualcuno può spiegare perché il seguente codice non verrà compilato? Almeno su g ++ 4.2.4.

E più interessante, perché verrà compilato quando lancio MEMBER su int?

#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;
}

È necessario definire effettivamente il membro statico da qualche parte (dopo la definizione della classe). Prova questo:

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

const int Foo::MEMBER;

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

Ciò dovrebbe eliminare il riferimento indefinito.

Il problema sorge a causa di un interessante scontro di nuove funzionalità C ++ e di ciò che stai cercando di fare. Innanzitutto, diamo un'occhiata alla push_backfirma:

void push_back(const T&)

Si aspetta un riferimento a un oggetto di tipo T. Sotto il vecchio sistema di inizializzazione, esiste un membro del genere. Ad esempio, il codice seguente viene compilato correttamente:

#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;
}

Questo perché c'è un oggetto reale da qualche parte in cui è memorizzato quel valore. Se, tuttavia, si passa al nuovo metodo per specificare i membri const statici, come sopra, Foo::MEMBERnon è più un oggetto. È una costante, in qualche modo simile a:

#define MEMBER 1

Ma senza il mal di testa di una macro di preprocessore (e con sicurezza di tipo). Ciò significa che il vettore, che si aspetta un riferimento, non può ottenerne uno.

Lo standard C ++ richiede una definizione per il membro const statico se la definizione è in qualche modo necessaria.

La definizione è obbligatoria, ad esempio se viene utilizzato l'indirizzo. push_backaccetta il suo parametro come riferimento const, quindi il compilatore necessita rigorosamente dell'indirizzo del proprio membro ed è necessario definirlo nello spazio dei nomi.

Quando si lancia esplicitamente la costante, si crea un temporaneo ed è questo temporaneo che è associato al riferimento (in base a regole speciali nello standard).

Questo è un caso davvero interessante, e in realtà penso che valga la pena sollevare un problema in modo che lo std venga cambiato per avere lo stesso comportamento per il tuo membro costante!

Sebbene, in un modo strano, questo potrebbe essere visto come un uso legittimo dell'operatore unario "+". Fondamentalmente il risultato di unary +è un valore e quindi si applicano le regole per l'associazione dei valori ai riferimenti const e non usiamo l'indirizzo del nostro membro const statico:

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;

Non ho idea del perché il cast funzioni, ma Foo :: MEMBER non viene assegnato fino alla prima volta che Foo viene caricato, e poiché non lo carichi mai, non viene mai assegnato. Se avessi un riferimento a un Foo da qualche parte, probabilmente funzionerebbe.

Con C ++ 11, quanto sopra sarebbe possibile per i tipi di base come

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

La constexprparte crea un'espressione statica in contrapposizione a una variabile statica , che si comporta proprio come una definizione del metodo inline estremamente semplice. Tuttavia, l'approccio si è rivelato un po 'traballante con i constexprs di stringhe C all'interno delle classi dei template.

Per quanto riguarda la seconda domanda: push_ref accetta il riferimento come parametro e non è possibile avere un riferimento a un membro const statico di una classe / struttura. Dopo aver chiamato static_cast, viene creata una variabile temporanea. E un riferimento a questo oggetto può essere passato, tutto funziona bene.

O almeno il mio collega che ha risolto questo ha detto così.