如何在C++中实现支持可变长度与类型的行式存储？

问题描述 #

我正尝试在C++中实现一个可变长度的行式存储系统，要求每行可存储不同长度、不同类型的数据，例如第一行可为[1, 8.6, "hello"]，第二行可为[2, 9.6]。

最初计划为每行使用带可变模板的tuple，每行存储为std::tuple<Types...>，整个存储用std::vector<std::tuple<Types...>>表示。但遇到的问题是，声明Map类时需显式指定参数类型（如Map<int, double, std::string>），这限制了向同一个Map实例插入不同长度和类型的记录。

简化代码示例：

#include <vector>
#include <tuple>
#include <utility>

template <typename... Types>
class Tuple {
private:
    std::tuple<Types...> data;
public:
    Tuple() : data() {}

    Tuple(Types &&... args) : data(std::forward<Types>(args)...) {}
};

template <typename... Types>
class Map {
private:
    std::vector<Tuple<Types...>> record;
public:
    void addRow(Types &&... args) {
        record.emplace_back(std::forward<Types>(args)...);
    }
};

请问是否可以创建一个支持每行存储不同长度和类型数据的Map类？该如何在C++中实现？

解决方案 #

当然可以实现这样的存储系统，核心思路是让每行的存储类型具备类型擦除能力，从而容纳任意结构的数据。以下是几种可行的实现方式：

方法一：使用std::any存储行内元素 #

用std::vector<std::any>作为每行的存储类型，整个系统用std::vector<std::vector<std::any>>来保存所有行。这种方式最简单直接，适合快速实现：

#include <vector>
#include <any>
#include <string>
#include <iostream>

class Map {
private:
    std::vector<std::vector<std::any>> records;
public:
    // 接受任意数量、任意类型的参数，构造一行并添加
    template <typename... Args>
    void addRow(Args&&... args) {
        std::vector<std::any> row;
        // 展开参数并添加到行中
        (row.emplace_back(std::forward<Args>(args)), ...);
        records.push_back(std::move(row));
    }

    // 示例：获取指定行指定位置的元素，需要显式转换类型
    template <typename T>
    T get(size_t row_idx, size_t col_idx) const {
        return std::any_cast<T>(records[row_idx][col_idx]);
    }
};

// 使用示例
int main() {
    Map myMap;
    myMap.addRow(1, 8.6, std::string("hello"));
    myMap.addRow(2, 9.6);

    std::cout << myMap.get<int>(0, 0) << std::endl;
    std::cout << myMap.get<double>(0, 1) << std::endl;
    std::cout << myMap.get<std::string>(0, 2) << std::endl;
    std::cout << myMap.get<int>(1, 0) << std::endl;
    std::cout << myMap.get<double>(1, 1) << std::endl;

    return 0;
}

优缺点：

• 优点：实现简单，完全支持任意类型和长度的行。
• 缺点：访问元素时必须显式指定类型，类型错误会在运行时抛出异常；没有编译期类型检查，性能略低于模板实现。

方法二：使用std::variant限定允许的类型 #

如果希望限制行内元素只能是预先定义的几种类型（比如只允许int、double、string），可以用std::variant替代std::any，这样能获得部分编译期类型安全：

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

using CellType = std::variant<int, double, std::string>;

class Map {
private:
    std::vector<std::vector<CellType>> records;
public:
    template <typename... Args>
    void addRow(Args&&... args) {
        std::vector<CellType> row;
        (row.emplace_back(std::forward<Args>(args)), ...);
        records.push_back(std::move(row));
    }

    // 访问元素，使用std::visit处理不同类型
    void printCell(size_t row_idx, size_t col_idx) const {
        const auto& cell = records[row_idx][col_idx];
        std::visit([](const auto& val) {
            std::cout << val << " ";
        }, cell);
    }
};

// 使用示例
int main() {
    Map myMap;
    myMap.addRow(1, 8.6, std::string("hello"));
    myMap.addRow(2, 9.6);

    myMap.printCell(0, 0);
    myMap.printCell(0, 1);
    myMap.printCell(0, 2);
    std::cout << std::endl;
    myMap.printCell(1, 0);
    myMap.printCell(1, 1);

    return 0;
}

优缺点：

• 优点：编译期检查元素类型是否符合限定，访问时可以通过std::visit优雅处理不同类型，性能比std::any略好。
• 缺点：需要预先定义允许的类型，灵活性不如std::any。

方法三：基于多态的自定义行类型 #

如果需要更复杂的行为（比如每行支持自定义序列化/反序列化），可以定义一个抽象基类Row，然后为不同结构的行创建派生类，用std::unique_ptr<Row>存储：

#include <vector>
#include <memory>
#include <string>
#include <iostream>
#include <tuple>
#include <utility>

class Row {
public:
    virtual ~Row() = default;
    virtual void print() const = 0; // 纯虚函数，定义行的行为
};

// 模板派生类，适配任意tuple类型
template <typename... Types>
class TupleRow : public Row {
private:
    std::tuple<Types...> data;
public:
    TupleRow(Types&&... args) : data(std::forward<Types>(args)...) {}

    void print() const override {
        // 递归打印tuple元素
        printTuple(data);
    }

private:
    template <typename Tuple, size_t... Idx>
    void printTupleImpl(const Tuple& t, std::index_sequence<Idx...>) const {
        ((std::cout << std::get<Idx>(t) << " "), ...);
    }

    template <typename Tuple>
    void printTuple(const Tuple& t) const {
        printTupleImpl(t, std::make_index_sequence<std::tuple_size_v<Tuple>>());
    }
};

class Map {
private:
    std::vector<std::unique_ptr<Row>> records;
public:
    template <typename... Args>
    void addRow(Args&&... args) {
        records.emplace_back(std::make_unique<TupleRow<Args...>>(std::forward<Args>(args)...));
    }

    void printRow(size_t row_idx) const {
        records[row_idx]->print();
        std::cout << std::endl;
    }
};

// 使用示例
int main() {
    Map myMap;
    myMap.addRow(1, 8.6, std::string("hello"));
    myMap.addRow(2, 9.6);

    myMap.printRow(0);
    myMap.printRow(1);

    return 0;
}

优缺点：

• 优点：可以为行添加自定义行为，扩展性强，保留了tuple的类型信息（在派生类中）。
• 缺点：实现相对复杂，访问元素需要通过基类接口或动态类型转换，有轻微的运行时多态开销。

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