区分句法相同但语义不同的类型的最佳方法？

如何解决区分句法相同但语义不同的类型的最佳方法？

我将 C++ 和 Eigen 库用于光线追踪项目。我需要区分位置向量，它们参与任何任意变换，包括平移和方向向量，它们只参与旋转和缩放。除了这一操作之外，向量是相同的，并且都派生自 Eigen::Vector3d 类。

数学很简单——转换被编码为 4x4 矩阵。一个 3 元素 position 向量被拉伸为 4 个元素，最后一个元素 w 被硬编码为 1。然后当它乘以一个包含平移的矩阵时，w=1 强制平移即将发生。一个 3 元素的 direction 向量同样被拉伸为 4 个元素，但新元素被硬编码为 0。然后当 it 相乘时，0 强制转换为不会发生。实际上，3D 中的平移被视为 4D 中的倾斜，w 坐标决定了 4D 中的矢量位置，以及它是在倾斜的 w=1 平面上，还是在不倾斜的 w=0 平面上。在这两种情况下，在矩阵乘法之后，最后一个元素被删除以将向量变回 3D。

明显但错误的解决方案是：

#include <Eigen/Dense>

//stretch a 3D vector to 4D by appending a new element
inline Eigen::Vector4d extend(const Eigen::Vector3d& v,double w) {
  Eigen::Vector4d result;
  result<<v,w;
  return result;
}

//Reverse of extend()
inline Eigen::Vector3d deextend(const Eigen::Vector4d& v) {
  return v.head<3>();
}

typedef Eigen::Vector3d PositionVector;
typedef Eigen::Vector3d DirectionVector;

inline PositionVector operator*(const Eigen::Matrix4d& M,PositionVector v) {
  return deextend(M*extend(v,1));
}

inline DirectionVector operator*(const Eigen::Matrix4d& M,DirectionVector v) {
  return deextend(M*extend(v,0));
}

但这不起作用，因为 PositionVector 和 DirectionVector 并不是真正不同的类型，因此编译器无法区分它们。

我的下一个想法（部分可行）是让两个对象直接扩展 Eigen::Vector3D：

#include <Eigen/Dense>

inline Eigen::Vector4d extend(...) {/* same as above */}
inline Eigen::Vector3d deextend(...) {/* same as above */}

class PositionVector:public Eigen::Vector3d {};
class DirectionVector:public Eigen::Vector3d {};

inline PositionVector operator*(...) {/*same as above*/}
inline DirectionVector operator*(...) {/*same as above*/}

我说它部分有效，因为虽然此代码按原样有效，但我不得不添加一堆 static_cast<> 并将构造函数委托给其余代码。我在区分类型方面做得太好了，现在编译器并不总是足够聪明，无法在没有任何提示的情况下在特征向量和我的向量之间进行转换。

#include <Eigen/Dense>

inline Eigen::Vector4d extend(...) {/* same as above */}
inline Eigen::Vector3d deextend(...) {/* same as above */}

class PositionVector:public Eigen::Vector3d {
 /* This is a subset of the literally dozens of potential constructors I might have to make.
    They are the only ones my code has used so far,but who knows about the future? */
  PositionVector() {}
  PositionVector(Eigen::Vector3d matrix): Eigen::Vector3d(matrix) {}
  PositionVector(double x,double y,double z):Eigen::Vector3d(x,y,z) {}
};
class DirectionVector:public Eigen::Vector3d {
/* Exact same constructors,except with DirectionVector() instead of PositionVector(). I wish
   you could just inherit constructors,but in C++ you can't. */
  DirectionVector() {}
  DirectionVector(Eigen::Vector3d matrix): Eigen::Vector3d(matrix) {}
  DirectionVector(double x,z) {}
};

inline PositionVector operator*(...) {/*same as above*/}
inline DirectionVector operator*(...) {/*same as above*/}

/* An example of code which uses these classes */
class Ray {
  //...other stuff
  PositionVector r0;
  DirectionVector v0;
  PositionVector operator()(double t) {
    /* Ugly static cast. How many more will I need? */
    return static_cast<Eigen::Vector3d>(r0+v*t);
  }
  Ray &operator*=(const Eigen::Matrix4d &M) {
    r0 = M*r0;
    v = M*v;
    return *this;
  }
};

inline Ray operator*(const Eigen::Matrix4d &M,Ray ray) {
  ray *= M;
  return ray;
}

Eigen::Matrix4d M=/*...*/;
Ray ray1=/*...*/;
Ray ray2=M*ray1;
PositionVector r=ray2(42.0);

我看到的一项改进是，由于 PositionVector 和 DirectionVector 几乎相同，我可以将它们模板化：

#include <Eigen/Dense>

inline Eigen::Vector4d extend(...) {/* same as above */}
inline Eigen::Vector3d deextend(...) {/* same as above */}

template<int W>
class PDVector:public Eigen::Vector3d {
 /* Still needs potentially many more constructors,but now only in one place */
  PDVector() {}
  PDVector(Eigen::Vector3d matrix): Eigen::Vector3d(matrix) {}
  PDVector(double x,z) {}
};
typedef PDVector<1> PositionVector;
typedef PDVector<0> DirectionVector;

template<int W>
inline PDVector<W> operator*(const Eigen::Matrix4d& M,PDVector<W> v) {
  return deextend(M*extend(v,W));
}

我理解为什么编译器需要这种丑陋的东西。我不是在抱怨语言。但是，似乎我正在与语言作斗争，这通常表明可能有一种更优雅的方式来完成所有这些，而我只是对语言了解得不够多。如果我真的需要所有这些丑陋的东西，我已经准备好将它隐藏在库的深处，但是我如何保持调用界面的美观和干净？我怎样才能不让这种丑陋泄露出去？有没有更好的方法来做我想做的事情？

区分句法相同但语义不同的类型的最佳方法？

如何解决区分句法相同但语义不同的类型的最佳方法？

相关推荐