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

How to create a variant of re-sizeable and fixed size containers

本文关键字：何创建 创建 可调整      更新时间：2023-10-16

>我有一个类，其底层数据是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和其他可调整大小的容器的联合？
另外，如何重载下标运算符 [] 以使类函数为二维数组？

变体有效。

但是，访问行的用法一方面需要对std::vector<T>和std::unique_ptr<T[]>进行处理，另一方面需要对std::deque<T>进行处理。由于vector和unique_ptr<T[]>使用连续内存，因此不需要连续存储deque元素。

假设我们首先要为向量和unique_ptr实现运算符 []。

步骤 1

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

因此，假设您添加一个私有成员"w"：

size_t w;

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

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

步骤 2

现在我们正在寻找的运算符 [] 可以看起来像这样：

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：：访问 cpp首选项。

步骤 3

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

目前我们的运算符 [] 返回 T*，我们希望保留它。

对于 deque，我们不能只获取一行中第一个元素的地址，并假设同一行中的所有元素都相邻地存储在一起，连续地存储。因此，为了允许以相同的方法使用 deque，我们至少需要行是连续的。我们可以通过 T 的向量来实现这一点。在类的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;

运算符 [] 现在将更改为：

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

相关文章：