Question

我正在使用两个第三方库，它们都实现了自己的2D矢量类。不幸的是，我必须同时使用它们，所以无论如何我可以编写一些“朋友”函数，以便当我尝试在其他库的函数中使用它们时，可以自动转换为另一个函数吗？

Answer 1

自动 -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 2

一种方法是从这些类派生并为彼此提供转换运算符。但是你必须在代码中使用派生类对象。以下是一些示例代码：

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

Answer 3

转换运算符必须是成员函数。

在这种情况下，我使用了convert<X,Y>函数模板，对于我想要“强制转换”的每对类型都有完整的特化或重载。在这种情况下，你不需要模板，只需要两个重载，每个方向一个，因为对于给定的X，只有一件事你将其转换为。

然后在一个和另一个之间切换很少有任何麻烦（值得注意的例外是当你使用模板代码时，需要一个参数类型可以转换为另一个参数类型）。您可以在代码中轻松查看两个API之间的边界，而不会引入太多噪音。

我经常遇到这种情况的原因是编写操作系统抽象层 - 底层操作系统有一组对象或不透明的句柄用于各种操作系统概念，而你正在实现的API有另一个。没有ConvertHostMutexToGuestMutex，ConvertGuestMutexToHostMutex，ConvertHostSocketOptsToGuestSocketOpts等，从一组概念“转换”到另一组概念要好得多。缺点是通常的重载过载，实际定义函数的位置并不一定明显。

自动投两个第三方课程？

3 个答案: