Wie werden Operationen an zwei Vorlagen desselben Typs ordnungsgemäß ausgeführt?

Question

Ich erhalte den folgenden Fehler vom Compiler: error: no match for 'operator+' (operand types are 'Expected<double>' and 'Expected<double>') Erwartet ist entweder ein Typ oder eine Ausnahme.

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

Ich glaube an meine Header-Datei Ich habe genug getan, um sie zu überladen und sie zusammenzufügen. In der ersten erwarte ich, dass zwei Vorlagen zusammengefügt werden. In meiner Hauptdatei rufe ich einfach an:

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

Und dann wird der Fehler ausgelöst. Bevor ich Expected<U> op(Expected<T> t, Expected<V> v)\ Teil des Codes hinzugefügt habe, konnte ich kompilieren und ausführen, wenn ich eine Funktion namens operator T() { return value(); } hätte, die implizit die Expected<T> auf welchen Typ auch immer übergeben wurde. Allerdings erkannte ich, dass meine apply Funktion wurde nie verwendet. Nicht nur das, wenn ich den Typ von 10 überprüfe, wurde ich ein double anstelle eines Expected<double> zurückgegeben, also beseitigte ich die operator T() Funktion, und der Compiler informierte mich, dass es nicht weiß, wie man zwei Expected<T> zusammen addiert.

Wie gehe ich vor, um diesen Fehler zu beheben? Ich habe mir den ganzen Tag den Kopf dagegengeschlagen.

Answer 1

Die Körper der Vorlagenfunktionen werden niemals zum Ableiten von Vorlagenparametern verwendet. U kann nicht von den Argumenten abgeleitet werden, so dass Ihre + Überladungen ignoriert werden.

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

Dies wird nicht kompilieren, aber das ist, weil Sie falsch apply schrieb. Eine std::function ist kein Lambda, und ein Lambda ist kein std::function. Wenn Sie den Typ einer std::function 999/1000 Male herleiten, die Sie vermasseln, ist, weil std::function über Art Löschung ist und Abzug über Typenabzug ist, und das sind entgegengesetzte Konzepte.

Noch wichtiger, Sie komponieren sie rückwärts, und sie komponieren nicht so.

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

oder etwas ähnliches.