допустим написал след. шаблонную функцию
template <class Type>
void function(Type t1, Type t1) {
/*to do*/
}
теперь в программе, если вызываю функцию надо писать
function<int>(...) или нечто в этом роде.
Так вот можно ли с помощью, например typedef, или еще чего-нить сделать так, чтоб мне эту функцию можно было вызывать нечто
вроде
functionI()...
За некоторым исключением, явно можно типы не указывать - они автоматически будут выведены компилятором исходя от фактического типа аргумента функции. В противном случае придется явно указывать тип(ы). 'typedef' к функции не применим.
Маленький пример(явное указание типов):
template<class T> struct A { typedef T B; };
template<> struct A<bool> { typedef bool B; };
template<> struct A<int> { typedef int B; };
template<class T> void f(typename A<T>::B v){}
// typedef f<int> new_f; не сработает, т.к. 'f<int>' не является типом
struct E { int a; };
int main()
{
int i;
bool b;
E s;
f<int>(i);
f<bool>(b);
f<E>(s);
//f(i); ошибка, невозможно вывести тип
//f(s); ошибка -^
// new_f(i); ошибка, см. выше
}
Но для шаблонных классов можно(код из stl):
typedef basic_string<char, char_traits<char>, allocator<char> >
string;
typedef basic_string<wchar_t, char_traits<wchar_t>,
allocator<wchar_t> > wstring;
Помимо этого обсуждается введение в стандарт 'template typedef'
(
http://open-std.org/jtc1/sc22/wg21/docs/papers/2002/n1406.pdf)
Внешне это выглядит так(например):
'template <typename Type1, typename Type2> typedef A<B<Type1, Type2>* > NewType;'
В настоящее время приходится делать так:
template<typename T1, typename T2>
struct NewT
{
typedef A<B<T1, T2>*> Type;
};
// и и спользовать так
NewT<T1, T2>::Type obj;
// а будет(возможно) так
NewType<T1, T2> obj;
...чем отличается template<class=...> от template<typename=...>
В данном случае ничем. Иногда используют соглашения, согласно которым используется 'typename' если в качестве параметра
шаблона используются примитивные(и/или POD) типы, и 'class' во всех остальных случаях.
Действительная необходимость использования 'typename' возникает в подобных случаях:
struct A { struct C{}; };
template<class T> void foo()
{
T::C * y; // умножение члена T::C на y
}
template<class T> void foo()
{
typename T::C * y; // определение объекта, имеющего тип T::C
}
а также в случаях, подобному определению ф-ии f из первого примера
