Auto-cast deux cours de tiers?

Question

J'utilise deux bibliothèques tierces, qui implémentent leur propre classe de vecteurs 2D. Malheureusement, je dois travailler avec les deux, alors est-ce que je peux écrire des fonctions "ami" de sorte que l'une puisse automatiquement être convertie en l'autre quand j'essaie de les utiliser dans des fonctions de l'autre bibliothèque?

Answer 1

Les opérateurs de conversion doivent être des fonctions membres.

Dans des situations comme celle-ci, j'ai utilisé un modèle de fonction convert<X,Y>, avec des spécialisations ou des surcharges complètes pour chaque paire de types que je veux "lancer". Dans ce cas, vous n'avez pas besoin du modèle, juste deux surcharges, une dans chaque direction, car pour un X donné, il n'y a qu'une seule chose à laquelle vous le convertissez.

Ensuite, il est rarement difficile de basculer entre l'un et l'autre (l'exception notable étant lorsque vous utilisez un code de modèle qui nécessite qu'un type de paramètre soit convertible en un autre). Vous pouvez facilement voir dans le code la limite entre les deux API, sans introduire beaucoup de bruit. La raison pour laquelle j'ai souvent eu cette situation est l'écriture de couches d'abstraction d'OS - le système d'exploitation sous-jacent a un ensemble d'objets ou de poignées opaques pour différents concepts d'OS et l'API que vous implémentez en a un autre. ConverthostMutexToGuestMutex, ConvertGuestMutexToHostMutex, ConvertHostSocketOptsToGuestSocketOpts etc ... L'inconvénient est l'habituel avec une surcharge généralisée, que ce n'est pas nécessairement évident où les fonctions sont réellement définies.

Answer 2

Auto -cast ne semble pas être possible. Vous pouvez définir la fonction de conversion globale et l'appeler explicitement. Pourriez-vous afficher la définition de ces classes? Peut être un truc avec l'héritage sera possible.

Quelque chose comme ça, mais ce n'est pas auto-cast:

class T1 {}; 
class T2 {}; 

class UnionType : public T1, public T2 
{ 
public: 
    UnionType(const T1& val) {} // real storing should be here 
    UnionType(const T2& val) {} // real storing should be here 

    operator T1() { T1 t; return t; } // real conversion should be here 
    operator T2() { T2 t; return t; } // real conversion should be here 
}; 

int main() 
{ 
    T1 t; 
    T2 t2 = UnionType(t); 

    return 0; 
} 

Answer 3

Une façon serait de tirer de ces cours et fournir aux opérateurs de conversion pour l'autre. Mais alors vous devez utiliser les objets de la classe dérivée à travers votre code. Voici un exemple de code:

class ThirdParty1 
{ 
    public: 
     ThirdParty1(int x, int y) : m_x(x), m_y(y) 
     { 
     } 
     int getX() const { return m_x; } 
     int getY() const { return m_y; } 

    private: 
     int m_x; 
     int m_y; 
}; 

class ThirdParty2 
{ 
    public: 
     ThirdParty2(int x, int y) : m_x(x), m_y(y) 
     { 
     } 
     int getX() const { return m_x; } 
     int getY() const { return m_y; } 

    private: 
     int m_x; 
     int m_y; 
}; 

template<class Type, class AdaptedType> 
class TP1Adaptor : public Type 
{ 
    public: 
     TP1Adaptor(int x, int y): Type(x,y) 
     { 
     } 
     operator AdaptedType() 
     { 
      return AdaptedType(getX(),getY()); 
     } 


}; 

typedef TP1Adaptor<ThirdParty1, ThirdParty2> First2D; 
typedef TP1Adaptor<ThirdParty2, ThirdParty1> Second2D; 

void f(ThirdParty1 tp) 
{ 
} 


void f1(ThirdParty2 tp) 
{ 
} 


int main() 
{ 
    First2D f(0,0); 
    f1(f); 


    return 0; 
}