Abzug einer Klasse von der Template-Klasse in Vorlage C++

Question

Ich habe folgendes Problem: Ich habe eine Klasse, in der ich brauche den Typ eines Objekts in Abhängigkeit von der Template-Klasse zu bestimmen:

template<class a_type> class inputPort_varExp{ 
protected: 
RTT::InputPort<a_type> inport; 
RTT::InputPort<a_type_der> inport_derivative; 
... 

in mein Fall würde Sie mag, um automatisch die a_type_der mit folgenden Logik abziehen:

• wenn typeid (A_TYPE) == typeid (Frame), dann typeid (a_type_der) = typeid (Twist),

• wenn typeid (A_TYPE) == typeid (double) dann typeid (a_type_der) = typeid (double),

• usw.

Dank.

Answer 1

Ich würde das "Typ-Traits" -Konzept hier verwenden.

Dies hat den Vorteil, dass es eine Kompilierzeitlösung ist (keine Laufzeitfehler aufgrund fehlender typspezifischer Codes), und Sie müssen die inputPort_varExp-Klasse nicht für jeden Typ bearbeiten, den Sie als a_type übergeben.

Die Idee ist, erstellen Sie eine Vorlage Klasse/Struktur einem Typ zum anderen zur Karte: -

template< typename t > 
class DerivativeTrait 
{ 
    public: 
    typedef DerivativeType t; 
    //this provides a default derivate... 
    //you'd need to decide if that was a safe thing to do 
}; 

Sie dann diese Eigenschaft Klasse spezialisieren können: -

template<> 
class DerivativeTrait<Frame> 
{ 
    public: 
    typedef DerivativeType Twist; 
}; 

Sie können nun diese verwenden

typedef DerivativeTrait<a_type>::DerivativeType a_type_der; 

Note seit C++ 11 Sie die usi nutzen könnten -: in Ihre inputPort_varExp a_type_der definieren ng keyword anstelle von typedef.

Einige andere Optionen:

Wenn Sie die Typen, die Sie zu inputPort_varExp passieren in bearbeiten in der Lage sind, können Sie nur eine typedef zu diesen Klassen hinzufügen - dies würde für Ihren Fall nicht funktionieren, da Sie doppelt in so passieren eine Art.

Eine weitere einfache Alternative besteht darin, einen zusätzlichen Vorlagenparameter für a_type_der hinzuzufügen, der jedoch eine falsche Kombination nicht verhindert (z. B. Frame und double).

Sie könnten auch declltype in Betracht ziehen, wenn der Typ vom Compiler abgeleitet werden kann.

Answer 2

dank @ROX -Code für zukünftige Referenzen

template< typename t > 
class DerivativeTrait 
{ 
    public: 
    typedef t DerivativeType; 
}; 
//special cases: Frame and rotation 

template<> 
class DerivativeTrait<KDL::Frame> 
{ 
    public: 
    typedef KDL::Twist DerivativeType; 
}; 


//the class where the derivative is needed 

template<class a_type> class inputPortDerivative_varExp{ 
protected: 
    typedef typename DerivativeTrait<a_type>::DerivativeType a_type_der; 
    RTT::InputPort<a_type> inport; 
    RTT::InputPort<a_type_der> inportDerivative; 
... 
};