テンプレート型のC++オペレータオーバーロードでエラーが発生する

Question

私はこれを最小限の検証可能な例にする方法に苦労していますが、どうやってそれを行うのか考えることはできません。私は一緒に追加しようとしている2つの予想されるタイプがあります。予想されるデータ型は、int、doubleなどのデータ型にすることができます。例外でもかまいません。理論的には、例外を持つデータ型を追加することができなければなりません。値を求めても、プログラムを正常に実行することができます。プログラムをクラッシュさせずに例外を返す必要があります。

このプログラムを実行しようとするたびに、何処から始めても何もわからないエラーメッセージが数百行あります。私が見ているエラーはno matching function for call to 'operator+(double&,double&)です。これが正しいかどうかわかりません。 2つのExpectedを一緒に追加するには、型自体を追加したくありません。最後に、Expectedを追加して返され、Expectedを取得したいと思います。

私は本当にここにこだわっていますが、私はapplyの機能が正しく実装されていないと言われましたが、正にその理由がわかりません。私は間違って何をしていますか？

#include <stdexcept> 
#include <exception> 
#include <functional> 
#include <variant> 

template<typename T> 
class Expected 
{ 

public: 
    Expected(T t) : state(t), valid(true){} 
    Expected(std::exception_ptr e) : state(e), valid(false){} 
    Expected(std::exception e) : state(std::make_exception_ptr(e)), valid(false){} 

    T value() const 
    { 
     if(valid) return std::get<T>(state); 
     std::rethrow_exception(std::get<std::exception_ptr>(state)); 
    } 

    bool isValid() 
    { 
     if(valid) return true; 
     return false; 
    } 

    template<typename U> 
    Expected<U> apply(std::function<U(T)> f) 
    { 
     if(!valid) return std::get<std::exception_ptr>(state); 
     try 
     { 
      return f(std::get<T>(state)); 
     } 
     catch(...) 
     { 
      return std::current_exception(); 
     } 
    } 
private: 

    std::variant<T, std::exception_ptr> state; 
    bool valid; 

}; 

template<typename T> 
std::ostream& operator<< (std::ostream& o, Expected<T> e) 
{ 
    try 
    { 
     o << e.value(); 
    } 
    catch(std::exception &a) 
    { 
     o << a.what(); 
    } 
    catch(...) 
    { 
     o << "Unexpected Error"; 
    } 

    return o; 
} 

template<typename T, typename V> 
auto operator+(Expected<T> t, Expected<V> v) 
{ 
    return t.apply([&](T myT){return operator+(myT,v);}); 
} 
template<typename T, typename V> 
auto operator+(Expected<T> t, V v) 
{ 
    return t.apply([&](T myT){return operator+(myT,v);}); 
} 
template<typename T, typename V> 
auto operator+(V v, Expected<T> t) 
{ 
    return t.apply([&](T myT){return operator+(v,myT);}); 
} 

int main() 
{ 
    Expected<int> a = 1; 
    Expected<int> b = 2; 

    std::cout << a + b << std::endl; 
} 

Answer 1

は、最初の問題の減少した例です：

int main() { 
    operator+(1, 2); // error 
} 

あなたが名前で組み込み演算子を呼び出すことはできません。オペレーターによってのみ呼び出すことができます。さらに、演算子を使用するだけで、とにかく読みやすくなります。そのようにしてください。 +を使用してください。 （コードの一部で、おそらくoperator+の代わりにopを使用しています）。ここで

---

は、第二の問題の減少した例です：

template <typename T> 
struct X { 
    template<typename U> 
    U apply(std::function<U(T)> f); 
}; 

int main() { 
    X<int>{}.apply([](int){return 2.0;}); // error 
} 

は基本的に、はstd::functionを推測することはほとんど常に間違っています。このラムダはであり、std::functionではなく、はであり、std::function<double(int)>ではありません。あなたがしたいことは、ほとんどの場合、任意の呼び出し可能なものを推論し、メタ関数を使用して結果を判定します。

template <typename T> 
struct X { 
    template <typename F, typename U = std::invoke_result_t<F&, T>> 
    U apply(F f); 
}; 

Answer 2

まずオフ：一般的に、あなたはあまりにも多くのエラーを取得している場合、あなたは、コード内の1つの問題に至るまでですまで（つまり、まだ複数として報告することができ、いくつかのコードを除外して、テストケースを簡素化エラー、しかし）。そのエラーを理解するか、具体的なことを聞​​かせてください。この場合、これはoperator +という1つのオーバーロードで開始することを意味し、operator <<はありません。

---

ここには複数の問題があります。先ず、なぜ論理a + bの代わりにoperator+ (a, b)と呼んでいますか？これは、実際には、operator+関数が2つのdoubleを取っていないため、質問で明示的に言及したエラーが発生します。組み込み演算子+は関数ではなく、そのように呼び出すことはできません。

第2の問題は、ラムダ式の型がstd::functionではないため、テンプレートパラメータUがapplyであることをラムダ式から推論できないことです。これは、あなたがそれのための明示的なテンプレート引数を提供しなければならないことを意味：

return t.template apply<decltype(std::declval<T>() + v)>([&](T myT){return myT + v;}); 

この変更はoperator +のすべての3つのオーバーロードで発生する必要があります（私は第三過負荷に未知のopを想定することは奇妙なタイプミスで、実際にもする必要があります+と呼んでください）。

キーワードがapplyより前に必要であることに注意してください。依存コンテキストで使用されているためです。

Barry's answerは、std::functionを完全に取り除くことにより、より良いアプローチを提供することに注意してください。

最後に、#include <iostream>が見つかりません。

これらの変更がすべて行われた場合、コード[works]。ここで