Я писав такі речі

char *x=NULL;

припускаючи, що

 char *x=2;

створив би charвказівник на адресу 2.

Але в підручнику з програмування GNU C сказано, що int *my_int_ptr = 2;ціле число зберігається 2до будь-якої випадкової адреси, my_int_ptrколи воно виділяється.

Здається, це означає, що мій власний char *x=NULLприсвоює будь-яке значення NULLприведення charдо якоїсь випадкової адреси в пам'яті.

Поки

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

int main()
{
    char *x=NULL;

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

    return EXIT_SUCCESS;
}

насправді друкує

дорівнює NULL

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

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 для деталей.

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

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. Всюди, в оголошеннях з однією змінною, у списках параметрів, у членах struct та ін. Ви можете оголосити свої вказівники type* pointer-variableзамість type *pointer-variable; це цілком законно і має більше сенсу.

Я хотів би додати щось ортогональне до багатьох чудових відповідей. Насправді ініціалізація до NULLє далеко не поганою практикою і може бути корисною, якщо цей вказівник може використовуватися чи не використовуватись для зберігання динамічно виділеного блоку пам'яті.

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

Оскільки згідно зі стандартом ISO-IEC 9899 free є аргументом nop, коли аргумент є 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.