如何创建可调整大小和固定大小容器的变体

Question

我有一个类，其基础数据是std::vector、std::unique_ptr 和std::deque 的变体。如下代码所示。

template<class T>
class matrix2d
{
private:
    typename std::variant<std::vector<T>,
                          std::unique_ptr<T[]>,
                          std::deque<T>> data;

public:
    matrix2d<T>() = delete;
    matrix2d<T>(size_t h, size_t w, int type) {
        try {
            switch (type) {
            case 0:
                data = std::vector<T>(h*w);
                break;
            case 1:
                data = std::make_unique<T[]>(h*w);
                break;
            case 2:
                data = std::deque<T>(h*w);
                break;
            default:
                throw std::runtime_error("Unrecognized type of matrix2d class data");
            }
        }
        catch (const std::exception& e) {
            std::cerr << e.what() << std::endl;
        }
    }
    auto operator[](size_t i) {
        return (std::begin(data) + i);
    }
};

int main()
{
    matrix2d<int> a2d(4,5,0);
    for (size_t i{}; i<4; ++i) {
        for (size_t j{}; j<5; ++j) {
            a2d[i][j] = 5.0;
        }
    }
}

我的问题如下：

是否可以创建 unique_ptr 和其他可调整大小的容器的联合？
另外，如何重载下标运算符 [] 以使类函数成为二维数组？

Answer 1

变体有效。

然而，访问行的用法需要对std::vector<T> 和std::unique_ptr<T[]>和std::deque<T>进行不同的处理。由于vector 和unique_ptr<T[]> 使用连续内存，deque 的元素不需要连续存储。

假设我们首先要为 vector 和 unique_ptr 实现 operator[]。

步骤 1

我们需要在类中添加一个成员来保存行的大小，这是计算行号 i 在数组中的位置所必需的。

假设您添加了一个私有成员“w”：

size_t w;

并且你在构造函数中初始化它：

matrix2d<T>(size_t h, size_t w, int type) : w(w) {
   // ...

第二步

现在我们正在寻找的 operator[] 可以如下所示：

auto operator[](size_t i) {
    return std::visit([i, w = this->w](auto&& arg){return &arg[i*w];}, data);
}

即使我们在此处对std::variant 管理的任何类型使用相同的操作，也需要使用std::visit。但是，std::visit 也能够对存储的每种类型进行不同的操作，请参阅std::visit on cppreference。

第三步

如果我们也想支持deque，这需要不同的处理方式。

目前我们的 operator[] 返回 T*，我们想保留它。

对于双端队列，我们​​不能只取一行中第一个元素的地址，并假设同一行中的所有元素都紧随其后，连续地存储。因此，为了允许使用相同的方法使用双端队列，我们​​至少需要行是连续的。我们可以通过 Ts 的向量双端队列来实现。这在类中的 variant 声明中可能如下所示：

 std::variant< std::vector<T>,
               std::unique_ptr<T[]>,
               td::deque<std::vector<T>> > data;

在构造函数中，deque 的初始化将是：

case 2: { // TODO: use enum instead
  auto d = std::deque<std::vector<T>>(h);
  for(auto& item : d) {
    item = std::vector<T>(w);
  }
  data = d;
}
break;

operator[] 现在将更改为：

auto operator[](size_t i) {
    return std::visit([i, w = this->w](auto&& arg){
        using U = std::decay_t<decltype(arg)>;
        if constexpr (std::is_same_v<U, std::deque<std::vector<T>>>) {
            return &arg[i][0];
        }
        else {
            return &arg[i*w];
        }
    }, data);
}

---

http://coliru.stacked-crooked.com/a/192fbf6705aecc7c