C++ 我可以使用模板作为多态处理数组的安全解决方案吗？

众所周知，以多态方式处理数组项是危险的，因为一般来说，基类和派生类的大小不同，指针算法很可能失败

void doSomethingOnBases(Base* bases, int numBases)
{
    for(int i = 0; i < numBases; i++)
    {
        bases[i].doSomething();
    }
}


//...
//...
Derived deriveds[60];    // declare 60 derived objects
doSomethingOnBases(deriveds, 60);    // will crash and burn
//...
//...

void doSomethingOnBases（Base*Base，int-numBases）
{
for（int i=0；i

但如果我做了这件事呢

template <class X>
void doSomethingOnArray(X* arr, int numItems)
{
    for(int i = 0; i < numItems; i++)
    {
        arr[i].doSomething();
    }
}


//...
//...
Derived deriveds[60];    // declare 60 derived objects
doSomethingOnArray(deriveds, 60);    
//...
//...

模板
无效doSomethingOnArray（X*arr，整数）
{
对于（int i=0；i

在这种情况下，编译器将看到传入的

Derived*

，并生成

doSomethingOnArray（Derived*，int）

，这是一个精确的类型匹配，因此没有指针算术错误

---

如果我可以保证在

doSomethingArray（）

中取消引用的任何对象都有

doSomething（）

方法，那么这是伪造多态性的安全方法吗？

只要您在第二个示例中喜欢这样做，而不是像这样做

doSomethingOnBases<Base>(deriveds, 60);

或

---

如果出于某种原因确实需要基类引用…

使用模板是可能的，但另一种解决方案是传递一个

base**base

，其中包含指向从base派生的对象的指针数组

void doSomethingOnBases(Base** bases, int numBases)
{
    for(int i = 0; i < numBases; i++)
    {
        bases[i]->doSomething();
    }
}

void dosomethingonbase（Base**Base，int numBases）
{
for（int i=0；idoSomething（）；
}
}

这将允许您保留一个混合派生对象的数组，而不仅仅是一个单一类型的

派生

数组

---

顺便说一句：请注意，如果您使用的是模板化解决方案，那么您甚至不需要从Base继承。

只要X有一个doSomethng（）方法，理论上它就不应该关心，而且是完全正确的。

void doSomethingOnBases(Base** bases, int numBases)
{
    for(int i = 0; i < numBases; i++)
    {
        bases[i]->doSomething();
    }
}

for (Base& b : arr)
    …

void doSomethingOnBases(Base** bases, int numBases)
{
    for(int i = 0; i < numBases; i++)
    {
        bases[i]->doSomething();
    }
}