controllo se membro esista utilizzando enable_if

Question

Ecco quello che sto cercando di fare:

template <typename T> struct Model 
{ 
    vector<T> vertices ; 

    #if T has a .normal member 
    void transform(Matrix m) 
    { 
     each vertex in vertices 
     { 
      vertex.pos = m * vertex.pos ; 
      vertex.normal = m * vertex.normal ; 
     } 
    } 
    #endif 

    #if T has NO .normal member 
    void transform(Matrix m) 
    { 
     each vertex in vertices 
     { 
      vertex.pos = m * vertex.pos ; 
     } 
    } 
    #endif 
} ; 

Ho visto examples di usare enable_if, ma non riesco a capire come applicare enable_if a questo problema, o se addirittura può essere applicato.

Answer 1

Questo è diventato modo più semplice con C++ 11.

template <typename T> struct Model 
{ 
    vector<T> vertices; 

    void transform(Matrix m) 
    { 
     for(auto &&vertex : vertices) 
     { 
      vertex.pos = m * vertex.pos; 
      modifyNormal(vertex, m, special_()); 
     } 
    } 

private: 

    struct general_ {}; 
    struct special_ : general_ {}; 
    template<typename> struct int_ { typedef int type; }; 

    template<typename Lhs, typename Rhs, 
      typename int_<decltype(Lhs::normal)>::type = 0> 
    void modifyNormal(Lhs &&lhs, Rhs &&rhs, special_) { 
     lhs.normal = rhs * lhs.normal; 
    } 

    template<typename Lhs, typename Rhs> 
    void modifyNormal(Lhs &&lhs, Rhs &&rhs, general_) { 
     // do nothing 
    } 
}; 

cose da notare:

• è possibile denominare membri di dati non statici in decltype e sizeof senza bisogno di un oggetto.
• È possibile applicare SFINAE estesa. Fondamentalmente qualsiasi espressione può essere controllata e se non è valida quando gli argomenti sono sostituiti, il modello viene ignorato.

Answer 2

È necessaria una funzione meta per rilevare il membro in modo che sia possibile utilizzare enable_if. L'idioma per farlo è chiamato Member Detector. È un po 'complicato, ma può essere fatto!

Answer 3

Questa non è una risposta al tuo caso esatto, ma è una risposta alternativa al titolo della domanda e al problema in generale.

#include <iostream> 
#include <vector> 

struct Foo { 
    size_t length() { return 5; } 
}; 

struct Bar { 
    void length(); 
}; 

template <typename R, bool result = std::is_same<decltype(((R*)nullptr)->length()), size_t>::value> 
constexpr bool hasLengthHelper(int) { 
    return result; 
} 

template <typename R> 
constexpr bool hasLengthHelper(...) { return false; } 

template <typename R> 
constexpr bool hasLength() { 
    return hasLengthHelper<R>(0); 
} 

// function is only valid if `.length()` is present, with return type `size_t` 
template <typename R> 
typename std::enable_if<hasLength<R>(), size_t>::type lengthOf (R r) { 
    return r.length(); 
} 

int main() { 
    std::cout << 
     hasLength<Foo>() << "; " << 
     hasLength<std::vector<int>>() << "; " << 
     hasLength<Bar>() << ";" << 
     lengthOf(Foo()) << 
     std::endl; 
    // 1; 0; 0; 5 

    return 0; 
} 

Rilevante https://ideone.com/utZqjk.

Crediti per dyreshark su freenode IRC# C++.