Überprüfen Sie, ob ein Mitglied mit enable_if existiert

Hier ist, was ich versuche zu tun:

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

Ich habe gesehen, Beispiele mit enable_if, aber ich kann nicht verstehen, wie sich zu bewerben enable_if zu diesem problem, oder ob es auch angewendet werden kann.

Kommentar zu dem Problem - Öffnen

enable_if wird nicht verwendet, um zu überprüfen, ob ein Mitglied existiert, sondern es dient der Beseitigung von überlastungen. Kommentarautor: Pubby

Kann ich nicht es verwenden, um etwas zu tun (Vorschlag im edit oben)? Kommentarautor: bobobobo

Nein, Sie wollen eine static, wenn, die noch nicht existiert. Was Sie wollen, ist völlig möglich, es will einfach nicht verwenden Sie eine syntax wie die. Kommentarautor: Pubby

InformationsquelleAutor der Frage bobobobo | 2012-12-09

c++sfinae templates

Diese hat sich Weg einfacher mit 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
    }
};

Dinge zu beachten:

Man kann den Namen nicht-statischen Daten-member in decltype und sizeof ohne ein Objekt.
Können Sie anwenden erweiterte SFINAE. Im Prinzip ist jeder Ausdruck kann geprüft werden, und wenn es ist nicht gültig, wenn die Argumente ersetzt werden, die Vorlage wird ignoriert.

InformationsquelleAutor der Antwort Johannes Schaub - litb

7

Benötigen Sie eine meta-Funktion zu erkennen, Ihr Mitglied, so dass Sie verwenden können enable_if. Das idiom zu tun, dies wird als Mitglied Detektor. Es ist ein bisschen schwierig, aber es kann getan werden!

InformationsquelleAutor der Antwort ltjax

Dies ist nicht die Antwort auf Ihre genauen Fall, aber es ist eine alternative Antwort auf die Frage, Titel und problem im Allgemeinen.

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