如何在C / C ++中最好地处理动态多维数组?

时间:2008-12-13 21:38:32

标签: c++ c arrays multidimensional-array

在C和/或C ++中操作动态(所有维度直到运行时都不知道)的可接受/最常用的方法是什么。

我正在努力找到实现此Java代码的最简洁方法:

public static void main(String[] args){
 Scanner sc=new Scanner(System.in);
 int rows=sc.nextInt();
 int cols=sc.nextInt();
 int[][] data=new int[rows][cols];
 manipulate(data);
}

public static void manipulate(int[][] data){
   for(int i=0;i<data.length;i++)
   for(int j=0;j<data[0].length.j++){
         System.out.print(data[i][j]);       
   }    
}

(从std_in读取只是为了澄清尺寸在运行时才知道)。

编辑:我注意到这个问题非常受欢迎,即使它很老了。我实际上并不同意最高投票的答案。我认为C的最佳选择是使用一维数组,如Guge所说:“你可以分配行 cols sizeof(int)并通过表[row * cols + col]访问它。”

C ++有很多选择,如果你真的喜欢boost或stl,那么下面的答案可能更合适,但最简单也可能最快的选择是使用C中的单维数组。

如果你想要[] []语法,那么C和C ++中另一个可行的选择是lillq在底部的答案是手动构建带有大量malloc的数组。

10 个答案:

答案 0 :(得分:21)

使用 boost::multi_array

在您的示例中,您在编译时唯一需要知道的是维度数。这是文档中的第一个示例:

#include "boost/multi_array.hpp"
#include <cassert>

int 
main () {
  // Create a 3D array that is 3 x 4 x 2
  typedef boost::multi_array<double, 3> array_type;
  typedef array_type::index index;
  array_type A(boost::extents[3][4][2]);

  // Assign values to the elements
  int values = 0;
  for(index i = 0; i != 3; ++i) 
    for(index j = 0; j != 4; ++j)
      for(index k = 0; k != 2; ++k)
        A[i][j][k] = values++;

  // Verify values
  int verify = 0;
  for(index i = 0; i != 3; ++i) 
    for(index j = 0; j != 4; ++j)
      for(index k = 0; k != 2; ++k)
        assert(A[i][j][k] == verify++);

  return 0;
}

编辑:正如评论中所建议的,here is a "simple" example应用程序允许您在运行时定义多维数组大小,从控制台输入询问。 以下是此示例应用程序的示例输出(使用常量编译,表示它是3维):

Multi-Array test!
Please enter the size of the dimension 0 : 4

Please enter the size of the dimension 1 : 6

Please enter the size of the dimension 2 : 2

Text matrix with 3 dimensions of size (4,6,2) have been created.

Ready!
Type 'help' for the command list.

>read 0.0.0
Text at (0,0,0) :
  ""

>write 0.0.0 "This is a nice test!"
Text "This is a nice test!" written at position (0,0,0)

>read 0.0.0
Text at (0,0,0) :
  "This is a nice test!"

>write 0,0,1 "What a nice day!"
Text "What a nice day!" written at position (0,0,1)

>read 0.0.0
Text at (0,0,0) :
  "This is a nice test!"

>read 0.0.1
Text at (0,0,1) :
  "What a nice day!"

>write 3,5,1 "This is the last text!"
Text "This is the last text!" written at position (3,5,1)

>read 3,5,1
Text at (3,5,1) :
  "This is the last text!"

>exit

代码中的重要部分是主要功能,我们从用户获取尺寸并使用以下内容创建数组:

const unsigned int DIMENSION_COUNT = 3; // dimension count for this test application, change it at will :)

// here is the type of the multi-dimensional (DIMENSION_COUNT dimensions here) array we want to use
// for this example, it own texts
typedef boost::multi_array< std::string , DIMENSION_COUNT > TextMatrix;

// this provide size/index based position for a TextMatrix entry.
typedef std::tr1::array<TextMatrix::index, DIMENSION_COUNT> Position; // note that it can be a boost::array or a simple array

