C++面向数据设计如何在不使用虚函数的情况下实现多态？

面向数据设计（DOD）的核心是优先组织数据以优化缓存效率，而非围绕对象封装逻辑。要在DOD中实现多态（用统一接口处理不同数据类型），同时避开虚函数带来的对象布局开销和缓存失效风险，可采用以下几种实用方案：

1. 标签分派（静态多态，编译期确定） #

通过类型标签区分不同数据组，编译期自动匹配对应的处理函数，完全无运行期开销，最契合DOD的性能要求。

示例代码 #

#include <vector>
#include <iostream>

// 按类型紧凑存储的数据结构
struct CircleData {
    std::vector<float> radii;
};

struct RectangleData {
    std::vector<float> widths;
    std::vector<float> heights;
};

// 类型标签
struct CircleTag {};
struct RectangleTag {};

// 针对不同标签的处理函数
float calculate_area(CircleTag, const CircleData& data, size_t index) {
    const float r = data.radii[index];
    return 3.14159f * r * r;
}

float calculate_area(RectangleTag, const RectangleData& data, size_t index) {
    return data.widths[index] * data.heights[index];
}

int main() {
    CircleData circles{{1.0f, 2.0f}};
    RectangleData rects{{3.0f, 4.0f}, {5.0f, 6.0f}};

    std::cout << "Circle area: " << calculate_area(CircleTag{}, circles, 0) << "\n";
    std::cout << "Rectangle area: " << calculate_area(RectangleTag{}, rects, 0) << "\n";
    return 0;
}

适用场景：编译期即可确定数据类型，需要极致性能的批量数据处理场景。

2. 自定义函数指针表（运行期多态） #

手动实现类似虚表的函数指针结构体，将数据与处理逻辑分离。每个数据组关联对应的函数表，既保留运行期动态切换的灵活性，又避免了OOP虚函数的对象布局冗余。

示例代码 #

#include <vector>
#include <iostream>

// 函数表前向声明
struct ShapeVTable;

// 基础数据结构：仅含函数表指针
struct ShapeData {
    const ShapeVTable* vtable;
};

// 派生数据结构：紧凑存储对应类型的数据
struct CircleData : ShapeData {
    std::vector<float> radii;
};

struct RectangleData : ShapeData {
    std::vector<float> widths;
    std::vector<float> heights;
};

// 函数表：定义所有多态操作
struct ShapeVTable {
    float (*calculate_area)(const ShapeData*, size_t);
};

// Circle的具体实现
float circle_area(const ShapeData* shape, size_t index) {
    const auto* circle = static_cast<const CircleData*>(shape);
    return 3.14159f * circle->radii[index] * circle->radii[index];
}

// Rectangle的具体实现
float rect_area(const ShapeData* shape, size_t index) {
    const auto* rect = static_cast<const RectangleData*>(shape);
    return rect->widths[index] * rect->heights[index];
}

// 静态函数表实例
const ShapeVTable CircleVTable = {circle_area};
const ShapeVTable RectangleVTable = {rect_area};

int main() {
    CircleData circles;
    circles.vtable = &CircleVTable;
    circles.radii = {1.0f, 2.0f};

    RectangleData rects;
    rects.vtable = &RectangleVTable;
    rects.widths = {3.0f, 4.0f};
    rects.heights = {5.0f, 6.0f};

    const ShapeData* shapes[] = {&circles, &rects};
    for (const auto* shape : shapes) {
        std::cout << "Area: " << shape->vtable->calculate_area(shape, 0) << "\n";
    }
    return 0;
}

适用场景：需要运行期动态添加或切换数据类型，同时保持数据紧凑存储的场景。

3. 变体类型（编译期+运行期多态） #

利用C++17的std::variant存储不同类型的数据实例，通过std::visit实现类型安全的分派。变体保证数据内联存储，无堆分配开销，性能接近静态多态，同时支持运行期类型切换。

示例代码 #

#include <vector>
#include <iostream>
#include <variant>

// 单个数据实例（适合小对象场景）
struct Circle {
    float radius;
};

struct Rectangle {
    float width;
    float height;
};

// 变体类型：可存储Circle或Rectangle
using Shape = std::variant<Circle, Rectangle>;

// 访问器：定义不同类型的处理逻辑
struct AreaCalculator {
    float operator()(const Circle& c) const {
        return 3.14159f * c.radius * c.radius;
    }

    float operator()(const Rectangle& r) const {
        return r.width * r.height;
    }
};

int main() {
    std::vector<Shape> shapes = {Circle{1.0f}, Rectangle{3.0f, 5.0f}};

    for (const auto& shape : shapes) {
        float area = std::visit(AreaCalculator{}, shape);
        std::cout << "Area: " << area << "\n";
    }
    return 0;
}

适用场景：数据类型数量有限、需要存储单个异构对象，同时兼顾性能和灵活性的场景。

内容的提问来源于stack exchange，提问作者Nathan Doromal