Por que não inferir o parâmetro do modelo do construtor?

minha pergunta hoje é muito simples: por que o compilador não pode inferir parâmetros de modelo de construtores de classe, tanto quanto pode fazer a partir de parâmetros de função? Por exemplo, por que o código a seguir não poderia ser válido:

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
}

Como eu disse, entendo que isso não é válido, então minha pergunta é por que não é? Permitir isso criaria grandes lacunas sintáticas? Existe uma instância em que não se desejaria essa funcionalidade (onde inferir um tipo causaria problemas)? Estou apenas tentando entender a lógica por trás da permissão de inferência de template para funções, mas não para classes construídas adequadamente.

Acho que não é válido porque o construtor nem sempre é o único ponto de entrada da classe (estou falando sobre o construtor de cópia e operador =). Suponha que você esteja usando sua classe assim:

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

Não tenho certeza se seria tão óbvio para o analisador saber que tipo de modelo é MyClass pm;

Não tenho certeza se o que eu disse faz sentido, mas fique à vontade para adicionar algum comentário, essa é uma pergunta interessante.

C ++ 17

É aceito que C ++ 17 terá dedução de tipo a partir de argumentos do construtor.

Exemplos:

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

Artigo aceito .

Você não pode fazer o que pede por motivos que outras pessoas abordaram, mas você pode fazer o seguinte:

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

que para todos os efeitos e propósitos é a mesma coisa que você pede. Se você adora encapsulamento, pode tornar make_variable uma função de membro estático. Isso é o que as pessoas chamam de construtor nomeado. Portanto, ele não apenas faz o que você deseja, mas é quase chamado do que você deseja: o compilador está inferindo o parâmetro do modelo a partir do construtor (nomeado).

NB: qualquer compilador razoável irá otimizar o objeto temporário quando você escrever algo como

auto v = make_variable(instance);

Na era iluminada de 2016, com dois novos padrões em nosso currículo desde que essa pergunta foi feita e um novo chegando, o crucial é saber que os compiladores que suportam o padrão C ++ 17 compilarão seu código como está .

Dedução de argumento de modelo para modelos de classe em C ++ 17

Aqui (cortesia de uma edição de Olzhas Zhumabek da resposta aceita) está o artigo detalhando as mudanças relevantes no padrão.

Lidando com as preocupações de outras respostas

A resposta com melhor classificação atual

Esta resposta indica que "construtor de cópia e operator=" não saberia as especializações de modelo corretas.

Isso é um absurdo, porque o construtor de cópia padrão operator= existe apenas para um tipo de modelo conhecido :

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;

Aqui, como observei nos comentários, não há razão para MyClass *pmser uma declaração legal com ou sem a nova forma de inferência: MyClass não é um tipo (é um modelo), portanto, não faz sentido declarar um ponteiro de tipo MyClass. Esta é uma maneira possível de corrigir o exemplo:

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

Aqui, jápm é do tipo correto e, portanto, a inferência é trivial. Além disso, é impossível misturar tipos acidentalmente ao chamar o construtor de cópia:

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

Aqui, pmhaverá um ponteiro para uma cópia de m. Aqui, MyClassestá sendo construído a partir de m- que é do tipo MyClass<string>(e não do tipo inexistente MyClass). Assim, no ponto em que pm's tipo é inferido, não é suficiente informação para saber que o tipo de molde m, e portanto, o tipo de modelo de pm, é string.

Além disso, o seguinte sempre gerará um erro de compilação :

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

Isso ocorre porque a declaração do construtor de cópia não é modelada:

MyClass(const MyClass&);

Aqui, o tipo de modelo do argumento do construtor de cópia corresponde ao tipo de modelo da classe geral; isto é, quando MyClass<string>é instanciado, MyClass<string>::MyClass(const MyClass<string>&);é instanciado com ele, e quando MyClass<int>é instanciado, MyClass<int>::MyClass(const MyClass<int>&);é instanciado. A menos que seja explicitamente especificado ou um construtor com modelo seja declarado, não há razão para o compilador instanciar MyClass<int>::MyClass(const MyClass<string>&);, o que obviamente seria inapropriado.

A resposta de Cătălin Pitiș

Pitiș dá um exemplo deduzindo Variable<int>e Variable<double>, em seguida, afirma:

Eu tenho o mesmo nome de tipo (Variável) no código para dois tipos diferentes (Variável e Variável). Do meu ponto de vista subjetivo, isso afeta muito a legibilidade do código.

Conforme observado no exemplo anterior, Variableele próprio não é um nome de tipo, embora o novo recurso faça com que ele se pareça sintaticamente.

Pitiș então pergunta o que aconteceria se nenhum construtor fosse fornecido que permitiria a inferência apropriada. A resposta é que nenhuma inferência é permitida, porque a inferência é disparada pela chamada do construtor . Sem uma chamada de construtor, não há inferência .

Isso é semelhante a perguntar qual versão de fooé deduzida aqui:

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

A resposta é que esse código é ilegal, pelo motivo declarado.

Resposta de MSalter

Esta é, pelo que eu posso dizer, a única resposta que levanta uma preocupação legítima sobre o recurso proposto.

O exemplo é:

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

A questão principal é: o compilador seleciona o construtor inferido por tipo aqui ou o construtor de cópia ?

Experimentando o código, podemos ver que o construtor de cópia está selecionado. Para expandir o exemplo :

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

Não tenho certeza de como a proposta e a nova versão da norma especificam isso; parece ser determinado por "guias de dedução", que são um novo padrão de linguagem que ainda não entendo.

Também não sei por que a var4dedução é ilegal; o erro do compilador de g ++ parece indicar que a instrução está sendo analisada como uma declaração de função.

Ainda ausente: torna o código a seguir bastante ambíguo:

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

Supondo que o compilador suporte o que você pediu. Então este código é válido:

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

// Some code here

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

Agora, eu tenho o mesmo nome de tipo (Variável) no código para dois tipos diferentes (Variável e Variável). Do meu ponto de vista subjetivo, isso afeta muito a legibilidade do código. Ter o mesmo nome de tipo para dois tipos diferentes no mesmo namespace parece enganoso para mim.

Atualização posterior: Outra coisa a considerar: especialização de modelo parcial (ou total).

E se eu me especializar em Variável e não fornecer nenhum construtor como você espera?

Então eu teria:

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

Então eu tenho o código:

Variable v( 10);

O que o compilador deve fazer? Use a definição de classe de Variável genérica para deduzir que é Variável e descubra que Variável não fornece um construtor de parâmetro.

Os padrões C ++ 03 e C ++ 11 não permitem a dedução do argumento do modelo a partir dos parâmetros passados ​​para o construtor.

Mas existe uma proposta para "Dedução de parâmetros de modelo para construtores", então você pode obter o que está pedindo em breve. Editar: na verdade, esse recurso foi confirmado para C ++ 17.

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

Muitas classes não dependem dos parâmetros do construtor. Existem apenas algumas classes que têm apenas um construtor e parametrizam com base no (s) tipo (s) deste (s) construtor (es).

Se você realmente precisa de inferência de modelo, use uma função auxiliar:

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);
}

A dedução de tipos é limitada às funções de modelo no C ++ atual, mas há muito se percebeu que a dedução de tipos em outros contextos seria muito útil. Conseqüentemente, C ++ 0x's auto.

Embora exatamente o que você sugere não seja possível em C ++ 0x, o seguinte mostra que você pode chegar bem perto:

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>
}

Você está certo, o compilador poderia adivinhar facilmente, mas não está no padrão ou C ++ 0x até onde eu sei, então você terá que esperar pelo menos mais 10 anos (padrões ISO taxa fixa de retorno) antes que os fornecedores de compiladores adicionem este recurso

Vejamos o problema com referência a uma classe com a qual todos deveriam estar familiarizados - std :: vector.

Em primeiro lugar, um uso muito comum de vetor é usar o construtor que não leva parâmetros:

vector <int> v;

Nesse caso, obviamente, nenhuma inferência pode ser realizada.

Um segundo uso comum é criar um vetor pré-dimensionado:

vector <string> v(100);

Aqui, se a inferência fosse usada:

vector v(100);

obtemos um vetor de ints, não de strings, e presumivelmente não é dimensionado!

Por último, considere os construtores que usam vários parâmetros - com "inferência":

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

Qual parâmetro deve ser usado para inferência? Precisaríamos de alguma forma de dizer ao compilador que deveria ser o segundo.

Com todos esses problemas para uma classe tão simples quanto vetorial, é fácil ver por que a inferência não é usada.

Fazendo do ctor um modelo, a variável pode ter apenas uma forma, mas vários ctors:

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;         
}

Vejo? Não podemos ter vários membros Variable :: data.

Consulte The C ++ Template Argument Deduction para obter mais informações sobre isso.