从Base*容器向下强制转换为Derived*容器，无需显式转换

我正在编写一个科学代码，需要创建三维细胞，由一组面定义，由一组顶点定义。

这3个类(Cell, Face, Vertex)分别是由一些一般的几何类(Polyhedron, Polygon, Point)推导而来，它们实现了一些类似Polygon::CalculateArea()的几何例程。

Face类在Polygon类的基础上增加了科学所需的额外数据和功能，如Face::Interpolate()。我不想让这些成员函数在基类(Polygon)中成为虚函数。

现在，问题是。我用指向Face的指针向量初始化Cell，这是由基类Polyhedron构造函数处理的，它将Face*向上转换为Polygon*:

Polyhedron::Polyhedron( std::initializer_list<Polygon*> polygons );

稍后，我想访问存储在Cell中的Face*，以便我可以调用Face::Interpolate()，但它已被存储为Polygon*，因此没有Polygon::Interpolate()成员函数。我可以手动将其下拉回Face*，但不是很干净。该代码的用户必须执行如下操作:

Face * temp_face = (Face*)cell->GetFaces()[0]; // Could use static_cast
temp_face->Interpolate();

这是不明显的

我希望界面是透明的，这样就可以工作了:

cell->GetFaces()[0]->Interpolate();

我可以想到两到三种方法来实现这一点。我正在寻找一个更好的解决方案或反馈建议:

1. 在Cell::GetFaces()，目前只是从Polyhedron::GetPolygons()继承，我可以创建一个包装器，将std::vector<Polygon*>复制到一个新的矢量std::vector<Face*>。这对我来说似乎很草率，不容易维护，效率低下，容易出错。

2. 我可以存储std::vector<std::shared_ptr<Polygon>>而不是存储std::vector<Polygon*>。据我所知，这些智能指针保留了类型意识，因此它们可以调用正确的析构函数，但它们可能只是存储对析构函数的引用，具体取决于实现。我不想为了性能目的而使用shared_ptr——我知道它们很好也很友好，但我创建了数百万个这样的多边形，很容易在正确的地方破坏它们。我不能轻易地使用unique_ptr，因为std::initializer_list构造函数中使用了复制构造函数。

3. 模板整个多面体类，用F*替换Polygon*的每个实例，并检查F是Polygon的基础:

   template<typename F = Polygon>
   typename std::enable_if<std::is_base_of<Polygon, F>::value, void>::type
   class Polyhedron
   

   ，然后从具有给定typename的父类继承:

   class Cell : public Polyhedron<Face>
   

   对我来说，这似乎是最好的方法，因为它具有最少的样板文件，并且没有向用户暴露任何内容;但是它仍然感觉很乱，特别是在可能有多个类型都必须指定的"实际"情况下:

   class Cell: public Polyhedron<Face,Vertex,type3,type4,type5,...>
   

有更好的方法吗?可能是在原始向量(或其他容器)中保留类型的一种方法?

如果不是，上面哪个方法是最佳实践，为什么?

这是对这个问题的抽象看法。当尝试运行sumOfSomethingSpecific()时，会出现这个问题。在我的实际问题中，该函数位于派生类Derived_B中，该类设计用于与Derived_A一起工作，但为了解决问题，它没有区别。

class Base_A
{
public:
    Base_A();
    ~Base_A();
    // I don't want virtual doSomethingSpecific() here.
};
class Derived_A
{
public:
    using Base_A::Base_A;
    double doSomethingSpecific();
};
// I could template this whole class
// template <typename T>
// where T replaces Base_A
class B
{
public:
    // This can be initialized with:
    // std::vector<Derived_A*>
    // which is what I want to do, but we lose info about doSomethingSpecific()
    // even if I write a separate constructor its still stored as
    // std::vector<Base_A*>
    B(std::vector<Base_A*> v) : v(v) {};
    ~B();
    double sumOfSomethingSpecific()
    {
        double sum = 0;
        for(auto&& A : v) {
            // Can't do this, A is a pointer of type Base_A*, but this is the abstraction that I want to achieve
            sum += A->doSomethingSpecific();
            // Could do this, but its ugly and error-prone
            Derived_A* tempA = (Derived_A*)A;
            sum += tempA->doSomethingSpecific();
        }
        return sum;
    }
protected:
    std::vector<Base_A*> v;
};