Правильное использование realloc ()

Только не вызывайте free() на своем исходном ptr на счастливом пути. По сути, realloc() сделал это за вас.

ptr = malloc(sizeof(int));
ptr1 = realloc(ptr, count * sizeof(int));
if (ptr1 == NULL) // reallocated pointer ptr1
{       
    printf("\nExiting!!");
    free(ptr);
    exit(0);
}
else
{
    ptr = ptr1;           // the reallocation succeeded, we can overwrite our original pointer now
}

Применение исправлений как правок на основе хороших комментариев ниже.

Прочитав этот вопрос на comp.lang.c, можно обнаружить 3 случая:

1. «Когда он может, он просто возвращает вам тот же указатель, который вы ему вручили».
2. «Но если он должен перейти в какую-то другую часть памяти, чтобы найти достаточно непрерывного пространства, он вернет другой указатель (и предыдущее значение указателя станет непригодным для использования)».
3. «Если realloc не может найти достаточно места, он возвращает нулевой указатель и оставляет предыдущую область выделенной».

Это можно напрямую перевести в код:

int* ptr = (int*)malloc(sizeof(int));
int* tmp = (int*)realloc(ptr, count * sizeof(int));
if(tmp == NULL)
{
    // Case 3, clean up then terminate.
    free(ptr);
    exit(0);
}
else if(tmp == ptr)
{
    // Case 1: They point to the same place, so technically we can get away with
    // doing nothing.
    // Just to be safe, I'll assign NULL to tmp to avoid a dangling pointer.
    tmp = NULL;
}
else
{
    // Case 2: Now tmp is a different chunk of memory.
    ptr = tmp;
    tmp = NULL;
}

Итак, если подумать, опубликованный вами код в порядке (почти). Приведенный выше код упрощается до:

int* ptr = (int*)malloc(sizeof(int));
int* tmp = (int*)realloc(ptr, count * sizeof(int));
if(tmp == NULL)
{
    // Case 3.
    free(ptr);
    exit(0);
}
else if(ptr != tmp)
{
    ptr = tmp;
}
// Eliminate dangling pointer.
tmp = NULL;

Обратите внимание на дополнительный else if(ptr != tmp), который исключает случай 1, где вы не хотели бы вызывать free(ptr), потому что ptr и tmp относятся к одному и тому же местоположению. Кроме того, в целях безопасности я обязательно назначил NULL tmp, чтобы избежать проблем с висячими указателями, пока tmp находится в области действия.

OP: ... может отличаться от ptr или NULL в случае сбоя запроса.
A: Не всегда. NULL может быть возвращен законно (не ошибка), если count равно 0.

OP: Достаточно ли предположить, что перераспределенный указатель указывает на другой блок памяти, а не на тот же блок.
A: Нет

OP: Должен ли я поставить другое условие, которое будет сравнивать равенство ptr и ptr1 и исключать выполнение оператора free (ptr)?
A: Нет.

Если realloc() возвращает NULL (и count не равен 0), значение ptr все еще действует, указывая на данные без изменения размера. free(ptr) или нет, зависит от ваших целей.

Если realloc() вернет не NULL, не free(ptr), все готово освобождено.

Пример: https://codereview.stackexchange.com/questions/36662/critique-of-realloc-wrapper

#include <assert.h>
#include <stdlib.h>

int ReallocAndTest(char **Buf, size_t NewSize) {
  assert(Buf);
  void *NewBuf = realloc(*Buf, NewSize);
  if ((NewBuf == NULL) && (NewSize > 0)) {
    return 1;  // return failure
  }
  *Buf = NewBuf;
  return 0;
}

realloc вернет тот же адрес в ptr, если у него достаточно места для расширения фактического фрагмента памяти, указанного ptr. В противном случае он переместит данные в новый фрагмент и освободит старый фрагмент. Нельзя полагаться на то, что ptr1 отличается от ptr. Ваша программа ведет себя неопределенно.

Если realloc возвращает другой адрес, он сначала освобождает старый, поэтому вам не нужно делать это самостоятельно.

Кстати, ни разу не забрасывайте отдачу malloc/realloc :). Ваш код должен быть таким:

ptr=malloc(sizeof(int));
ptr=realloc(ptr,count*sizeof(int));
if(ptr==NULL)
{   
    // error!    
    printf("\nExiting!!");
    // no need to free, the process is exiting :)
    exit(0);
}

Если realloc перемещает ваши данные, он освободит старый указатель за кулисами. У меня нет копии стандарта C11, но он гарантирован стандартом C99.

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

Глава и стих:

7.22.3.5 Функция перераспределения

Сводка

1

     #include <stdlib.h>
     void *realloc(void *ptr, size_t size);

Описание

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

3 Если ptr - нулевой указатель, функция realloc ведет себя как функция malloc для указанного размера. В противном случае, если ptr не соответствует указателю, ранее возвращенному функцией управления памятью, или если пространство было освобождено вызовом функции free или realloc, поведение не определено. Если память для нового объекта не может быть выделена, старый объект не освобождается и его значение не изменяется.

Возврат

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

Акцент добавлен. Обратите внимание на пункт 4; возвращаемый указатель может быть таким же, как ваш исходный указатель.