161

I watched Walter Brown's talk at Cppcon14 about modern template programming (Part I, Part II) where he presented his void_t SFINAE technique.

Example:
Given a simple variable template that evaluates to void if all template arguments are well formed:

template< class ... > using void_t = void;

and the following trait that checks for the existence of a member variable called member:

template< class , class = void >
struct has_member : std::false_type
{ };

// specialized as has_member< T , void > or discarded (sfinae)
template< class T >
struct has_member< T , void_t< decltype( T::member ) > > : std::true_type
{ };

I tried to understand why and how this works. Therefore a tiny example:

class A {
public:
    int member;
};

class B {
};

static_assert( has_member< A >::value , "A" );
static_assert( has_member< B >::value , "B" );

1. has_member< A >

  • has_member< A , void_t< decltype( A::member ) > >
    • A::member exists
    • decltype( A::member ) is well-formed
    • void_t<> is valid and evaluates to void
  • has_member< A , void > and therefore it chooses the specialized template
  • has_member< T , void > and evaluates to true_type

2. has_member< B >

  • has_member< B , void_t< decltype( B::member ) > >
    • B::member does not exist
    • decltype( B::member ) is ill-formed and fails silently (sfinae)
    • has_member< B , expression-sfinae > so this template is discarded
  • compiler finds has_member< B , class = void > with void as default argument
  • has_member< B > evaluates to false_type

http://ideone.com/HCTlBb

Questions:
1. Is my understanding of this correct?
2. Walter Brown states that the default argument has to be the exact same type as the one used in void_t for it to work. Why is that? (I don't see why this types need to match, doesn't just any default type does the job?)

ACyclic
  • 5,036
  • 2
  • 24
  • 27
nonsensation
  • 3,317
  • 5
  • 26
  • 39

2 Answers2

146

1. Primary Class Template

When you write has_member<A>::value, the compiler looks up the name has_member and finds the primary class template, that is, this declaration:

template< class , class = void >
struct has_member;

