Стыдно задавать такие вопросы.
Нужно ли освобождать память возвращаемую функцией ?

неизвестно.

В общем случае правило простое: убирать должен тот, кто нагадил. Такого вида функции должны возвращать адрес static переменной.

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

В C++ проще, можно вернуть объект на стеке, который скопируется специальным оператором копирования, а когда будет ненужным, удалит свою память внутри себя деструктором.

мой совет: НЕ удаляйте. Особенно если функция 1 или 2 раза срабатывает. При выходе всё само подчистится(но если оно в цикле, то может и рухнуть на середине, от нехватки памяти, если по замыслу быдлокодера удалять таки было нужно. Проверьте, покрутите е в цикле. А что делать?)

char *a;
 a = unknown_function ();

unknown_function - неизвестная нам функция.Да и описания этой функции мы найти не можем.

/usr/lib64/gcc/x86_64-slackware-linux/4.8.1/include/stddef.h

дык написано же, что __null только для g++, а не для си... да и то что внутри компилятора дело компилятора...

на доку не сошлёшься? чего-т я такого не помню...

/usr/lib64/gcc/x86_64-slackware-linux/4.8.1/include/stddef.h

/* A null pointer constant.  */

#if defined (_STDDEF_H) || defined (__need_NULL)
#undef NULL··   /* in case <stdio.h> has defined it. */
#ifdef __GNUG__
#define NULL __null
#else   /* G++ */
#ifndef __cplusplus
#define NULL ((void *)0)
#else   /* C++ */
#define NULL 0
#endif  /* C++ */
#endif  /* G++ */
#endif· /* NULL not defined and <stddef.h> or need NULL.  */
#undef· __need_NULL

такой вот у меня NULL

просто от них меньше всего проблем.

ненужностью.

не всё то NULL, что ссылается на нулевой адрес...
если вспоминать про 16-ти битные x86, то можно ещё устроить демагогию о его атавизмах, как модели памяти... и при какой-как будут реализоваться указатели... мне, откровенно говоря, лень...

на доку не сошлёшься? чего-т я такого не помню...

ладно, уговорил.... константные указатели самые поездатые...

чем же? правда сам не припомню, что бы я пользовался ими для чего-либо, кроме как посмотреть, переваривает ли их компилятор...

я согласен с тезисом: «указатель, передаваемый в функцию,  должен указывать на константу, если функция не меняет данные», но делать все указатели константыми ИМХО бесполезное излишество... не могу даже представить от какой ошибки это может уберечь... да и синтаксис у них глаза сломаешь...

понимаешь в чём тут дело: пока у тебя просто тупо указатели, то их константность особо и не играет роли. Но всё меняется, когда приходят ОНИ. Указатели на массивы, и указатели на указатели. Ну и всё остальное. Вот тут -- согласись, чёрт ногу сломит. И попросту невозможно писать такой код (а другого не бывает), если у  тебя не просто хрен знает что, а ещё такое хрен знает что, которое В ЛЮБОЙ МОМЕНТ КАК УГОДНО И КОМУ УГОДНО МОЖЕТ ИЗМЕНИТСЯ. И для тебя будет неожиданным ЛЮБОЕ изменение, кроме того, на которое ты рассчитываешь. И вот тут-то ты и помянешь меня добрым словом (или помянешь недобрым мамку того быдлокодера, который написал void ***x; )

на тот момент изложения -- ещё нет.

что ЭТО быдлокод по определению? Можно...

не совсем одно и то же... стандарт рассматривает их как разные сущности...
NULL (как и целочисленный 0 и (void*)0) — это «null pointer constant». для него определено то, что он должен преобразовываться в нулевой указатель (null pointer), внутреннее представление, зависящее от реализации...

насколько я понимаю стандарт, то NULL это такая сущность, которая переходит в null pointer, если засунуть его в указатель. Также указатель можно сравнивать с NULL, и если в указатель запихали NULL предварительно, то указатель будет равен NULL.

Т.е. разница конечно есть, но она точно такая же, как разница между int x равным 5, и константой 5L.

При этом с NULL и 0L такой связи нету, и быть не может, ибо NULL это совсем другое. И указатель равный NULL это совсем не тоже самое, что 0.

Это достаточно кривое и скользкое место в стандарте. Оговорки таки есть. Но мне лениво их искать, и да, это действительно именно "оговорки".

ну например в i8086 оно не всегда будет работать. Ибо там 4096 NULL, и только один из них равен NULL. А в компиляторе, как обычно, никто и не подумал ставить костыли, которые в рантайме определяют NULL это или не NULL. Уверен, что это не единственный такой процессор. Конечно, даже если это UB и не UB, то всё равно такой UB-NULL может появится _только_ если выше по коду УЖЕ было такое UB. В этих строках это прошлое UB просто вскроется, и всё поломает.

