コンストラクタからテンプレートパラメータを推測しないのはなぜですか？

今日の私の質問は非常に単純です：コンパイラーがクラスコンストラクターからテンプレートパラメーターを推測できないのはなぜですか？たとえば、次のコードが有効でなかった理由：

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
}

私が言うように、これは有効ではないことを理解しているので、私の質問はなぜそうではないのですか？これを許可すると、主要な構文上の穴が作成されますか？この機能が不要なインスタンスはありますか（タイプを推測すると問題が発生します）？関数のテンプレート推論を許可する背後にあるロジックを理解しようとしていますが、適切に構築されたクラスではありません。

コンストラクタは常にクラスの唯一のエントリポイントではないため、これは有効ではないと思います（私はコピーコンストラクタとoperator =について話しています）。したがって、次のようにクラスを使用しているとします。

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

MyClass pmがどのテンプレートタイプであるかをパーサーが知ることがそれほど明白かどうかはわかりません。

私が言ったことが意味を成しているかどうかはわかりませんが、コメントを自由に追加してください。それは興味深い質問です。

C ++ 17

C ++ 17がコンストラクターの引数から型の推論を受けることは認められています。

例：

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

受理された論文。

他の人が対処した理由のためにあなたが求めることを行うことはできませんが、これを行うことができます：

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

すべての意図と目的のためにあなたが求めるものと同じです。カプセル化が好きな場合は、make_variableを静的メンバー関数にすることができます。これが、名前付きコンストラクタと呼ばれるものです。したがって、それはあなたが望むことをするだけでなく、それはほとんどあなたが望むものと呼ばれます：コンパイラは（名前付き）コンストラクタからテンプレートパラメータを推論します。

注意：あなたが次のようなものを書くとき、合理的なコンパイラーは一時オブジェクトを最適化します

auto v = make_variable(instance);

2016年の賢明な時代に、この質問が出されてから2つの新しい標準が登場し、すぐに新しい標準が登場したため、C ++ 17標準をサポートするコンパイラがコードをそのままコンパイルすることを知っておくことが重要です。

C ++ 17でのクラステンプレートのテンプレート引数の控除

ここに（承認された回答のOlzhas Zhumabekによる編集の礼儀）は、規格への関連する変更を詳述した論文です。

他の回答からの懸念への対処

現在の最高評価の答え

この回答は、「コピーコンストラクターとoperator=」は正しいテンプレートの特殊化を知らないことを指摘しています。

標準のコピーコンストラクターoperator= が存在し、既知のテンプレートタイプに対してのみ存在するため、これはナンセンスです。

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;

私はコメントで述べたようにここでは、存在しない理由のためのMyClass *pm推論の新しいフォームの有無にかかわらず、法的宣言すべき：MyClass タイプではありません（それはテンプレートだ）、それはのポインタを宣言しても意味がありませんので、タイプMyClass。この例を修正する方法の1つを次に示します。

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

ここでpmは、すでに正しいタイプであるため、推論は簡単です。さらに、コピーコンストラクターを呼び出すときに誤って型を混在させることはできません。

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

ここでpmは、のコピーへのポインタになりますm。ここでMyClassは、からコピーが構築されています。mこれはタイプですMyClass<string>（存在しないタイプではありませんMyClass）。したがって、pmのタイプが推定される時点では、のテンプレートタイプ、つまりのテンプレートタイプがmであることを知るのに十分な情報pmがありstringます。

さらに、次の場合は常に コンパイルエラーが発生します。

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

これは、コピーコンストラクターの宣言がテンプレート化されていないためです。

MyClass(const MyClass&);

ここで、copy-constructor引数のtemplate-typeは、クラス全体のtemplate-typeと一致しています。すなわち、時にMyClass<string>インスタンス化され、MyClass<string>::MyClass(const MyClass<string>&);それをインスタンス化され、そしてときにMyClass<int>インスタンス化され、MyClass<int>::MyClass(const MyClass<int>&);インスタンス化されます。明示的に指定されていないか、テンプレート化されたコンストラクターが宣言されていない限り、コンパイラーがをインスタンス化する理由はありませんMyClass<int>::MyClass(const MyClass<string>&);。これは明らかに不適切です。

CătălinPitișによる回答

Pitişは推測する例を示しますVariable<int>とVariable<double>、次に述べ、：

2つの異なる型（変数と変数）のコードに同じ型名（変数）があります。私の主観的な観点から、それはコードの可読性にかなり影響します。

