Comment pouvons-nous résoudre les erreurs de compilation lors de l'utilisation de CRTP et Typedef dans les classes dérivées C ?

Polymorphisme statique et utilisation de Typedef à partir de classes dérivées en C

L'une des fonctionnalités puissantes de C, Curiously Recurring Template Pattern (CRTP), permet le polymorphisme statique. Cela permet une flexibilité au moment de la compilation pour déterminer le type d'objets créés en fonction des arguments du modèle. Cependant, étendre CRTP pour permettre la modification des types de retour de fonction en fonction des types dérivés pose un défi.

Considérez le code suivant qui tente de généraliser CRTP :

template <typename derived_t>
class base {
public:
    typedef typename derived_t::value_type value_type;
    value_type foo() {
        return static_cast<derived_t*>(this)->foo();
    }
};

template <typename T>
class derived : public base<derived<T>> {
public:
    typedef T value_type;
    value_type foo() {
        return T();
    }
};

Ce code ne parvient pas à être compilé dans Microsoft Visual Studio 2010 en raison de l'erreur : « value_type » n'est pas membre de 'derived'.

Le problème vient du fait que dérivé est incomplet lorsqu'il est utilisé comme argument de modèle pour base dans sa liste de classes de base. Pour résoudre ce problème, une solution de contournement courante consiste à utiliser un modèle de classe de traits.

Présentation du modèle base_traits :

template <typename derived_t> 
struct base_traits;

Redéfinition de la classe de base à l'aide des traits :

template <typename derived_t> 
struct base { 
    typedef typename base_traits<derived_t>::value_type value_type;
    value_type base_foo() {
        return base_traits<derived_t>::call_foo(static_cast<derived_t*>(this));
    }
};

Et spécialiser les base_traits pour les dérivés :

template <typename T> 
struct base_traits<derived<T> > {
    typedef T value_type;

    static value_type call_foo(derived<T>* x) { 
        return x->derived_foo(); 
    }
};

Cette approche permet d'utiliser à la fois les types et les fonctions de la classe dérivée à travers les traits. En spécialisant base_traits pour chaque argument de modèle, vous pouvez fournir les membres requis pour chaque classe dérivée.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!