Wie erreicht man typsicheren dynamischen Versand mit virtuellen Vorlagenmethoden in C?

Typpolymorphismus in C: Methoden virtueller Vorlagen

Bei der C-Programmierung kann die Kombination virtueller Elementfunktionen mit Klassenvorlagen eine Herausforderung darstellen. Diese Situation entsteht, wenn Sie Methoden basierend auf Laufzeittypinformationen dynamisch versenden möchten, aber dennoch typsicheres Verhalten beibehalten möchten.

Das Problem

Betrachten Sie die folgende abstrakte Klasse und seine abgeleitete Implementierung:

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

Die Absicht hier ist, dass der Aufruf von setData("foodouble", data) das von foodouble identifizierte Double auf den Wert von data setzen würde.

Mögliche Lösungen

1. Statischen Polymorphismus entfernen:

Ein Ansatz besteht darin, statischen Polymorphismus (Vorlagen) zu eliminieren und einen generischen Speicher für Schlüssel-Wert-Paare einzuführen:

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

Diese Lösung bietet dynamischen Polymorphismus ohne Notwendigkeit einer Vorlagenspezialisierung.

2. Dynamischen Polymorphismus entfernen:

Eine andere Option besteht darin, den Laufzeitpolymorphismus beizubehalten, aber den statischen Polymorphismus zu entfernen:

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

Hier ermöglicht der Typ Erasure mit boost::any das Versenden an Nicht-Vorlagen Methoden ohne Einbußen bei der Typensicherheit.

Das obige ist der detaillierte Inhalt vonWie erreicht man typsicheren dynamischen Versand mit virtuellen Vorlagenmethoden in C?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!