/*  This function will allow the user to manipulate the created array
    by managing it's commands.
    Returns true if the exit command have been called.
*/
bool process_command( const std::string& entry, TextMatrix& text_matrix );

/* Print the position values in the standard output. */
void display_position( const Position& position );

int main()
{
    std::cout << "Multi-Array test!" << std::endl;

    // get the dimension informations from the user
    Position dimensions; // this array will hold the size of each dimension 

    for( int dimension_idx = 0; dimension_idx < DIMENSION_COUNT; ++dimension_idx )
    {
        std::cout << "Please enter the size of the dimension "<< dimension_idx <<" : ";
        // note that here we should check the type of the entry, but it's a simple example so lets assume we take good numbers
        std::cin >> dimensions[dimension_idx]; 
        std::cout << std::endl;

    }

    // now create the multi-dimensional array with the previously collected informations
    TextMatrix text_matrix( dimensions );

    std::cout << "Text matrix with " << DIMENSION_COUNT << " dimensions of size ";
    display_position( dimensions );
    std::cout << " have been created."<< std::endl;
    std::cout << std::endl;
    std::cout << "Ready!" << std::endl;
    std::cout << "Type 'help' for the command list." << std::endl;
    std::cin.sync();


    // we can now play with it as long as we want
    bool wants_to_exit = false;
    while( !wants_to_exit )
    {
        std::cout << std::endl << ">" ;
        std::tr1::array< char, 256 > entry_buffer; 
        std::cin.getline(entry_buffer.data(), entry_buffer.size());

        const std::string entry( entry_buffer.data() );
        wants_to_exit = process_command( entry, text_matrix );
    }

    return 0;
}

你可以看到,为了加入数组中的元素,它非常简单:你只需使用operator(),如下面的函数所示:

void write_in_text_matrix( TextMatrix& text_matrix, const Position& position, const std::string& text )
{
    text_matrix( position ) = text;
    std::cout << "Text \"" << text << "\" written at position ";
    display_position( position );
    std::cout << std::endl;
}

void read_from_text_matrix( const TextMatrix& text_matrix, const Position& position )
{
    const std::string& text = text_matrix( position );
    std::cout << "Text at ";
    display_position(position);
    std::cout << " : "<< std::endl;
    std::cout << "  \"" << text << "\"" << std::endl;
}

注意:我在VC9 + SP1中编译了这个应用程序 - 只得到了一些遗忘警告。

答案 1 :(得分:8)

在C ++中有两种表示二维数组的方法。一个比另一个更灵活。

数组数组

首先创建一个指针数组,然后用另一个数组初始化每个指针。

// First dimension
int** array = new int*[3];
for( int i = 0; i < 3; ++i )
{
    // Second dimension
    array[i] = new int[4];
}

// You can then access your array data with
for( int i = 0; i < 3; ++i )
{
    for( int j = 0; j < 4; ++j )
    {
        std::cout << array[i][j];
    }
}

此方法的问题在于您的第二个维度被分配了多个数组,因此不会减轻内存分配器的工作。你的记忆可能会碎片化导致性能下降。它提供了更大的灵活性,因为第二维中的每个数组可以具有不同的大小。

保存所有值的大数组

这里的技巧是创建一个大型数组来保存您需要的每个数据。如果您希望能够使用array [i] [j]语法访问数据,那么您仍然需要第一个指针数组。

int* buffer = new int[3*4];   
int** array = new int*[3];

for( int i = 0; i < 3; ++i )
{
    array[i] = array + i * 4;
}

int *数组不是必需的,因为您可以通过从值的二维坐标计算缓冲区中的索引来直接在缓冲区中访问数据。

// You can then access your array data with
for( int i = 0; i < 3; ++i )
{
    for( int j = 0; j < 4; ++j )
    {
        const int index = i * 4 + j;
        std::cout << buffer[index];
    }
}