(In the OP, that's written as a definition.)

The template argument list <A> is compared to the template parameter list of this primary template. Since the primary template has two parameters, but you only supplied one, the remaining parameter is defaulted to the default template argument: void. It's as if you had written has_member<A, void>::value.

2. Specialized Class Template

Now, the template parameter list is compared against any specializations of the template has_member. Only if no specialization matches, the definition of the primary template is used as a fall-back. So the partial specialization is taken into account:

template< class T >
struct has_member< T , void_t< decltype( T::member ) > > : true_type
{ };

The compiler tries to match the template arguments A, void with the patterns defined in the partial specialization: T and void_t<..> one by one. First, template argument deduction is performed. The partial specialization above is still a template with template-parameters that need to be "filled" by arguments.

The first pattern T, allows the compiler to deduce the template-parameter T. This is a trivial deduction, but consider a pattern like T const&, where we could still deduce T. For the pattern T and the template argument A, we deduce T to be A.

In the second pattern void_t< decltype( T::member ) >, the template-parameter T appears in a context where it cannot be deduced from any template argument.

There are two reasons for this:

  • The expression inside decltype is explicitly excluded from template argument deduction. I guess this is because it can be arbitrarily complex.

  • Even if we used a pattern without decltype like void_t< T >, then the deduction of T happens on the resolved alias template. That is, we resolve the alias template and later try to deduce the type T from the resulting pattern. The resulting pattern, however, is void, which is not dependent on T and therefore does not allow us to find a specific type for T. This is similar to the mathematical problem of trying to invert a constant function (in the mathematical sense of those terms).

Template argument deduction is finished(*), now the deduced template arguments are substituted. This creates a specialization that looks like this:

template<>
struct has_member< A, void_t< decltype( A::member ) > > : true_type
{ };

The type void_t< decltype( A::member ) > can now be evaluated. It is well-formed after substitution, hence, no Substitution Failure occurs. We get:

template<>
struct has_member<A, void> : true_type
{ };

3. Choice

Now, we can compare the template parameter list of this specialization with the template arguments supplied to the original has_member<A>::value. Both types match exactly, so this partial specialization is chosen.

On the other hand, when we define the template as:

template< class , class = int > // <-- int here instead of void
struct has_member : false_type
{ };

template< class T >
struct has_member< T , void_t< decltype( T::member ) > > : true_type
{ };

We end up with the same specialization:

template<>
struct has_member<A, void> : true_type
{ };

but our template argument list for has_member<A>::value now is <A, int>. The arguments do not match the parameters of the specialization, and the primary template is chosen as a fall-back.

(*) The Standard, IMHO confusingly, includes the substitution process and the matching of explicitly specified template arguments in the template argument deduction process. For example (post-N4296) [temp.class.spec.match]/2:

A partial specialization matches a given actual template argument list if the template arguments of the partial specialization can be deduced from the actual template argument list.

But this does not just mean that all template-parameters of the partial specialization have to be deduced; it also means that substitution must succeed and (as it seems?) the template arguments have to match the (substituted) template parameters of the partial specialization. Note that I'm not completely aware of where the Standard specifies the comparison between the substituted argument list and the supplied argument list.

Arsen Khachaturyan
  • 6,472
  • 4
  • 32
  • 36
dyp
  • 35,820
  • 10
  • 96
  • 156
  • I cannot even find in which step the Standard inserts the default template-arguments of the primary (class) template into the template argument list supplied to the partial specialization :( – dyp Dec 29 '14 at 12:25
  • 3
    Thank you! I've read it over and over again, and I guess my thinking of how template argument deduction exactly works and what the compiler chooses for the final template is at the moment not correct. – nonsensation Dec 30 '14 at 12:12
  • 1
    @JohannesSchaub-litb Thanks! That's a bit depressing, though. Are there really no rules for matching a template argument with a specialization? Not even for explicit specializations? – dyp Dec 30 '14 at 16:27
  • @dyp for explicit specializations, there is no argument deduction involved and stuff is much simplier. As far as I can remember, the necessary text for matching to explicit specializations is present (and is a few words), but don't quote me on that :) Has been some time since I last looked into the spec for anything. – Johannes Schaub - litb Dec 30 '14 at 16:53
  • These phrases seem to be sufficient to describe explicit specializations: 14.4p1, and the "Unless a ..." rules in 14.7.1p1..p5. The matching is implicit by 3.8 and 14.4p1. – Johannes Schaub - litb Dec 30 '14 at 17:34
  • @JohannesSchaub-litb Thanks again. How is 3.8 "Object lifetime" related to matching of template argument lists? – dyp Dec 30 '14 at 19:53
  • @dyp sorry for the confusion. I meant 3p8. – Johannes Schaub - litb Dec 30 '14 at 21:01
  • 2
    W/r/t default template arguments, http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#2008 – T.C. Jan 28 '15 at 10:41
  • 1
    @dyp A few weeks later and reading alot about this and with a hint from [this snippet](https://gist.github.com/jefftrull/ff6083e2e92fdabb62f6) i think i begin to understand how this works. Your explanation makes from read to read more sense to me, thanks! – nonsensation Feb 25 '15 at 23:05
  • 1
    I wanted to add, that the term **primary** template was the key (the templates first encounter in the code) – nonsensation Sep 27 '16 at 12:51
  • 1
    @dyp. Thanks for your answer. But I didn't understand this sentence. " In the second pattern, the template-parameter appears in a non-deduced context. Hence, we cannot deduce the template parameter T from the second template argument void." could you please clarify this ? – PreeJackie Nov 21 '17 at 08:32
  • 1
    @praveen I've tried to elaborate that section a bit, let me know if that helps. – dyp Nov 21 '17 at 11:54
  • @dyp Thanks a lot – PreeJackie Nov 21 '17 at 14:53
18
// specialized as has_member< T , void > or discarded (sfinae)
template<class T>
struct has_member<T , void_t<decltype(T::member)>> : true_type
{ };

That above specialization exists only when it is well formed, so when decltype( T::member ) is valid and not ambiguous. the specialization is so for has_member<T , void> as state in the comment.

When you write has_member<A>, it is has_member<A, void> because of default template argument.

And we have specialization for has_member<A, void> (so inherit from true_type) but we don't have specialization for has_member<B, void> (so we use the default definition : inherit from false_type)

Jarod42
  • 173,454
  • 13
  • 146
  • 250