Perché non dedurre il parametro del modello dal costruttore?

la mia domanda oggi è piuttosto semplice: perché il compilatore non può dedurre i parametri del modello dai costruttori di classi, così come può fare dai parametri delle funzioni? Ad esempio, perché il codice seguente non può essere valido:

template<typename obj>
class Variable {
      obj data;
      public: Variable(obj d)
              {
                   data = d;
              }
};

int main()
{
    int num = 2;
    Variable var(num); //would be equivalent to Variable<int> var(num),
    return 0;          //but actually a compile error
}

Come ho detto, capisco che questo non è valido, quindi la mia domanda è: perché non lo è? Consentire ciò creerebbe dei grandi buchi sintattici? C'è un'istanza in cui non si vorrebbe questa funzionalità (in cui inferire un tipo causerebbe problemi)? Sto solo cercando di capire la logica alla base dell'autorizzazione dell'inferenza dei modelli per le funzioni, ma non per le classi costruite adeguatamente.

Penso che non sia valido perché il costruttore non è sempre l'unico punto di ingresso della classe (sto parlando di copia costruttore e operatore =). Quindi supponi di usare la tua classe in questo modo:

MyClass m(string s);
MyClass *pm;
*pm = m;

Non sono sicuro che sarebbe così ovvio per il parser sapere quale tipo di modello è MyClass pm;

Non sono sicuro che quello che ho detto abbia senso, ma sentiti libero di aggiungere qualche commento, questa è una domanda interessante.

C ++ 17

È accettato che C ++ 17 avrà la deduzione del tipo dagli argomenti del costruttore.

Esempi:

std::pair p(2, 4.5);
std::tuple t(4, 3, 2.5);

Documento accettato .

Non puoi fare ciò che chiedi per motivi che altre persone si sono rivolti, ma puoi farlo:

template<typename T>
class Variable {
    public: Variable(T d) {}
};
template<typename T>
Variable<T> make_variable(T instance) {
  return Variable<T>(instance);
}

che a tutti gli effetti è la stessa cosa che chiedi. Se ami l'incapsulamento, puoi rendere make_variable una funzione membro statica. Questo è ciò che la gente chiama costruttore denominato. Quindi non solo fa quello che vuoi, ma è quasi chiamato come vuoi: il compilatore sta deducendo il parametro del modello dal costruttore (denominato).

NB: qualsiasi compilatore ragionevole ottimizzerà l'oggetto temporaneo quando scrivi qualcosa di simile

auto v = make_variable(instance);

Nell'era illuminata del 2016, con due nuovi standard sotto la cintura da quando è stata posta questa domanda e uno nuovo dietro l'angolo, la cosa cruciale da sapere è che i compilatori che supportano lo standard C ++ 17 compileranno il tuo codice così com'è .

Deduzione degli argomenti del modello per i modelli di classe in C ++ 17

Qui (per gentile concessione di una modifica di Olzhas Zhumabek della risposta accettata) è il documento che dettaglia le modifiche rilevanti allo standard.

Affrontare le preoccupazioni da altre risposte

L'attuale risposta più votata

Questa risposta sottolinea che "copia costruttore e operator=" non conoscerebbero le corrette specializzazioni del modello.

Questo non ha senso, perché il costruttore di copia standard operator= esiste solo per un tipo di modello noto :

template <typename T>
class MyClass {
    MyClass(const MyClass&) =default;
    ... etc...
};

// usage example modified from the answer
MyClass m(string("blah blah blah"));
MyClass *pm;   // WHAT IS THIS?
*pm = m;

Qui, come ho notato nei commenti, non c'è motivo per MyClass *pmessere una dichiarazione legale con o senza la nuova forma di inferenza: MyClass non è un tipo (è un modello), quindi non ha senso dichiarare un puntatore di tipo MyClass. Ecco un modo possibile per correggere l'esempio:

MyClass m(string("blah blah blah"));
decltype(m) *pm;               // uses type inference!
*pm = m;

Qui pmè già del tipo corretto, quindi l'inferenza è banale. Inoltre, è impossibile mescolare accidentalmente i tipi quando si chiama il costruttore di copie:

