なぜC++でテンプレートタイプが割り当てられないのですか？

Question

int x = fromString("test")：は 'ValueTypeに'

int x = fromString<int>("test")のためのテンプレート引数を推定できませんでした：

を期待通りに正常に動作し、なぜここにコンパイラ闘争はいますか？私は、この愚かな例だけでなく、あらゆる種類の本当のテンプレート関数でそれを見ることができます。それは言語の特徴でなければなりませんが、何ですか？

Answer 1

C++は戻り値の型推論を行いません。すなわち、それがintに代入されているという事実は、テンプレートパラメータの減算には使用されません。

（他の誰かがすでに過負荷にキャスト溶液を提示するので、編集を削除しました。）

Answer 2

あなたのテンプレートが自動的にあなたがここでそれを追加する必要が理由である推定することはできませんテンプレートの戻り値の型を持っているように見えます。例えば悪い選択に加えて

Answer 3

（おそらくint x = to<int>("1235")ではなくtoStringを持っていることは理にかなっています）、問題は、[1]戻り値の型は、オーバーロードの解決や型推論^{に参加しないということです。}

// assuming template <typename T> T to(std::string): 
// 
f(to("123"));   // where there are two overloads f(int), f(double) 
int x = 1.5 * to("123"); // T == int? T == double? 
to("123");    // now what? returned object can be ignored! 

ので、決定は戻り値の型は、オーバーロードの解決や型推論に参加しないことである。この理由は、式が戻り値の型が推論することができない多くの場所で使用することができるということです。

^[1]このルールには1つの例外があります。これは、オーバーロードが宛先ポインタまたは明示的キャストのいずれかによって選択される必要がある複数のオーバーロードを伴う関数ポインタの評価ですが、他のコンテキストでは使用されません。

void f(); 
void f(int); 
void g(void (*)()); 
void g(void (*)(int)); 

void (*p1)() = &f;  // overload selected based on destination type 
void (*p2)(int) = &f; 
g((void (*)(int))&f); // overload selected based on explicit cast 

Answer 4

戻り値の型に基づいて推論することはできません。ただし、オーバーロードされたキャスト演算子を使用して、同様の構文を使用して回避策を実装することができます

#include <iostream> 
#include <sstream> 
#include <string> 
using namespace std; 

class FromString{ 
private: 
    string m_data; 
public: 
    FromString(const char*data) : m_data(data) {} 

    template<typename T> 
    operator T(){ 
     T t; 
     stringstream ss(m_data); 
     ss >> t; 
     return t; 
    } 

}; 

template<> FromString::operator bool(){ 
    return (m_data!="false"); //stupid example 
} 

int main(){ 

    int ans = FromString("42");  
    bool t = FromString("true"); 
    bool f = FromString("false"); 

    cout << ans << " " << t << " " << f << endl; 

    return 0; 
} 

出力：機能の

42 1 0 

Answer 5

戻り値の型は、オーバーロードの解決ではなく、他の方法に依存していますまわり。 operator=は通常明示的なoperator=が定義されている場合を除いて（スタンドアロンとしてもメンバとしても関係なく）、等しいLHS/RHS引数タイプに対してのみ存在します。operator=は通常、同じ引数タイプに対してのみ存在します。operator=

したがって、オーバーロードの解像度はoperator=(int &, int)で、関数からの戻り値がintに変換可能かどうかを確認します。 operator intのテンポラリを返す場合、operator intがtemplate<typename T> operator Tの一般形式であっても、これは許容可能な解像度です。

したがって：

template<typename T, typename U> 
U convert_impl(T const &t); 

template<typename T> 
struct convert_result { 
    convert_result(T const &t) : t(t) { } 
    template<typename U> operator U(void) const { return convert_impl<U>(t); } 
    T const &t; 
}; 

template<typename T> 
convert_result<T> convert(T const &t) { return t; }