Где и зачем нужно ставить ключевые слова template и typename в C++?

Краткий ответ: зачем это нужно

Проблема возникает из-за того, что компилятор C++ разбирает код в два прохода. На первом проходе он видит только сам шаблон, не зная, какой конкретно тип будет подставлен вместо T. Когда компилятор встречает конструкцию вроде Container::const_iterator, он не может определить, является ли const_iterator типом, статической переменной или даже функцией. Это называется зависимое имя (dependent name) — оно зависит от шаблонного параметра.

По умолчанию компилятор считает, что такое имя — это не тип (например, статический член данных или функция). Чтобы указать, что это именно тип, используется ключевое слово typename. Аналогично, если вы хотите вызвать шаблонную функцию-член или обратиться к шаблонному вложенному типу, компилятору нужно подсказать, что следующий за точкой или стрелкой идентификатор — это шаблон, с помощью ключевого слова template.

Правило для typename

Ключевое слово typename ставится перед зависимым именем, которое является типом. Оно обязательно в следующих случаях:

• В объявлении переменной: typename T::iterator it;
• В параметре шаблона: template<typename T> (здесь это синоним class)
• В using-декларации: using value_type = typename T::value_type;

Пример без typename (ошибка компиляции):

template<typename T>
void foo() {
    T::iterator it; // Ошибка: компилятор думает, что iterator — это статическая переменная
}

Пример с typename (работает):

template<typename T>
void foo() {
    typename T::iterator it; // Правильно: говорим, что iterator — это тип
}

Правило для template

Ключевое слово template ставится перед зависимым именем шаблона, когда вы хотите обратиться к нему через ::, . или ->. Оно нужно, чтобы компилятор понял, что следующий за ним идентификатор — это шаблон, а не что-то иное.

Пример без template (ошибка):

template<typename T>
void bar() {
    T::SomeClass<int> obj; // Ошибка: компилятор думает, что < — это оператор меньше
}

Пример с template (работает):

template<typename T>
void bar() {
    T::template SomeClass<int> obj; // Правильно: говорим, что SomeClass — это шаблон
}

Полный пример для наглядности

#include <vector>
#include <iostream>

struct MyContainer {
    template<typename U>
    using Nested = std::vector<U>;
};

template<typename T>
void example() {
    // typename: T::value_type — это тип
    typename T::value_type val{};

    // template: T::template Nested — это шаблон
    typename T::template Nested<int> vec;
    vec.push_back(42);

    std::cout << vec[0] << std::endl;
}

int main() {
    example<std::vector<double>>(); // Работает: vector имеет value_type и нет шаблонов внутри
    // example<MyContainer>();       // Тоже работает, если MyContainer определит value_type
}

Когда можно опускать

• typename не нужен, если имя не зависит от шаблонного параметра (например, std::vector<int>::iterator — конкретный тип, компилятор знает его сразу).
• template не нужен, если контекст однозначен (например, в глобальной области видимости или когда имя шаблона уже известно).

Запомните простое мнемоническое правило: "Если компилятор может ошибиться — подскажи ему". Сомневаетесь, является ли имя типом? Добавьте typename. Сомневаетесь, является ли имя шаблоном? Добавьте template.