Чому ця функція шаблону не веде себе так, як очікувалося?

Я читав про функції шаблону і заплутався у цій проблемі:

#include <iostream>

void f(int) {
    std::cout << "f(int)\n";
}

template<typename T>
void g(T val) {
    std::cout << typeid(val).name() << "  ";
    f(val);
}

void f(double) {
    std::cout << "f(double)\n";
}

template void g<double>(double);

int main() {
    f(1.0); // f(double)
    f(1);   // f(int)
    g(1.0); // d  f(int), this is surprising
    g(1);   // i  f(int)
}

Результати однакові, якщо я не пишу template void g<double>(double);.

Я думаю, g<double>що після цього слід створити екземпляри f(double), і тому заклик до fвходу gповинен закликати f(double). Дивно, але до цих пір викликає f(int)в g<double>. Хтось може мені допомогти зрозуміти це?

Прочитавши відповіді, я зрозумів, в чому насправді моя плутанина.

Ось оновлений приклад. Це здебільшого без змін, за винятком того, що я додав спеціалізацію для g<double>:

#include <iostream>

void f(int){cout << "f(int)" << endl;}

template<typename T>
void g(T val)
{
    cout << typeid(val).name() << "  ";
    f(val);
}

void f(double){cout << "f(double)" << endl;}

//Now use user specialization to replace
//template void g<double>(double);

template<>
void g<double>(double val)
{
    cout << typeid(val).name() << "  ";
    f(val);
}

int main() {
    f(1.0); // f(double)
    f(1);  // f(int)
    g(1.0); // now d  f(double)
    g(1);  // i  f(int)
}

Зі спеціалізацією користувача g(1.0)поводиться так, як я очікував.

Чи не повинен компілятор автоматично робити те саме , що описується g<double>там же (або навіть після main(), як описано в розділі 26.3.3 мови програмування C ++ , 4-е видання)?

Ім'я f- це залежне ім'я (це залежить від Tаргументу val), і воно буде вирішено в два етапи :

1. Пошук без ADL розглядає декларації функцій ..., які видно з контексту визначення шаблону .
2. ADL вивчає декларації функцій ..., які видно або з контексту визначення шаблону, або з контексту інстанції шаблону .

void f(double)не видно з контексту визначення шаблону, і ADL його також не знайде, тому що

Для аргументів основного типу пов’язаний набір просторів імен та класів порожній

Ми можемо трохи змінити ваш приклад:

struct Int {};
struct Double : Int {};

void f(Int) { 
    std::cout << "f(Int)";
}

template<typename T>
void g(T val) {
    std::cout << typeid(val).name() << ' ';
    f(val);
    // (f)(val);
}

void f(Double) { 
    std::cout << "f(Double)";
}

int main() {
    g(Double{});
}

Тепер ADL знайдеться void f(Double)на другому кроці, і вихід буде 6Double f(Double). Ми можемо відключити ADL, написавши (f)(val)(або ::f(val)) замість f(val). Тоді результат буде 6Double f(Int), згідно з вашим прикладом.

Проблема f(double)не була оголошена в тому місці, де ви її називаєте; якщо ви перемістите його декларацію перед template g, воно буде викликано.

Редагувати: Навіщо використовувати ручну інстанцію?

(Я розповім лише про шаблони функцій, аналогічна аргументація має місце і для шаблонів класів.) Основне використання полягає у скороченні часу компіляції та / або приховуванні коду шаблону від користувачів.

Програма C ++ вбудована у двійкові файли в 2 етапи: компіляція та зв'язування. Для компіляції функціонального дзвінка потрібен лише заголовок функції. Для того, щоб зв'язок вдався, потрібен об’єктний файл, що містить скомпільоване тіло функції.

Тепер, коли компілятор бачить виклик шаблонованої функції, від того, що він робить, залежить те, чи знає тіло шаблону або лише заголовок. Якщо він бачить лише заголовок, він робить те саме, що якби функція не була шаблонна: ставить інформацію про виклик посилання на об'єктний файл. Але якщо він також бачить тіло шаблону, він також робить інше: він створює власний екземпляр тіла, компілює це тіло і також вкладає його в файл об'єктів.

Якщо кілька вихідних файлів викликають один і той же екземпляр шаблонованої функції, кожен їх об'єктний файл буде містити скомпільовану версію екземпляра функції. (Linker знає про це і вирішує всі виклики до однієї компільованої функції, тому в остаточному бінарному файлі програми / бібліотеки буде лише один.) Однак для складання кожного з вихідних файлів функція повинна була бути ініційована і складено, на що знадобився час.

Досить, щоб лінкер виконав цю роботу, якщо тіло функції знаходиться в одному об’єктному файлі. Вручну інстанціювати шаблон у вихідному файлі - це спосіб змусити компілятор помістити тіло функції в об'єктний файл відповідного вихідного файлу. (Це якось так, як якщо б функція була викликана, але інстанція записується там, де виклик функції був би недійсним.) Коли це зроблено, всі файли, які викликають вашу функцію, можуть бути зібрані, знаючи лише заголовок функції, таким чином заощадити час, що знадобиться для інстанціювання та складання тіла функції при кожному з викликів.

Друга причина (приховування реалізації) може мати сенс зараз. Якщо автор бібліотеки хоче, щоб користувачі її функції шаблону могли використовувати цю функцію, вона зазвичай надає їм код шаблону, щоб вони могли скласти його самостійно. Якщо вона хотіла б зберегти вихідний код шаблону в секреті, вона могла б вручну інстанціювати шаблон у коді, який він використовує для створення бібліотеки та надання користувачам отриманої таким чином об’єкта замість джерела.

Це має сенс?