Question

我正在尝试声明具有可变大小的数组，由用户输入提供。

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

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);
}

我预计这不起作用，但我想要这样的东西，我不知道怎么做。

Answer 1

看起来你基本上是在这里实现一个动态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，类似free分配给o和o->matrix的所有内存。

修改：

但是，您的评论是：

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

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

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

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

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

free(array);

Answer 2

在C：中动态分配2d数据数据

为整个数据分配内存。 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]访问内存。

Answer 3

您可以使用带有结构的用户创建一个带有大小输入的数组。

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

如果你想要一个2D数组，

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);
}

Answer 4

我认为通常人们可以在使用范围变量时使用动态内存分配。例如，可以在堆栈上分配从用户输入调整的数组，而不使用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 */

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

Answer 5

最简单的方法是使用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...
}

Answer 6

#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;
}

c中的可变数组大小

6 个答案: