Warum kann das Standardargument später nicht in den Vorlagenfunktionen hinzugefügt werden?

Question

C++ Standard Abschnitt 8.3.6.4 sagt, dass

Für Nicht-Template-Funktionen, Standardargumente später Erklärungen einer Funktion im gleichen Umfang aufgenommen in werden können. [...]

Aber meine Frage ist, warum es für Vorlagenfunktionen nicht erlaubt ist? Was ist der Grund dafür, das Hinzufügen von Standardargumenten in späteren Deklarationen im selben Gültigkeitsbereich für Vorlagenfunktionen nicht zuzulassen?

Betrachten Sie dieses Programm, das gut kompiliert. (Non Template-Funktion) (siehe Live-Demo here.)

#include <iostream> 

int f(int a,int b,int c=3); 
int f(int a,int b=9,int c); // default argument in middle, ok allowed 

int main() 
{ 
    f(3); 
    f(3,6); 
    f(3,6,9); 
    return 0; 
} 

int f(int a,int b,int c) 
{ 
    std::cout<<a<<' '<<b<<' '<<c<<'\n'; 
    return 0; 
} 

Aber nach nicht in der Zusammenstellung. (Template-Funktion) (siehe Live-Demo here.)

#include <iostream> 

template <typename T> 
void f(T a,int b,int c=3); 
template <typename T> 
void f(T a,int b=9,int c); // compiler error why??? 

int main() 
{ 
    f(3); 
    f(3,6); 
    f(3,6,9); 
    return 0; 
} 

template <typename T> 
void f(T a,int b,int c) 
{ 
    std::cout<<a<<' '<<b<<' '<<c<<'\n'; 
} 

Answer 1

Dies ist eine historische Einschränkung, die relativ früh im Standardisierungsprozess hinzugefügt wurde (in C++ 98, aber nicht im ARM).

Ich erinnere mich nicht an den genauen Grund (und auch nicht mein Kollege, der fast sicher war, als die Entscheidung getroffen wurde). Wie auch immer, ich habe eine Vermutung ...

Damals instanziierten alle Compiler die Templates, indem sie die Token durch das Parsen wiederholten. Einige analysieren überhaupt keine Vorlagen. Bedenken Sie:

template<class T> struct S { 
    T f(T); // (1) 
}; 
template<class T> T S<T>::f(T p = 42) { return p; } // (2) 
S<int> s; // Causes the "real" parsing of (1), but not (2). 
int r = s.f(); // (3) 

Bei Aufruf der Lösung (3), ältere Compiler daher oft nur Zugriff auf die instanziiert Erklärung hatte (1), während (2) wurde noch nicht wirklich analysiert (nur Token-gepuffert). Daher war diesen Compilern das hinzugefügte Standardargument in (3) nicht bekannt.

Ist verdächtige Vorsicht angebracht, beschließt das Komitee daher, generelle Standardargumente in Templates generell zu verbieten.

Diese Einschränkung ist wahrscheinlich heute weniger (technisch) gerechtfertigt, da andere Standardanforderungen seither dazu geführt haben, Vorlagen in ihrer generischen Form zu analysieren (obwohl MSVC dies beispielsweise immer noch nicht tut).Allerdings ist es immer noch ein wenig mühsam zu implementieren, da Standardargumente möglicherweise in verschiedenen Kontexten instanziiert werden müssen.

Answer 2

Weil es im Grunde unmöglich ist.

Um Ihr Ziel zu erreichen, muss der Compiler eine Funktion implementieren, die bei zwei Template-Funktionen zurückgibt, ob sie die gleiche Funktion haben oder nicht. Das Problem ist, dass diese Funktion nicht ausführbar ist.

Für reguläre Nicht-Template-Funktionen ist dies eine schreckliche Idee, aber immer noch machbar, weil Sie nur die Argumenttypen und Arbeit erledigt haben müssen.

Leider, für Vorlagenfunktionen, wird dies ... schwieriger. Bedenken Sie:

template<typename T> void f(T t); 
template<typename U> std::enable_if_t<std::is_same<U, int>::value> f(U u = U()); 

Sie können sehen, dass sie wahrscheinlich die gleiche Funktion erklären, wennT ist int. Sonst nicht. Es gibt problematischere Interaktionen mit Standardvorlagenargumenten und ähnlichen Dingen, aber kurz gesagt, dies wäre für Vorlagen nicht entscheidbar.