¿Qué es un puntero nulo y qué es un puntero nulo?

Simplemente olvídate de esa respuesta. Una cita de su enlace :

"un puntero sin tipo de retorno es llamado puntero nulo."

Esto es tan sencillo INCORRECTO. Un puntero tipo de retorno? ¿EN SERIO? Esta es una mala fuente...

void* es puntero universaltipo porque cualquier tipo de puntero (excepto puntero a const y / o volátil) se puede convertir implícitamente a void*. En otras palabras, usted puede asigne cualquier puntero a una variable de tipo void*. Un puntero nulo es un puntero valor 0

El tipo void en general significa que no se da información de tipo.

Siempre debe tener en cuenta que un puntero transmite dos piezas de información: el tipo de los datos apuntados(int, double, ...), que especifica cómo interpretarlo, y la dirección de los datos a los que apunta, que especifica donde puede obtener el valor real de los datos apuntados.

La información de tipo está en el tipo del puntero (double*, int*, ...), mientras que la dirección de los datos es el valor real contenido en la variable puntero.

Por lo tanto, un puntero void (void *) es un puntero que no especifica ninguna información de tipo. Te dice dónde están los datos, pero no te dice cómo interpretarlos. Sabes que en esa dirección hay algo, pero no sabes si es un int, un double o una serie de vacas voladoras. Para utilizar realmente tales datos, usted tiene que conseguir la información del tipo sobre ella de alguna otra manera (por ejemplo, con algún otro parámetro mágico), cast that pointer to a regular pointer type and then use it as usual.

void * se utiliza a menudo en C para proporcionar algún tipo de apoyo a la programación genérica; véase, por ejemplo, el qsort C función de biblioteca.

Un puntero NULL, en cambio, es un puntero que apunta a nada. En este caso, la información de tipo sobre el puntero en general está presente, pero es la dirección de los datos apuntados la que falta. Por supuesto, es posible tener un void * que es NULL.

Ejemplo rápido (suponiendo que v se declara como double v;):

                         Type information present
             +----------------------+----------------------+
             |          ✔           |          ✘           |
         +---+----------------------+----------------------+
    p  c |   |                      |                      |
 v  o  o | ✔ | double * ptr = &v;   | void * ptr = &v;     |
 a  i  n |   |                      |                      |
 l  n  t +---+----------------------+----------------------+
 i  t  e |   |                      |                      |
 d  e  n | ✘ | double * ptr = NULL; | void * ptr = NULL;   |
    d  t |   |                      |                      |
         +---+----------------------+----------------------+

Trivia: NULL, al menos en el estándar actual, se garantiza que sea 0.

En otras áreas del lenguaje, void siempre se usa para especificar la falta de tipo. Usarlo como valor de retorno (nota: Estoy hablando ahora de void, no void *) significa que la función no devuelve ningún valor, y lanzar una expresión a void es una forma elegante de descartar un valor (estás señalando al compilador y a otros programadores que eres consciente de que no estás usando un cierto valor).

Por favor, díganos: ¿cuál es la diferencia:

• entre el depósito de gas y la situación sin gas
• entre el tarro de galletas y no-cookies
• entre el término "dinero" y "bolsillos vacíos"

Si se te ocurren estos, serás capaz de captar null vs void* dillema.

void es un no-tipo. null es un no-valor.

Aquí hay algunas diferencias con respecto a la aritmética de punteros:

Se deriva del hecho de que void es un tipo incompleto.

void *vp;
vp++;     // error, incomplete type
vp += 2;  // same error

void *p = 0;
p++;      // still same error

int *p = 0;
p++;      // well-formed program, but UB ($5.6/5)

El artículo enlazado es simplemente incorrecto. Su primera frase:

Un puntero sin tipo de retorno es llamado puntero nulo

Está activando todo tipo de alarmas para mí. Esta es una escritura muy confusa.

Estás casi en lo correcto. "Puntero a vacío "es un tipo (no un"tipo de retorno"). Los valores de cualquier tipo pueden ser devueltos por las funciones, y por lo tanto ser (de la función) tipo de retorno.

Un puntero nulo es un puntero que, independientemente de su tipo, es apuntando al objeto null, que no es ningún objeto válido que se pueda crear. Se puede decir que un puntero nulo apunta a "nada".

Un puntero a void también puede ser nulo;

void *nothing = 0;

Es un código perfectamente válido, y solo dice que este puntero es capaz de apuntar a un objeto sin tipo, pero en este momento no lo es.

El puntero nulo apunta a 0x000000(que es incorrecto para acceder al puntero), mientras que el puntero nulo es un puntero correcto a un tipo no especificado(void *). Sin embargo, el puntero nulo puede ser un puntero nulo, pero al no referenciar el puntero se generará un error.

A void *ptr es el puntero que se puede utilizar para apuntar cualquier tipo de datos. Tal vez int, float, double. No tiene tipo de retorno que es inicialmente puntero se crea con tipo puntero (que tiene valor hexadecimal) y podemos asignar este puntero a cualquier tipo de datos.

Mientras que el puntero null es el puntero que tiene un valor NULL como dirección, al puntero se le asigna un valor NULL para que no pueda usarse para acceder a otros datos que su dirección pueda contener mientras se crea. Creo que es una buena programación técnica para asignar un puntero NULL si no se utiliza en este momento.