Überlastung der Plus-Operator für einen Satz von Klassen

Question

den folgenden Codeausschnitt Bitte beachten Sie:

template<class E> 
class vector_expression 
{}; 

template<class Tuple> 
class vector 
    : public vector_expression<vector<Tuple>> 
{}; 

template<class E1, class E2, class BinaryOperation> 
class vector_binary_operation 
    : public vector_expression<vector_binary_operation<E1, E2, BinaryOperation>> 
{ 
public: 
    vector_binary_operation(E1&& e1, E2&& e2, BinaryOperation op) 
     : m_e1(e1), m_e2(e2), 
      m_op(op) 
    {} 

private: 
    E1 m_e1; 
    E2 m_e2; 
    BinaryOperation m_op; 
}; 

template<class E1, class E2> 
vector_binary_operation<E1, E2, std::plus<>> operator+(E1&& e1, E2&& e2) { 
    return{ std::forward<E1>(e1), std::forward<E2>(e2), std::plus<>{} }; 
} 

Der obige Code dass vector_binary_operation speichert Verweise auf Objekte mit Namen und macht Kopien für Provisorien gewährleistet. Das Problem ist die Schnittstelle von operator+, weil es tatsächlich diesen Operator für jeden Typ definiert. Was muss ich ändern, wenn ich die Funktionalität beibehalten möchte, aber nur den Operator für Typen definieren möchte, die von vector_expression abgeleitet sind?

Answer 1

Sie könnten SFINAE und std::is_base_of auf folgende Weise verwenden:

template<class E1, class E2> 
std::enable_if_t<std::is_base_of_v<vector_expression<std::decay_t<E1>>, std::decay_t<E1>>&& 
       std::is_base_of_v<vector_expression<std::decay_t<E2>>, std::decay_t<E2>>, 
       vector_binary_operation<std::decay_t<E1>, std::decay_t<E2>, std::plus<>>> 
operator+(E1&& e1, E2&& e2) { 
    return { 
      std::forward<std::decay_t<E1>>(e1), 
      std::forward<std::decay_t<E2>>(e2), 
      std::plus<>{} 
      }; 
} 

Live Demo

Answer 2

@ 101010 gab bereits das Prinzip. Ich erweitere es ein wenig, wie Sie diese Frage auch in einem Kommentar von einem meiner answers gestellt haben.

Wie ich denke, Sie sind eine Überlastung mehr Operatoren als operator+, dann ist es zweckmäßig, eine Züge Klasse zu schreiben, die überprüft, ob alle bestanden Typen sind vector_expression s:

template<typename ... Ts> struct is_vector_expression 
    : public std::false_type {}; 
template<typename T> struct is_vector_expression<T> 
    : public std::is_base_of<vector_expression<std::decay_t<T> >, std::decay_t<T> >::type {}; 
template<typename T, typename ... Ts> struct is_vector_expression<T, Ts ...> 
    : public std::integral_constant<bool, is_vector_expression<T>::value 
             && is_vector_expression<Ts ...>::value> {}; 

Wenn C 17 ++ verwenden, können Sie auch überspringen die variadic Vorlage Sachen und verwenden std::conjunction.

Als nächstes können Sie, dass in einem geeigneten Alias ​​wickeln, so dass Sie sich std::enable_if_t die ganze Zeit nicht schreiben:

template<typename ... Ts> 
using enable_for_vector_expression = std::enable_if_t<is_vector_expression<Ts...>::value>; 

Schließlich können Sie verwenden, die wie im folgenden Beispiel für alle überlastet Betreiber:

template<typename E1, typename E2, 
     typename = enable_for_vector_expression<E1, E2> > 
auto operator+(E1&& e1, E2&& e2) 
{ 
    //... 
}