Чтобы определить параметр шаблона, вам нужно либо сообщить компилятору, что параметр является типом, либо значением.
В начале ...
Если я правильно помню, комитет C ++ не хотел добавлять новое ключевое слово в язык C ++, и поэтому он решил разрешить следующие обозначения:
template<int I>
int getTwice()
{
return I * 2 ;
}
template<class T>
std::string getType(const T & t)
{
return typeid(t).name() ;
}
void doSomething()
{
std::cout << "25 : " << getTwice<25>() << std::endl ;
std::cout << "5 : " << getTwice<5>() << std::endl ;
std::cout << "type(25) : " << getType(25) << std::endl ;
std::cout << "type(25.5) : " << getType(25.5) << std::endl ;
std::cout << "type(abc) : " << getType("abc") << std::endl ;
}
Какие выходные данные в g ++:
25 : 50
5 : 10
type(25) : i
type(25.5) : d
type(abc) : A4_c
Первая запись была шаблоном над значением. Итак, у нас есть тип значения в объявлении шаблона:
// "I" is the value, and "int" is the type of the value
template <int I>
Вторая запись была шаблоном над неизвестным типом, и тот факт, что тип не был «известен», был отмечен ключевым словом «класс». Таким образом, в этом контексте «класс» означает «тип».
// "T" is a type... And "class" is the "this-is-a-type" keyword
template <class T>
Вы заметите, что со второй нотацией, несмотря на ключевое слово class, T может быть ... int или другим встроенным типом. Но тогда лучше иметь это любопытство, чем добавлять новое ключевое слово, вы согласны? ...
Упс ...
Все было хорошо и хорошо, пока кто-то не написал следующий код:
template<class T> // T could be any STL container, for example a vector<char>
void printContainerData(const T & t)
{
std::cout << "aVector:" ;
for(T::const_iterator it = t.begin(), itEnd = t.end(); it != itEnd; ++it)
{
std::cout << " " << (*it) ;
}
std::cout << std::endl ;
}
Конечно, где T :: const_iterator - это тип ... Но тогда это может быть статический член класса типа T и, следовательно, значение. Компилятор может быть довольно запутанным.
В конце концов ...
Решение состояло в том, чтобы сообщить компилятору, что T :: const_iterator действительно тип ... Что приведет к такой записи:
for(class T::const_iterator it = t.begin(), // etc.
Но это считалось невозможным / правильным (класс - это объявления классов, нет?). Поэтому, волоча ноги, они решили, что ключевое слово действительно необходимо, чтобы сообщить компилятору, что символ является типом, а не значением.
«Тип» не рассматривался, я полагаю, потому что создание ключевого слова могло бы привести к поломке большого количества кода. Так что вместо этого использовалось имя типа. С помощью typename мы можем написать:
for(typename T::const_iterator it = t.begin(), // etc.
И для согласованности мы должны использовать:
template <typename T>
Когда T предполагается типом, а не значением.
Но по причинам совместимости старые обозначения:
template <class T>
все еще авторизован.
А как насчет ??
eben предложил ответ выше, ответ, который я хотел бы прокомментировать, потому что это довольно интересно:
template<template <class T> class U> // must be "class"
std::string to_string(const U<char>& u)
{
return std::string(u.begin(),u.end());
}
Я прокомментирую только его «значение» (этот код не может быть использован с контейнерами STL на моем компиляторе g ++, но я думаю, что это не главное): в один момент это накладывает ограничение на U, говоря: « U - это шаблон класса T. Это часть:
template <class T> class U
Что также можно написать:
template <typename T> class U
Поскольку U на самом деле является классом (а не встроенным типом), а T - типом любого типа.
И в следующей строке написано, что U специализируется на char:
std::string to_string(const U<char>& u)
Итак, этот «универсальный код» будет работать только для U, если U объявлен как:
template<typename T>
class U
{
// Etc.
} ;
И U образуется через символ:
U<char> u ;
// etc.
to_string(u)
Но одна вещь была забыта: нотация, предложенная Эбеном, может быть написана двумя способами:
template<template <class T> class U>
std::string to_string(const U<char>& u)
template<template <typename T> class U>
std::string to_string(const U<char>& u)
Второе ключевое слово "class" само по себе не является ключевым словом "type". Это тип, который является шаблонным классом над T. Таким образом, запутанная запись.
Другой способ написания кода Эбена, снятие ограничений, описанных выше, будет выглядеть примерно так:
template<typename U>
std::string to_string(const U & u)
{
return std::string(u.begin(),u.end());
}
И пусть компилятор сделает свое волшебство:
std::list<char> myList ;
// etc.
std::cout << to_string(myList) << std:endl ;
(например, код Eben не работал с контейнерами STL, настроенными на "char" в моем компиляторе g ++ ...)