Why does libstdc++ use … … in it’s implementation of is_function? If we check out the cppreference section for std::is_function it gives a sample implementation and says for the first … … case: // specialization for variadic functions such as std::printf template<class Ret, class… Args> struct is_function<Ret(Args……)> : std::true_type {}; so we need the second … Read more
See paragraph [temp.class.spec] 14.5.5/8 of the standard: The type of a template parameter corresponding to a specialized non-type argument shall not be dependent on a parameter of the specialization. [ Example: template <class T, T t> struct C {}; template <class T> struct C<T, 1>; // error template< int X, int (*array_ptr)[X] > class A … Read more
AFAIK that’s changed in C++0x. I guess it was just an oversight (considering that you can always get the partial specialization effect with more verbose code, by placing the function as a static member of a class). You might look up the relevant DR (Defect Report), if there is one. EDIT: checking this, I find … Read more
Function partial specialization is not allowed yet as per the standard. In the example, you are actually overloading & not specializing the max<T1,T2> function. Its syntax should have looked somewhat like below, had it been allowed: // Partial specialization is not allowed by the spec, though! template <typename T> inline T const& max<T,T> (T const& … Read more
I think a lot of it is historical. Non-type template parameters weren’t originally allowed at all. When they were added, there were lots of limitations. As people tried different possibilities, and confirmed that they didn’t cause problems, some of the limitations were removed. Some of those original limitations remain for no particular reason beyond the … Read more
You can’t partially specialize a function. If you wish to do so on a member function, you must partially specialize the entire template (yes, it’s irritating). On a large templated class, to partially specialize a function, you would need a workaround. Perhaps a templated member struct (e.g. template <typename U = T> struct Nested) would … Read more
I would like tag dispatch because: Easy to extend with new tags Easy to use inheritance (example) It is fairly common technique in generic programming It seems tricky to me to add third variant in second example. When you’ll want to add, for example non-POD-of-PODs type you’ll have to replace bool in template <typename T, … Read more
I will dedicate my answer to case #4, because according to the OP’s EDIT, the compilers now agree on cases #6-8: # | The code | g++ (6.1) | clang++ (3.8.0) | 4 | foo<double&, d, d> | #1 — why? | #2 as expected | Seems like clang++ 3.8.0 behaves correctly and gcc 6.1 … Read more
AFAIK that’s changed in C++0x. I guess it was just an oversight (considering that you can always get the partial specialization effect with more verbose code, by placing the function as a static member of a class). You might look up the relevant DR (Defect Report), if there is one. EDIT: checking this, I find … Read more
In C#, the closest to specialization is to use a more-specific overload; however, this is brittle, and doesn’t cover every possible usage. For example: void Foo<T>(T value) {Console.WriteLine(“General method”);} void Foo(Bar value) {Console.WriteLine(“Specialized method”);} Here, if the compiler knows the types at compile, it will pick the most specific: Bar bar = new Bar(); Foo(bar); … Read more