MyClass m(string("blah blah blah"));
auto pm = &(MyClass(m));

Qui, pmsarà un puntatore a una copia di m. Qui, MyClassviene costruito da copia, mche è di tipo MyClass<string>(e non di tipo inesistente MyClass). Quindi, nel punto in cui pmviene dedotto il tipo di, ci sono informazioni sufficienti per sapere che il tipo di modello di m, e quindi il tipo di modello di pm, è string.

Inoltre, quanto segue solleverà sempre un errore di compilazione :

MyClass s(string("blah blah blah"));
MyClass i(3);
i = s;

Questo perché la dichiarazione del costruttore di copia non è basata su modelli:

MyClass(const MyClass&);

Qui, il tipo di modello dell'argomento del costruttore di copia corrisponde al tipo di modello della classe nel suo complesso; cioè, quando MyClass<string>viene istanziato, MyClass<string>::MyClass(const MyClass<string>&);viene istanziato con esso, e quando MyClass<int>viene istanziato, MyClass<int>::MyClass(const MyClass<int>&);viene istanziato. A meno che non sia esplicitamente specificato o venga dichiarato un costruttore basato su modelli, non c'è motivo per il compilatore di istanziare MyClass<int>::MyClass(const MyClass<string>&);, il che sarebbe ovviamente inappropriato.

La risposta di Cătălin Pitiș

Pitiș fa un esempio deducendo Variable<int>e Variable<double>, quindi afferma:

Ho lo stesso nome di tipo (variabile) nel codice per due diversi tipi (variabile e variabile). Dal mio punto di vista soggettivo, influisce molto sulla leggibilità del codice.

Come notato nell'esempio precedente, di per Variablesé non è un nome di tipo, anche se la nuova funzionalità lo fa sembrare sintatticamente simile.

Pitiș chiede quindi cosa accadrebbe se non fosse fornito alcun costruttore che consentirebbe l'inferenza appropriata. La risposta è che non è consentita alcuna inferenza, perché l'inferenza viene attivata dalla chiamata al costruttore . Senza una chiamata al costruttore, non c'è inferenza .

Questo è simile a chiedere quale versione di fooviene dedotta qui:

template <typename T> foo();
foo();

La risposta è che questo codice è illegale, per il motivo dichiarato.

La risposta di MSalter

Questa è, per quanto ne so, l'unica risposta per sollevare una legittima preoccupazione sulla funzionalità proposta.

L'esempio è:

Variable var(num);  // If equivalent to Variable<int> var(num),
Variable var2(var); // Variable<int> or Variable<Variable<int>> ?

La domanda chiave è: il compilatore seleziona qui il costruttore dedotto dal tipo o il costruttore di copia ?

Provando il codice, possiamo vedere che il costruttore di copia è selezionato. Per espandere l'esempio :

Variable var(num);          // infering ctor
Variable var2(var);         // copy ctor
Variable var3(move(var));   // move ctor
// Variable var4(Variable(num));     // compiler error

Non sono sicuro di come la proposta e la nuova versione dello standard lo specifichino; sembra essere determinato da "guide alla deduzione", che sono un nuovo pezzo di standardese che ancora non capisco.

Inoltre, non sono sicuro del motivo per cui la var4detrazione è illegale; l'errore del compilatore da g ++ sembra indicare che l'istruzione viene analizzata come una dichiarazione di funzione.

Ancora mancante: rende il seguente codice abbastanza ambiguo:

int main()
{
    int num = 2;
    Variable var(num);  // If equivalent to Variable<int> var(num),
    Variable var2(var); //Variable<int> or Variable<Variable<int>> ?
}

Supponendo che il compilatore supporti ciò che hai chiesto. Allora questo codice è valido:

Variable v1( 10); // Variable<int>

// Some code here

Variable v2( 20.4); // Variable<double>

Ora, ho lo stesso nome del tipo (Variabile) nel codice per due diversi tipi (Variabile e Variabile). Dal mio punto di vista soggettivo, influisce molto sulla leggibilità del codice. Avere lo stesso nome di tipo per due tipi diversi nello stesso spazio dei nomi mi sembra fuorviante.

