В какой момент происходит создание шаблона привязки?

template <class T>
void f(T value)
{
g(value);
}

void g(int v);

void h()
{
extern g(double);
f(2);
}

void h()
{
struct X {}; // local structure
std::vector<X> v; // error: can't use local structure as template parameter
}

«В 1985 году было выпущено первое издание языка программирования C ++, которое стало окончательной ссылкой на язык, так как еще не было официального стандарта.» Вики C ++ История Так что между C ++ 11 и C ++ 14 ничего не изменилось. Я могу предположить (и, пожалуйста, примите это с небольшим количеством соли), что это изменилось между «предварительной стандартизацией» и стандартизацией. Может быть, кто-то, кто лучше знает историю C ++, может пролить больше света здесь.

Что касается того, что на самом деле происходит:

---

Сначала давайте уберемся с простого:

extern g(double);

Это неверный C ++. Исторически, к сожалению, C допускал пропуск типа. В C ++ вы должны написать extern void g(double),

---

Далее давайте проигнорируем g(double) Перегрузка, чтобы ответить на ваш первый вопрос:

template <class T>
void f(T value)
{
g(value);
}

void g(int v);

int main()
{
f(2);
}

В C ++ есть печально известный двухфазный поиск имен:

• На первом этапе, при определении шаблона, все независимые имена решены. Невыполнение этого требования является серьезной ошибкой;
• Зависимые имена разрешаются на втором этапе при создании шаблона.

Правила немного сложнее, но в этом суть.

g зависит от параметра шаблона T так что проходит первый этап. Это означает, что если вы никогда не создаете экземпляр fкод компилируется просто отлично. На втором этапе f создается с T = int, g(int) сейчас ищется, но не найден:

17 : error: call to function 'g' that is neither visible in the template definition nor found by argument-dependent lookup
g(value);
^
24 : note: in instantiation of function template specialization 'f<int>' requested here
f(2);
^
20 : note: 'g' should be declared prior to the call site
void g(int v);

Для произвольного имени g Чтобы пройти с летающими цветами у нас есть несколько вариантов:

1. декларировать g ранее:

void g(int);

template <class T>
void f(T value)
{
g(value);
}

2. приносить g в с T:

template <class T>
void f(T)
{
T::g();
}

struct X {
static void g();
};

int main()
{
X x;
f(x);
}

3. приносить g в с T через ADL:

template <class T>
void f(T value)
{
g(value);
}

struct X {};

void g(X);

int main()
{
X x;
f(x);
}

Это, конечно, меняет семантику программы. Они предназначены для иллюстрации того, что вы можете и не можете иметь в шаблоне.

---

А почему ADL не находит g(int), но находит g(X):

§ 3.4.2 Поиск имени в зависимости от аргумента [basic.lookup.argdep]

3. Для каждого типа аргумента T в вызове функции существует набор из нуля или более связанных пространств имен и набор из нуля или более
   связанные классы должны быть рассмотрены […]:

   • Если T является фундаментальным типом, то связанные с ним наборы пространств имен и классов являются пустыми.

   • Если T является типом класса (включая объединения), его ассоциированными классами являются: сам класс; класс, членом которого он является, если таковой имеется; а также
     его прямые и косвенные базовые классы. Его связанные пространства имен
     пространства имен, членами которых являются связанные с ним классы. […]

---

И, наконец, мы получаем, почему extern void g(double); внутри главное не найдено: прежде всего мы показали, что g(fundamental_type) найден тогда и только тогда объявлено до f определение. Итак, давайте сделаем это void g(X) внутри main, ADL находит это?

template <class T>
void f(T value)
{
g(value);
}

struct X{};int main()
{
X x;
void g(X);

f(x);
}

Нет. Потому что он не находится в том же пространстве имен, что и X (то есть глобальное пространство имен) ADL не может его найти.

Доказательство того g не в глобальном

int main()
{
void g(X);

X x;
g(x); // OK
::g(x); // ERROR
}

34: ошибка: в глобальном пространстве имен нет члена с именем «g»; ты имел ввиду
просто г?