Qual è la differenza tra un puntatore pendente e un puntatore null in C? Tecnicamente, entrambi sembrano uguali.


Risposta 1:

Non c'è differenza se non si dereferenzia nessuno di questi puntatori. Pertanto, penzoloni implica che la memoria a cui punta il puntatore può essere riutilizzata per qualcos'altro, ma il programma presuppone che il vecchio contenuto sia ancora lì e tenta di accedervi. Questo di solito porta a comportamenti errati ad un certo punto nell'esecuzione del programma.

Oltre a ciò, ritengo che la domanda stessa indichi fortemente che non "capisci i puntatori". Se immagini la memoria come una riga di caselle numerate, in cui ogni casella può avere contenuto (un valore, generalmente 0 ... 255), il puntatore è semplicemente un numero intero (qui sto semplificando le specifiche dell'architettura) che contiene il numero (non il valore) di una di quelle caselle.


Risposta 2:

Vedo un sacco di "inglese" qui, che potrebbe essere utile per qualcuno che già conosce il concetto, ma per chi non lo fa non saranno altro che testi incomprensibili. Tuttavia, il quoziente divertente nelle risposte e nelle metafore sta spuntando, si scusa se insulta qualcuno.

Puntatore nullo: un puntatore che contiene l'indirizzo per nulla o indica la posizione NULL. Scrivere in questa posizione è un errore. Questo è progettato per impedire ai programmatori di scrivere accidentalmente in una posizione di memoria che potrebbe causare un errore di segmentazione e / o crash. L'idea era di inizializzare sempre un puntatore con NULL e verificare la presenza di NULL prima di scrivere. Considera questo scenario:

int * p; // in questo momento questo puntatore contiene un indirizzo casuale, può puntare a qualsiasi posizione, anche fuori dal segmento

* p = 10; // questo sicuramente darà la colpa.

modo sicuro sarebbe qualcosa del genere:

int * p = NULL;

if (p! = null)

* p = 10;

Puntatore ciondolante: come suggerisce il nome, un puntatore che non ha idea di dove puntare dal momento che il blocco di memoria a cui stava puntando originariamente è stato rilasciato.

Esistono molti modi per far pendere un puntatore. Il modo più comune sarebbe di nuovo, copiare ed eliminare

int * p = NULL; int * q = NULL;

p = nuovo x;

q = p;

elimina q; // sia q che il puntatore del blocco di memoria di q vengono rimossi dalla memoria

// da qui abbiamo un puntatore p con un indirizzo che non esiste in memoria. Se proviamo ad assegnare un valore a questo puntatore, siamo nei guai, p qui è puntatore penzolante

* p = 10; // incidente

altri modi in cui è possibile creare accidentalmente un puntatore penzolante potrebbero essere la copia superficiale dell'oggetto mediante assegnazione o il passaggio di un oggetto a un metodo utilizzando quindi il costruttore di copia fornito dal compilatore che esegue di nuovo una copia superficiale per l'utente.


Risposta 3:

Vedo un sacco di "inglese" qui, che potrebbe essere utile per qualcuno che già conosce il concetto, ma per chi non lo fa non saranno altro che testi incomprensibili. Tuttavia, il quoziente divertente nelle risposte e nelle metafore sta spuntando, si scusa se insulta qualcuno.

Puntatore nullo: un puntatore che contiene l'indirizzo per nulla o indica la posizione NULL. Scrivere in questa posizione è un errore. Questo è progettato per impedire ai programmatori di scrivere accidentalmente in una posizione di memoria che potrebbe causare un errore di segmentazione e / o crash. L'idea era di inizializzare sempre un puntatore con NULL e verificare la presenza di NULL prima di scrivere. Considera questo scenario:

int * p; // in questo momento questo puntatore contiene un indirizzo casuale, può puntare a qualsiasi posizione, anche fuori dal segmento

* p = 10; // questo sicuramente darà la colpa.

modo sicuro sarebbe qualcosa del genere:

int * p = NULL;

if (p! = null)

* p = 10;

Puntatore ciondolante: come suggerisce il nome, un puntatore che non ha idea di dove puntare dal momento che il blocco di memoria a cui stava puntando originariamente è stato rilasciato.

Esistono molti modi per far pendere un puntatore. Il modo più comune sarebbe di nuovo, copiare ed eliminare

int * p = NULL; int * q = NULL;

p = nuovo x;

q = p;

elimina q; // sia q che il puntatore del blocco di memoria di q vengono rimossi dalla memoria

// da qui abbiamo un puntatore p con un indirizzo che non esiste in memoria. Se proviamo ad assegnare un valore a questo puntatore, siamo nei guai, p qui è puntatore penzolante

* p = 10; // incidente

altri modi in cui è possibile creare accidentalmente un puntatore penzolante potrebbero essere la copia superficiale dell'oggetto mediante assegnazione o il passaggio di un oggetto a un metodo utilizzando quindi il costruttore di copia fornito dal compilatore che esegue di nuovo una copia superficiale per l'utente.


Risposta 4:

Vedo un sacco di "inglese" qui, che potrebbe essere utile per qualcuno che già conosce il concetto, ma per chi non lo fa non saranno altro che testi incomprensibili. Tuttavia, il quoziente divertente nelle risposte e nelle metafore sta spuntando, si scusa se insulta qualcuno.

Puntatore nullo: un puntatore che contiene l'indirizzo per nulla o indica la posizione NULL. Scrivere in questa posizione è un errore. Questo è progettato per impedire ai programmatori di scrivere accidentalmente in una posizione di memoria che potrebbe causare un errore di segmentazione e / o crash. L'idea era di inizializzare sempre un puntatore con NULL e verificare la presenza di NULL prima di scrivere. Considera questo scenario:

int * p; // in questo momento questo puntatore contiene un indirizzo casuale, può puntare a qualsiasi posizione, anche fuori dal segmento

* p = 10; // questo sicuramente darà la colpa.

modo sicuro sarebbe qualcosa del genere:

int * p = NULL;

if (p! = null)

* p = 10;

Puntatore ciondolante: come suggerisce il nome, un puntatore che non ha idea di dove puntare dal momento che il blocco di memoria a cui stava puntando originariamente è stato rilasciato.

Esistono molti modi per far pendere un puntatore. Il modo più comune sarebbe di nuovo, copiare ed eliminare

int * p = NULL; int * q = NULL;

p = nuovo x;

q = p;

elimina q; // sia q che il puntatore del blocco di memoria di q vengono rimossi dalla memoria

// da qui abbiamo un puntatore p con un indirizzo che non esiste in memoria. Se proviamo ad assegnare un valore a questo puntatore, siamo nei guai, p qui è puntatore penzolante

* p = 10; // incidente

altri modi in cui è possibile creare accidentalmente un puntatore penzolante potrebbero essere la copia superficiale dell'oggetto mediante assegnazione o il passaggio di un oggetto a un metodo utilizzando quindi il costruttore di copia fornito dal compilatore che esegue di nuovo una copia superficiale per l'utente.


Risposta 5:

Vedo un sacco di "inglese" qui, che potrebbe essere utile per qualcuno che già conosce il concetto, ma per chi non lo fa non saranno altro che testi incomprensibili. Tuttavia, il quoziente divertente nelle risposte e nelle metafore sta spuntando, si scusa se insulta qualcuno.

Puntatore nullo: un puntatore che contiene l'indirizzo per nulla o indica la posizione NULL. Scrivere in questa posizione è un errore. Questo è progettato per impedire ai programmatori di scrivere accidentalmente in una posizione di memoria che potrebbe causare un errore di segmentazione e / o crash. L'idea era di inizializzare sempre un puntatore con NULL e verificare la presenza di NULL prima di scrivere. Considera questo scenario:

int * p; // in questo momento questo puntatore contiene un indirizzo casuale, può puntare a qualsiasi posizione, anche fuori dal segmento

* p = 10; // questo sicuramente darà la colpa.

modo sicuro sarebbe qualcosa del genere:

int * p = NULL;

if (p! = null)

* p = 10;

Puntatore ciondolante: come suggerisce il nome, un puntatore che non ha idea di dove puntare dal momento che il blocco di memoria a cui stava puntando originariamente è stato rilasciato.

Esistono molti modi per far pendere un puntatore. Il modo più comune sarebbe di nuovo, copiare ed eliminare

int * p = NULL; int * q = NULL;

p = nuovo x;

q = p;

elimina q; // sia q che il puntatore del blocco di memoria di q vengono rimossi dalla memoria

// da qui abbiamo un puntatore p con un indirizzo che non esiste in memoria. Se proviamo ad assegnare un valore a questo puntatore, siamo nei guai, p qui è puntatore penzolante

* p = 10; // incidente

altri modi in cui è possibile creare accidentalmente un puntatore penzolante potrebbero essere la copia superficiale dell'oggetto mediante assegnazione o il passaggio di un oggetto a un metodo utilizzando quindi il costruttore di copia fornito dal compilatore che esegue di nuovo una copia superficiale per l'utente.


Risposta 6:

Vedo un sacco di "inglese" qui, che potrebbe essere utile per qualcuno che già conosce il concetto, ma per chi non lo fa non saranno altro che testi incomprensibili. Tuttavia, il quoziente divertente nelle risposte e nelle metafore sta spuntando, si scusa se insulta qualcuno.

Puntatore nullo: un puntatore che contiene l'indirizzo per nulla o indica la posizione NULL. Scrivere in questa posizione è un errore. Questo è progettato per impedire ai programmatori di scrivere accidentalmente in una posizione di memoria che potrebbe causare un errore di segmentazione e / o crash. L'idea era di inizializzare sempre un puntatore con NULL e verificare la presenza di NULL prima di scrivere. Considera questo scenario:

int * p; // in questo momento questo puntatore contiene un indirizzo casuale, può puntare a qualsiasi posizione, anche fuori dal segmento

* p = 10; // questo sicuramente darà la colpa.

modo sicuro sarebbe qualcosa del genere:

int * p = NULL;

if (p! = null)

* p = 10;

Puntatore ciondolante: come suggerisce il nome, un puntatore che non ha idea di dove puntare dal momento che il blocco di memoria a cui stava puntando originariamente è stato rilasciato.

Esistono molti modi per far pendere un puntatore. Il modo più comune sarebbe di nuovo, copiare ed eliminare

int * p = NULL; int * q = NULL;

p = nuovo x;

q = p;

elimina q; // sia q che il puntatore del blocco di memoria di q vengono rimossi dalla memoria

// da qui abbiamo un puntatore p con un indirizzo che non esiste in memoria. Se proviamo ad assegnare un valore a questo puntatore, siamo nei guai, p qui è puntatore penzolante

* p = 10; // incidente

altri modi in cui è possibile creare accidentalmente un puntatore penzolante potrebbero essere la copia superficiale dell'oggetto mediante assegnazione o il passaggio di un oggetto a un metodo utilizzando quindi il costruttore di copia fornito dal compilatore che esegue di nuovo una copia superficiale per l'utente.


Risposta 7:

Vedo un sacco di "inglese" qui, che potrebbe essere utile per qualcuno che già conosce il concetto, ma per chi non lo fa non saranno altro che testi incomprensibili. Tuttavia, il quoziente divertente nelle risposte e nelle metafore sta spuntando, si scusa se insulta qualcuno.

Puntatore nullo: un puntatore che contiene l'indirizzo per nulla o indica la posizione NULL. Scrivere in questa posizione è un errore. Questo è progettato per impedire ai programmatori di scrivere accidentalmente in una posizione di memoria che potrebbe causare un errore di segmentazione e / o crash. L'idea era di inizializzare sempre un puntatore con NULL e verificare la presenza di NULL prima di scrivere. Considera questo scenario:

int * p; // in questo momento questo puntatore contiene un indirizzo casuale, può puntare a qualsiasi posizione, anche fuori dal segmento

* p = 10; // questo sicuramente darà la colpa.

modo sicuro sarebbe qualcosa del genere:

int * p = NULL;

if (p! = null)

* p = 10;

Puntatore ciondolante: come suggerisce il nome, un puntatore che non ha idea di dove puntare dal momento che il blocco di memoria a cui stava puntando originariamente è stato rilasciato.

Esistono molti modi per far pendere un puntatore. Il modo più comune sarebbe di nuovo, copiare ed eliminare

int * p = NULL; int * q = NULL;

p = nuovo x;

q = p;

elimina q; // sia q che il puntatore del blocco di memoria di q vengono rimossi dalla memoria

// da qui abbiamo un puntatore p con un indirizzo che non esiste in memoria. Se proviamo ad assegnare un valore a questo puntatore, siamo nei guai, p qui è puntatore penzolante

* p = 10; // incidente

altri modi in cui è possibile creare accidentalmente un puntatore penzolante potrebbero essere la copia superficiale dell'oggetto mediante assegnazione o il passaggio di un oggetto a un metodo utilizzando quindi il costruttore di copia fornito dal compilatore che esegue di nuovo una copia superficiale per l'utente.


Risposta 8:

Vedo un sacco di "inglese" qui, che potrebbe essere utile per qualcuno che già conosce il concetto, ma per chi non lo fa non saranno altro che testi incomprensibili. Tuttavia, il quoziente divertente nelle risposte e nelle metafore sta spuntando, si scusa se insulta qualcuno.

Puntatore nullo: un puntatore che contiene l'indirizzo per nulla o indica la posizione NULL. Scrivere in questa posizione è un errore. Questo è progettato per impedire ai programmatori di scrivere accidentalmente in una posizione di memoria che potrebbe causare un errore di segmentazione e / o crash. L'idea era di inizializzare sempre un puntatore con NULL e verificare la presenza di NULL prima di scrivere. Considera questo scenario:

int * p; // in questo momento questo puntatore contiene un indirizzo casuale, può puntare a qualsiasi posizione, anche fuori dal segmento

* p = 10; // questo sicuramente darà la colpa.

modo sicuro sarebbe qualcosa del genere:

int * p = NULL;

if (p! = null)

* p = 10;

Puntatore ciondolante: come suggerisce il nome, un puntatore che non ha idea di dove puntare dal momento che il blocco di memoria a cui stava puntando originariamente è stato rilasciato.

Esistono molti modi per far pendere un puntatore. Il modo più comune sarebbe di nuovo, copiare ed eliminare

int * p = NULL; int * q = NULL;

p = nuovo x;

q = p;

elimina q; // sia q che il puntatore del blocco di memoria di q vengono rimossi dalla memoria

// da qui abbiamo un puntatore p con un indirizzo che non esiste in memoria. Se proviamo ad assegnare un valore a questo puntatore, siamo nei guai, p qui è puntatore penzolante

* p = 10; // incidente

altri modi in cui è possibile creare accidentalmente un puntatore penzolante potrebbero essere la copia superficiale dell'oggetto mediante assegnazione o il passaggio di un oggetto a un metodo utilizzando quindi il costruttore di copia fornito dal compilatore che esegue di nuovo una copia superficiale per l'utente.


Risposta 9:

Vedo un sacco di "inglese" qui, che potrebbe essere utile per qualcuno che già conosce il concetto, ma per chi non lo fa non saranno altro che testi incomprensibili. Tuttavia, il quoziente divertente nelle risposte e nelle metafore sta spuntando, si scusa se insulta qualcuno.

Puntatore nullo: un puntatore che contiene l'indirizzo per nulla o indica la posizione NULL. Scrivere in questa posizione è un errore. Questo è progettato per impedire ai programmatori di scrivere accidentalmente in una posizione di memoria che potrebbe causare un errore di segmentazione e / o crash. L'idea era di inizializzare sempre un puntatore con NULL e verificare la presenza di NULL prima di scrivere. Considera questo scenario:

int * p; // in questo momento questo puntatore contiene un indirizzo casuale, può puntare a qualsiasi posizione, anche fuori dal segmento

* p = 10; // questo sicuramente darà la colpa.

modo sicuro sarebbe qualcosa del genere:

int * p = NULL;

if (p! = null)

* p = 10;

Puntatore ciondolante: come suggerisce il nome, un puntatore che non ha idea di dove puntare dal momento che il blocco di memoria a cui stava puntando originariamente è stato rilasciato.

Esistono molti modi per far pendere un puntatore. Il modo più comune sarebbe di nuovo, copiare ed eliminare

int * p = NULL; int * q = NULL;

p = nuovo x;

q = p;

elimina q; // sia q che il puntatore del blocco di memoria di q vengono rimossi dalla memoria

// da qui abbiamo un puntatore p con un indirizzo che non esiste in memoria. Se proviamo ad assegnare un valore a questo puntatore, siamo nei guai, p qui è puntatore penzolante

* p = 10; // incidente

altri modi in cui è possibile creare accidentalmente un puntatore penzolante potrebbero essere la copia superficiale dell'oggetto mediante assegnazione o il passaggio di un oggetto a un metodo utilizzando quindi il costruttore di copia fornito dal compilatore che esegue di nuovo una copia superficiale per l'utente.


Risposta 10:

Vedo un sacco di "inglese" qui, che potrebbe essere utile per qualcuno che già conosce il concetto, ma per chi non lo fa non saranno altro che testi incomprensibili. Tuttavia, il quoziente divertente nelle risposte e nelle metafore sta spuntando, si scusa se insulta qualcuno.

Puntatore nullo: un puntatore che contiene l'indirizzo per nulla o indica la posizione NULL. Scrivere in questa posizione è un errore. Questo è progettato per impedire ai programmatori di scrivere accidentalmente in una posizione di memoria che potrebbe causare un errore di segmentazione e / o crash. L'idea era di inizializzare sempre un puntatore con NULL e verificare la presenza di NULL prima di scrivere. Considera questo scenario:

int * p; // in questo momento questo puntatore contiene un indirizzo casuale, può puntare a qualsiasi posizione, anche fuori dal segmento

* p = 10; // questo sicuramente darà la colpa.

modo sicuro sarebbe qualcosa del genere:

int * p = NULL;

if (p! = null)

* p = 10;

Puntatore ciondolante: come suggerisce il nome, un puntatore che non ha idea di dove puntare dal momento che il blocco di memoria a cui stava puntando originariamente è stato rilasciato.

Esistono molti modi per far pendere un puntatore. Il modo più comune sarebbe di nuovo, copiare ed eliminare

int * p = NULL; int * q = NULL;

p = nuovo x;

q = p;

elimina q; // sia q che il puntatore del blocco di memoria di q vengono rimossi dalla memoria

// da qui abbiamo un puntatore p con un indirizzo che non esiste in memoria. Se proviamo ad assegnare un valore a questo puntatore, siamo nei guai, p qui è puntatore penzolante

* p = 10; // incidente

altri modi in cui è possibile creare accidentalmente un puntatore penzolante potrebbero essere la copia superficiale dell'oggetto mediante assegnazione o il passaggio di un oggetto a un metodo utilizzando quindi il costruttore di copia fornito dal compilatore che esegue di nuovo una copia superficiale per l'utente.