Как правильно напечатать адрес переменной, уже освобожденной из кучи?

Лучшей практикой управления указателями на объекты, которые могут быть освобождены, является преобразование каждого указателя в uintptr_t, пока он еще действителен (указывает на объект до его освобождения), и использование этих значений uintptr_t для печати и других целей.

Согласно C 2018 6.2.4 2, «значение указателя становится неопределенным, когда объект, на который он указывает (или только что прошедший), достигает конца своего времени существования». Основная причина этого правила состоит в том, чтобы разрешить реализации C, в которых байты в указателе не содержат прямого адреса памяти, но содержат информацию, которая используется для поиска адресной информации в различных структурах данных. Когда объект освобождается, несмотря на то, что байты в указателе не изменяются, данные в этих структурах могут измениться, и тогда попытка использования указателя может потерпеть неудачу по разным причинам. Примечательно, что попытка напечатать значение может завершиться неудачей, поскольку прежний адрес больше не доступен в структурах данных. Однако, поскольку это правило существует, даже менее экзотические реализации C могут использовать его для оптимизации, поэтому компилятор C может реализовать, например, free(x); printf("%p", (void *) x); эквивалентно free(x); printf("%p", (void *) NULL);.

Чтобы обойти это, вы можете сохранить указатель как значение uintptr_t и использовать это значение uintptr_t для дальнейшего использования, включая печать:

#include <inttypes.h>
#include <stdint.h>
...
uintptr_t ux = (uintptr_t) (void *) x;
free(x);
…
printf("%" PRIxPTR, ux);

Обратите внимание, что для строгого соответствия мы сначала преобразуем указатель в void *, а затем в uintptr_t. Это просто потому, что стандарт C не определяет явно поведение преобразования любого указателя в uintptr_t, но определяет поведение преобразования указателя на объект в void * и преобразования void * в uintptr_t.

Ваш код в порядке.

Не имеет значения, действителен ли указатель¹ или нет, если все, что вам нужно сделать, это вывести значение самого указателя. В конце концов, вы можете вывести значение NULL, которое по определению является недопустимым значением указателя, используя %p без проблем.

Очевидно, что если вы попытаетесь сделать что-то с *heap или heap[i] после того, как память была освобождена, вы столкнетесь с неопределенным поведением, и может случиться что угодно, но вы можете проверить или распечатать heap (или address) все, что хотите, без проблем.

<ч> <суп>

1. Where "valid" means "pointing to an object within that object's lifetime".

Согласно стандарту C:

Спецификаторы преобразования и их значения:

...

p

Аргумент должен быть указателем на void. Значение указателя преобразуется в последовательность печатных символов способом, определяемым реализацией.

Итак, чтобы полностью соответствовать стандарту C, вам нужно привести heap к void *:

logger("Heap at %p successfully deallocated", ( void * ) address);

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

void *address = &heap; -->> void *address = heap;

В вашем коде вы получаете адрес, если локальный параметр функции не имеет значения.

Из-за моего ограниченного рейтинга я пока не могу комментировать сообщения других, поэтому использование «ответа», пока это не ответ, а комментарий.

Ответ/комментарий Эрика Постпишила выше требует рецензирования. Я не согласен и не понимаю его рассуждений.

" ... Когда объект освобождается, несмотря на то, что байты в указателе не изменяются, данные в этих структурах могут измениться, и тогда попытка использовать указатель может потерпеть неудачу различными способами. В частности, попытка напечатать value может завершиться ошибкой, потому что .."

Обратите внимание на прототип стандартного вызова C free(): void free(void *ptr). В месте вызова ptr value останется неизменным до и после бесплатного вызова — он передается через value.

«Использовать» указатель будет/может потерпеть неудачу по-разному, если под использованием мы подразумеваем уважение к нему после вызова free(). Печать значения указателя не приводит к его уважению. Также печать (значения) указателя с вызовом printf с использованием %p должна быть корректной, даже если представление значения указателя определено реализацией.

"*... ​​Однако, поскольку это правило существует, даже менее экзотические реализации C могут использовать его для оптимизации, поэтому компилятор C может реализовать free(x); printf("%p", (void *) x); эквивалентно free(x); printf("%p", (void ) NULL); например. ..."

Даже если он (компилятор) сделает это, я не могу легко понять, что бы это оптимизировало, вызов специального минимизированного printf со значением 0 для указателя? Также рассмотрите что-то вроде:

extern недействительным my_free (недействительным * ptr); // где-то определено.. my_free(myptr); printf("%p", myptr);

Ему нечего было бы оптимизировать, как вы здесь предлагаете, и он (компилятор) ничего не мог сделать о значении myptr.

Так что нет, я не могу согласиться с вашей интерпретацией стандарта C на данном этапе.

(мое) РЕДАКТИРОВАТЬ:

Если только в некоторых «экзотических» реализациях с указателем памяти, реализованным в виде структуры, и он передается в/из «пользовательского» void*. Тогда пользовательское значение кучи будет недействительным или нулевым при попытке его распечатать.. Но тогда каждый вызов C, который принимает void* в качестве указателя на память, должен будет различать, какой void* указывает на кучу, а не - скажем, memcpy, memset, - и тогда это становится довольно занятым...