非成员转换函数；转换不同的类型，例如从DirectX向量到OpenGL向量

Question

我目前正在开发一个游戏“引擎”，它需要在3D引擎、物理引擎和脚本语言之间移动数值。由于我需要经常将来自物理引擎的向量应用于3D对象，并且希望能够通过脚本系统控制3D以及物理对象，因此我需要一种机制来将一种类型的向量(例如vector3d<float>)转换为另一种类型的向量(例如btVector3)。不幸的是，我不能假设类/结构是如何布局的，所以一个简单的reinterpret_cast可能无法做到这一点。

所以问题是:有没有某种“静态”/非成员类型的方法来基本实现这一点：

vector3d<float> operator vector3d<float>(btVector3 vector) {
    // convert and return
}

btVector3 operator btVector3(vector3d<float> vector) {
    // convert and return
}

现在还不能编译，因为强制转换操作符需要是成员方法。(error C2801: 'operator foo' must be a non-static member)

Answer 1

我建议把它们写成一对自由函数(也就是说，不用担心把它们变成“运算符”)：

vector3d<float> vector3dFromBt(const btVector3& src) {
    // convert and return
}

btVector3 btVectorFrom3d(const vector3d<float>& src) {
    // convert and return
}

void f(void)
{
  vector3d<float> one;   
// ...populate...   
  btVector3 two(btVectorFrom3d(one));    
// ...
  vector3d<float> three(vector3dFromBt(two));
}

Answer 2

您还可以使用模板化的包装类，如：

template<class V>
class vector_cast {};

template<>
class vector_cast<vector3d> {
  const vector3d& v;

public:

  vector_cast(const vector3d& v) : v(v) {};

  operator vector3d () const {
    return vector3d(v);
  }

  operator btVector3 () const {
    // convert and return
  }
};

template<>
class vector_cast<btVector3> {
  const btVector3& v;

public:

  vector_cast(const btVector3& v) : v(v) {};

  operator btVector3 () const {
    return btVector3(v);
  }

  operator vector3d () const {
    // convert and return
  }
};

用法：

void set_origin(btVector3 v);

// in your code:

vector3d v;
// do some fancy computations
set_origin(vector_cast(v));

// --- OR the other way round --- //

void set_velocity(vector3d v);

// in your code:

btVector3 v;
// do some other computations
set_velocity(vector_cast(v));

Answer 3

你在问题中的陈述是正确的。类型转换运算符需要是非静态成员。如果您确实需要转换类型语义，则可以扩展这些类中的每个类，以便在应用程序代码中使用：

// header:
class ConvertibleVector3d;

ConvertibleBtVector : public btVector3
{
  operator ConvertibleVector3d() const;
}

ConvertibleVector3d : public vector3d<float>
{
  operator ConvertibleBtVector() const;
}

//impl:
ConvertibleBtVector::operator ConvertibleVector3d() const
  {
    ConvertibleVector3d retVal;
// convert this into retVal...
    return retVal;
  }

ConvertibleVector3d::operator ConvertibleBtVector() const;
  {
    ConvertibleBtVector retVal;
// convert this into retVal...
    return retVal;
  }

void f(void)
{
  ConvertibleVector3d one;   
// ...populate...   
  ConvertibleBtVector two(one);    
// ...
  ConvertibleVector3d three;
  three = two;
}

名称有点冗长，但希望其意图是明确的。

公共继承意味着您应该能够以与基类相同的方式使用这些类的实例，除非它们彼此之间是可分配和可构造的。当然，这将两个类结合在一起，但这可能是可以接受的，因为这听起来像是您的应用程序想要做的事情。