如何在两个相同类型的模板上正确执行操作？

Question

我从编译器得到以下错误：error: no match for 'operator+' (operand types are 'Expected<double>' and 'Expected<double>')预期是一种类型或异常。

template<typename T> 
class Expected 
{ 
    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(); 
     } 
    } 
}; 


#define MixedMode(op)\ 
template<typename T, typename U, typename V>\ 
Expected<U> op(Expected<T> t, Expected<V> v)\ 
{\ 
    return t.apply([&](T myT){return op(v,myT);});\ 
}\ 
template<typename T, typename U, typename V>\ 
Expected<U> op(Expected<T> t, V v)\ 
{\ 
    return t.apply([&](T myT){return op(myT,v);});\ 
}\ 
\ 
template<typename T, typename U, typename V>\ 
Expected<U> op(V v, Expected<T> t)\ 
{\ 
    return t.apply([&](T myT){return op(v,myT);});\ 
}\ 


MixedMode(operator+) 

int main() 
{ 
    Expected<double> a; 
    Expected<double> b; 

    a + b; 
} 

我相信我的头文件我做的已经够让他们过载，并把它们相加。在第一个我期待两个模板添加在一起。在我的主文件中，我只是打电话：

Expected<double> a; 
Expected<double> b; 
std::cout << a + b << std::endl; 

然后错误被抛出。在我添加Expected<U> op(Expected<T> t, Expected<V> v)\部分代码之前，如果我有一个名为operator T() { return value(); }的函数，它将隐式地将Expected<T>转换为传入的任何类型，但我能够编译和运行。但是，我意识到我的apply函数从未被使用。不仅如此，当我检查a+b的类型时，我返回了double而不是Expected<double>，因此我取消了operator T()函数，编译器通知我它不知道如何将两个Expected<T>一起添加。

我该如何解决这个错误？我一整天都在殴打我。

Answer 1

模板函数的主体决不会用于推导模板参数。 U不能从参数中推导出来，所以你的+重载被忽略。

#define MixedMode(op)\ 
template<typename T, typename V>\ 
auto op(Expected<T> t, Expected<V> v)\ 
{\ 
    return t.apply([&](T myT){return op(v,myT);});\ 
}\ 
template<typename T, typename V>\ 
auto op(Expected<T> t, V v)\ 
{\ 
    return t.apply([&](T myT){return op(myT,v);});\ 
}\ 
template<typename T, typename V>\ 
auto op(V v, Expected<T> t)\ 
{\ 
    return t.apply([&](T myT){return op(v,myT);});\ 
} 

这将无法编译，但是那是因为你写的apply错了。

A std::function不是拉姆达，而拉姆达不是std::function。如果你正在推断你正在搞的std::function 999/1000次的类型，因为std::function是关于类型删除和扣除是关于类型扣除，并且那些是相反的概念。

更重要的是，你是在向后写作，而他们不是这样写的。

template<class F> 
Expected<std::invoke_result_t<F&,T&>> apply(F f){ 

或类似的东西。