在C++中，如果一个类包含虚函数，则会为该类创建一个虚函数表（vtable），该表包含指向实现每个虚函数的函数指针。每个对象都包含一个指向其类的vtable的指针，以便在运行时调用适当的虚函数。

然而，在使用包含虚函数的类的数组时，每个对象的vtable指针会占用额外的内存空间。在对内存使用效率有着严格要求的情况下，这可能是不可接受的。

解决此问题的一种方法是使用C++模板和非虚函数来实现多态性。具体地说，可以定义一个模板类，其中包含一个指向一个实现多态性的非虚函数的指针。每个实例化的类都可以具有不同的函数实现。

以下是一个简单的示例代码，展示了如何使用模板类来实现多态性，同时避免使用vtable指针：

// 定义一个模板类，其中包含一个指向实现多态性的函数的指针
template
class ArrayBase {
public:
    using Element = T;

    // 定义非虚函数process，其在不同T中的实现会导致不同的行为
    using Processor = void(*)(Element&);

    ArrayBase(Processor processor) : m_processor(processor) {}

    // 定义一个处理数组元素的方法，其中调用process函数指针
    void processElements(Element* elements, int count) {
        for (int i = 0; i < count; i++) {
            m_processor(elements[i]);
        }
    }

private:
    Processor m_processor;
};

// 定义一个我们关心的类型，并使用它实例化ArrayBase
struct MyType {
    int value;
};

using MyArray = ArrayBase;

// 定义一些具有不同处理函数的MyArray实例
void myTypeProcessorA(MyType& element) {
    element.value *= 2;
}

void myTypeProcessorB(MyType& element) {
    element.value *= 3;
}

int main() {
    // 创建一个MyArray实例，并具有处理函数myTypeProcessorA
    MyArray myArrayA(myTypeProcessorA);

    // 创建一个MyArray实例，并具有处理函数myTypeProcessorB
    MyArray myArrayB(myTypeProcessorB);

    // 填充数组
    MyType myElements[10];
    for (int i = 0; i < 10; i++) {
        myElements[i].value = i;
    }

    // 处理数组元素
    myArrayA.processElements(myElements, 10);
    myArrayB.processElements(myElements, 10);

    // 检查处理结果
    for (int i = 0; i < 10; i++) {
        std::cout << myElements[i].value << std::endl;
    }

    return 0;
}

在这个示例中，我们使用模板类ArrayBase，它封装了指向一个实现多态性的非虚函数的指针m_processor。然后，我们使用MyType类型实例化