Che cosa è un puntatore nullo e che cosa è un puntatore nullo?

StackOverflow https://stackoverflow.com/questions/4334831

Domanda

Così mi stava attraversando alcune domande di intervista e mi sono imbattuto in uno dei puntatori vuoti e nulli , che rivendicazioni:

  

un puntatore senza tipo di ritorno è chiamato un puntatore nullo. Può essere qualsiasi tipo di tipo di dati.

Questo mi ha confuso a fondo! Sembra vuoto e nulla potrebbe essere usato in modo intercambiabile in base a questa domanda, e non credo che per essere corretto. Ho assunto vuoto di essere un tipo di ritorno e NULL ad essere un valore. Ma io sono solo un codice-rookie e non sono sicuro che ho ragione.

Si prega di esprimere le vostre opinioni su ciò che un puntatore nullo è e un puntatore vuoto è. Non sto cercando di differenza tra nullo.

È stato utile?

Soluzione

I due concetti sono ortogonali:

  1. Un puntatore nullo, (void *) è un puntatore grezzo a qualche posizione di memoria.
  2. Un puntatore nullo è un puntatore speciale che non punta a nulla, per definizione. Può essere un puntatore a qualsiasi tipo, nulla o altrimenti.

Un puntatore nullo può essere nullo o no: 

void *void_ptr1 = nullptr;
void *void_ptr2 = malloc(42);
void *void_ptr3 = new Foo;               // void * can point to almost anything
void *void_ptr4 = (char*)void_ptr3 + 1;  // even somewhere inside an object

Un puntatore non nullo può anche essere nullo o meno: 

Foo *f = nullptr;
Foo *g = new Foo;

Altri suggerimenti

Basta dimenticare pianura su quella risposta. Una citazione dal tuo link:

  

"un puntatore senza tipo di ritorno è   chiamato un puntatore nullo ".

Questa è sooo pianura SBAGLIATO . tipo di ritorno di un puntatore ? VERAMENTE? Questa è una cattiva fonte ...

void* è puntatore universale tipo perché qualsiasi tipo di puntatore (ad eccezione di puntatore a const e / o volatili) può essere implicitamente convertito in void*. In altre parole, è possibile assegnare qualsiasi puntatore ad una variabile di tipo void*. Un puntatore nullo è un puntatore valore 0

Il tipo void in generale significa che nessuna informazione di tipo è dato.

Si dovrebbe sempre tenere a mente che un puntatore trasmette due informazioni: il tipo dei dati appuntiti (int, double, ...), che specifica come interpretare, e il indirizzo dei dati a cui punta, che specifica , dove è possibile ottenere il valore reale dei dati a punta.

Le informazioni sul tipo è nel tipo del puntatore ( double *, int *, ...), mentre l'indirizzo dei dati è il valore effettivo contenuto nella variabile puntatore.

Quindi, un puntatore void (void *) è un puntatore che non specificano alcuna informazione tipo. Ti dice dove i dati sono, ma non dice come interpretarlo. Si sa che a quell'indirizzo c'è qualcosa, ma non si sa se è un int, un double o un array di mucche volanti. Per effettivamente utilizzare tali dati, è necessario ottenere informazioni di tipo su di esso in qualche altro modo (ad esempio con qualche altro parametro di magia), cast che puntatore a un regolare tipo di puntatore e quindi utilizzarlo come al solito.

void * è spesso usato in C per fornire qualche tipo di supporto di programmazione generica; vedi ad esempio la qsort C funzione di libreria .

Un puntatore NULL, invece, è un puntatore che punta a nulla. In questo caso, le informazioni sul tipo sul puntatore in generale è presente, ma è l'indirizzo dei dati appuntiti che manca. Naturalmente, è possibile avere un void * che è NULL.

esempio rapida (supponendo che v è dichiarato come 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, almeno nella attuale standard, è garantito per essere 0

In altre aree del linguaggio, void viene sempre utilizzato per specificare la mancanza di tipo. Utilizzando come valore di ritorno (nota: sto parlando ora circa void, non void *) significa che la funzione non restituisce alcun valore, e lanciando un'espressione per vuoto è un modo elegante per scartare un valore (Tu sei la segnalazione al compilatore e ad altri programmatori che sei consapevole che non si sta usando un certo valore).

Per favore, ci dica: che cosa è la differenza:

  • tra il serbatoio di gas e la situazione no-gas
  • tra marmellata e no-cookie
  • tra termine 'denaro' e 'tasche vuote'

Se si arriva con questi, you'l essere in grado di cogliere nulla vs void * dillema.

vuoto è un non-type. Null è un non-valore.

Ecco alcune differenze rispetto alla aritmetica dei puntatori:

deriva dal fatto che vuoto è 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)

L'articolo collegato è semplicemente sbagliato. La sua prima frase:

  

un puntatore con nessun tipo di ritorno è   chiamato un puntatore nullo

sta provocando tutti i tipi di allarmi per me. Questo è un pezzo molto confusa della scrittura.

Si è quasi corretto. "Puntatore a vuoto" è un tipo (non un "tipo di ritorno"). Valori di qualsiasi tipo possono essere restituiti da funzioni, e quindi essere tipo di ritorno (della funzione).

Un puntatore nullo è un puntatore che, indipendentemente dal tipo, è puntato verso l'oggetto nullo, che non è un oggetto valido che può essere creato. Un puntatore nullo si può dire che il punto a "nulla".

Un puntatore a vuoto può anche essere nullo; 

void *nothing = 0;

è un codice perfettamente valido, e dice solo che questo puntatore è in grado di indicare un oggetto non tipizzato, ma in questo momento non lo è.

puntatore nullo è scegliere 0x000000 (che è corretto puntatore accesso), mentre puntatore nullo è una corretta puntatore a un tipo non specificato (void *). Tuttavia, puntatore nullo può essere puntatore nullo, ma poi unreferencing il puntatore genererà errore.

A void *ptr è il puntatore che può essere utilizzato per indicare qualsiasi tipo di dati. E 'forse int, float, double. Non ha tipo di ritorno che viene inizialmente puntatore viene creato con tipo di puntatore (avente valore esadecimale) e si può assegnare questo puntatore a qualsiasi tipo di dati.

valore NULL Mentre puntatore nullo è il puntatore con avere valore NULL come indirizzo, il puntatore viene assegnato in modo che esso non può essere utilizzato per accedere altri dati che l'indirizzo può contenere mentre la creazione. Penso che sia una buona tecnica di programmazione per assegnare un puntatore NULL se non è utilizzato al momento.

Autorizzato sotto: CC-BY-SA insieme a attribuzione
Non affiliato a StackOverflow
scroll top