17

I have tried to construct a case that requires no typename or template, but still yield a variable or template depending on whether a given name t is a function parameter pack or not

template<typename T> struct A { template<int> static void f(int) { } }; 
template<typename...T> struct A<void(T...,...)> { static const int f = 0; }; 
template<typename> using type = int; 

template<typename T> void f(T t) { A<void(type<decltype(t)>...)>::f<0>(1); }

int main() {
   f(1);   
}

The above will refer to the static const int, and do a comparison. The following just has T t changed to be a pack and make f refer to a template, but GCC does not like either

template<typename ...T> void f(T ...t) { A<void(type<decltype(t)>...)>::f<0>(1); }

int main() {
   f(1, 2, 3);   
}

GCC complains for the first

main.cpp:5:68: error: incomplete type 'A<void(type<decltype (t)>, ...)>' used in nested name specifier
 template<typename T> void f(T t) { A<void(type<decltype(t)>...)>::f<0>(1); }

And for the second

 main.cpp:5:74: error: invalid operands of types '<unresolved overloaded function type>' and 'int' to binary 'operator<'
  template<typename ...T> void f(T ...t) { A<void(type<decltype(t)>...)>::f<0>(1); }

I have multiple questions

  • Does the above code work according to the language, or is there an error?
  • Since Clang accepts both variants but GCC rejects, I wanted to ask what compiler is correct?

  • If I remove the body of the primary template, then for the f(1, 2, 3) case, Clang complains

    main.cpp:5:42: error: implicit instantiation of undefined template 'A<void (int)>'

    Please note that it says A<void (int) >, while I would expected A<void (int, int, int)>. How does this behavior occur? Is this a bug in my code - i.e is it illformed, or is it a bug in Clang? I seem to remember a defect report about the order of expansion vs the substitution of alias template, is that relevant and does it render my code ill-formed?

Improve this question
8
  • For me void(T...,...) looks like T... is in non deduce context but I'm not sure how compiler should react... Commented Nov 3, 2016 at 17:53
  • 1
    @W.F. i have seen this in "is_function" traits implementations to detect functions with that pattern. I would be surprised if that would not deduce T because then I'm not sure how is_function should detect them. Commented Nov 3, 2016 at 17:55
  • Didn't know I need to have a look there Commented Nov 3, 2016 at 17:59
  • Why would this not require template between :: and f in the case where f is a template? Commented Nov 3, 2016 at 18:24
  • @Yakk I was in the impression that type<dependent-type> is not dependent if it's template<typename> using type = int;, but I could be wrong. See open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1390 . When asking this question, I forgot about that DR I made long ago, but now I see that actually, it has not been resolved yet. The committee only clarified that they want it to be non-dependent. Apart from that, however, is anything else wrong with my snippet? Commented Nov 3, 2016 at 18:29

2 Answers 2

Reset to default
7

Expanding a parameter pack either should, or does, make an expression type dependent. Regardless of whether the things expanded are type dependent.

If it did not, there would be a gaping hole in the type dependency rules of C++ and it would be a defect in the standard.

So A<void(type<decltype(t)>...)>::f when t is a pack, no matter what tricks you pull in the void( here ) parts to unpack the t, should be a dependent type, and template is required before the f if it is a template.

In the case where t is not a pack, it is intended that type<decltype(t)> not be dependent (See http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1390), but the standard may or may not agree at this point (I think not?)

If compilers did "what the committee intended", then when t is not a pack:

A<void(type<decltype(t)>...)>::f<0>(1)

could mean

A<void(int...)>::f<0>(1)

which is

A<void(int, ...)>::f<0>(1)

and if f is a template (your code makes it an int, but I think swapping the two should work) this would be fine. But the standard apparently currently disagrees?

So if http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1390 was implemented, then you could swap your two A specializations. The void(T...,...) specialization should have a template<int> void f(int), and the T specialization should have a static const int.

Now in the case where A<> is dependent (on the size of a pack), ::f is an int and does not need template. In the case where A<> is not dependent, ::f is a template but does not need disambiguation.

We can replace the type<decltype(t)>... with:

decltype(sizeof(decltype(t)*))...

and sizeof(decltype(t)*) is of non-dependent type (it is std::size_t), decltype gives us a std::size_t, and the ... is treated as a old-school ... arg. This means void(std::size_t...) becomes a non-dependent type, so A<void(std::size_t...)> is not dependent, so ::f being a template is not a template in a dependent context.

In the case where t is a parameter pack with one element

decltype(sizeof(decltype(t)*))...

becomes

std::size_t

but in a dependent context (one copy per element in t pack). So we get

A<void(std::size_t)>::f

which is presumed to be a scalar value, so

A<void(std::size_t)>::f<0>(1)

becomes an expression evaluating to false.

(Chain of logic generated in a discussion with Johannes in comments in original question).

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

3 Comments

Nice, this even gives a solution that will not require template anymore. Should a bugreport be filed against clang for not requiring template, and for giving that weird A<void(int)> error message?
The "pack expansion makes it dependent"-DR is open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#2024
These are the Q/A for which it is worth to be active on StackOverflow. Thank you for the lesson. +1
4

Your second case is ill-formed; A<void(type<decltype(t)>...)>::f<0>(1) should be

A<void(type<decltype(t)>...)>::template f<0>(1)
//                             ~~~~~~~~~

For the first case, both compilers are behaving incorrectly; this was considered sufficiently confusing that CWG 1520 was raised to query the correct behavior; the conclusion was that pack expansion should be applied before alias substitution:

The latter interpretation (a list of specializations) is the correct interpretation; a parameter pack can't be substituted into anything, including an alias template specialization. CWG felt that this is clear enough in the current wording.

This is reminiscent of CWG 1558 (alias templates and SFINAE), which was fixed for C++14, but per the above even C++11 compilers are expected to get this correct, so it is disappointing that gcc and clang get it wrong (though in fairness they do behave correctly in simpler cases, including the motivating example in CWG 1520). Note that MSVC had a similar bug till recently; it is fixed in VS2015.

Your code (only in the first case) is correct; but as a workaround, you could alter your alias template to use and discard its template parameter, fixing your program for both compilers - of course that means that your CWG 1390 exploit will cease to be valid:

template<typename T> using type = decltype(((int(*)(T*))(0))(0)); // int

However, I don't think your CWG 1390 trick can work as presented, since even though the expansion-substitution of type<decltype(t)>... is not dependent on the types of t..., it is dependent on their number:

template<typename T> struct A { template<int> static void f(int) {} }; 
template<> struct A<void(int, int, int)> { static const int f = 0; };

As Yakk points out, it can be made to work if you swap the member function template and data member, since a data member is OK in dependent context.

Improve this answer

9 Comments

Nice trick with the "use and discard", to make both compilers happy with my first case. The need for template for the second case makes me sad. If I understand correctly, if open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1390 gets resolved as desired by the commitee-comment, then case 2 will be valid too, without template?
@JohannesSchaub-litb Yep.
When t is a pack ... with one element, type<decltype(t)>... expands to int, so the clause reduces to A<void(int)>::f<0>(1). In A<void(int)>, f is not a template, it is an int. So template is wrong here, as f is not a template. Then 0<0>(0) is just a sequence of 0<0 (which is false), then false>(1) (which is false). Or am I missing something here?
@Yakk the ellipsis is on the other side of the closing angle bracket.
@ecatmur Typo in comment. Fixed. Conclusion unchanged? Oh blast, it is a template here, not an int. Sigh. I got the specializations backwards.
|

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.