声明一个大小未知的二维数组，C

我在C中声明了一个数组作为结构的成员。该数组声明为：

char        mValue[MAXROWS][MAXCOLUMNS]; 

其中

MAXROWS

和

MAXROWS

为300。有更好的方法吗？我是说，我应该把它们声明为指针吗

---

谢谢

另一种技术是创建线性阵列，然后将其转换为二维：

char *p = malloc(ROWS * COLUMNS);

// To access x, y
// This is in row-major ordr
*(p + (x * COLUMNS) + y);

---

正如前面的海报所建议的，一个好方法是创建一个线性阵列，然后“将其转换为二维”。很多时候，缓存2D指针会大大提高使用此数组的程序的速度，如下所示：

mystruct *p = (mystruct*)calloc(ROWS * COLUMNS, sizeof(mystruct));
mystruct **p2 = (mystruct**)calloc(ROWS, sizeof(mystruct*));
for (int i = 0; i < ROWS; i++)
    p2[i] = p + i*COLUMNS;

---

如果数组需要具有动态大小，则需要将其设置为指针，或者将数组设置为结构的最后一个成员，并在分配结构大小时玩游戏

相关comp.lang.c常见问题解答条目：

---

如果所有行的大小相同，则应使用1D数组，并按顺序存储行：

ABCDE
FGHIJ   --->  ABCDEFGHIJKLMNO
KLMNO

第i行第j列的元素将位于1D数组中的索引

i*行长度+j

---

您可以使用

malloc（ROW\u LENGTH*NUM\u ROWS）

分配数组。我发现，对于这种代码，最好创建用于访问元素的辅助函数。根据您的分析数据，将它们转换为宏可能是有意义的，但要格外小心

#include <stdio.h>  /* For printf */

/* This is the bit that would go in a header, like char2darray.h */
#include <stdlib.h> /* For calloc */
#include <assert.h> /* For assert */

struct Char2DArray
{
   int rows;
   int columns;
   char *values;
};

/* This is the bit that would go in a source file, like char2darray.c */

void C2DA_initialize(struct Char2DArray *array, int rows, int columns)
{
    assert(array != 0);
    array->values = calloc(rows * columns, sizeof(char));
    array->rows = rows;
    array->columns = columns;
}

void C2DA_set(struct Char2DArray *array, int row, int column, int value)
{
    assert(array != 0);
    assert(array->values != 0);
    assert(row < array->rows);
    assert(row >= 0);
    assert(column < array->columns);
    assert(column >= 0);

    array->values[(row * array->rows) + column] = value;
}

char C2DA_get(struct Char2DArray *array, int row, int column)
{
    assert(array != 0);
    assert(array->values != 0);
    assert(row < array->rows);
    assert(row >= 0);
    assert(column < array->columns);
    assert(column >= 0);

    return array->values[(row * array->rows) + column];
}

void C2DA_free(struct Char2DArray *array)
{
    free(array->values);
    array->values = 0;
}

/* Here's a main.c to use it */
int main()
{
    struct Char2DArray a;
    C2DA_initialize(&a, 16, 16);
    unsigned char c = 0;
    int x, y;
    for (x=0; x<16; x++) {
        for (y=0; y<16; y++) {
            C2DA_set(&a, x, y, (char)c);
            c++;
        }
    }
    printf("Character with hex value 0x55 is %c\n", C2DA_get(&a, 5, 5));
    C2DA_free(&a);
    return 0;
}

#包括/*用于printf*/
/*这是头中的位，如char2darray.h*/
#包括/*用于calloc*/
#包括/*用于断言*/
结构Char2DArray
{
int行；
int列；
字符*值；
};
/*这是源文件中的位，如char2darray.c*/
void C2DA_初始化（结构Char2DArray*数组，int行，int列）
{
断言（数组！=0）；
数组->值=calloc（行*列，sizeof（char））；
数组->行=行；
数组->列=列；
}
无效C2DA_集（结构Char2DArray*数组，int行，int列，int值）
{
断言（数组！=0）；
断言（数组->值！=0）；
断言（行<数组->行）；
断言（行>=0）；
断言（列<数组->列）；
断言（列>=0）；
数组->值[（行*数组->行）+列]=值；
}
char C2DA_get（结构Char2DArray*数组，int行，int列）
{
断言（数组！=0）；
断言（数组->值！=0）；
断言（行<数组->行）；
断言（行>=0）；
断言（列<数组->列）；
断言（列>=0）；
返回数组->值[（行*数组->行）+列]；
}
无效C2DA_free（结构Char2DArray*数组）
{
自由（数组->值）；
数组->值=0；
}
/*这里有一个main.c来使用它*/
int main（）
{
结构char2da数组；
C2DA_初始化（&a，16，16）；
无符号字符c=0；
int x，y；
对于（x=0；x我发现，当面临类似问题时，改变我的方法非常有用

向量向量填充了相同的任务，避免了内存分配障碍，保持了相同的速记。可能还有其他陷阱，但我还没有遇到

//Declaration of mValues, undefined size:
std::vector< std::vector<char> > mValues; 

//Filling of mValues:
    int max_x = 100 ;
    int max_y = 100 ;
    char char_foo = 'a';
    for ( int x = 0; x <= max_x; ++x ) {
        vector<char> temp;
        for ( int y = 0; y <= max_y; ++y ) {
             temp.push_back( char_foo );
        }
        mValues.push_back( temp );
    }

// Referencing with familiar index notation:
    mValues[a][b]; //The a-th row's b-th element

//多值声明，未定义大小：
std:：vectormValues；
//M值的填充：
int max_x=100；
int max_y=100；
char_foo='a'；
对于（int x=0；x，但是我应该如何在结构中声明数组？@Juli-当像这样手动执行时，您将其定义为
char*
-
struct foo{char*arr；int p；}；
//Declaration of mValues, undefined size:
std::vector< std::vector<char> > mValues; 

//Filling of mValues:
    int max_x = 100 ;
    int max_y = 100 ;
    char char_foo = 'a';
    for ( int x = 0; x <= max_x; ++x ) {
        vector<char> temp;
        for ( int y = 0; y <= max_y; ++y ) {
             temp.push_back( char_foo );
        }
        mValues.push_back( temp );
    }

// Referencing with familiar index notation:
    mValues[a][b]; //The a-th row's b-th element