ermöglichen Bedingtes einen Operator Überlastung

Question

beachten Sie bitte folgende Code-Schnipsel:

template<class E> 
class vector_expression {}; 

template<class Tuple> 
class vector 
    : public vector_expression<vector<Tuple>> 
{ 
public: 
    using value_type = typename Tuple::value_type; 
    using size_type = typename Tuple::size_type; 
}; 

namespace detail 
{ 
    template<class E> 
    constexpr bool is_vector_expression_v = std::is_base_of_v<vector_expression<std::decay_t<E>>, std::decay_t<E>>; 

    template<class E, class = void> 
    struct value_type { using type = std::decay_t<E>; }; 
    template<class E> 
    struct value_type<E, std::enable_if_t<is_vector_expression_v<E>>> { using type = typename std::decay_t<E>::value_type; }; 

    template<class E> 
    using value_type_t = typename value_type<E>::type; 

    template<class E1, class E2, class BinaryOperation> 
    class vector_binary_operation 
    { 
    public: 
     using value_type = std::result_of_t<BinaryOperation(value_type_t<E1>, value_type_t<E2>)>; 
    }; 
} 

Wie kann ich bedingt eine operator[](size_type i) für vectory_binary_operation aktivieren? Die Idee ist, zurückzukehren ...

• m_op(m_e1[i], m_e2[i]) iff m_e1 und m_e2 sind beide vector_expression s
• m_op(m_e1, m_e2[i]) iff m_e1 ist kein vector_expression
• m_op(m_e1[i], m_e2) iff m_e2 ist kein vector_expression

Wie kann ich das machen? Ich habe versucht, den Operator als template<class F1 = E1, class F2 = E2> zu behandeln und std::enable_if_t<is_vector_expression_v<F1> && is_vector_expression_v<F2> zu verwenden (und so weiter). Aber das ergibt die Compiler-Fehlermeldung kein Typ namens 'type' in 'std :: enable_if'; 'enable_if' kann nicht verwendet werden, um diese Deklaration zu deaktivieren.

Answer 1

auf einer Funktion oder Operator verwendet enable_if diese Weise:

template<class A, class B, 
     std::enable_if_t<condition_test_here<A,B>::value>* = nullptr> 
auto operator+(A, const B&) 
{ 
    ... 
}