分配（和取消分配）內存char * [64]在C

我想知道如何我可以在C中分配（和取消分配）字符指針數組（char * [64]）。看看網絡上的例子，但他們都關注其他數據類型或一維數組。分配（和取消分配）內存char * [64]在C

2010-06-07 Lienau

'char * [64]'*是*一維數組類型。它的分配方式與分配任何其他一維數組的方式完全相同。 – AnT 2010-06-07 20:56:19

這回答在The C FAQ。

下面是代碼適用於char *而不是int *的一些示例數據。

#include <stdlib.h> 

#define nrows 10 
#define ncolumns 64 

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

    int i; 

    //allocate 10 char* 
    char **array1 = (char**)calloc(nrows,sizeof(char*)); 
    for(i = 0; i < nrows; i++)  
    { 
     //allocate 64 chars in each row 
     array1[i] = (char*)calloc(ncolumns,sizeof(char)); 
     sprintf_s(array1[i],numcolumns,"foo%d",i); 
    } 

    for(i=0;i<nrows;i++) 
     printf("%s\n",array1[i]); 

    //prints: 
    // foo0 
    // foo1 
    // .. 
    // foo9 
    for(i=0;i<nrows;i++) 
      free(array1[i]); 

    free(array1); 

    return 0; 
}

來源

2010-06-07 21:15:57 cigarman

其實我已經計劃在64個字符*（或10或其他），但謝謝。這正是我需要的！ – Lienau 2010-06-07 21:34:53

使用calloc優於malloc 的優點是它在分配時清零內存。因此Coleman使用calloc是一個很好的防禦措施。一個不經意的未初始化的指針，其值爲0 是一個比值是不可預知的值小得多的危險錯誤。隨機指針可能導致極其難以追蹤錯誤。 – pbernatchez 2010-06-08 04:24:31

如果你想要一個固定大小的數組，那麼根本不需要使用動態分配的機會是相當公平的。如果你要動態地分配它，你會做這樣的事情：

char **array; 
array = malloc(64 * sizeof(char *));

當它的時間來釋放它，你只是不喜歡平常：

free(array);

注意，但是，如果數組中的指針指向處的任何東西（尤其是動態分配的內存），則需要單獨處理以釋放該內存 - 通常在之前可釋放指針數組。

來源

2010-06-07 21:00:02

您使用malloc在堆上分配內存：

char** pPointers; 
pPointers = malloc(sizeof(char*) * 64);

現在你有64個指針字符（多個）的陣列。

你釋放內存與此調用：

free(pPointers);

你可能值分配給您的數組：

pPointers[0] = "abc"; 
pPointers[1] = &cSampleCharVariable; 
pPointers[2] = strdup("123");

解放出來這個內存取決於指針指向什麼。在上面的示例中，只有pPointers [2]可以被解除分配。

來源

2010-06-07 21:04:35 harper

我需要做些什麼來釋放[0]和[1]？ – Lienau 2010-06-07 21:09:18

否。編譯器將[0]字符串「abc」放入const內存部分，不允許釋放它。 [1]是一個指向之前已經分配的cSampleCharVariable的指針。如果這是一個用malloc分配的對象，則必須以某種方式釋放它。但是這與這個指針數組無關。 – harper 2010-06-08 05:42:21

如果你在你的問題中給出的類型：

char *foo[64];

然後，你不需要爲foo明確地分配內存 - 這是一個正常的陣列。要在foo爲指針分配內存，只需使用一個循環：

int i; for (i = 0; i < 64; i++) { foo[i] = malloc(somesize); }

（你真的不應該使用魔法值64在循環，雖然，無論是使用#define FOOSIZE 64，或使用sizeof foo/sizeof foo[0]確定數組的大小）。

來源

2010-06-07 21:15:05 caf

在被明顯（比其他答案一般較少）的風險，sizeof (char * [64])等於64 * sizeof (char *)，所以你可以只寫p = malloc (sizeof (char * [64]))分配內存和free (p)釋放它。

來源

2010-06-07 21:43:27

做65個接受答案的分配是可行的，但是如果你提前知道char數據的長度，你可以通過做這樣的事情來讓它變得更快。

假設cItems是int即陣列中元件的數量，比如64假定aItemSizes []包含char數據的長度爲您的陣列中的每個元素：

int iItem; 
char **aItems, *pData; 

for (cbCharData=iItem=0; iItem<cItems ; iItem++) 
    cbCharData += aItemSizes[iItem]; 
aItems = (char**)malloc(sizeof(char*)*cItems + cbCharData); 
for (iItem=0, pData=&aItems[cItems] ; iItem<cItems ; pData+=aItemSizes[iItem], iItem++) 
    aItem[iItem] = pData;

現在aItem [ iItem]指向一個內存位置，該位置可以處理達到aItemSizes [iItem]字符，並且您只需要一個分配，即WAAAAAAAAAAAAAAAAAAAAAAAAAAY更快。我道歉編譯錯誤因爲我沒有測試這個。要釋放它，你只能釋放一個項目。

來源

2010-06-08 01:40:15 johnnycrash

分配（和取消分配）內存char * [64]在C

回答

相關問題