Является ли это использование C-указателей безопасным от утечки памяти?

Question

char *a() { 
    char *t = malloc(8); 
    t[0] = 'a'; 
    t[1] = 'b'; 
    //... 
    t[7] = 'h'; 
    return t; 
} 

int main(void) { 
    char *x = a(); 
    //do something with x 
    //... 
    free(x); 
    return 0; 
} 

Имеет ли этот код какие-либо потенциальные проблемы, так как память выделена в a() и использована память в main()?

Answer 1

Нет, у вас не будет проблем, потому что вы назначили функцию в a и используете ее в main.

Answer 2

Никаких проблем — на самом деле, это не правильный способ выделить память, которая по-прежнему будет использоваться после того, как функция возвращает — но вы можете free() память, когда вы закончите его использования. Восемь байтов не будут проблемой, но кодирование против утечек памяти - хорошая привычка.

Answer 3

Пока вы не забываете освободить память, на которую указывает x, тогда у вас не будет никаких проблем. Используя malloc(), вы выделили память в куче, которая остается одна, когда возвращается к вызывающей функции.

Answer 4

Во-первых, a() объявляется возвращающим void, но вы пытаетесь вернуть char *. Измените подпись, чтобы вернуть char *.

Во-вторых, ваша функция прекрасна, но ваш пример кода имеет утечку памяти, потому что вы никогда не освобождаете память, на которую указывает возвращаемый указатель.

В-третьих, как указал gbrandt, вы не проверяете успех после вызова malloc. malloc может потерпеть неудачу, и проверить, действительно ли это - хорошая привычка.

---

Другой способ сделать это было бы передать указатель на указатель в() вместо, а затем вызывающий должен создать указатель себя перед передачей его к(), но в любом случае вы по-прежнему необходимо освободить память. Если честно, я бы пошел с вашим подходом к этому в этом случае. Нет никаких веских оснований для этого, просто подумал, что я бы сказал об этом.

void a(char **p) 
{ 
    *p = malloc(8); 
    if (*p) 
    { 
     **p[0] = 'a'; 
     **p[1] = 'b'; 
     ... 
     **p[7] = 'h'; 
    } 
} 

int main(void) 
{ 
    char *x; 
    a(&x); 
    //do something with x 
    ..... 
    free(x); 
} 

Если этот альтернативный подход путает вас, пожалуйста, дайте мне знать, как я был бы счастлив дать объяснение (хотя, на данный момент, мне нужно, чтобы вернуться к работе!)

Answer 5

Помимо того, неправильный тип возврата на a() (должен быть char * вместо void), код не вызывает проблем.

Обязательно укажите free() память, которую вы выделили, когда закончите с ней.

Answer 6

Весь хороший совет выше. Небольшие проблемы с кодом, большой ...

Вы не проверяете успех в malloc или после вызова функции. Никогда не забывайте об обработке ошибок.

Answer 7

Большинство ответов здесь указывает, что это не проблема, просто забудьте освободить() позже. Это технически верно, но это действительно проблема. Каждый раз, когда вы выделяете память в одной области и ожидаете ее освобождения в другой, вы просите утечку памяти. Люди не помнят, чтобы освободить память. Также возникает проблема, что вызывающий должен знать, что вы использовали malloc, а не alloca() или new() или что-то еще. Если они вызывают что-либо, кроме согласованной процедуры дезадаптации, результаты не определены.

Короче говоря, обычно бывает ошибкой выделять память и передавать ее обратно вызывающему абоненту.

Лучше ожидать, что память будет выделена вызывающим абонентом, потому что, если они ее распределяют, они не забудут освободить ее и сделать это правильно.

Answer 8

Спасибо. Я только что редактировал код. Думаю, на этот раз у него не должно возникнуть проблемы. Btw, в C, когда функция заканчивается, компилятор очищает все переменные (включая массив & указатель) в стеке?