0

我正在尝试声明由用户输入给出的可变大小的数组。

到目前为止，我有这样的事情：

typedef struct _object{   
    int rowsAmount;  
    int columsAmount;
    int* rows;
    int* colums;
} object;

object* newObject(int ra, int ca){
    object* o = malloc(sizeof(object));
    o->rowsAmount = ra;
    o->columsAmount = ca;
    o->rows = [ra];    
    o->colums = [ca];
    return o;
}

int main(){
    newObject(3,4);
}

我预计这行不通，但我想要这样的东西，但我不知道该怎么做。

4

6 回答 6

3

看起来你基本上在这里实现了一个动态 Matrix 对象。你想要这样的东西：

typedef struct _object{   
    int rowsAmount;  
    int columsAmount;
    int* matrix;
    int** rows;
} object;

object* newObject(int ra, int ca){
    object* o = malloc(sizeof(object));
    o->rowsAmount = ra;
    o->columsAmount = ca;
    o->matrix = malloc(ra * ca * sizeof(int));
    o->rows = malloc(ra * sizeof(int*));
    for (size_t i = 0; i != ra; ++i) o->rows[i] = o->matrix + (i * ca);
    return o;
}

您还应该创建一个析构函数destroyObject，它同样是为andfree分配的所有内存。oo->matrix

编辑：

但是，您的评论是：

“我只是想学习c，这只是关于设置大小。我只是碰巧用2个数组尝试了它”

...使这个问题有些混乱，因为它表明您实际上并没有尝试创建矩阵（二维数组），尽管您在这里使用了“行”/“列”术语，但您只是想了解如何在 C 中动态分配数组。

如果是这种情况，C 中的数组是使用指针变量动态分配的，并且malloc：

size_t array_size = 10; /* can be provided by user input */
int* array = malloc(sizeof(int) * array_size);

稍后，一旦您完成使用动态分配的数组，就必须释放它：

free(array);
于 2013-04-22T10:04:23.113 回答
0

我认为当可以使用范围变量时，人们经常使用动态内存分配。例如，根据用户输入调整大小的数组可以在堆栈上分配，而无需使用 malloc/free：

int array_size;
scanf("%d", &array_size);
if (array_size > 0) {
    /* Allocate array on stack */
    float array[array_size];

    /* ... do smth with array ... */
}
/* Out of scope, no need to free array */

当然，如果你的数据块很大，堆内存是必须的，但对于小的分配范围就可以了。

于 2013-04-22T12:04:24.103 回答
0

您可以使用用户输入的大小创建一个数组，而无需结构。

int *array1;
int size;
// get input from user
array1 = malloc(sizeof(int)*size);
// do your stuff
free(array1);

如果你想要一个二维数组，

int **array2;
int row, col;
int i;
array2 = malloc(sizeof(int*)*row);
for(i=0;i<row;++i)
    array2[i] = malloc(sizeof(int)*col);
//use the array
for(i=0;i<row;++i)
    free(array2[i]);
free(array2);

如果你真的需要一个结构数组，那么在你的newObject()函数中为它分配内存

typedef struct _object{   
    int rowsAmount;  
    int columsAmount;
    int** array;
    //int* colums;
} object;

object* newObject(int ra, int ca){
    int i;
    object* o = malloc(sizeof(object));
    o->rowsAmount = ra;
    o->columsAmount = ca;
    o->array = malloc(sizeof(int*)*ra);    
    for(i=0;i<ra;i++)
        o-<array[i]=malloc(sizeof(int)*ca);
    return o;
}

int main(){
    newObject(3,4);
}
于 2013-04-22T10:17:57.263 回答
0

在 C 中动态分配二维数据数组：

  • 为整个数据分配内存。该内存由 指向arrayData。
  • 为每一行分配一个指针的一维数组
  • 将这些指针指向每行对应的内存地址

代码：

int *arrayData = malloc(sizeof(int) * rows * columns);
int **array = malloc(sizeof(int*) * rows);
for(int i=0; i < rows;++i){
   array[i] = arrayData + i * columns;
}

您现在可以以array[row][col].

于 2013-04-22T10:03:39.807 回答
-1 
#include <stdio.h>
#include <stdlib.h>

typedef struct _object{   
    int rowsAmount;  
    int columsAmount;
    int **rows;
//  int* colums;
} object;

object* newObject(int ra, int ca){
    int r;
    object* o = malloc(sizeof(object));
    o->rowsAmount = ra;
    o->columsAmount = ca;
    o->rows = (int **)malloc(ra*sizeof(int *));
    for(r=0;r<ra;++r)
        o->rows[r] = (int*)malloc(ca*sizeof(int));
    return o;
}

int main(){
    object *obj= newObject(3,4);
    obj->rows[2][3]=5;
    return 0;
}
于 2013-04-22T10:27:05.363 回答
-1

最简单的方法是使用 boost::multi_array 不仅可以获得任意数量的维度，而且还可以非常有效地存储为单个连续的内存块，而不是 n 维数组。

CPU 旨在快速遍历数组，您可以使用它来潜在地利用编译器的缓存/预取/流水线功能。

例如

// 2 dimensions
int xDim;
int yDim;
cin >> xDim; // From user..
cin >> yDim;
// Initialise array
boost::multi_array<int,2> my2dgrid(boost::extents[xDim][yDim]);
// Iterate through rows/colums
for(int j = 0 ; j < yDim-1; j++) { // Row traversal
for(int i = 0 ; i < xDim-1; i++) { // Column traversal
   int value = grid[j][i]; // Get a value
   grid[j][i] = 123; // set a value
   // Do something...
}
于 2013-04-22T10:12:41.073 回答