C++ C++；-基于向量的二维对象数组

正如我建议的那样，我修复了我的2D数字数组，使其能够与Vector类一起工作

头文件：

#include <vector>

typedef std::vector<int> Array;
typedef std::vector<Array> TwoDArray;

#包括
向量数组；
typedef std：：向量TwoDArray；

下面是它的使用方法：

TwoDArray Arr2D; 

// Add rows
for (int i = 0; i < numRows; ++i) {
    Arr2D.push_back(Array());
}

// Fill in test data
for (int i = 0; i < numRows; i++) {    
    for (int j = 0; j < numCols; j++) {
        Arr2D[i].push_back(ofRandom(0, 10));           
    }
}

// Make sure the data is there
for (int i = 0; i < numRows; i++) {    
    for (int j = 0; j < numCols; j++) {
        std::cout << Arr2D[i][j] << ' ';
    }
std::cout << '\n';
}

TwoDArray Arr2D；
//添加行
对于（int i=0；i
typedef std::vector<int> Array;
typedef std::vector<Array> TwoDArray;

typedef std:：向量数组；
typedef std：：向量TwoDArray；

到

typedef std:：向量数组；
typedef std：：向量TwoDArray；
您需要更改

typedef std::vector<int> Array;
typedef std::vector<Array> TwoDArray;

typedef std:：向量数组；
typedef std：：向量TwoDArray；

到

typedef std:：向量数组；
typedef std：：向量TwoDArray；
在大纲中：

struct MyObject {};

typedef std::vector<MyObject> Array;
typedef std::vector<Array> TwoDArray;

// stuff

Arr2D[i].push_back( MyObject() );  

structmyobject{}；
向量数组；
typedef std：：向量TwoDArray；
//东西
Arr2D[i].向后推（MyObject（））；

请注意，要将内容存储在向量中，它们必须是可复制和可分配的。
在大纲中：

struct MyObject {};

typedef std::vector<MyObject> Array;
typedef std::vector<Array> TwoDArray;

// stuff

Arr2D[i].push_back( MyObject() );  

structmyobject{}；
向量数组；
typedef std：：向量TwoDArray；
//东西
Arr2D[i].向后推（MyObject（））；

请注意，要将内容存储在向量中，它们必须是可复制和可分配的。
new MyObject（）
将返回一个指针，指向新创建的类的实例
MyObject
。如果您创建了
vector
，则需要执行类似于
推回（MyObject（））
new MyObject（）
将返回一个指向新创建的类的实例的指针
MyObject
。如果您已经创建了
向量
，则需要执行类似于
推回（MyObject（））
的操作尝试以下操作：

template<class T>
struct Array2D {
    vector<vector<T>> Array;
};

模板
结构阵列2d{
矢量阵列；
};

现在，您可以像这样向任何对象声明它

Array2D<MyObject>::Array array;

Array2D:：数组；

甚至

Array2D<MyObject*>::Array array;

Array2D:：数组；

和平常一样，带着你的一天

请注意，当您将对象分配给stl容器时，它应该实现默认的无参数构造函数、复制构造函数和重载运算符=（常量和非常量），否则您应该插入指向该对象的指针。
尝试以下操作：

template<class T>
struct Array2D {
    vector<vector<T>> Array;
};

模板
结构阵列2d{
矢量阵列；
};

现在，您可以像这样向任何对象声明它

Array2D<MyObject>::Array array;

Array2D:：数组；

甚至

Array2D<MyObject*>::Array array;

Array2D:：数组；

和平常一样，带着你的一天

请注意，当您将对象分配给stl容器时，它应该实现默认的无参数构造函数、复制构造函数和重载运算符=（常量和非常量），否则您应该插入指向该对象的指针。
如果我是您，我将使用指针数组而不是对象本身（但在执行“clear（）”）之前，您必须处理解除分配问题）

typedef std:：vector 2DArray；
2da阵列；
对于（int i=0；i如果我是您，我将使用指针数组而不是对象本身（但在执行“clear（）”）之前，您必须处理释放）

