Comment obtenir une répartition dynamique de type sécurisé avec des méthodes de modèles virtuels en C ?

Polymorphisme de type en C : méthodes de modèles virtuels

En programmation C, combiner des fonctions de membre virtuel avec des modèles de classe peut être un défi. Cette situation se produit lorsque vous souhaitez distribuer dynamiquement des méthodes basées sur des informations de type d'exécution, tout en conservant un comportement sécurisé.

Le problème

Considérez la classe abstraite suivante et son implémentation dérivée :

<code class="cpp">class AbstractComputation {
public:
    template <class t> virtual void setData(std::string id, T data) = 0;
    template <class t> virtual T getData(std::string id) = 0;
};

class Computation : public AbstractComputation {
public:
    template <class t> void setData(std::string id, T data);
    template <class t> T getData(std::string id, T data);
};</class></class></class></class></code>

L'intention ici est que l'appel de setData("foodouble", data) définirait le double identifié par foodouble à la valeur de data.

Solutions possibles

1. Supprimer le polymorphisme statique :

Une approche consiste à éliminer le polymorphisme statique (modèles) et à introduire un magasin générique pour les paires clé-valeur :

<code class="cpp">class ValueStore {
    template <typename t>
    void setData(std::string const & id, T value);
    template <typename t>
    T getData(std::string const & id) const;
};

class AbstractComputation {
public:
    template <typename t>
    void setData(std::string const & id, T value) { m_store.setData(id, value); }
    template <typename t>
    T getData(std::string const & id) const { return m_store.getData<t>(id); }
protected:
    ValueStore m_store;
};</t></typename></typename></typename></typename></code>

Cette solution fournit un polymorphisme dynamique sans le besoin de spécialisation en modèles.

2. Supprimer le polymorphisme dynamique :

Une autre option consiste à conserver le polymorphisme d'exécution mais à supprimer le polymorphisme statique :

<code class="cpp">class AbstractComputation {
public:
    template <typename t>
    void setData( std::string const & id, T value ) { setDataImpl( id, boost::any( value ) ); }
    template <typename t>
    T getData( std::string const & id ) const {
        boost::any res = getDataImpl( id );
        return boost::any_cast<t>( res );
    }
protected:
    virtual void setDataImpl( std::string const & id, boost::any const & value ) = 0;
    virtual boost::any getDataImpl( std::string const & id ) const = 0;
};</t></typename></typename></code>

Ici, tapez erasure à l'aide de boost::any permet la distribution vers des fichiers non modélisés. méthodes sans sacrifier la sécurité des types.

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!