动态分配二维数组c语言

❶ c语言中二维数组如何申请动态分配内存

1、使用malloc函数，先分配第一维的大小，然后再循环分配每一维的大小。

2、例程，分配3行4列二维数组：

#include<stdio.h>
#include<malloc.h>
intmain()
{
int**a;
inti,j;
a=(int**)malloc(sizeof(int*)*3);//为二维数组分配3行
for(i=0;i<3;++i){//为每列分配4个大小空间
a[i]=(int*)malloc(sizeof(int)*4);
}
//初始化
for(i=0;i<3;++i){
for(j=0;j<4;++j){
a[i][j]=i+j;
}
}
//输出测试
for(i=0;i<3;++i){
for(j=0;j<4;++j){
printf("%d",a[i][j]);
}
printf("
");
}
//释放动态开辟的空间
for(i=0;i<3;++i){
free(a[i]);
}
free(a);
return0;
}
/*
输出：
0123
1234
2345
*/

❷ C璇瑷濡备綍鍦ㄥ瓙鍑芥暟涓瀵逛富鍑芥暟涓镄勪簩缁存暟缁勫艰繘琛屼慨鏀癸纻 浜岀淮鏁扮粍宸茬粡鍦ㄤ富鍑芥暟涓鐢ㄥ姩镐佹暟缁勫垎閰崭简绌洪棿銆

鐢ㄦ寚阍埚仛鍑芥暟鍙傛暟鍙浠ュ疄鐜帮紒

❸ C语言如何动态分配二维数组

动态分配二维数组：

void main(int argc, char * argv[])

{

int NC=100, NR=200;

int i,j;

char **a; // a[NR][NC] -- *a[NR] -- a[j][i]

a = (char **) malloc(sizeof(char *) * NR);

for (j=0;j<NR;j++){

a[j] = (char *) malloc(sizeof(char) * NC);

}

// 释放空间: free(a);

编译错误是因为p[j]=(char *)malloc，而不是题目的(char *)malloc(n*sizeof(char))。

(3)动态分配二维数组c语言扩展阅读：

二维数组的动态分配

二维数组A[m][n]，这是一个m行，n列的二维数组。设a[p][q]为A的第一个元素，即二维数组的行下标从p到m+p，列下标从q到n+q，按“行优先顺序”存储时则元素a[i][j]的地址计算为：

LOC(a[i][j]) = LOC(a[p][q]) + ((i − p) * n + (j − q)) * t

按“列优先顺序”存储时，地址计算为：

LOC(a[i][j]) = LOC(a[p][q]) + ((j − q) * m + (i − p)) * t

存放该数组至少需要的单元数为(m-p+1) * (n-q+1) * t 个字节。

❹ C语言-二维数组动态分配

pArray2=(int**)malloc(sizeof(int*[3])); //分配了3个int*的空间，32地址环境下指针的长度都是32位的也就是4字节，那3个int*就是12字节，和3个int长度是一样的，凑巧而已
也可以写成这样：
pArray2=(int**)malloc(3*sizeof(int*)); //分配3个int*的空间
现在pArray2指向的有效空间内包含3个指针，这3个指针是int*,也就是指向int的指针，这3个指针的值是随机的，还不能用，先要让它们指向合适的空间才行
于是就有：
for(....)
*(pArray2+i)=(int*)malloc(sizeof(int[3])); //这就是给pArray2指向的空间内的3个指针校正方向，让每一个指针指向由3个int整数组成的数组的首地址，这才是最终的数据空间
和pArray2一样，也可以写成：
*(pArray2+i)=(int*)malloc(3*sizeof(int)); //3个int

❺ c语言如何动态创建二维数组

既然是动态创建，那么，所创建的二维数组的行、列数应该具有“普适”性，即，应由“用户”确定二维数组的规模。这是有难度的。因为，二维数组要牵扯行指针，且需要固定每行的列元素个数，用这种思路就没有办法达到“普适”。
为此，必须清醒地知道，所谓二维数组，其元素在内存中依然是以一维的方式存放的。说实话，二维数组本质上是不存在的。
既然如此，那么，“构造”一个所谓的二维数组，只要能提供足够实用的函数（工具）操作这个二维数组就可以了。
综上，接受由用户决定的二维数组行、列值，申请一个一维数组的空间，按照二维数组方式进行定位和操作就可以了。
为简便起见，我用如下定义，你可以更改里面的类型，以适应自己的需要：
typedef int USER_TYPE;

// 定义一个控制二维数组（矩阵）的“控制头”，由三个成员组成

typedef struct MATRIX
{
USER_TYPE *data; // 真正用来存储二维数组元素的空间

int Row; // 二维数组行数

int Col; // 二维数组列数

}MATRIX;

MATRIX *initMatrix(int row, int col); // 初始化二维数组

USER_TYPE getElementAt(MATRIX matrix, int i, int j); // 取得指定下标的元素

void setElementAt(MATRIX matrix, int i, int j, USER_TYPE val); // 给指定下标的元素赋值
void destroyMatrix(MATRIX *matrix); // 销毁二维数组

void destroyMatrix(MATRIX *matrix)
{
free(matrix->data);
free(matrix);

}

void setElementAt(MATRIX matrix, int i, int j, USER_TYPE val)
{
matrix.data[i*matrix + j] = val;

}

USER_TYPE getElementAt(MATRIX matrix, int i, int j)
{
return matrix.data[i*matrix.Col + j];

}

MATRIX *initMatrix(int row, int col)
{
MATRIX *mp;

mp = (MATRIX *)malloc(sizeof(MATRX));
mp->data = (USER_TYPE *)malloc(sizeof(USER_TYPE) * row * col);
mp->Row = row;
mp->Col = col;

return mp;

}
把上面的函数当成工具，完成二维数组初始化、赋值、取值等一系列操作，如果需要比较，还需要编写比较的函数。

❻ c璇瑷 杈揿叆涓涓猰*n鏁村舰镄勪簩缁存暟缁,瀵瑰叾姣忚屾眰鍜,鍜屽崟镫瀛樻斁鍦ㄤ竴涓涓缁存暟缁勪腑锛

m,n 杈揿叆钖庯纴锷ㄦ佸垎閰 2缁存暟缁 a, 鍜屽瓨鏀 姣忚屽拰 镄 1缁存暟缁 b.
铹跺悗杈揿叆 m*n涓 鏁村舰鏁版嵁锛屾渶钖庤緭鍑 姣忚屽拰銆
#include <stdio.h>
int main(){
int **a; // a[m][n] or a[NR][NC]
int *b;
int NR,NC;
int i,j;
printf("input number of rows m:\n");
scanf("%d",&NR);
printf("input number of cols n:\n");
scanf("%d",&NC);
a = (int **) malloc(sizeof(int *) * NR);
for (j=0;j<NR;j++){
a[j] = (int *) malloc(sizeof(int) * NC);
}
b = (int *) malloc(sizeof(int *) * NR);
printf("input 2-d array data, %d rows %d colums:\n",NR,NC);
for (j=0;j<NR;j++) for (i=0;i<NC;i++) scanf("%d",&a[j][i]);
for (j=0;j<NR;j++){
b[j]=0;
for (i=0;i<NC;i++) b[j]=b[j]+a[j][i];
}
printf("sum of each line:\n");
for (j=0;j<NR;j++) printf("%d ",b[j]);
return 0;
}
渚嫔傦细
input number of rows m: 3
input number of cols n: 4
input 2-d array data, 3 rows 4 colums:
1 2 3 4
5 6 7 8
9 10 11 12
sum of each line:
10 26 42

❼ c语言：怎样用malloc函数动态分配二维数组，使之可输入数组的行数和每行的列数。

这个是可以的，但是和其他网友说的一样，内存是线性的，当你在语言中分配一个多维数组的时候，编译器其实也是分配线性内存的，但是我们可以通过模拟来实现类似数组的操作，下面演示一个分配以及操作数组的实例（列数要固定，这里假设列数为4）：
int _tmain(int argc, _TCHAR* argv[])
{
int (*p)[4] = (int (*)[4])0;
int row = 3;
int (*mem)[4] = (int (*)[4])0; // 定义数组首指针
mem = (int (*)[4])malloc(sizeof(int(*)[4]) * row); // 分配row行， 4列的数组
// 分别为二维数组的第一维各个元素赋值。
mem[0][0] = 1;
mem[0][1] = 2;
mem[0][2] = 3;
mem[0][3] = 4;
// 打印二维数组的各个元素的值
printf("%d, %d, %d, %d", mem[0][0], mem[0][1], mem[0][2], mem[0][3]);
free(mem);
return 0;
}

不过这里列数必须指定，还有一种方法，这种方法可以保证用户输入任意行或列，而不必要将列数定死，演示如下：

int getElement(int* arr, int colNum, int row, int col);
void setElement(int* arr, int colNum, int row, int col, int val);

int _tmain(int argc, _TCHAR* argv[])
{
int *arr = (int*)0;
int row = 3;
int col = 5;
//分配 row 行 col 列的整形数组
arr = (int*)malloc(sizeof(int) * col * row);
// 将最后一个元素值设置为100
setElement(arr, col, 2, 4, 100);
//输出最后一个元素的值
printf("%d", getElement(arr, col, 2, 4));
free(arr);
return 0;
}
//各个参数说明如下：
//arr: 数组首地址
//colNum：数组列数
//row: 要取得的元素所在行
//col: 要取得的元素所在列
int getElement(int* arr, int colNum, int row, int col)
{
return *(arr + sizeof(int) * (row - 1) * colNum + col);
}

// 此函数用来设置指定行和列的元素的值：
//arr: 数组首地址
//colNum：数组列数
//row: 要取得的元素所在行
//col: 要取得的元素所在列
//val: 要设置的值
void setElement(int* arr, int colNum, int row, int col, int val)
{
*(arr + sizeof(int) * (row - 1) * colNum + col) = val;
}

其实归根到底，还是对指针的操作，希望可以帮到你，呵呵。