Использование realloc (X, 0) вместо free() и использование malloc с длиной строки +1

Поведение realloc, когда размер равен 0, отличается в C11 (текущая версия). Стандарт говорит (7.20.3.1 для C11, 7.22.3.1 для C1x)

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

Итак, используйте free и не полагайтесь на realloc.

При работе со строками через char* всегда не забывайте включать один дополнительный символ для нулевого терминатора \0. Это обычный способ показать, где заканчивается строка (другой способ — явная длина строки).

При использовании malloc и free помните, что они должны точно совпадать. Вам нужно free указать точный указатель (значение), возвращаемый malloc или realloc.

массив = realloc (массив, 0);

Realloc с нулевым размером эквивалентен free() в некоторых реализациях C, но не все.

И проблема в том, что бесплатная не работает, она не освобождает используемое пространство

Подумайте, что означает char **array и как он распределяется в вашем приложении. Часто указатели на указатели используются как двумерные массивы, выраженные в виде массива массивов. Большинство приложений выделяют эти множественными вызовами malloc(). array — это просто массив из char *, где каждый элемент этого массива представляет собой массив из char. Простой вызов free() для массива char * освободит массив char *, но не каждый из массивов char.

Вам нужно вызвать free() несколько раз, как описано здесь.

Я пробовал с разными номерами, и это работает каждый раз, но если я не делаю этого +1, это не работает правильно.

Строки C имеют нулевое завершение, что означает, что программа отслеживает, где заканчивается строка, помещая нулевой символ в конец строки. Это означает, что строка C длиной N требует места для N символов плюс один нулевой символ. Тогда общая длина области памяти равна N+1.

Первый вопрос:

realloc(array, 0) не эквивалентно free(array).

Стандарт (C99, §7.20.3.4 ¶1) гласит:

Функция realloc освобождает старый объект, на который указывает ptr, и возвращает указатель на новый объект, размер которого указан size.

и не дает "особого случая" для size==0; таким образом, вы получаете указатель на объект нулевого размера, но который потенциально все еще является объектом и все еще должен быть освобожден.

Интересно, я думаю, что realloc может просто не сработать в таких обстоятельствах, возвращая NULL; в этом случае в вашем коде происходит утечка памяти, поскольку при сбое realloc он не освобождает исходный блок памяти, который вы ему передали (вот почему вы никогда не выполняете array = realloc(array, size), но всегда используете промежуточную переменную для проверки наличия NULL во избежание утечек памяти).

На самом деле стандарт определяет size==0 поведение, определяемое реализацией, для всех функций выделения памяти, а не только для malloc, как я помнил; таким образом, поведение определяется реализацией, как описано ниже:

Более интуитивно, realloc «концептуально эквивалентно» malloc+memcpy+free для другого указателя, а malloc-обработка 0-байтового фрагмента памяти возвращает либо NULL, либо уникальный указатель, который нельзя использовать для хранения чего-либо (вы спросили для 0 байт), но все еще должен быть freeed. Так что нет, не используйте realloc таким образом, он может работать в некоторых реализациях (а именно, в Linux), но это точно не гарантируется.

Кроме того, непонятно, как вы пришли к выводу, что free не работает. Я могу придумать два способа убедить вас в этом:

1. значение array и данных, на которые он указывает, не изменилось;
2. выделенная память в диспетчере задач/top/во что бы то ни стало не уменьшается.

Для первого случая это нормально; когда вы освобождаете указатель, он не стирается волшебным образом — ваш указатель по-прежнему указывает туда, куда он указывал, но эта память больше не ваша — теперь она возвращается к среде выполнения C, которая, вероятно, повторно отдаст ее в будущем. malloc. Вот почему эта штука называется "висячий указатель", и многие люди после free устанавливают его на NULL, чтобы избежать повторной записи в области памяти, которая уже была освобождена.

Что касается второго, то аллокаторы обычно не возвращают оперативную память немедленно (если только мы не говорим о действительно больших кусках памяти); идея состоит в том, что, вероятно, приложению скоро снова понадобится такая память, и сохранение этой памяти для текущего процесса может избежать непрерывных системных вызовов для получения/отдачи памяти от ОС. Поскольку системные утилиты для мониторинга обычно используемой памяти могут видеть только то, что ОС отдала процессу, нормально, что они не показывают никакого уменьшения использования памяти.

Кстати, помните, что если вы char ** array содержите указатели на вещи, выделенные с помощью malloc, вы должны сначала free их , иначе у вас будет утечка памяти.

Второй вопрос:

Строки C заканчиваются нулем, т. е. последним символом строки всегда является \0, обозначающий конец строки, а strlen указывает длину строки без нулевого ограничителя. Таким образом, если вы не добавите этот +1, вы выделяете на char меньше памяти, чем требуется для фактического хранения вашей строки.

Приложение

Под не работает я подразумеваю, что произошел сбой (проблема могла быть где-то еще), но когда я изменил его на realloc (X, 0), он действительно работал в смысле удаления используемой динамической используемой памяти.

Как говорится на странице руководства,

Сбои в malloc(), calloc(), realloc() или free() почти всегда связаны с повреждением кучи, например, с переполнением выделенного фрагмента или двойным освобождением одного и того же указателя.

Вероятно, у вас есть какая-то другая ошибка в вашем коде, но, не видя ее, невозможно сказать, что и где идет не так.

По второму вопросу:

В C строка должна заканчиваться нулевым символом '\0'. Когда вы используете strlen, этот символ не учитывается, но вам нужно выделить для него достаточно места (это +1).

Если вы попытаетесь напечатать строку, не содержащую нулевой символ, может быть напечатано несколько «случайных» символов, но это также может привести к сбою. Если вы используете strcpy, вы сделаете переполнение буфера.

Если вы надеетесь сохранить совместимость, realloc(p,0) никогда не будет эквивалентно free(p), а нулевое выделение памяти без последующего освобождения — это обычная утечка памяти, даже в Linux.

/* leak.c */
#include <mcheck.h>
#include <stdlib.h>
int main(int argc, char* argv[]) {
    void* p;
    mtrace();
    p = malloc(0x100);
    p = realloc(p, 0);
    exit(EXIT_SUCCESS);
}

$ cc -g leak.c -o leak
$ export MALLOC_TRACE=/tmp/t
$ ./leak
$ mtrace ./leak $MALLOC_TRACE

Проблема заключается в char ** array !! Как это построено? Похоже, это не непрерывный блок памяти, и он был построен так:

char **array  = malloc(sizeof(char*)*size);
for (size_t i=0; i< size; i++) {
    array[i] = malloc(strlen(string)+1);
}

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

for (size_t i=0; i<size; i++) {
    free(array[i]);
}
free(array);

Также с realloc NULL также может означать сбой, поэтому вы висите на старом указателе!. никогда не делай

foo= realloc(foo, new_size);

do

if (tmp = realloc(foo, new_size) ) {
     foo = tmp;
} else {
   // clean your ram, how do you handle failure?
   free(foo);foo = NULL;
   // or you're ok without the new size,or try to realloc again
   // up to you
}