14.7.2 Поиск имен, шаблоны и доступ к членам базовых классов

Стандарт C++ предписывает, что все имена, которые не зависят от параметров шаблона, связаны с их текущими определениями при разборе функции или класса шаблона.⁹ Только зависимые имена ищутся в момент инстанцирования. Например, рассмотрим

void foo(double);

struct A {
  template <typename T>
  void f () {
    foo (1);        // 1
    int i = N;      // 2
    T t;
    t.bar();        // 3
    foo (t);        // 4
  }

  static const int N;
};

Здесь имена foo и N появляются в контексте, который не зависит от типа T. Поэтому компилятор потребует, чтобы они были определены в контексте использования в шаблоне, а не только до момента инстанцирования, и здесь будет использоваться ::foo(double) и A::N, соответственно. В частности, он преобразует целое значение в double при передаче его в ::foo(double).

Напротив, bar и вызов foo в четвёртой помеченной строке используются в контекстах, зависящих от типа T, поэтому они ищутся только в момент инстанцирования, и вы можете предоставить объявления для них после объявления шаблона, но перед его инстанцированием. В частности, если вы инстанцируете A::f<int>, последняя строка вызовет перегруженный ::foo(int) , если он был предоставлен, даже если после объявления struct A.

Это различие между поиском зависимых и независимых имён называется двухэтапным (или зависимым) поиском имён. G++ реализует его начиная с версии 3.4.

Двухэтапный поиск имён иногда приводит к ситуациям с поведением, отличным от кода без шаблонов. Наиболее распространённым, вероятно, является следующий случай:

template <typename T> struct Base {
  int i;
};

template <typename T> struct Derived : public Base<T> {
  int get_i() { return i; }
};

В get_i(), i не используется в зависимом контексте, поэтому компилятор будет искать имя, объявленное в области окружающего пространства имён (то есть в глобальной области здесь). Он не будет искать в базовом классе, поскольку это зависимый контекст, и вы можете объявить специализации Base даже после объявления Derived, поэтому компилятор не может точно знать, к чему бы относилось i. Если глобальной переменной i нет, то вы получите сообщение об ошибке.

Чтобы сделать явным, что вам нужен член базового класса, вам нужно отложить поиск до момента инстанцирования, когда базовый класс известен. Для этого вам нужно получить доступ к i в зависимом контексте, используя либо this->i (помните, что this имеет тип Derived<T>*, поэтому очевидно, что он зависимый), либо используя Base<T>::i. В качестве альтернативы, Base<T>::i может быть включено в область видимости объявлением using.

Другой, похожий пример, связан с вызовом функций-членов базового класса:

template <typename T> struct Base {
    int f();
};

template <typename T> struct Derived : Base<T> {
    int g() { return f(); };
};

Опять же, вызов f() не зависит от аргументов шаблона (нет аргументов, зависящих от типа T, и не указано, что вызов должен быть в зависимом контексте). Таким образом, глобальное объявление такой функции должно быть доступно, так как объявление в базовом классе не видно до момента инстанцирования. Поэтому компилятор выведет следующее сообщение об ошибке:

x.cc: In member function `int Derived<T>::g()':
x.cc:6: error: there are no arguments to `f' that depend on a template
   parameter, so a declaration of `f' must be available
x.cc:6: error: (if you use `-fpermissive', G++ will accept your code, but
   allowing the use of an undeclared name is deprecated)

Чтобы сделать код корректным, используйте this->f(), или Base<T>::f(). Использование флага -fpermissive также позволит компилятору принять код, пометив все вызовы функций, для которых объявление не видно на момент определения шаблона, для последующего поиска в момент инстанцирования, как если бы это был зависимый вызов. Мы не рекомендуем использовать -fpermissive для обхода некорректного кода, а также он будет ловить только случаи вызова функций в базовых классах, а не случаи использования переменных в базовых классах (как в приведённом выше примере).

Обратите внимание, что некоторые компиляторы (включая G++ версии до 3.4) делают эти примеры неправильно и принимают приведенный выше код без ошибки. Эти компиляторы не реализуют двухэтапный поиск имён корректно.

Далее: Временные объекты, Предыдущее: Статические определения, Вверх: Непонимание C++ [Содержание][Индекс]