я не путаю. Это теперь расширение GCC. Да, БЕЗ плюсов. Вот так вот, ВНЕЗАПНО...

разве это не одно и то же?

не совсем одно и то же... стандарт рассматривает их как разные сущности...
NULL (как и целочисленный 0 и (void*)0) — это «null pointer constant». для него определено то, что он должен преобразовываться в нулевой указатель (null pointer), внутреннее представление, зависящее от реализации...

строго говоря, это не гарантируется т.к. преобразование указатель->int даёт НЁХ, никаких оговорок на счёт нулевых указателей нет.
ИРЛ, конечно, должно работать везде...

не путай си с плюсами... а __null может быть только если внутренним символом компилятора/libc.
хотя C11 я пока не видел...

я согласен с тезисом: «указатель, передаваемый в функцию,  должен указывать на константу, если функция не меняет данные», но делать все указатели константыми ИМХО бесполезное излишество... не могу даже представить от какой ошибки это может уберечь... да и синтаксис у них глаза сломаешь...

по поводу массивов, только одно замечание:

на самом деле оно определено...

ещё можно было про массивы переменной длинны упомянуть...

только если то, что в одну куча свалил «нулевой указатель» и «макрос NULL».

разве это не одно и то же?

ну а не правильно? Целое число != указатель. Это как тёплое и мягкое. Замороженный лёд не тёплый и не мягкий, да. Однако, это не пруф того, что мягкое можно сравнивать с тёплым.

разве?

вот меня тоже интересует, чем «константный указатель на константу» лучше остальных...

очевидно жеж! Чем меньше ☣, тем лучше!

Ты прочитал такую простыню, и ниосилил рефрен?

Суть в том, что чем больше степеней свободы, тем сложнее система, и тем капризнее она и своенравней.  И тем меньше она нужна.

Ну сам посуди: если ты видишь const, ты знаешь, что "это не меняется". Разв это плохо? Легче читать, легче поддерживать. А уж писать так вообще просто. Если я вижу код без const, я знаю на 146% -- написано новичком, который не просидел ни одной бессонной ночи, отлаживая свой кривой код.

Ну да, может он синтаксис C с молоком матери всосал, а папа на ночь ему стандарт пел?

посмотри...

PS: кстати. Сейчас тенденция такова, что NULL так вообще считай отменили. Теперь NULL это __null типа nullptr_t. Вот так вот...

что я неправильно написал?

только если то, что в одну куча свалил «нулевой указатель» и «макрос NULL».
И ещё то, что ты, кажется, обвиняешь в быдлокодинге и нарушении стандарта всех кто использует 0 вместо NULL в коде...

и ещё про это говорил, что не точно:

строго говоря и согласно стандарту:

if (NULL) { /* false*/ }
if ((int)NULL) { /* implementation-defined */ }

Важно: не стоит путать NULL с нулём. Это разные вещи! В стандарте прямо сказано, что значение указателя NULL не определено (точнее, определено, но для каждой конкретной системы по своему. Часто оно действительно 0, потому ваш быдлокод, где вы путаете тёплое с мягким, иногда даже будет работать)

И тем не менее, в стандарте также определено, что преобразовав NULL в целое, вы гарантированно получите ноль. Если-же преобразовать в целое указатель, который на что-то указывает, вы гарантированно получите НЕ НОЛЬ (Важно: вы получите НЕ НОЛЬ, но вовсе НЕ обязательно, что вы получите адрес, или вообще хоть что-то осмысленное! Вы получите ☣, которая не ноль). Таким образом, вы можете узнать, что указатель куда-то указывает

что я неправильно написал?

Нельзя так говорить, особенно новичкам.

что 0 вместо NULL в коде нельзя использовать тоже говорить не хорошо... а именно так звучит то что ты писал...

вот меня тоже интересует, чем «константный указатель на константу» лучше остальных...

про массивы потом просмотрю...

перевирать не надо... я не говорил «одно и тоже»...

говорил "равнозначно". ИМХО многие поймут как "одно и то же". Нельзя так говорить, особенно новичкам.

это тоже не играет роли, что там у K&R было.

лучше чем?..

ага. Чуть более чем все массивы == константные указатели.

Читай дальше... А у меня тут дела, потом допишу...

а вовсе не то, что как ты говоришь "одно и тоже"

перевирать не надо... я не говорил «одно и тоже»...

ЕМНИП у K&R он как раз обычный, целочисленный 0, а такое стандарт просто допускает...

хорошо... возьму другую метафору: ключ на 19 самый лучший...

да, и константные указатели в чистом виде используются чуть чаще, чем никогда...