分配（和取消分配）内存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

回答

相关问题