Я писал такие вещи, как

char *x=NULL;

в предположении, что

 char *x=2;

создаст charуказатель на адрес 2.

Но в The GNU C Programming Tutorial говорится, что int *my_int_ptr = 2;целочисленное значение сохраняется 2по любому случайному адресу, по которому my_int_ptrоно выделяется.

Это может означать, что я char *x=NULLприсваиваю любое значение NULLcast для a charнекоторому случайному адресу в памяти.

Пока

#include <stdlib.h>
#include <stdio.h>

int main()
{
    char *x=NULL;

    if (x==NULL)
        printf("is NULL\n");

    return EXIT_SUCCESS;
}

действительно печатает

нулевой

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

char *x;
x=NULL;

вместо.

Можно ли инициализировать указатель C значением NULL?

TL; DR Да, очень нравится.

Фактическое утверждение , сделанное на направляющей читается как

С другой стороны, если вы используете только одно начальное присваивание, int *my_int_ptr = 2;программа попытается заполнить содержимое ячейки памяти, на которую указывает my_int_ptrзначение 2. Поскольку my_int_ptrон заполнен мусором, это может быть любой адрес. [...]

Ну, они являются неправильно, вы правы.

Для оператора ( пока игнорируем тот факт, что указатель на целочисленное преобразование является поведением, определяемым реализацией )

int * my_int_ptr = 2;

my_int_ptrявляется переменной (типа указателя на int), у нее есть собственный адрес (тип: адрес указателя на целое число), вы сохраняете значение 2в этом адресе.

Теперь, my_int_ptrбудучи типом указателя, мы можем сказать, что он указывает на значение «type» в ячейке памяти, на которую указывает хранимое значение my_int_ptr. Таким образом, вы существенно присваивая значение из переменной указателя, а не значение ячейки памяти , на которую указывает указатель.

Итак, в заключение

 char *x=NULL;

инициализирует переменную указателя , xчтобы NULL, не значение в адреса памяти , на который указывает указатель .

Это то же самое, что и

 char *x;
 x = NULL;    

Расширение:

Теперь, будучи строго согласованным, утверждение вроде

 int * my_int_ptr = 2;

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

• my_int_ptr переменная-указатель, тип int *
• целочисленная константа по определению 2имеет тип int.

и они не являются «совместимыми» типами, поэтому эта инициализация недействительна, поскольку она нарушает правила простого присваивания, упомянутые в главе §6.5.16.1 / P1, описанной в ответе Лундина .

Если кому-то интересно, как инициализация связана с простыми ограничениями присваивания, цитата C11, глава §6.7.9, P11

Инициализатор скаляра должен быть единственным выражением, необязательно заключенным в фигурные скобки. Начальным значением объекта является значение выражения (после преобразования); применяются те же ограничения типов и преобразования, что и для простого присваивания, принимая тип скаляра как неквалифицированную версию его объявленного типа.

Учебник неправильный. В ISO C int *my_int_ptr = 2;это ошибка. В GNU C это означает то же, что и int *my_int_ptr = (int *)2;. Это преобразует целое число 2в адрес памяти каким-то образом, как определено компилятором.

Он не пытается хранить что-либо в месте, указанном по этому адресу (если есть). Если вы продолжите писать *my_int_ptr = 5;, он попытается сохранить номер 5в месте, адресованном по этому адресу.

Чтобы прояснить, почему руководство неверно, int *my_int_ptr = 2;это «нарушение ограничений», это код, который не разрешается компилировать, и компилятор должен дать вам диагностику при обнаружении этого.

Согласно 6.5.16.1 Простое назначение:

Ограничения

Одно из следующих должно иметь место:

• левый операнд имеет атомарный, квалифицированный или неквалифицированный арифметический тип, а правый - арифметический тип;
• левый операнд имеет атомарную, квалифицированную или неквалифицированную версию структуры или типа объединения, совместимую с типом правого;
• левый операнд имеет атомарный, квалифицированный или неквалифицированный тип указателя, и (учитывая тип, который левый операнд будет иметь после преобразования lvalue) оба операнда являются указателями на квалифицированные или неквалифицированные версии совместимых типов, а тип, на который указывает левый, имеет все квалификаторы типа, на который указывает справа;
• левый операнд имеет атомарный, квалифицированный или неквалифицированный тип указателя, и (учитывая тип, который левый операнд будет иметь после преобразования lvalue) один операнд является указателем на тип объекта, а другой - указателем на квалифицированную или неквалифицированную версию void, а тип, на который указывает левый, имеет все квалификаторы типа, на который указывает правый;
• левый операнд является атомарным, квалифицированным или неквалифицированным указателем, а правый - константой нулевого указателя; или
• левый операнд имеет тип атомарный, квалифицированный или неквалифицированный _Bool, а правый - указатель.

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

