Невизначене посилання на статичний const int

Сьогодні я натрапив на цікаве питання. Розглянемо цей простий приклад:

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

// This would also fail
// void foo(const int & a) { /* code */ }

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

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

При компіляції я отримую помилку:

Undefined reference to 'Bar::kConst'

Зараз я майже впевнений, що це тому, що static const intзначення ніде не визначено, що є навмисним, оскільки, на моє розуміння, компілятор повинен мати змогу зробити заміну під час компіляції і не потребувати визначення. Однак, оскільки функція приймає const int &параметр, здається, вона не робить заміну, а віддає перевагу посиланню. Я можу вирішити цю проблему, внісши такі зміни:

foo(static_cast<int>(kConst));

Я вважаю, що це зараз змушує компілятор зробити тимчасовий int, а потім передати посилання на це, що він може успішно зробити під час компіляції.

Мені було цікаво, чи це було навмисно, чи я очікую занадто багато від gcc, щоб мати змогу розглянути цю справу? Або це те, чого я не повинен робити з якихось причин?

Це навмисно, 9.4.2 / 4 говорить:

Якщо статичний елемент даних має тип const інтеграл або тип const перелічення, його оголошення у визначенні класу може вказувати константу-ініціалізатор, яка повинна бути інтегральним константним виразом (5.19). У цьому випадку член може з'являтися у інтегральних константних виразах. Член все ще повинен бути визначений у області простору імен, якщо він використовується в програмі

Коли ви передаєте статичний елемент даних за посиланням const, ви "використовуєте" його, 3.2 / 2:

Вираз потенційно обчислюється, якщо він не з'являється там, де потрібен інтегральний константний вираз (див. 5.19), є операндом оператора sizeof (5.3.3) або операндом оператора типового оператора, і вираз не позначає значення l тип поліморфного класу (5.2.8). Об'єкт або незавантажена функція використовується, якщо його ім'я відображається у потенційно оціненому виразі.

Отже, насправді ви "використовуєте" його, коли передаєте його також за значенням, або в a static_cast. Просто GCC в одному випадку відпустив вас, але не в іншому.

[Редагувати: gcc застосовує правила з чернеток C ++ 0x: "Змінна або незавантажена функція, ім'я якої відображається як потенційно обчислюваний вираз, підтримується, якщо це не об'єкт, який задовольняє вимогам щодо появи у константі вираз (5.19) і негайно застосовується перетворення lvalue в rvalue (4.1). " Статичний привід виконує перетворення lvalue-rvalue негайно, тому в C ++ 0x це не "використовується".]

Практична проблема з посиланням const полягає в тому, що fooв межах його прав брати адресу свого аргументу і порівнювати її, наприклад, з адресою аргументу з іншого виклику, що зберігається в глобальному. Оскільки статичний член даних є унікальним об'єктом, це означає, що якщо ви телефонуєте foo(kConst)з двох різних TU, то адреса переданого об'єкта повинна бути однаковою в кожному випадку. AFAIK GCC не може це домовитись, якщо об'єкт не визначений в одній (і лише одній) TU.

Добре, отже, у цьому випадку fooце шаблон, отже, визначення видно у всіх TU, тому, можливо, компілятор теоретично міг би виключити ризик того, що він щось робить із адресою. Але загалом ви, звичайно, не повинні брати адреси або посилання на неіснуючі об'єкти ;-)

Якщо ви пишете статичну змінну const за допомогою ініціалізатора всередині оголошення класу, це точно так само, ніби ви писали

class Bar
{
      enum { kConst = 1 };
}

і GCC поводитиметься з ним так само, це означає, що у нього немає адреси.

Має бути правильний код

class Bar
{
      static const int kConst;
}
const int Bar::kConst = 1;

Це справді дійсний випадок. Особливо тому, що foo може бути функцією зі STL, як std :: count, яка приймає const T & як третій аргумент.

Я витратив багато часу, намагаючись зрозуміти, чому у компоновщика проблеми з таким базовим кодом.

Повідомлення про помилку

Невизначене посилання на 'Bar :: kConst'

повідомляє нам, що лінкер не може знайти символ.

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

З "U" ми бачимо, що Bar :: kConst не визначений. Отже, коли лінкер намагається виконати свою роботу, він повинен знайти символ. Але ти тільки оголошуєте kConst і не визначаєте його.

Рішенням на С ++ також є його визначення наступним чином:

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();
}

Потім ви можете бачити, що компілятор помістить визначення у згенерований об'єктний файл:

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

Тепер ви можете побачити 'R', який говорить, що це визначено в розділі даних.

g ++ версія 4.3.4 приймає цей код (див. це посилання ). Але g ++ версія 4.4.0 це відхиляє.

Я думаю, що цей артефакт С ++ означає, що будь-який час, на який Bar::kConstйдеться, замість нього використовується його буквальне значення.

Це означає, що на практиці не існує змінної, на яку можна зробити посилання.

Можливо, вам доведеться зробити це:

void func()
{
  int k = kConst;
  foo(k);
}

Ви також можете замінити його функцією-членом constexpr:

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

Простий фокус: використовуйте +перед kConstпереданою функцією. Це не дозволить константі брати посилання, і таким чином код не генерує запит на зв'язування до об'єкта константи, але замість цього буде продовжувати значення константи часу компілятора.

Я відчув ту саму проблему, яку згадав Cloderic (статичний const у тернарному операторі:) r = s ? kConst1 : kConst2, але він скаржився лише після вимкнення оптимізації компілятора (-O0 замість -Os). Сталося на gcc-none-eabi 4.8.5.