Klirren nicht schließen nicht Template-Argument in variadische Template-Funktion mit varargs

Question

den Code vor:

#include <tuple> 

template<class... Args, class T> 
T method(std::tuple<Args...>, Args..., T, ...) { 
    return T(); 
} 

int main() { 
    method(std::make_tuple<int, float, double>(1, 1.0f, 1.0), 
     1, 1.0f, 1.0, 1); 
} 

g++ seit 4.9 hat kein Problem damit zu kompilieren. clang++ auf der anderen Seite liefert einen Fehler:

main.cpp:9:5: error: no matching function for call to 'method' 
    method(std::make_tuple<int, float, double>(1, 1.0f, 1.0), 
    ^~~~~~ 
main.cpp:4:3: note: candidate template ignored: couldn't infer template argument 'T' 
T method(std::tuple<Args...>, Args..., T, ...) { 
^
1 error generated. 

Welche Compiler ist richtig?

Answer 1

Der Code ist schlecht formatiert. Beide Compiler nicht korrekt kompilieren:

#include <tuple> 

template<class... Args, class T> 
T method(std::tuple<Args...>, Args..., T) { 
    return T(); 
} 

int main() { 
    method(std::make_tuple<int, float, double>(1, 1.0f, 1.0), 
     1, 1.0f, 1.0, 1); 
} 

Wir haben von [temp.deduct.call], Hervorhebung von mir:

When a function parameter pack appears in a non-deduced context (14.8.2.5), the type of that parameter pack is never deduced.

Args... erscheint in einem nicht abgeleitet Kontext, da aus [temp .deduct.type]:

The non-deduced contexts are: [...] A function parameter pack that does not occur at the end of the parameter-declaration-list.

so durch den genauen Wortlaut der Norm, Args... darf nicht geschlossen werden, so dass Sie es ausdrücklich vorsehen müssen - die nach wie vor in diesem Fall ist wirklich nicht möglich zu fällen T.

Aber in diesem Fall erscheint Args... sowohl in einem abgeleiteten und nicht abgeleiteten Kontext - es soll nichts Args... vom tuple Argumente als {int, float, double} abgeleitet verhindert wird aus werden und dann einfach wieder mit, dass für die variadische Argumente herzuzuleiten und dann am Ende T als int abzuleiten.

Aber dieser vorgeschlagene Prozess würde mit dem typischen Deduktionsprozess in Konflikt geraten, wo wir jedes Parameter/Argument-Paar unabhängig behandeln. In diesem Fall hängt der Abzug auf T sehr stark von Abzug auf Args... aus dem tuple<> Parameter/Argument-Paar.

Wenn Sie einfach den Bestell Flip:

template <class... Args, class T> 
T method(std::tuple<Args...>, T, Args...) { ... } 

dann beide Compiler kompilieren.

Ich habe keine Ahnung, warum gcc das ursprüngliche Beispiel mit Varargs akzeptiert. Das ist eindeutig falsch.

Außerdem, wenn Sie die Template-Parameter Spezifikation Flip, so dass Sie T, ohne Abzug angeben können, dann akzeptiert Klirren aber gcc ablehnt:

template<class T, class... Args> 
T method(std::tuple<Args...>, Args..., T) { 
    return T(); 
} 

int main() { 
    method<int>(std::make_tuple<int>(1), 1, 1); 
} 

Ich würde diese wohlgeformt sein erwarten - Args... kann abgeleitet werden und T muss nicht sein. Die Formulierung "niemals abgeleitet" ist meiner Meinung nach fraglich.