前の例で述べたように、新機能により構文的には1つのように見えますVariableが、それ自体は型名ではありません。

次に、ピチッチは、適切な推論を可能にするコンストラクターが提供されない場合にどうなるかを尋ねます。答えは、推論はコンストラクター呼び出しによってトリガーされるため、推論は許可されないということです。コンストラクタ呼び出しがなければ、推論はありません。

これは、fooここで推定されたのバージョンを尋ねるのと同じです。

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

答えは、述べられた理由により、このコードは違法であるということです。

MSalterの回答

これは、私が知る限り、提案された機能に関する正当な懸念を提起する唯一の答えです。

例は次のとおりです。

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

重要な問題は、コンパイラーがここで型推論されたコンストラクターを選択するか、それともコピーコンストラクターを選択するかです。

コードを試してみると、コピーコンストラクターが選択されていることがわかります。例を拡張するには：

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

提案と標準の新しいバージョンがこれをどのように指定しているかはわかりません。それは私がまだ理解していない新しい標準のビットである「控除ガイド」によって決定されるようです。

var4控除が違法である理由もわかりません。g ++からのコンパイラエラーは、ステートメントが関数宣言として解析されていることを示しているようです。

まだ足りない：次のコードがあいまいになります。

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

コンパイラがあなたの要求をサポートするとします。その後、このコードは有効です：

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

// Some code here

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

これで、2つの異なる型（変数と変数）のコードに同じ型名（変数）があります。私の主観的な観点から、それはコードの可読性にかなり影響します。同じ名前空間の2つの異なる型に同じ型名を付けると、誤解を招くように見えます。

後の更新： 考慮すべきもう1つのこと：テンプレートの部分的（または完全）特殊化。

変数を特化して、期待するようなコンストラクターを提供しない場合はどうなりますか？

だから私は持っているでしょう：

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

それから私はコードを持っています：

Variable v( 10);

コンパイラは何をすべきですか？汎用のVariableクラス定義を使用してVariableであると推定し、Variableが1つのパラメーターコンストラクターを提供していないことを発見しますか？

C ++ 03およびC ++ 11標準では、構成子に渡されるパラメーターからのテンプレート引数の推定は許可されていません。

しかし、「コンストラクタのテンプレートパラメータの控除」の提案があるので、すぐに求めているものを手に入れることができます。編集：実際、この機能はC ++ 17で確認されています。

参照：http : //www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3602.htmlおよびhttp://www.open-std.org/jtc1/sc22/wg21/docs/ papers / 2015 / p0091r0.html

多くのクラスはコンストラクターパラメーターに依存しません。コンストラクターが1つだけあり、このコンストラクターのタイプに基づいてパラメーター化するクラスはわずかです。

テンプレートの推論が本当に必要な場合は、ヘルパー関数を使用します。

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

型の推論は現在のC ++のテンプレート関数に限定されていますが、他のコンテキストでの型の推論は非常に役立つことが長い間認識されてきました。したがって、C ++ 0x autoです。

一方で、正確に何を示唆すると、C ++ 0xのではできません、次のショーでは、あなたはかなり近づくことができます。

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

あなたは正しいですが、コンパイラは簡単に推測できますが、私が知る限り、標準またはC ++ 0xにはないため、コンパイラプロバイダがこの機能を追加する前に、少なくとも10年（ISO標準の固定回転率）待つ必要があります。

std :: vectorを使い慣れているクラスを参照して、問題を見てみましょう。

まず、非常に一般的なベクターの使用法は、パラメーターを取らないコンストラクターを使用することです。

vector <int> v;

この場合、明らかに推論は実行できません。

2番目の一般的な使用法は、事前にサイズ設定されたベクトルを作成することです。

vector <string> v(100);

ここで、推論が使用された場合：

vector v(100);

文字列ではなく整数のベクトルを取得しますが、おそらくサイズが設定されていません！

最後に、「推論」を使用して、複数のパラメーターを取るコンストラクターを検討してください。

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

推論に使用するパラメーターはどれですか？コンパイラーに2番目のコンパイラーであることを伝える何らかの方法が必要です。

ベクトルのように単純なクラスのこれらすべての問題により、推論が使用されない理由が簡単にわかります。

Actorをテンプレートにすることで、Variableは1つの形式のみを持つことができますが、さまざまな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;         
}

見る？Variable :: dataメンバーを複数持つことはできません。

詳細については、C ++テンプレート引数の控除を参照してください。