Había estado escribiendo cosas como

char *x=NULL;

asumiendo que

 char *x=2;

crearía un charpuntero a la dirección 2.

Pero, en The GNU C Programming Tutorial dice que int *my_int_ptr = 2;almacena el valor entero 2en cualquier dirección aleatoria en la my_int_ptrque se encuentre cuando se asigna.

Esto parecería implicar que el mío char *x=NULLestá asignando cualquier valor de NULLcast a a chares a alguna dirección aleatoria en la memoria.

Mientras

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

int main()
{
    char *x=NULL;

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

    return EXIT_SUCCESS;
}

de hecho, imprime

es nulo

cuando lo compilo y ejecuto, me preocupa que confíe en un comportamiento indefinido, o al menos un comportamiento subespecificado, y que debería escribir

char *x;
x=NULL;

en lugar.

¿Es posible inicializar un puntero C a NULL?

TL; DR Sí, mucho.

La afirmación real hecha en la guía se lee como

Por otro lado, si usa solo la asignación inicial única int *my_int_ptr = 2;, el programa intentará llenar el contenido de la ubicación de memoria señalada por my_int_ptrcon el valor 2. Como my_int_ptrestá lleno de basura, puede ser cualquier dirección. [...]

Bueno, están equivocados, tienes razón.

Para la declaración, ( ignorando, por ahora, el hecho de que la conversión de puntero a entero es un comportamiento definido por la implementación )

int * my_int_ptr = 2;

my_int_ptres una variable (de tipo puntero a int), tiene una dirección propia (tipo: dirección de puntero a entero), está almacenando un valor de 2en esa dirección.

Ahora, al my_int_ptrser un tipo de puntero, podemos decir que apunta al valor de "tipo" en la ubicación de memoria apuntada por el valor retenido my_int_ptr. Por lo tanto, esencialmente está asignando el valor de la variable de puntero, no el valor de la ubicación de memoria a la que apunta el puntero.

Entonces, para concluir

 char *x=NULL;

inicializa la variable de puntero xa NULL, no el valor en la dirección de memoria apuntada por el puntero .

Esto es lo mismo que

 char *x;
 x = NULL;    

Expansión:

Ahora, siendo estrictamente conforme, una declaración como

 int * my_int_ptr = 2;

es ilegal, ya que implica una violación de la restricción. Para ser claro,

• my_int_ptr es una variable de puntero, tipo int *
• una constante entera, 2tiene tipo int, por definición.

y no son tipos "compatibles", por lo que esta inicialización no es válida porque viola las reglas de asignación simple, mencionadas en el capítulo §6.5.16.1 / P1, descritas en la respuesta de Lundin .

En caso de que alguien esté interesado en cómo la inicialización está vinculada a restricciones de asignación simples, citando C11, capítulo §6.7.9, P11

El inicializador de un escalar será una sola expresión, opcionalmente encerrada entre llaves. El valor inicial del objeto es el de la expresión (después de la conversión); Se aplican las mismas restricciones de tipo y conversiones que para la asignación simple, tomando el tipo del escalar como la versión no calificada de su tipo declarado.

El tutorial está mal. En ISO C, int *my_int_ptr = 2;es un error. En GNU C, significa lo mismo que int *my_int_ptr = (int *)2;. Esto convierte el entero 2en una dirección de memoria, de alguna manera según lo determine el compilador.

No intenta almacenar nada en la ubicación a la que se dirige esa dirección (si corresponde). Si continuara escribiendo *my_int_ptr = 5;, intentaría almacenar el número 5en la ubicación a la que se dirige esa dirección.

Para aclarar por qué el tutorial es incorrecto, int *my_int_ptr = 2;es una "violación de restricción", es un código que no se puede compilar y el compilador debe proporcionarle un diagnóstico al encontrarlo.

Según 6.5.16.1 Asignación simple:

Restricciones

Uno de los siguientes deberá ser válido:

• el operando izquierdo tiene tipo aritmético atómico, calificado o no calificado, y el derecho tiene tipo aritmético;
• el operando izquierdo tiene una versión atómica, calificada o no calificada de un tipo de estructura o unión compatible con el tipo de la derecha;
• el operando izquierdo tiene un tipo de puntero atómico, calificado o no calificado, y (considerando el tipo que tendría el operando izquierdo después de la conversión de lvalue) ambos operandos son punteros a versiones calificadas o no calificadas de tipos compatibles, y el tipo apuntado por la izquierda tiene todo los calificadores del tipo señalado por la derecha;
• el operando izquierdo tiene un tipo de puntero atómico, calificado o no calificado, y (considerando el tipo que tendría el operando izquierdo después de la conversión de lvalue) un operando es un puntero a un tipo de objeto, y el otro es un puntero a una versión calificada o no calificada de void, y el tipo señalado por la izquierda tiene todos los calificadores del tipo señalado por la derecha;
• el operando izquierdo es un puntero atómico, calificado o no calificado, y el derecho es una constante de puntero nulo; o
• el operando izquierdo tiene tipo _Bool atómico, calificado o no calificado, y el derecho es un puntero.

