This is yet another C++ 11 feature that’s now supported in VC++ 2013. Until now, the following code would not compile with VC++.
template <typename T = int> void Foo(T t = 0) { }
// error C4519: default template arguments are only
// allowed on a class template
Visual C++ 2013 compiles this fine, and the template type is inferred correctly.
Foo(12L); // Foo<long>
Foo(12.1); // Foo<double>
Foo('A'); // Foo<char>
Foo(); // Foo<int>
The usefulness of this feature is more evident in the following example.
template <typename T> class Manager
{
public:
void Process(T t) { }
};
template <typename T> class AltManager
{
public:
void Process(T t) { }
};
template <typename T, typename M = Manager<T>> void Manage(T t)
{
M m;
m.Process(t);
}
Manage(25); // Manage<int, Manager<int>>
Manage<int, AltManager<int>>(25); // Manage<int, AltManager<int>>
Not all arguments need to have defaults.
template <typename B, typename T = int> void Bar(B b = 0, T t = 0) { }
Bar(10); // Bar<int, int>
Bar(10L); // Bar<long, int>
Bar(10L, 20L); // Bar<long, long>
Bar(); // will not compile
When you have overloaded function templates with default arguments, you can run into compiler errors when the type cannot be inferred.
template <typename T = int> void Foo(T t = 0) { }
template <typename B, typename T = int> void Foo(B b = 0, T t = 0) { }
Foo(12L); // will not compile
Foo(12.1); // will not compile
Foo('A'); // will not compile
Foo(); // Foo<int>
So, that’s one thing to watch out for when using default template arguments with function templates.
