Perché il compilatore non può dedurre il tipo di modello dagli argomenti predefiniti?

Question

Mi ha sorpreso il seguente codice ha provocato un errore di could not deduce template argument for T:

struct foo 
{ 
    template <typename T> 
    void bar(int a, T b = 0.0f) 
    { 
    } 
}; 

int main() 
{ 
    foo a; 
    a.bar(5); 

    return 0; 
} 

Calling a.bar<float>(5) risolve il problema. Perché il compilatore non può dedurre il tipo dall'argomento predefinito?

Answer 1

In C++ 03, la specifica vieta esplicitamente l'argomento di default venga utilizzato per dedurre un argomento di template (C++ 03 §14.8.2/17):

A template type-parameter cannot be deduced from the type of a function default argument.

In C++ 11 , è possibile fornire un argomento modello predefinito per il modello di funzione:

template <typename T = float> 
void bar(int a, T b = 0.0f) { } 

L'argomento di modello predefinito è obbligatorio, tuttavia. Se l'argomento del modello predefinito non viene fornito, l'argomento della funzione predefinita non è ancora utilizzabile per la deduzione degli argomenti del modello. Specificamente, vale (C++ 11 14.8.2.5/5):

The non-deduced contexts are:

...

• A template parameter used in the parameter type of a function parameter that has a default argument that is being used in the call for which argument deduction is being done.

Answer 2

Una buona ragione potrebbe essere che

void foo(bar, xyzzy = 0); 

è simile ad una coppia di sovraccarichi.

void foo(bar b) { foo(b, 0); } 
foo(bar, xyzzy); 

Inoltre, a volte è vantaggioso refactoring in tale:

void foo(bar b) { /* something other than foo(b, 0); */ } 
foo(bar, xyzzy); 

Anche quando scritto come uno, è ancora come due funzioni in un unico, nessuno dei quali è "preferito" in alcun senso . Stai chiamando la funzione a un argomento; quello a due argomenti è effettivamente una funzione diversa. La notazione degli argomenti predefinita li fonde in uno solo.

Se il sovraccarico dovesse avere il comportamento che si sta richiedendo, quindi per coerenza dovrebbe funzionare nel caso in cui il modello è diviso in due definizioni. Ciò non avrebbe senso perché quindi la deduzione sarebbe tirare i tipi da una funzione non correlata che non viene chiamata! E se non fosse implementato, significherebbe che sovraccaricare diverse lunghezze di lista dei parametri diventa un "cittadino di seconda classe" rispetto a "default-argumenting".

È utile se la differenza tra sovraccarico e impostazione predefinita è completamente nascosta al client.

Answer 3

Ci sarebbero alcune difficoltà tecniche nel conseguirlo in generale. Ricordare che gli argomenti predefiniti nei modelli non vengono istanziati finché non sono necessari. Si consideri poi:

template<typename T, typename U> void f(U p = T::g()); // (A) 
template<typename T> T f(long, int = T()); // (B) 
int r = f<int>(1); 

Questo si risolve oggi eseguendo (tra l'altro) le seguenti operazioni:

1. tentativo di dedurre parametri di modello per i candidati (A) e (B); fallisce per (A), che viene quindi eliminato.
2. esegue la risoluzione di sovraccarico; (B) è selezionato
3. forma la chiamata, istanziare l'argomento di default

Al fine di dedurre da un argomento di default, tale argomento di default dovrebbe essere in sé istanziato prima di completare il processo di deduzione. Ciò potrebbe fallire, causando errori al di fuori del contesto di SFINAE. Ad esempio, un candidato che potrebbe essere del tutto inappropriato per una chiamata potrebbe innescare un errore.