Undefined reference to static const int

C'est intentionnel, 9.4.2/4 dit:

Si une donnée membre statique est de const intégrale ou const type d'énumération,
sa déclaration dans la classe
définition pouvez spécifier un
constante d'initialiseur qui doit être une
partie intégrante d'expression constante (5.19) Dans
ce cas, le membre peut apparaître dans
partie intégrante des expressions constantes. L'
membre doit encore être définie dans un
espace de noms de la portée si elle est utilisée dans la
programme

Lorsque vous passez à la donnée membre statique par référence const, vous "utilisation", 3.2/2:

Une expression est potentiellement évalué
à moins qu'il apparaît à l'endroit où une partie intégrante
expression constante est requise (voir
5.19), est l'opérande de l'opérateur sizeof (5.3.3), ou est l'opérande de
l'opérateur typeid et l'expression
ne désigne pas une lvalue de
polymorphes type de classe (5.2.8). Un
objet ou non surchargé la fonction est
utilisé si son nom apparaît dans un
potentiellement expression évaluée.

Donc, en fait, vous "utilisez" quand vous passez par une valeur trop, ou dans un static_cast. C'est juste que GCC a vous laisser descendre le crochet dans un cas mais pas dans l'autre.

[Edit: gcc est l'application des règles de C++0x brouillons: "Une variable ou non surchargé la fonction dont le nom apparaît comme potentiellement évalué l'expression est de rll-utilisé, sauf si c'est un objet qui satisfait aux exigences pour apparaître dans une expression constante (5.19) et la lvalue-à-rvalue de conversion (4.1) est immédiatement appliquée.". La statique de la fonte effectue lvalue-rvalue conversion immédiatement, donc dans C++0x ce n'est pas "utilisé".]

Le problème pratique de la const de référence est que foo est dans son droit de prendre l'adresse de son argument, et de la comparer par exemple avec l'adresse de l'argument à partir d'un autre appel, stockée dans un mondial. Depuis une donnée membre statique est un objet unique, cela signifie que si vous appelez foo(kConst) à partir de deux différents Cus, l'adresse de l'objet passé doit être la même dans chaque cas. Autant que je sache, GCC ne peut pas faire en sorte que, sauf si l'objet est défini dans un (et un seul) TU.

OK, donc dans ce cas foo est un modèle, d'où la définition est visible dans tous les Syndicats, alors peut-être que le compilateur pourrait, en théorie, d'écarter le risque qu'il fait n'importe quoi avec l'adresse. Mais en général, vous avez certainement ne devriez pas prendre des adresses ou des références à des non-existant objets 😉

OriginalL'auteur Steve Jessop

C'est vraiment un cas valide. Surtout parce que foo pourrait être une fonction de la STL comme std::count qui prend un const T& comme troisième argument.

J'ai passé beaucoup de temps à essayer de comprendre pourquoi l'éditeur de liens a eu des problèmes avec un tel code de base.

Le message d'erreur

Undefined reference to 'Bar::kConst'

nous dit que le linker ne trouve pas un symbole.

$nm -C main.o
0000000000000000 T main
0000000000000000 W void foo<int>(int const&)
0000000000000000 W Bar::func()
0000000000000000 U Bar::kConst

Nous pouvons voir à partir de la 'U' cette Barre::kConst est pas défini. Par conséquent, lorsque l'éditeur de liens essaie de faire son travail, elle doit trouver le symbole. Mais vous ne déclarer kConst et de ne pas le définir.

La solution en C++ est aussi le définir comme suit:

template <typename T>
void foo(const T & a) { /* code */ }

class Bar
{
public:
   static const int kConst = 1;
   void func()
   {
      foo(kConst);           //This is the important line
   }
};

const int Bar::kConst;       //Definition <--FIX

int main()
{
   Bar b;
   b.func();
}

Ensuite, vous pouvez voir que le compilateur va mettre la définition dans le générés fichier objet:

$nm -C main.o
0000000000000000 T main
0000000000000000 W void foo<int>(int const&)
0000000000000000 W Bar::func()
0000000000000000 R Bar::kConst

Maintenant, vous pouvez voir le " R " en disant qu'elle est définie dans la section de données.

OriginalL'auteur Stac

Vous pouvez aussi le remplacer par un constexpr fonction de membre:

class Bar
{
  static constexpr int kConst() { return 1; };
};

OriginalL'auteur Ben-Uri

Truc Simple: utiliser + avant la kConst transmis à la fonction. Cela permettra d'éviter la constante de la prise d'une référence à partir de, et de cette façon, le code ne génère pas d'une demande de l'éditeur de liens à l'objet constant, mais il continuera avec le compilateur constante de temps de la valeur à la place.

OriginalL'auteur Ethouris