数组
的空间分配是固定的，不能是动态的
，象
int
a[10]
，刚开始定义这个数组时就分配给它
10×sizeof(int)
个字节，不管你能不能用完它都是占这么多内存，但是如果你输入的数据多于10个，就会溢出，导致错误的产生！！！所以请注意！！！
‘贰’ C语言二维数组内存是怎么分配的
二维数组在内存中其实是一个平坦的一维数组，下面具体说明：
int
arr[3][5]
和
int
arr[15]
所使用的内存区大小是一样的，都是15*sizeof(int)个字节。
如果你做下面这样一个定义：
union{
int
a[3][5];
int
b[15];
}U;
你会发现
U.a
=
&U.b
U.a[0]
==
&U.b[0]
U.a[1]
==
&U.b[5]
U.a[2]
==
&U.b[10]
&U.a[2][3]
==
&U.b[13]
规律是：
&U.a[m][n]
==
&U.b[m*5+n]，其中5就是数组a的第二维度。
实际上，二维数组在运行时也是用这样的公式转化为对一维数组的访问。
‘叁’ 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语言二维数组动态分配空间及数组调用问题
您好大陪，我用的是VC
int **a,i,x = 2, y = 2;
a = new int*[x];
for (i = 0;i <滚核蠢 x; i++)
{
a[i] = new int[y];
}
for (i = 0; i <氏裂 y; i++)
{
delete []a[i];
}
delete a;
‘伍’ 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))。
(5)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语言：怎样用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;
}
其实归根到底，还是对指针的操作，希望可以帮到你，呵呵。
‘柒’ C语言动态分配二维数组问题
这里，楼主肯定知道*和++符号的优先级关系，要不也不敢写成*p++。
这里*p++的确等价于*（p++），因为，++的优先级要比*的高。
当然，这个优先级问题，不是楼主问题的重点。
不过区别一下两句
*(p++)=(pp+i*row);
*(p+i)=(pp+i*row);
能看到第一句的指针做着自加的运算，而后取自加后的地址进行赋值。
而第二句的则是首地址加偏移量，然后赋值。
当然，如果只是做赋值操作，这两句完全可尘档以说是等价的。
但是，在楼主的程序里面，这个p的指针则是要作为返回值的。
自加之后的指针，也就是做了*p++操作后的的首地址，自然已经变成自加之后的了。
而做*(p+i)后，p指针的首地址并没有发生变化。
所以，在返回的时候，*p++的地址已经不是我们所期望的了。
程序会在main函数里面奔溃，也就是在程序第37行。（当使用*p++）
回答完楼主的问题，我再来完善一下楼主的程序：
在第46行，的freep（）这个函数没有见过……
估计应该是free（冲轮）吧。
如果是free（）那就不能放在这里派判乱，而是放在if(p){}的程序块中，否则会引起重复释放的错误。
参考我下面的代码：
...
intmain(){
int**p=malloc2d(2,2);
inti=0;
intj=0;
if(p){
for(i=0;i<2;i++){
for(j=0;j<2;j++){
*(*(p+)+j)=1;
}
}
for(i=0;i<2;i++){
for(j=0;j<2;j++){
printf("%d ",*(*(p+i)+j));
}
}
free(p);
}
else//当p为NULL时，就没有必要释放了。
printf("error ");
return0;
}
‘捌’ 关于C语言中动态分配二维数组的问题，求助
#include <stdlib.h>
#include <string.h>模念
struct Array{
int range;
int row;
int **arr;
};
Array create(const char *pathname){//由文件内容创建动态数组
Array a;
a.range = 0;
a.row = 0;
int file_size;
char *str;
//打开文件
FILE *fp;
fp = fopen(pathname,"r");
if(!fp){
perror("fopen error");
exit(1);
}
//计算文件大小，并蠢岁读取文件
fseek(fp,0,SEEK_END);
file_size = ftell(fp);
//在内存的动态存储区中分配n个长度为size的连续空间，初始为0
str = (char *)calloc(file_size,sizeof(char));
rewind(fp);
fread(str,sizeof(char),file_size,fp);
//获取行数
for(int i = 0;i <= file_size;i++){
if(str[i] == '\n') a.range++;
}
a.range = a.range + 1;
//获取列数
for(int i = 0;i <= file_size;i++){
if(str[i] == ',') a.row++;
if(str[i] == '\n')
{
a.row = a.row + 1;
break;
}
}
//创建动态数组
a.arr = (int**)calloc(a.range,sizeof(int*));
for(int i=0;i<a.range;i++)
{
a.arr[i] = (int*)calloc(a.row,sizeof(int));//一维指针旦档困
}
printf("%s\n",str);
free(str);
//读取数据到数组
rewind(fp);//文件指针重返文件头
printf("%d%d\n",a.range,a.row);
for(int i=0;i<a.range;i++)
for(int j=0;j<a.row;j++)
{
fscanf(fp,"%d",&a.arr[i][j]);
fseek(fp,1,1);//跳过逗号跟换行符
}
fclose(fp);
return a;
}
void destroy(Array a){//释放数组内存
for(int i=0;i<a.row;i++)
{
free(a.arr[i]);//释放第二维指针
}
free(a.arr);//释放第一维指针
}
int main()
{
Array arr;
char path[40];
printf("请输入文件名\n");
scanf("%s",path);
arr = create(path);
for(int i=0;i<arr.range;i++)
for(int j=0;j<arr.row;j++)
{
printf("%d",arr.arr[i][j]);
}
destroy(arr);
printf("\n");
printf("success\n");
return 0;
}
‘玖’ c语言 二维数组动态分配
你这个定义是对的 ，这个是指针数组，每个元素都是指向char类型的指针，动态分配时需要一个一个的分配空间
aa[0] =( char*)malloc(***)类似这样的为每个元素分配，如果不知道动态长度可以固定分配一个大一些的空间aa[0] =( char*)malloc(256)//假设每个指针指向的空间不大于256
‘拾’ 怎么实现C语言里面数组的动态分配
1 定义指针。
2 使用malloc函数分配内存。
3 对数组进行访问即可。
对于一维动态数组，直接定义一维指针，并分配内存空间即可。
比如int类型的10个元素动态数组，写作
int *a;
a = (int *)malloc(sizeof(int) * 10);
如果是多维数组，需要从高维向低维逐层分配。如二维数组10*100空间。
int **a;
int i;
a = (int **) malloc(sizeof(int *) * 10); // 先分配10个int*的空间。
for(i = 0; i < 100; i ++)
a[i] = (int *)malloc(sizeof(int) * 100); // 对于每个int*，分配100个元素的空间。