数学库之间无缝切换

我认为如果不修改库，就无法隐式完成转换。

然而，为了简化转换代码，tou可以实现简单的转换函数，比如：

inline glm::vec2 make_glmVec2(const b2Vec2 &v) {
    return glm::vec2(v.x, v.y);
}
inline glm::vec3 make_glmVec3(const b2Vec3 &v) {
    return glm::vec3(v.x, v.y, v.z);
}

如果这两个库的类型之间（几乎）有直接的对应关系，您甚至可以为所有转换函数使用一个更简单的名称，如toGlm，并为您需要的所有类型简单地重载它：

inline glm::vec2 toGlm(const b2Vec2 &v) {
    return glm::vec2(v.x, v.y);
}
inline glm::vec3 toGlm(const b2Vec3 &v) {
    return glm::vec3(v.x, v.y, v.z);
}

编辑

我尝试实现一个"代理"类，它可以作为来自两个库的两个类之间的桥梁。代理类包含构造函数和强制转换运算符，它们允许您创建到这些类和从这些类创建。不幸的是，您需要显式调用构造函数，否则编译器甚至不会考虑使用这个类：

//Library 1:
class Vec1 {
public:
  int x;
  int y;
  Vec1(int _x, int _y) : x(_x), y(_y) {}
};
//Library 2:   
class Vec2 {
public:
  int e1;
  int e2;
  Vec2(int _x, int _y) : e1(_x), e2(_y) {}
};
//Your code
class VecProxy {
public:
  int pxX;
  int pxY;
  VecProxy(const Vec1& v1) : pxX(v1.x), pxY(v1.y) {}
  VecProxy(const Vec2& v2) : pxX(v2.e1), pxY(v2.e2) {}
  operator Vec1() {return Vec1(pxX, pxY); }
  operator Vec2() {return Vec2(pxX, pxY); }
};
int main() {
  Vec1 v1(2,3);
  Vec2 v2=VecProxy(v1);
  Vec1 v3=VecProxy(v2);
}

请注意，无论你朝哪个方向投射，你都可以使用相同的名称，这可能比我之前的建议要好一点。我认为你不能使构造函数被隐式调用。

理论上，可以将隐式转换运算符添加到一个或两个库中（尽管隐式转换不一定是个好主意）。但你说过你不能编辑任何一个libary，所以这就排除了这种可能性。

因此，一种替代方案是引入您自己的向量类，并为其提供必要的转换运算符。然后，每当您在代码中需要向量时，您总是将其存储为自定义类的对象，并在需要使用库时（隐式）进行转换。

但是，隐式转换可能带来的麻烦可能会超过表面上的好处（有关这方面的更多详细信息，请参阅更有效的C++的第5项）。

我知道这有点过时，但我最近在当前项目中遇到了同样的情况。我想分享我的解决方案，它对我来说很有效。这些正是我最常用的类型（我在项目中为更容易（读作：lazier）打字而定义了这些类型）。这可能会被扩展/调整，但希望这将为任何同时使用这两个库的人提供另一种选择。

typedef b2Vec2 b2vec2;
typedef b2Mat22 b2mat2;
typedef glm::vec2 vec2;
typedef glm::mat2 mat2;
//Conversion types
namespace Convert
{
///////////////////////////////////////
//Use case examples
//
// Turn the glm vector2 into a box2d type
// vec2 a = vec2( 1, 2 );
// b2vec2 b = Convert::v2(a).to_box2d;
//
// Access the box2d b2vec2 like a glm type
// b2vec2 c = b2vec2( 1, 2 );
// Convert::v2(c).to_glm = vec2(3,4);
//
// Turn the const glm vector2 into a box2d type
// const vec2 d = vec2( 1,2 );
// b2vec2 e = Convert::c_v2(d).to_box2d;

//Don't use these directly. See the use case examples
union _Vec2 {
    _Vec2( vec2* _v ):glm(_v){}
    _Vec2( b2vec2* _v ):box2d(_v){}
    vec2* glm;
    b2vec2* box2d;
};
union _CVec2 {
    _CVec2( const vec2* _v ):glm(_v){}
    _CVec2( const b2vec2* _v ):box2d(_v){}
    const vec2* glm;
    const b2vec2* box2d;
};
union _Mat2 {
    _Mat2( mat2* _m ):glm(_m){}
    _Mat2( b2mat2* _m ):box2d(_m){}
    mat2* glm;
    b2mat2* box2d;
};
//Convert between vec2 and b2vec2
struct v2 {
private:
    _Vec2 data;
public:
    vec2& to_glm;
    b2vec2& to_box2d;
    v2( vec2& _v )
    :data( &_v )
    ,to_glm( *data.glm )
    ,to_box2d( *data.box2d ){}
    v2( b2vec2& _v )
    :data( &_v )
    ,to_glm( *data.glm )
    ,to_box2d( *data.box2d ){}
};
//Convert between const vec2 and const b2vec2
struct c_v2 {
private:
    _CVec2 data;
public:
    const vec2& to_glm;
    const b2vec2& to_box2d;
    c_v2( const vec2& _v )
    :data( &_v )
    ,to_glm( *data.glm )
    ,to_box2d( *data.box2d ){}
    c_v2( const b2vec2& _v )
    :data( &_v )
    ,to_glm( *data.glm )
    ,to_box2d( *data.box2d ){}
};
//Convert between mat2 and b2mat22
struct m2 {
private:
    _Mat2 data;
public:
    mat2& to_glm;
    b2mat2& to_box2d;
    m2( mat2& _m )
    :data( &_m )
    ,to_glm( *data.glm )
    ,to_box2d( *data.box2d ){}
    m2( b2mat2& _m )
    :data( &_m )
    ,to_glm( *data.glm )
    ,to_box2d( *data.box2d ){}
};

}