The std::exchange was proposed in N3511 without default template argument, and later N3608 with a default template argument. Note that in N3608 the following reasoning was provided: Giving the second template argument a default value fixes the following two cases: DefaultConstructible x = …; if (exchange(x, {})) { … } int (*fp)(int); int f(int); double … Read more
You can have default template arguments, which are sufficient for your purposes: template<class T, class U = T, class V = U> class Test { }; Now the following work: Test<int> a; // Test<int, int, int> Test<double, float> b; // Test<double, float, float>
Enumerations can be template parameters in exactly the same way that ints can. enum Enum { ALPHA, BETA }; template <Enum E> class Foo { // … }; template <> void Foo <ALPHA> :: foo () { // specialise } class Bar : public Foo <BETA> { // OK } But you simply haven’t provided … Read more
You may create a trait for that: namespace detail { // To allow ADL with custom begin/end using std::begin; using std::end; template <typename T> auto is_iterable_impl(int) -> decltype ( begin(std::declval<T&>()) != end(std::declval<T&>()), // begin/end and operator != void(), // Handle evil operator , ++std::declval<decltype(begin(std::declval<T&>()))&>(), // operator ++ void(*begin(std::declval<T&>())), // operator* std::true_type{}); template <typename T> std::false_type … Read more
This was discussed on usenet some time ago, while i was trying to answer another question on stackoverflow: Point of Instantiation of Static Data Members. I think it’s worth reducing the test-case, and considering each scenario in isolation, so let’s look at it more general first: struct C { C(int n) { printf(“%d\n”, n); } … Read more
You have to write your own, but it’s simple: template<typename> struct is_std_array : std::false_type {}; template<typename T, std::size_t N> struct is_std_array<std::array<T,N>> : std::true_type {};
Type traits: #include <iostream> #include <type_traits> // C++0x //#include <tr1/type_traits> // C++03, use std::tr1 template<typename T> void printType(T param) { if(std::is_same<T,char*>::value) std::cout << “char*” << endl; else if(std::is_same<T,int>::value) std::cout << “int” << endl; else std::cout << “???” << endl; } Or even better yet, just overload the function: template<class T> void printType(T partam){ std::cout << … Read more
That is non-deducible context. That is why the template argument cannot be deduced by the compiler. Just imagine if you might have specialized TMap as follows: template <> struct TMap<SomeType> { typedef std::map <double, double> Type; }; How would the compiler deduce the type SomeType, given that TMap<SomeType>::Type is std::map<double, double>? It cannot. It’s not … Read more
Just define it in the header: template <typename T> struct S { static double something_relevant; }; template <typename T> double S<T>::something_relevant = 1.5; Since it is part of a template, as with all templates the compiler will make sure it’s only defined once.
To escape the dollar sign inside a string literal, use the backslash character: “\$” To escape it in a raw string literal (“””…”””), the workaround you provided is indeed the easiest solution at the moment. There’s an issue in the bug tracker, which you can star and/or vote for: KT-2425.