數組
的空間分配是固定的，不能是動態的
，象
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個元素的空間。