用新的字符串替换堆上的字符串

Question

我觉得使用动态类型语言已经改变了我对这方面的直觉!

说，如果我malloc空间的字符串，然后更新指针与另一个malloc(它使用的数据从第一个)，这是内存泄漏吗?

char* my_string = (char*)malloc(length + 1);
(void)snprintf(my_string, length, "blah...");
my_string = some_manipulation(my_string);

我们让char* some_manipulation(const char* str);为它的输出分配内存，这是由提供的参数生成的(可能不是相同的长度)。

第一个malloc现在丢失了，但是占用空间，直到退出?

Answer 1

说，如果我malloc空间的字符串，然后更新指针与另一个malloc(它使用的数据从第一个)，这是内存泄漏吗?

是的，如果你不存储string的第一个值，在第二次调用malloc()之前覆盖它。

<<p> 泄露代码/strong>

char * p = malloc(42);   
p = malloc(41);
/* here the program leaks 42 bytes. */

你只能free()第二次调用的41个字节

free(p);

作为对42字节块的引用丢失。

<<p> 非泄漏代码/strong>

char * p = malloc(42);
char * q = p;
p = malloc(41);

这里没有泄漏，因为您仍然可以泄漏:

free(p); /* Frees 41 bytes. */
free(q); /* Frees 42 bytes */

---

使用第一个

中的数据

所有这些都完全不依赖于在分配的内存中存储(或不存储)的内容。

Answer 2

当然可以。您似乎认为这里的字符串是一个不可变对象，这是一个很好的概念，但没有利用您释放占用的内存。

如果您知道对函数的调用在概念上使输入字符串无效(因此，调用函数后没有调用者再次需要它)，您可以这样做:

int some_manipulation(char **str)
{
    char *ret = malloc(...);
    /* handle error, return -1 */
    /* do whatever manipulation */
    free(*str);
    *str = ret;
    return 0;
}

Answer 3

如果在同一个指针上有两个malloc调用和一个free调用，几乎可以肯定有泄漏(除了第一个malloc失败)。

每个成功的malloc应该在指针生命周期结束的某个地方有一个相关的free。

泄漏:

foo* bar = NULL;
bar = malloc(sizeof(foo) * 10);
if (bar) {
    bar = malloc(sizeof(foo) * 20);
}
else {
    fprintf(stderr, "Error: Could not allocate memory to barn");
    exit(EXIT_FAILURE);
}
free(bar);
bar = NULL;

没有泄漏:

foo* bar = NULL;
bar = malloc(sizeof(foo) * 10);
if (bar) {
    free(bar);
    bar = NULL;
}
else {
    fprintf(stderr, "Error: Could not allocate memory to barn");
    exit(EXIT_FAILURE);
}
bar = malloc(sizeof(foo) * 20);
if (bar) {
    free(bar);
    bar = NULL;
}
else {
    fprintf(stderr, "Error: Could not allocate memory to barn");
    exit(EXIT_FAILURE);
}