typedef std:：vector 2DArray；
2da阵列；
对于（int i=0；i既然您正在寻找最佳的设计方法，为什么不遵循的建议并使您的数组密集（而不是参差不齐）。您不希望必须处理不同大小的行，是吗

#include <iostream>
#include <random>
#include <vector>

template<typename T>
class TwoDArray {
        std::vector<T> data;
        const size_t cols;
public:
        TwoDArray(size_t R, size_t C) : data(R*C), cols(C) {}
        T operator()(size_t r, size_t c) const { return data[cols*r+c]; }
        T& operator()(size_t r, size_t c) { return data[cols*r+c]; }
};

int main()
{
        // Make it
        const size_t numRows = 10;
        const size_t numCols = 10;
        TwoDArray<int> Arr2D(numRows, numCols);

        // Fill in test data
        std::random_device rd;
        std::mt19937 eng(rd());
        std::uniform_int_distribution<> unif(0,9);
        for (size_t i=0; i<numRows; ++i)
           for (size_t j=0; j<numCols; ++j)
                Arr2D(i,j) = unif(eng);

        // Make sure the data is there
        for (size_t i = 0; i < numRows; i++) {
            for (size_t j = 0; j < numCols; j++) {
                 std::cout << Arr2D(i,j) << ' ';
            }
            std::cout << '\n';
        }

}

#包括
#包括
#包括
样板
二类达雷{
std：：矢量数据；
const size\u t cols；
公众：
TwoDArray（大小R，大小C）：数据（R*C），cols（C）{
T运算符（）（size_T r，size_T c）常量{返回数据[cols*r+c]；}
运算符（）（size_T r，size_T c）{返回数据[cols*r+c]；}
};
int main（）
{
//成功
常数大小\u t numRows=10；
常数大小=10；
两个darray Arr2D（numRows，numCols）；
//填写测试数据
std：：随机_装置rd；
标准：mt19937英语（rd（））；
标准：均匀分布unif（0,9）；
对于（size_t i=0；i既然您正在寻找最佳的设计方法，为什么不遵循的建议并使您的数组密集（而不是参差不齐）。您不希望必须处理不同大小的行，是吗

#include <iostream>
#include <random>
#include <vector>

template<typename T>
class TwoDArray {
        std::vector<T> data;
        const size_t cols;
public:
        TwoDArray(size_t R, size_t C) : data(R*C), cols(C) {}
        T operator()(size_t r, size_t c) const { return data[cols*r+c]; }
        T& operator()(size_t r, size_t c) { return data[cols*r+c]; }
};

int main()
{
        // Make it
        const size_t numRows = 10;
        const size_t numCols = 10;
        TwoDArray<int> Arr2D(numRows, numCols);

        // Fill in test data
        std::random_device rd;
        std::mt19937 eng(rd());
        std::uniform_int_distribution<> unif(0,9);
        for (size_t i=0; i<numRows; ++i)
           for (size_t j=0; j<numCols; ++j)
                Arr2D(i,j) = unif(eng);

        // Make sure the data is there
        for (size_t i = 0; i < numRows; i++) {
            for (size_t j = 0; j < numCols; j++) {
                 std::cout << Arr2D(i,j) << ' ';
            }
            std::cout << '\n';
        }

}

#包括
#包括
#包括
样板
二类达雷{
std：：矢量数据；
const size\u t cols；
公众：
TwoDArray（大小R，大小C）：数据（R*C），cols（C）{
T运算符（）（size_T r，size_T c）常量{返回数据[cols*r+c]；}
运算符（）（size_T r，size_T c）{返回数据[cols*r+c]；}
};
int main（）
{
//成功
常数大小\u t numRows=10；
常数大小=10；
两个darray Arr2D（numRows，numCols）；
//填写测试数据
std：：随机_装置rd；
标准：mt19937英语（rd（））；
标准：均匀分布unif（0,9）；
对于（size_t i=0；i尝试给出不起作用的代码片段和错误-也许我们可以看到一些东西。尝试给出不起作用的代码片段和错误-也许我们可以看到一些东西。+1如果你来自Java背景，那么容易犯错误。+1如果你来自Java背景，那么容易犯错误。