En este caso, el operando izquierdo es un puntero no calificado. En ninguna parte menciona que el operando derecho puede ser un número entero (tipo aritmético). Entonces el código viola el estándar C.

Se sabe que GCC se comporta mal a menos que le indique explícitamente que sea un compilador C estándar. Si compila el código como -std=c11 -pedantic-errors, dará correctamente un diagnóstico como debe hacerlo.

int *my_int_ptr = 2

almacena el valor entero 2 en cualquier dirección aleatoria que esté en my_int_ptr cuando se asigna.

Esto está completamente mal. Si esto está realmente escrito, consiga un mejor libro o tutorial.

int *my_int_ptr = 2define un puntero entero que apunta a la dirección 2. Lo más probable es que se bloquee si intenta acceder a la dirección 2.

*my_int_ptr = 2, es decir, sin el inten la línea, almacena el valor dos en cualquier dirección aleatoria a la my_int_ptrque apunte. Habiendo dicho esto, puede asignar NULLa un puntero cuando esté definido. char *x=NULL;es perfectamente válido C.

Editar: Mientras escribía esto, no sabía que la conversión de entero a puntero es un comportamiento definido por la implementación. Consulte las buenas respuestas de @MM y @SouravGhosh para obtener más detalles.

Mucha confusión acerca de los punteros C proviene de una muy mala elección que se hizo originalmente con respecto al estilo de codificación, corroborada por una muy mala elección en la sintaxis del lenguaje.

int *x = NULL;C es correcta, pero es muy engañosa, incluso diría absurda, y ha dificultado la comprensión del idioma para muchos novatos. Hace pensar que más adelante podríamos hacer lo *x = NULL;que, por supuesto, es imposible. Verá, el tipo de la variable no lo es int, y el nombre de la variable no lo es *x, ni el *en la declaración juega ningún papel funcional en colaboración con el =. Es puramente declarativo. Entonces, lo que tiene mucho más sentido es esto:

int* x = NULL;que también es C correcta, aunque no se adhiere al estilo de codificación original de K&R. Deja perfectamente claro que el tipo es int*, y la variable de puntero lo es x, por lo que resulta claramente evidente incluso para los no iniciados que el valor NULLse está almacenando en x, que es un puntero a int.

Además, hace que sea más fácil derivar una regla: cuando la estrella está lejos del nombre de la variable, entonces es una declaración, mientras que la estrella que se adjunta al nombre es una desreferenciación del puntero.

Entonces, ahora se vuelve mucho más comprensible que más abajo podamos hacer x = NULL;o, *x = 2;en otras palabras, facilita que un novato vea cómo variable = expressionconduce a pointer-type variable = pointer-expressiony dereferenced-pointer-variable = expression. (Para los iniciados, por 'expresión' me refiero a 'rvalue').

La desafortunada elección en la sintaxis del lenguaje es que al declarar variables locales puedes decir int i, *p;cuál declara un número entero y un puntero a un número entero, por lo que te lleva a creer que *es una parte útil del nombre. Pero no lo es, y esta sintaxis es solo un caso especial peculiar, agregado por conveniencia y, en mi opinión, nunca debería haber existido, porque invalida la regla que propuse anteriormente. Hasta donde yo sé, en ninguna otra parte del lenguaje esta sintaxis es significativa, pero incluso si lo es, apunta a una discrepancia en la forma en que se definen los tipos de puntero en C.En cualquier otro lugar, en declaraciones de una sola variable, en listas de parámetros, en miembros de estructura, etc., puede declarar sus punteros como en type* pointer-variablelugar de type *pointer-variable; es perfectamente legal y tiene más sentido.

Me gustaría agregar algo ortogonal a las muchas respuestas excelentes. En realidad, la inicialización en NULLestá lejos de ser una mala práctica y puede ser útil si ese puntero puede o no usarse para almacenar un bloque de memoria asignado dinámicamente.

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

Dado que de acuerdo con el estándar ISO-IEC 9899 free es un nop cuando el argumento lo es NULL, el código anterior (o algo más significativo en la misma línea) es legítimo.

este es un puntero nulo

int * nullPtr = (void*) 0;

Esto es correcto.

int main()
{
    char * x = NULL;

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

    return EXIT_SUCCESS;
}

Esta función es correcta para lo que hace. Asigna la dirección de 0 al puntero char x. Es decir, apunta el puntero x a la dirección de memoria 0.

Alternativa:

int main()
{
    char* x = 0;

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

    return EXIT_SUCCESS;
}

Mi conjetura sobre lo que querías es:

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.