要记住的规则

计算机内存是线性的,并且仍会持续很长时间。请记住,计算机本身不支持二维数组,因此唯一的方法是将数组“线性化”为一维数组。

答案 2 :(得分:5)

您可以分配行 cols sizeof(int)并按表[row * cols + col]访问它。

答案 3 :(得分:4)

不使用boost的标准方法是使用std :: vector:

std::vector< std::vector<int> > v;
v.resize(rows, std::vector<int>(cols, 42)); // init value is 42
v[row][col] = ...;

这将自动处理新的/删除你需要的内存。但它相当慢,因为std::vector主要不是为了那样使用它(将std::vector嵌套到彼此中)。例如,所有内存不是在一个块中分配,而是为每列分开。行也不必都是相同的宽度。使用法线向量更快,然后像col_count * row + col那样进行索引计算以得到某一行和col:

std::vector<int> v(col_count * row_count, 42);
v[col_count * row + col) = ...;

但是这将失去使用[x][y]索引向量的能力。您还必须在某处存储行数和列数,而使用嵌套解决方案时,您可以使用v.size()获取行数,使用v[0].size()获取cols数量。

使用boost,您可以使用boost::multi_array,它可以完全满足您的需求(参见其他答案)。


还有使用本机C ++数组的原始方式。这包含了相当多的工作,并没有比嵌套的矢量解决方案更好:

int ** rows = new int*[row_count];
for(std::size_t i = 0; i < row_count; i++) {
    rows[i] = new int[cols_count];
    std::fill(rows[i], rows[i] + cols_count, 42);
}

// use it... rows[row][col] then free it...

for(std::size_t i = 0; i < row_count; i++) {
    delete[] rows[i];
}

delete[] rows;

您必须存储您在某处创建的列数和行数,因为您无法从指针接收它们。

答案 4 :(得分:4)

以下是在C中执行此操作的简便方法:

void manipulate(int rows, int cols, int (*data)[cols]) {
    for(int i=0; i < rows; i++) {
        for(int j=0; j < cols; j++) {
            printf("%d ", data[i][j]);       
        }
        printf("\n");
    }
}

int main() {
    int rows = ...;
    int cols = ...;
    int (*data)[cols] = malloc(rows*sizeof(*data));
    manipulate(rows, cols, data);
    free(data);
}

这是自C99以来的完全有效,但它不是任何标准的C ++:C ++要求数组类型的大小为编译时常量。在这方面,C ++现在落后于C十五年。这种情况不会很快改变(C ++ 17的可变长度数组提议不接近C99可变长度数组的功能)。

答案 5 :(得分:3)

C和C ++中的2D C风格数组是一个大小为rows * columns * sizeof(datatype)字节的内存块。

实际的[row] [column]维度仅在编译时静态存在。在运行时没有动态的东西!

所以,正如其他人提到的那样,你可以实现

  int array [ rows ] [ columns ];

如:

 int  array [ rows * columns ]

或者作为:

 int * array = malloc ( rows * columns * sizeof(int) );

下一步:声明一个可变大小的数组。 在C 中,这是可能的:

int main( int argc, char ** argv )
{
  assert( argc > 2 );

  int rows    = atoi( argv[1] );
  int columns = atoi( argv[2] );

  assert(rows > 0 && columns > 0);
  int data [ rows ] [ columns ];  // Yes, legal!

  memset( &data, 0, sizeof(data) );

  print( rows, columns, data );
  manipulate( rows, columns, data );
  print( rows, columns, data );
}

在C 中,您可以将可变大小的数组作为非可变大小的数组传递:

void manipulate( int theRows, int theColumns, int theData[theRows][theColumns] )
{
  for (   int r = 0; r < theRows;    r ++ )
    for ( int c = 0; c < theColumns; c ++  )
      theData[r][c] = r*10 + c;
}

然而,在C ++中是不可能的。您需要使用动态分配来分配数组,例如:

int *array = new int[rows * cols]();

