Quindi, sto cercando di implementare il prodotto dot ( https://en.wikipedia.org/wiki/Dot_product ) in un certo stile del moderno C ++ e ho trovato il seguente codice:
#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 e anche: cppinsights
Il codice sopra si compila ed esegue bene con g++
, tuttavia clang
( icc
e msvc
) soffocare su di esso:
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.
Ora, se rompo la definizione di v1
, v2
, i1
, i2
come:
auto v1 = {args...} ;
auto i1 = v1.begin();
auto v2 = {brgs...};
auto i2 = v2.begin();
clang
e msvc
non ho problemi, icc
soffoca ancora:
<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
Tuttavia se mi tolgo l'incriminato static_assert
quindi icc
non ha problemi di compilazione del codice sia.
E accanto alla (tipica) domanda: quale è giusto e perché :) la domanda concreta è:
Secondo [dcl.spec.auto]
:
se il tipo che sostituisce il tipo di segnaposto non è lo stesso in ogni detrazione, il programma è mal formato
clang
correttamente identificato che ci sono due diversi tipi definiti nella riga in questione: 'auto' deduced as 'std::initializer_list<int>' in declaration of 'v1' and deduced as 'const int *' in declaration of 'i1'
quindi vorrei sentire le tue opinioni se:
- ho colpito qualche estensione g ++ non documentata considerando questa situazione specifica (non menzionata in https://gcc.gnu.org/onlinedocs/gcc-9.2.0/gcc/C_002b_002b-Extensions.html#C_002b_002b-Extensions ) da g ++ a mia conoscenza gestisce correttamente i diversi tipi in un elenco di dichiarazioni automatiche,
- o per caso g ++ non ha dedotto che i due tipi fossero diversi (... hm ...)
- o qualcos'altro?
Grazie per aver letto questa lunga domanda. (Come bonus se qualcuno potesse rispondere perché icc
fallire su static_assert
sarebbe fantastico.)
auto v = { 1, 2, 3 }, i = v.begin();
. Non capisco che compila lo stesso insiede lambda. Esempio minimo: gcc.godbolt.org/z/a5XyxU . Si compila anche all'interno di un funzione definita dall'utente: gcc.godbolt.org/z/eYutyK , o una funzione modello: gcc.godbolt.org/z/jnEYXh .
template <typename T> void f(T a) { auto v = {a}, i = v.begin(); }
, quando invocato, ad esempio, come f(1);
. Riscritto come void f(int a) { /* same body */ }
causa errore di compilazione.
std::forward<Args>(args)
qui?