C++派生类的reinterpret_cast

Question

父类：

template <class T>
class Point
{
    protected

        T x;
        T y;

};

派生类：

template <class T>
class Point3DTopo: public Point <T>
{
    protected:

        T z;
        Face <T> *face;   //Points to any face
};

我想将 PointsList 类的一个对象转换为另一个对象 Points3DTopoList（反之亦然） 其中：

template <class T>
class PointsList
{
  protected:
         std::vector <Point <T> *> points;  //Only illustration, not possible with   templaes
};


template <class T>
class Points3DTopoList
{
  protected:
         std::vector <Point3DTopo <T> *> points;  //Only illustration, not possible with   templaes
};

是否允许这种转换？

Points3DTopoList <T> *pl = new Points3DTopoList <T> ();
...
PointsList <T> *pl = reinterpret_cast < PointsList <T> * > ( pl3D );

那么反向转换呢？

PointsTopoList <T> *pl = new PointsTopoList <T> ();
...
Points3DTopoList <T> *pl3D = reinterpret_cast < Points3DTopoList <T> * > ( pl );

每个Point3Topo的Face指针将被初始化为NULL还是未定义？

Answer 1

这样的演员阵容是不允许的。这是一个基本问题：您要么必须通过复制进行转换，要么调整您的类定义，以便您拥有一个 ListOf，即对点类型和内部类型进行参数化观点。

但是，无论如何，类设计都是有缺陷的：您不应该从 Point 派生 Point3D，这违反了 里氏替换原理 (LSP) – 或者更一般地说：3D 点不是 2D 点。事实上，恰恰相反：2D 点是 3D 点的特例。

所以如果你想在这里继承，它应该走另一种方式（即2D从3D继承），但这很可能也违反LSP，并且非常尴尬（从那时起，您的 2D 点将具有始终固定的冗余变量）。简单地说，2D和3D点之间不存在合适的继承关系，它们是不同的实体。

Answer 2

reinterpret_cast 唯一保证的是从 A* 到 B* 然后再返回到 A* 会产生原始指针。除了转换回 A* 之外，使用中间 B* 进行任何操作都是未定义的。

Answer 3

这只是双向的未定义行为。

Answer 4

鉴于 Point3DTopo 是从 Point 派生的，因此提供从 Points3DTopoList 到 PointsList 的转换可能是明智的。继承可以自动提供转换，但我怀疑您的公共接口要求（从问题中省略）使其比资产更麻烦。

提供转化路径的示例：

template<class T>
struct PointsList {
  // Points3DTopoList needs a way to construct a PointsList
  template<class Iter>
  PointsList(Iter begin, Iter end)
  : points(begin, end)
  {}

private:
  std::vector<Point<T> > points;
};

template<class T>
struct Points3DTopoList {

  operator PointsList<T>() const {
    return PointsList<T>(points.begin(), points.end());
  }

  PointsList<T> to_points_list() const {
    return PointsList<T>(points.begin(), points.end());
  }

private:
  std::vector<Point3DTopo<T> > points;
};

这提供了两个转化路径 - 通常您会选择一个而不提供另一个。转换运算符是隐式转换（在 C++0x 中，您可以将其标记为显式），而命名方法在技术术语中不是“转换”（因此从不适用于任何隐式或显式转换），而是显式调用并以这种方式使用。

您还可以在 PointsList 中使用接受 Points3DTopoList 的显式构造函数提供显式转换，这在当前的 C++ 中有效，但代价是颠倒了通常的依赖关系：也就是说，PointsList 会知道并关心 Points3DTopoList反之亦然。

但是，您提供一个“generic-Point”容器可能更有意义；也就是说，它接受任何具体的 Point-like 类型。

template<class Point>
struct GenericPointContainer {
private:
  std::vector<Point> points;
};

这里最大的优势是 GenericPointContainer 的方法可以使用 Point 派生类的各种功能，这些功能不存在于 Point 本身中，但仍然可以直接在 Point 上实例化。这是有效的，因为实例化类模板时，所有方法都不会被实例化，一个实际的例子是 std::reverse_iterator 如何重载operator+=，它只适用于随机访问迭代器，但可以在非随机访问迭代器上实例化，例如 std::reverse_iterator::iterator> 。

然后，各种列表类可能会变成简单的 typedef，如果它们仍然需要的话：

typedef GenericPointContainer<Point<int> > PointsList;
typedef GenericPointContainer<Point3DTopoList<int> > Points3DTopoList;

C++0x 确实可以帮助您使用模板 typedef（您可以在当前的 C++ 中使用重新绑定，但这会变得迟钝）；正如您所看到的，我必须为 typedef 指定 T，因此它并不像其他情况那样通用。

Answer 5

我已经得到了回答： C++ 重新解释转换？

而且它不会慢，因为只有指针将被复制。

您自己的演员阵容。