So, I am trying to implement the dot product (https://en.wikipedia.org/wiki/Dot_product) in some flavour of modern C++ and came up with the following code:
#include <iostream>
template<class... Args>
auto dot(Args... args)
{
auto a = [args...](Args...)
{
return [=](auto... brgs)
{
static_assert(sizeof...(args) == sizeof...(brgs));
auto v1 = {args...}, i1 = v1.begin();
auto v2 = {brgs...}, i2 = v2.begin();
typename std::common_type<Args...>::type s = 0;
while( i1 != v1.end() && i2!= v2.end())
{
s += *i1++ * *i2++;
}
return s;
};
};
return a(std::forward<Args>(args)...);
}
int main()
{
auto a = dot(1,3,-5)(4,-2,-1);
std::cout << a << std::endl;
}
Online: https://gcc.godbolt.org/z/kDSney and also: cppinsights
The code above compiles and executes nicely with g++, however clang (and icc and msvc) choke on it:
clang++ ./funcpp.cpp --std=c++17
./funcpp.cpp:12:4: error: 'auto' deduced as 'std::initializer_list<int>' in declaration of
'v1' and deduced as 'const int *' in declaration of 'i1'
auto v1 = {args...}, i1 = v1.begin();
^ ~~~~~~~~~ ~~~~~~~~~~
./funcpp.cpp:28:11: note: in instantiation of function template specialization
'dot<int, int, int>' requested here
auto a = dot(1,3,-5)(4,-2,-1);
^
1 error generated.
Now, if I break up the definition of v1, v2, i1, i2 like:
auto v1 = {args...} ;
auto i1 = v1.begin();
auto v2 = {brgs...};
auto i2 = v2.begin();
clang and msvc have no problems, icc still chokes:
<source>(10): error: static assertion failed
static_assert(sizeof...(args) == sizeof...(brgs));
^
detected during instantiation of "auto dot(Args...) [with Args=<int, int, int>]" at line 30
compilation aborted for <source> (code 2)
Execution build compiler returned: 2
However if I remove the offending static_assert then icc has no issues compiling the code either.
And beside of the (typical) question: which is right and why :) the concrete question is:
According to [dcl.spec.auto] :
if the type that replaces the placeholder type is not the same in each deduction, the program is ill-formed
clang correctly identified that there are two different types defined in the line in question: 'auto' deduced as 'std::initializer_list<int>' in declaration of 'v1' and deduced as 'const int *' in declaration of 'i1' so I'd like to hear your opinions whether:
- did I hit some undocumented g++ extension considering this specific situation (not mentioned in https://gcc.gnu.org/onlinedocs/gcc-9.2.0/gcc/C_002b_002b-Extensions.html#C_002b_002b-Extensions) since g++ to my knowledge correctly handles the different types in an auto declaration list,
- or by any chance g++ did not deduce the two types to be different (... hm...)
- or something else?
Thanks for reading through this long question.
(As a bonus if someone could answer why icc fails on the static_assert would be great.)
std::forward<Args>(args)here? – Amaryauto v = { 1, 2, 3 }, i = v.begin();. Don't understand that it compiles the same insiede lambda. Minimal example: gcc.godbolt.org/z/a5XyxU. It even compiles inside a user-defined functor: gcc.godbolt.org/z/eYutyK, or a template function: gcc.godbolt.org/z/jnEYXh. – Compliancytemplate <typename T> void f(T a) { auto v = {a}, i = v.begin(); }, when invoked, e.g., asf(1);. Rewritten asvoid f(int a) { /* same body */ }causes compilation error. – Compliancy