vérifier si le membre existe à l'aide de enable_if

Voici ce que j'essaie de faire:

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

J'ai vu exemples de l'aide enable_if, mais je ne peux pas comprendre comment appliquer enable_if à ce problème, ou si elle peut même être appliquée.

  • enable_if n'est pas utilisée pour vérifier si un membre existe, elle est plutôt utilisée pour supprimer les surcharges.
  • Je ne peux pas l'utiliser pour faire quelque chose comme (suggestion de modifier ci-dessus)?
  • Non, vous êtes désireux d'un static if qui n'existe pas encore. Ce que vous voulez, c'est tout à fait possible, il ne peut pas utiliser une syntaxe comme ça.
InformationsquelleAutor bobobobo | 2012-12-09
  1. 26

    C'est devenu façon plus facile avec le 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
    }
};

    Choses à noter:

    • Vous pouvez donner un nom non-membres de données statiques dans decltype et sizeof sans avoir besoin d'un objet.
    • Vous pouvez appliquer étendu SFINAE. Fondamentalement, toute expression peut être vérifié et, si elle n'est pas valable lorsque les arguments sont substitués, le modèle est ignoré.
    • C'est certainement beaucoup mieux SFINAE que avant, où vous avez eu à créer un membre du détecteur pour chaque type de membre que vous voulez détecter. Mais pourquoi les gens sautent à SFINAE, je préfère utiliser les traits de type pour faire ce type de compilation conditionnelle maintenant.
    • Je suppose que cela dépend de si vous avez plusieurs types de vérifier ou de plusieurs membres de la vérifier?
    • Types de caractères n'est utile que si vous connaissez les types à l'avance. Dans votre lien, vous devez savoir que VertexN est la classe spéciale. Donc, ils peuvent travailler dans des OP exemple, mais SFINAE fonctionne même si vous ne savez pas ce que les autres types vont être, qui l'OMI est beaucoup mieux d'encapsulation.
    • J'ai aimé l'utilisation de general_ et special_, je l'ai trouvé plus clair que l'utilisation d'int et long.
    InformationsquelleAutor Johannes Schaub - litb
  2. 7

    Vous avez besoin d'un méta fonction de détecter vos membres, de sorte que vous pouvez utiliser enable_if. L'idiome de faire ce qu'on appelle Membre Du Détecteur. C'est un peu délicat, mais il peut être fait!

    InformationsquelleAutor ltjax
  3. 2

    Ce n'est pas une réponse à votre cas précis, mais c'est une autre réponse à la question du titre et de problème en général.

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

    Pertinentes https://ideone.com/utZqjk.

    Crédits à dyreshark sur le réseau IRC freenode #c++.

    InformationsquelleAutor deceleratedcaviar