或最好(使用自动内存管理)

std::vector<int> array(rows * cols);

然后必须修改函数以接受1维数据:

void manipulate( int theRows, int theColumns, int *theData )
{
  for (   int r = 0; r < theRows;    r ++ )
    for ( int c = 0; c < theColumns; c ++  )
      theData[r * theColumns + c] = r*10 + c;
}

答案 6 :(得分:2)

如果您使用的是C而不是C ++,您可能需要查看Dave Hanson的库C Interfaces and Implementations中的Array_T抽象。它非常干净,设计精良。我让我的学生做一个二维版本作为练习。您可以这样做或只是编写一个执行索引映射的附加函数,例如,

void *Array_get_2d(Array_T a, int width, int height, int i, int j) {
    return Array_get(a, j * width, i, j);
}

有一个单独的结构可以存储宽度,高度和指向元素的指针。

答案 7 :(得分:1)

我最近遇到了类似的问题。我没有Boost可用。与普通数组相比,向量的向量结果非常慢。拥有一个指针数组会使初始化变得更加费力,因为你必须迭代每个维度并初始化指针,可能在这个过程中有一些非常笨拙的级联类型,可能有很多typedef。

免责声明:我不确定是否应该将此作为答案发布,因为它只回答了部分问题。我对以下内容道歉:

  • 我没有像其他评论员所说的那样介绍如何从标准输入中读取尺寸。
  • 这主要是针对C ++的。
  • 我只为两个维度编写了此解决方案。

无论如何我决定发布这个,因为我看到了在C ++中回答有关多维数组的问题而经常提出的向量向量,没有人提到它的性能方面(如果你关心它)。

我还解释了这个问题的核心问题是如何获得动态多维数组,这些数组可以像问题中的Java示例一样轻松使用,即没有必须用以下方法计算索引的麻烦伪多维一维数组。

我没有看到其他答案中提到的编译器扩展,比如GCC / G ++提供的用于声明具有动态边界的多维数组的方法与静态边界相同。据我所知,这个问题并没有限制标准C / C ++的答案。 ISO C99显然确实支持它们,但在C ++和C的早期版本中,它们似乎是特定于编译器的扩展。请参阅此问题:Dynamic arrays in C without malloc?

我提出了一种人们可能喜欢C ++的方式,因为它的代码很少,易于使用内置的静态多维数组,而且速度一样快。

template <typename T> 
class Array2D {
private:
    std::unique_ptr<T> managed_array_;
    T* array_;
    size_t x_, y_;

public:
    Array2D(size_t x, size_t y) {
        managed_array_.reset(new T[x * y]);
        array_ = managed_array_.get();
        y_ = y;
    }
    T* operator[](size_t x) const {
        return &array_[x * y_];
    }
};

你可以像这样使用它。尺寸不

auto a = Array2D<int>(x, y);
a[xi][yi] = 42;

您可以添加一个断言,至少除了最后一个维度之外的所有维度,并将想法扩展到两个以上的维度。我在博客上发了一篇关于获取多维数组的替代方法的帖子。我对那里的相对性能和编码工作也更加具体。

Performance of Dynamic Multi-Dimensional Arrays in C++

答案 8 :(得分:0)

您可以使用malloc来完成此操作,并且仍然可以通过普通数组[] []含义访问它,而不是数组[rows * cols + cols]方法。

main()
{
   int i;
   int rows;
   int cols;
   int **array = NULL;

   array = malloc(sizeof(int*) * rows);
   if (array == NULL)
       return 0;  // check for malloc fail

   for (i = 0; i < rows; i++)
   {
       array[i] = malloc(sizeof(int) * cols)
       if (array[i] == NULL)
           return 0;  // check for malloc fail
   }

   // and now you have a dynamically sized array
}

答案 9 :(得分:0)

无法确定C ++中给定数组的长度。最好的方法可能是传递数组每个维度的长度,并使用它而不是数组本身的.length属性。