Aggiornamento successivo: un'altra cosa da considerare: specializzazione del modello parziale (o completa).

E se mi specializzo Variabile e non fornisco un costruttore come ti aspetti?

Quindi avrei:

template<>
class Variable<int>
{
// Provide default constructor only.
};

Quindi ho il codice:

Variable v( 10);

Cosa dovrebbe fare il compilatore? Utilizzare la definizione della classe Variabile generica per dedurre che si tratta di Variabile, quindi scoprire che Variabile non fornisce un costruttore di parametri?

Lo standard C ++ 03 e C ++ 11 non consente la deduzione dell'argomento del modello dai parametri passati al costitutore.

Ma esiste una proposta per la "deduzione dei parametri del modello per i costruttori", quindi potresti ottenere presto ciò che stai chiedendo. Modifica: in effetti, questa funzionalità è stata confermata per C ++ 17.

Vedere: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3602.html e http://www.open-std.org/jtc1/sc22/wg21/docs/ carte / 2015 / p0091r0.html

Molte classi non dipendono dai parametri del costruttore. Esistono solo poche classi che hanno un solo costruttore e parametrizzano in base ai tipi di questo costruttore.

Se hai davvero bisogno dell'inferenza del modello, usa una funzione di supporto:

template<typename obj>
class Variable 
{
      obj data;
public: 
      Variable(obj d)
      : data(d)
      { }
};

template<typename obj>
inline Variable<obj> makeVariable(const obj& d)
{
    return Variable<obj>(d);
}

La detrazione dei tipi è limitata alle funzioni del modello nell'attuale C ++, ma è stato a lungo capito che la deduzione del tipo in altri contesti sarebbe molto utile. Quindi C ++ 0x's auto.

Anche se esattamente ciò che suggerisci non sarà possibile in C ++ 0x, quanto segue mostra che puoi avvicinarti abbastanza:

template <class X>
Variable<typename std::remove_reference<X>::type> MakeVariable(X&& x)
{
    // remove reference required for the case that x is an lvalue
    return Variable<typename std::remove_reference<X>::type>(std::forward(x));
}

void test()
{
    auto v = MakeVariable(2); // v is of type Variable<int>
}

Hai ragione, il compilatore potrebbe facilmente indovinare, ma non è nello standard o C ++ 0x per quanto ne so, quindi dovrai aspettare almeno altri 10 anni (tasso di turn around fisso degli standard ISO) prima che i fornitori di compilatori aggiungano questa funzione

Diamo un'occhiata al problema con riferimento a una classe con cui tutti dovrebbero avere familiarità - std :: vector.

In primo luogo, un uso molto comune di vector è utilizzare il costruttore che non accetta parametri:

vector <int> v;

In questo caso, ovviamente, non è possibile eseguire alcuna inferenza.

Un secondo uso comune è creare un vettore pre-dimensionato:

vector <string> v(100);

Qui, se fosse usata l'inferenza:

vector v(100);

otteniamo un vettore di int, non stringhe, e presumibilmente non è dimensionato!

Infine, considera i costruttori che accettano più parametri, con "inferenza":

vector v( 100, foobar() );      // foobar is some class

Quale parametro dovrebbe essere utilizzato per l'inferenza? Avremmo bisogno di un modo per dire al compilatore che dovrebbe essere il secondo.

Con tutti questi problemi per una classe semplice come il vettore, è facile capire perché l'inferenza non viene utilizzata.

Rendendo il ctor un modello la variabile può avere una sola forma ma diversi ctor:

class Variable {
      obj data; // let the compiler guess
      public:
      template<typename obj>
      Variable(obj d)
       {
           data = d;
       }
};

int main()
{
    int num = 2;
    Variable var(num);  // Variable::data int?

    float num2 = 2.0f;
    Variable var2(num2);  // Variable::data float?
    return 0;         
}

Vedere? Non possiamo avere più membri Variable :: data.

Vedere la deduzione dell'argomento del modello C ++ per ulteriori informazioni su questo argomento .