C++声明不知道大小的数组数组

我必须在不知道大小的情况下声明一个数组或数组的多维数组。我想要做类似我在这个情况下做简单的数组的东西：C++声明不知道大小的数组数组

int *array; 
cin >> size; 
array = new int[size];

也许我可以做一个循环来初始化指针这样的指针：

int **array; 
cin >> rows >> col; 
array = new *int[rows] 
for (int i = 0; i < rows; ++i) 
    array[i] = new int[col];

但我更喜欢唐如果有更好的解决方案是可能的，就不要这样做。

来源

2012-10-10 blackløtus

如果你想只在运行时已知大小的数组，你可能真正需要的是一个'的std :: VECTOR'。 – cHao

你了解了标准库吗？你知道一个'std :: vector'是什么吗？ – amdn

@PuraVida我非常了解标准库谢谢。我正在测试使用矢量>和数组int [] []的性能，所以我需要使用该数组，因此我不想使用循环来初始化它。 –

为什么不使用std :: vector？

std::vector<std::vector<int> > array;

如果你不希望使用指针数组，你可以使用你动态地分配你的规模和访问它行的一组后的一个大阵。

int rows = 10; 
int columns = 20; 

int* array = new int[rows * columns]; 

for (int count = 0; count < rows; count++) 
{ 
    int* row = &array[count * columns]; 

    for (int inner_count = 0; inner_count < columns; inner_count++) 
    { 
     int* element = &row[inner_count]; 

     //do something 
    } 
} 

delete [] array;

来源

2012-10-10 23:56:12

如果有问题的代码是性能敏感的，不要使用'vectors'的'vector'。与单个大块内存相比，您将面临大量的缓存未命中。 –

@ EdS.yea这是原因之一，我想尝试这样做，而不使用循环来初始化它。 –

你几乎不得不去使用循环版本。你可以让一个略有改善，这是分配了一个大的块，然后建立自己的int*索引到它：

int **array; 
int *storage; 
cin >> rows >> col; 
array = new *int[rows]; 
storage = new int[rows*col]; 
for (int i = 0; i < rows; ++i) 
    array[i] = storage + col * i;

这有你仍然可以使用array[i][j]语法访问数组很好的特性。

来源

2012-10-11 00:03:58 sblom

如果你愿意，你可以有更多的一点点方便由具有助手

template <typename T> 
struct C3DArray 
{ 
    vector<vector<vector<T>>> m; 
    C3DArray(int size_x, int size_y, int size_z) 
     : m(make(T(), size_z, size_y, size_x)) 
    { } 

    template <typename U> static std::vector<U> make(U v, size_t n) { 
     return { n, std::move(v) }; 
    } 

    template <typename U, typename... Dim> static auto make(U v, size_t n, Dim... other) 
     -> std::vector<decltype(make(v, other...))> { 
     return { n, make(v, other...) }; 
    } 
};

这使用variadics。使用这样的：

C3DArray<int> arr(3,4,20);

来源

2012-10-11 00:08:51 sehe

你可以使用一个单一的std ::向量包含整个二维数组，敷在一类隐藏的细节。下面是一个示例，它使用data(row, col)成员函数，该函数返回对row和col处元素的引用。我包含了一个示例2维矩阵int，其中阵列中的每个条目都被初始化为其产品row和col。当这个类的一个实例超出作用域时，默认的析构函数会被调用并释放内存，这样你就不必记得调用delete []来释放内存。矩阵的所有元素在内存中都是连续的，这对缓存很友好，并且应该给你提供良好的性能。

#include <iostream> 
#include <vector> 
#include <stdexcept> 

template <typename T> 
class matrix { 
    std::vector<T> data_; 
public: 
    size_t const rows_; 
    size_t const cols_; 
    matrix(size_t rows, size_t cols) 
     : rows_(rows) 
     , cols_(cols) 
     , data_(rows * cols) 
    {} 
    T& data(size_t row, size_t col) { 
     if (row > rows_ || col > cols_) throw std::out_of_range("matrix"); 
     return data_[ row * cols_ + col ]; 
    } 
}; 

int main(int argc, char** argv) 
{ 
    matrix<int> array(100,100); 

    for(size_t r=0; r < array.rows_; ++r) { 
     for(size_t c=0; c < array.cols_; ++c) { 
      array.data(r,c) = r * c; 
     } 
    } 

    std::cout << "8 x 7 = " << array.data(8,7) << std::endl; 

    return 0; // array goes out of scope here, memory released automatically 
}

当你运行这个你会得到

8 x 7 = 56

来源

2012-10-11 04:45:35 amdn

感谢您的解释，我会试试这个 –

C++声明不知道大小的数组数组

回答

相关问题