5

The following code demonstrates the core of a C++ template metaprogramming pattern I have been using to determine whether a type T is an instantiation of a specific class template:

#include <iostream>

template<class A, class B>
struct S{};

template<class A, class B>
constexpr bool isS(const S<A,B>*) {return true;}

template<class T>
constexpr bool isS(const T*) {return false;}

int main() {
  S<int,char> s;
  std::cout<<isS(&s)<<std::endl;
  return 0;
}

It features two overloads of a constexpr function template isS, and it outputs 1, as expected. If I remove the pointer from the second isS, i.e. replace it with

template<class T>
constexpr bool isS(const T) {return false;}

the program unexpectedly outputs 0. If both versions of isS make it through to the overload resolution phase of compilation, then the output implies that the compiler is choosing the second overload. I have tested this under GCC, Clang and vc++ using the online compilers here, and they all produce the same result. Why does this happen?

I have read Herb Sutter's "Why Not Specialize Function Templates" article several times, and it seems that both isS functions should be considered to be base templates. If this is so, then it is a question of which one is the most specialised. Going by intuition and this answer, I would expect the first isS to be the most specialised, because T can match every instantiation of S<A,B>*, and there are many possible instantiations of T that cannot match S<A,B>*. I'd like to locate the paragraph in the working draft that defines this behaviour, but I'm not entirely sure what phase of compilation is causing the problem. Is it something to do with "14.8.2.4 Deducing template arguments during partial ordering"?

This issue is particularly surprising given that the following code, in which the first isS takes a reference to const S<A,B> and the second takes a const T, outputs the expected value 1:

#include <iostream>

template<class A, class B>
struct S{};

template<class A, class B>
constexpr bool isS(const S<A,B>&) {return true;}

template<class T>
constexpr bool isS(const T) {return false;}

int main() {
  S<int,char> s;
  std::cout<<isS(s)<<std::endl;
  return 0;
}

So the problem seems to be something to do with how pointers are treated.

Improve this question
4
  • A const T parameter is equivalent to a T parameter (so you'll get an exact match), and you need a qualification conversion from S<int, char>* to S<int, char> const*. Try using S<int, char> const s; instead in your main. -- The more specialized test happens very late in overload resolution, if other tests could not decide between the overloads. Here, we can select the second one earlier because it has a better rank (exact match vs qualification adjustment). Commented Apr 6, 2016 at 12:26
  • @dyp Ok, but then why does the compiler pick the first isS in the code snippet at the bottom, involving references? Doesn't the compiler need to do a qualification conversion from S<int, char>& to const S<int, char>& in this case? Commented Apr 6, 2016 at 12:47
  • @Ose No, T* to const T* is a qualification adjustment conversion, T to const T& is an identity conversion as the reference binds directly to the argument. Commented Apr 6, 2016 at 12:57
  • @TartanLlama Oh I see, thanks. TemplateRex updated their answer with this information, so I'm going to accept it. Commented Apr 6, 2016 at 13:23

2 Answers 2

Reset to default
6

Because the second overload will drop the top-level const inside the const T, it will resolve to T* during argument deduction. The first overload is a worse match because it will resolve to S<int, char> const*, which requires a const-qualification conversion.

You need to add const in front of your variable s in order for the more specialized overload to kick in: 

#include <iostream>

template<class A, class B>
struct S {};

template<class A, class B>
constexpr bool isS(const S<A,B>*) {return true;}

//template<class T>
//constexpr bool isS(const T*) {return false;}

template<class T>
constexpr bool isS(const T) {return false;}

int main() {
  S<int,char> const s{}; // add const here
  std::cout<<isS(&s)<<std::endl;
  return 0;
}

Live Example

Changing the first overload to a const S<A,B>&, will give the correct result because there is an identity conversion instead of a qualification adjustment.

13.3.3.1.4 Reference binding [over.ics.ref]

1 When a parameter of reference type binds directly (8.5.3) to an argument expression, the implicit conversion sequence is the identity conversion, unless the argument expression has a type that is a derived class of the parameter type, in which case the implicit conversion sequence is a derived-to-base Conversion (13.3.3.1).

Note: when in doubt about such argument deduction games, it's handy to use the __PRETTY_FUNCTION__ macro which (on gcc/clang) will give you more information about the deduced types of the selected template. You can then comment out certain overloads to see how this affects the overload resolution. See this live example.

Improve this answer
Sign up to request clarification or add additional context in comments.

1 Comment

Thanks for this, but please see my comment above (below the question).
3

Your second version doesn't give the answer you expect because the first version of isS requires an implicit conversion, whereas the second does not.

template<class A, class B>
constexpr bool isS(const S<A,B>*);

template<class T>
constexpr bool isS(const T);

S<int,char> s;
isS(&s);

Note that &s is of type S<int,char>*. The first isS is looking for a const S<int,char>*, so the pointer needs a conversion. The second isS is a direct match.

If you find yourself needing this pattern often, you could generalize it, like so:

template<template<typename...> class TT, typename T>
struct is_specialization_of : std::false_type {};

template<template<typename...> class TT, typename... Ts>
struct is_specialization_of<TT, TT<Ts...>> : std::true_type {};

Then you check if a type is a specialization of S like this:

is_specialization_of<S, decltype(s)>::value
Improve this answer

3 Comments

Thanks for this, but please see my comment above (below the question). Also, +1 for the generalisation - I hadn't thought of doing that!
I've noticed two shortcomings of your generalisation. One is that it says const TT<Ts...> is not a specialisation of TT<Ts...>. If this is desirable (as it is in my case), a second specialisation for const TT<Ts...> needs to be added. The other shortcoming is that it can't be used with class templates that have a mixture of type and non-type parameters (which is actually most of my use cases). I don't see a way of generalising it further to cover this case...
The first shortcoming can be solved by wrapping it in a template alias which calls std::remove_const on the type first, or even std::decay to remove everything. The second is a problem I've come across before and still do not have a good solution for.

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.