Известно, что GCC ведет себя плохо, если вы явно не укажете, что это стандартный компилятор C. Если вы скомпилируете код как -std=c11 -pedantic-errors, он будет правильно давать диагностику, как и должен.

int *my_int_ptr = 2

сохраняет целочисленное значение 2 по любому случайному адресу в my_int_ptr при его выделении.

Это совершенно неверно. Если это действительно написано, пожалуйста, получите лучшую книгу или учебник.

int *my_int_ptr = 2определяет целочисленный указатель, который указывает на адрес 2. Скорее всего, вы получите сбой, если попытаетесь получить доступ к адресу 2.

*my_int_ptr = 2, т.е. без символа intв строке, сохраняет значение два для любого случайного адреса, на my_int_ptrкоторый указывает. Сказав это, вы можете назначить NULLуказателю, когда он будет определен. char *x=NULL;совершенно верно C.

Изменить: при написании этого я не знал, что преобразование целого числа в указатель - это поведение, определяемое реализацией. Подробности см. В хороших ответах @MM и @SouravGhosh.

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

int *x = NULL;правильно C, но это очень вводит в заблуждение, я бы даже сказал бессмысленно, и это затрудняет понимание языка для многих новичков. Это наводит на мысль, что в дальнейшем мы сможем сделать, *x = NULL;что, конечно, невозможно. Видите ли, тип переменной - нет int, имя переменной - нет *x, и при этом *в объявлении не играет никакой функциональной роли в сотрудничестве с =. Это чисто декларативно. Итак, что имеет гораздо больше смысла, так это:

int* x = NULL;что также является правильным C, хотя он не соответствует исходному стилю кодирования K&R. Он дает совершенно понять, что тип есть int*, а переменная-указатель есть x, поэтому даже для непосвященных становится ясно, что значение NULLсохраняется x, то есть указатель на int.

Кроме того, это упрощает вывод правила: когда звездочка находится вдали от имени переменной, тогда это объявление, а звездочка, прикрепленная к имени, - это разыменование указателя.

Итак, теперь становится намного понятнее, что дальше мы можем либо делать, x = NULL;либо, *x = 2;другими словами, новичку легче увидеть, как variable = expressionведет к pointer-type variable = pointer-expressionи dereferenced-pointer-variable = expression. (Для посвященных под «выражением» я подразумеваю «rvalue».)

Неудачный выбор в синтаксисе языка заключается в том, что при объявлении локальных переменных вы можете сказать, int i, *p;что объявляет целое число и указатель на целое число, поэтому это наводит на мысль, что *это полезная часть имени. Но это не так, и этот синтаксис - просто причудливый частный случай, добавленный для удобства, и, на мой взгляд, он никогда не должен был существовать, потому что он аннулирует правило, которое я предложил выше. Насколько мне известно, нигде в языке этот синтаксис не имеет смысла, но даже если это так, он указывает на несоответствие в способах определения типов указателей в C. Везде в других объявлениях с одной переменной, в списках параметров, в членах структуры и т. д. вы можете объявлять указатели как type* pointer-variableвместо type *pointer-variable; это совершенно законно и имеет больше смысла.

К многочисленным отличным ответам я хотел бы добавить что-то ортогональное. На самом деле инициализация NULL- это далеко не плохая практика и может быть удобной, если этот указатель может использоваться или не использоваться для хранения динамически выделяемого блока памяти.

int * p = NULL;
...
if (...) {
    p = (int*) malloc(...);
    ...
}
...
free(p);

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

это нулевой указатель

int * nullPtr = (void*) 0;

Это верно.

int main()
{
    char * x = NULL;

    if (x==NULL)
        printf("is NULL\n");

    return EXIT_SUCCESS;
}

Эта функция подходит для того, что делает. Он присваивает адрес 0 указателю символа x. То есть он указывает указателем x на адрес памяти 0.

Альтернатива:

int main()
{
    char* x = 0;

    if ( !x )
        printf(" x points to NULL\n");

    return EXIT_SUCCESS;
}

Я предполагаю, что вы хотели:

int main()
{
    char* x = NULL;
    x = alloc( sizeof( char ));
    *x = '2';

    if ( *x == '2' )
        printf(" x points to an address/location that contains a '2' \n");

    return EXIT_SUCCESS;
}

x is the street address of a house. *x examines the contents of that house.