Definizione di membri interi const statici nella definizione della classe

La mia comprensione è che C ++ consente di definire membri const statici all'interno di una classe purché sia ​​un tipo intero.

Perché, allora, il codice seguente mi dà un errore del linker?

#include <algorithm>
#include <iostream>

class test
{
public:
    static const int N = 10;
};

int main()
{
    std::cout << test::N << "\n";
    std::min(9, test::N);
}

L'errore che ottengo è:

test.cpp:(.text+0x130): undefined reference to `test::N'
collect2: ld returned 1 exit status

È interessante notare che, se commento la chiamata a std :: min, il codice si compila e si collega correttamente (anche se test :: N è indicato anche nella riga precedente).

Qualche idea su cosa sta succedendo?

Il mio compilatore è gcc 4.4 su Linux.

La mia comprensione è che C ++ consente di definire membri const statici all'interno di una classe purché sia ​​un tipo intero.

Hai ragione. È consentito inizializzare gli integrali cost statici nella dichiarazione della classe, ma questa non è una definizione.

http://publib.boulder.ibm.com/infocenter/comphelp/v8v101/index.jsp?topic=/com.ibm.xlcpp8a.doc/language/ref/cplr038.htm

È interessante notare che, se commento la chiamata a std :: min, il codice si compila e si collega correttamente (anche se test :: N è indicato anche nella riga precedente).

Qualche idea su cosa sta succedendo?

std :: min prende i suoi parametri per riferimento const. Se li prendessi per valore non avresti questo problema ma dato che hai bisogno di un riferimento hai bisogno anche di una definizione.

Ecco il capitolo / verso:

9.4.2 / 4 - Se un staticmembro di dati è di tipo constintegrale o constenumerazione, la sua dichiarazione nella definizione di classe può specificare un inizializzatore di costante che sarà un'espressione di costante integrale (5.19). In tal caso, il membro può apparire in espressioni di costanti integrali. Il membro deve essere ancora definito in un ambito dello spazio dei nomi se viene utilizzato nel programma e la definizione dell'ambito dello spazio dei nomi non deve contenere un inizializzatore .

Vedi la risposta di Chu per una possibile soluzione alternativa.

L'esempio di Bjarne Stroustrup nelle sue FAQ in C ++ suggerisce che hai ragione e che hai bisogno di una definizione solo se prendi l'indirizzo.

class AE {
    // ...
public:
    static const int c6 = 7;
    static const int c7 = 31;
};

const int AE::c7;   // definition

int f()
{
    const int* p1 = &AE::c6;    // error: c6 not an lvalue
    const int* p2 = &AE::c7;    // ok
    // ...
}

Dice "Puoi prendere l'indirizzo di un membro statico se (e solo se) ha una definizione fuori classe" . Il che suggerisce che funzionerebbe altrimenti. Forse la tua funzione min richiama in qualche modo indirizzi dietro le quinte.

Un altro modo per farlo, comunque per i tipi interi, è definire le costanti come enumerazioni nella classe:

class test
{
public:
    enum { N = 10 };
};

Non solo int. Ma non puoi definire il valore nella dichiarazione della classe. Se hai:

class classname
{
    public:
       static int const N;
}

nel file .h allora devi avere:

int const classname::N = 10;

nel file .cpp.

Ecco un altro modo per aggirare il problema:

std::min(9, int(test::N));

(Penso che la risposta di Crazy Eddie descriva correttamente perché il problema esiste.)

A partire da C ++ 11 puoi usare:

static constexpr int N = 10;

Questo teoricamente richiede ancora di definire la costante in un file .cpp, ma fintanto che non ne prendi l'indirizzo Nè molto improbabile che qualsiasi implementazione del compilatore produca un errore;).

C ++ consente di definire membri const statici all'interno di una classe

No, 3.1 §2 dice:

Una dichiarazione è una definizione a meno che non dichiari una funzione senza specificare il corpo della funzione (8.4), contiene lo specificatore extern (7.1.1) o una specifica di collegamento (7.5) e né un inizializzatore né un corpo di funzione, dichiara un dato statico membro in una definizione di classe (9.4), è una dichiarazione del nome di una classe (9.1), è una dichiarazione-enum-opaca (7.2), o è una dichiarazione typedef (7.1.3), una dichiarazione-using (7.3. 3) o una direttiva sull'uso (7.3.4).