Quelle est la différence entre un pointeur suspendu et un pointeur nul en C? Techniquement, les deux semblent identiques.


Réponse 1:

Il n'y a aucune différence tant que vous ne déréférencez aucun de ces pointeurs. Par conséquent, balancer implique que la mémoire vers laquelle le pointeur pointe peut être réutilisée pour autre chose, mais le programme suppose que l'ancien contenu est toujours là et essaie d'y accéder. Cela conduit généralement à un comportement incorrect à un moment donné de l'exécution du programme.

En plus de cela, je pense que la question elle-même indique fortement que vous ne "comprenez pas les pointeurs". Si vous imaginez la mémoire comme une ligne de cases numérotées, où chaque case peut avoir du contenu (une valeur, généralement 0 ... 255), alors le pointeur est simplement un entier (je simplifie les spécificités architecturales ici) contenant le numéro (pas le valeur) de l’une de ces cases.


Réponse 2:

Je vois beaucoup de "anglais" ici, ce qui pourrait être utile pour quelqu'un qui connaît déjà le concept, mais pour quelqu'un qui ne le fait pas, ce ne seront que des textes de charabia. Cependant, le quotient amusant dans les réponses et les métaphores tourne, excuses s'il insulte quelqu'un.

Null Pointer: un pointeur qui contient l'adresse de rien ou dire l'emplacement NULL. Écrire sur cet emplacement est une faute. Ceci est conçu pour empêcher les programmeurs d'écrire accidentellement sur un emplacement mémoire qui pourrait provoquer une erreur de segmentation et / ou un crash. L'idée était de toujours initialiser un pointeur avec NULL et de vérifier NULL avant d'écrire. Considérez ce scénario:

int * p; // en ce moment ce pointeur contient une adresse aléatoire, peut pointer vers n'importe quel emplacement, même hors segment

* p = 10; // cela causera très certainement des fautes.

moyen sûr serait quelque chose comme ceci:

int * p = NULL;

si (p! = NULL)

* p = 10;

Pointeur suspendu: comme son nom l'indique, un pointeur qui ne sait pas où pointer depuis le bloc de mémoire vers lequel il pointait à l'origine est libéré.

Il existe plusieurs façons de faire pendre un pointeur. La façon la plus courante serait de créer, copier et supprimer

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

p = nouveau x;

q = p;

supprimer q; // q et le pointeur de bloc de mémoire de q sont supprimés de la mémoire

// à partir de là, nous avons un pointeur p ayant une adresse qui n'existe pas en mémoire. Si nous essayons d'attribuer une certaine valeur à ce pointeur, nous sommes en difficulté, p voici le pointeur suspendu

* p = 10; //crash

d'autres façons dont vous pouvez probablement créer accidentellement un pointeur suspendu seraient de faire une copie superficielle de l'objet soit par assignation, soit en passant un objet à une méthode, utilisant ainsi le constructeur de copie fourni par le compilateur qui à nouveau effectue une copie superficielle pour vous.


Réponse 3:

Je vois beaucoup de "anglais" ici, ce qui pourrait être utile pour quelqu'un qui connaît déjà le concept, mais pour quelqu'un qui ne le fait pas, ce ne seront que des textes de charabia. Cependant, le quotient amusant dans les réponses et les métaphores tourne, excuses s'il insulte quelqu'un.

Null Pointer: un pointeur qui contient l'adresse de rien ou dire l'emplacement NULL. Écrire sur cet emplacement est une faute. Ceci est conçu pour empêcher les programmeurs d'écrire accidentellement sur un emplacement mémoire qui pourrait provoquer une erreur de segmentation et / ou un crash. L'idée était de toujours initialiser un pointeur avec NULL et de vérifier NULL avant d'écrire. Considérez ce scénario:

int * p; // en ce moment ce pointeur contient une adresse aléatoire, peut pointer vers n'importe quel emplacement, même hors segment

* p = 10; // cela causera très certainement des fautes.

moyen sûr serait quelque chose comme ceci:

int * p = NULL;

si (p! = NULL)

* p = 10;

Pointeur suspendu: comme son nom l'indique, un pointeur qui ne sait pas où pointer depuis le bloc de mémoire vers lequel il pointait à l'origine est libéré.

Il existe plusieurs façons de faire pendre un pointeur. La façon la plus courante serait de créer, copier et supprimer

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

p = nouveau x;

q = p;

supprimer q; // q et le pointeur de bloc de mémoire de q sont supprimés de la mémoire

// à partir de là, nous avons un pointeur p ayant une adresse qui n'existe pas en mémoire. Si nous essayons d'attribuer une certaine valeur à ce pointeur, nous sommes en difficulté, p voici le pointeur suspendu

* p = 10; //crash

d'autres façons dont vous pouvez probablement créer accidentellement un pointeur suspendu seraient de faire une copie superficielle de l'objet soit par assignation, soit en passant un objet à une méthode, utilisant ainsi le constructeur de copie fourni par le compilateur qui à nouveau effectue une copie superficielle pour vous.


Réponse 4:

Je vois beaucoup de "anglais" ici, ce qui pourrait être utile pour quelqu'un qui connaît déjà le concept, mais pour quelqu'un qui ne le fait pas, ce ne seront que des textes de charabia. Cependant, le quotient amusant dans les réponses et les métaphores tourne, excuses s'il insulte quelqu'un.

Null Pointer: un pointeur qui contient l'adresse de rien ou dire l'emplacement NULL. Écrire sur cet emplacement est une faute. Ceci est conçu pour empêcher les programmeurs d'écrire accidentellement sur un emplacement mémoire qui pourrait provoquer une erreur de segmentation et / ou un crash. L'idée était de toujours initialiser un pointeur avec NULL et de vérifier NULL avant d'écrire. Considérez ce scénario:

int * p; // en ce moment ce pointeur contient une adresse aléatoire, peut pointer vers n'importe quel emplacement, même hors segment

* p = 10; // cela causera très certainement des fautes.

moyen sûr serait quelque chose comme ceci:

int * p = NULL;

si (p! = NULL)

* p = 10;

Pointeur suspendu: comme son nom l'indique, un pointeur qui ne sait pas où pointer depuis le bloc de mémoire vers lequel il pointait à l'origine est libéré.

Il existe plusieurs façons de faire pendre un pointeur. La façon la plus courante serait de créer, copier et supprimer

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

p = nouveau x;

q = p;

supprimer q; // q et le pointeur de bloc de mémoire de q sont supprimés de la mémoire

// à partir de là, nous avons un pointeur p ayant une adresse qui n'existe pas en mémoire. Si nous essayons d'attribuer une certaine valeur à ce pointeur, nous sommes en difficulté, p voici le pointeur suspendu

* p = 10; //crash

d'autres façons dont vous pouvez probablement créer accidentellement un pointeur suspendu seraient de faire une copie superficielle de l'objet soit par assignation, soit en passant un objet à une méthode, utilisant ainsi le constructeur de copie fourni par le compilateur qui à nouveau effectue une copie superficielle pour vous.


Réponse 5:

Je vois beaucoup de "anglais" ici, ce qui pourrait être utile pour quelqu'un qui connaît déjà le concept, mais pour quelqu'un qui ne le fait pas, ce ne seront que des textes de charabia. Cependant, le quotient amusant dans les réponses et les métaphores tourne, excuses s'il insulte quelqu'un.

Null Pointer: un pointeur qui contient l'adresse de rien ou dire l'emplacement NULL. Écrire sur cet emplacement est une faute. Ceci est conçu pour empêcher les programmeurs d'écrire accidentellement sur un emplacement mémoire qui pourrait provoquer une erreur de segmentation et / ou un crash. L'idée était de toujours initialiser un pointeur avec NULL et de vérifier NULL avant d'écrire. Considérez ce scénario:

int * p; // en ce moment ce pointeur contient une adresse aléatoire, peut pointer vers n'importe quel emplacement, même hors segment

* p = 10; // cela causera très certainement des fautes.

moyen sûr serait quelque chose comme ceci:

int * p = NULL;

si (p! = NULL)

* p = 10;

Pointeur suspendu: comme son nom l'indique, un pointeur qui ne sait pas où pointer depuis le bloc de mémoire vers lequel il pointait à l'origine est libéré.

Il existe plusieurs façons de faire pendre un pointeur. La façon la plus courante serait de créer, copier et supprimer

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

p = nouveau x;

q = p;

supprimer q; // q et le pointeur de bloc de mémoire de q sont supprimés de la mémoire

// à partir de là, nous avons un pointeur p ayant une adresse qui n'existe pas en mémoire. Si nous essayons d'attribuer une certaine valeur à ce pointeur, nous sommes en difficulté, p voici le pointeur suspendu

* p = 10; //crash

d'autres façons dont vous pouvez probablement créer accidentellement un pointeur suspendu seraient de faire une copie superficielle de l'objet soit par assignation, soit en passant un objet à une méthode, utilisant ainsi le constructeur de copie fourni par le compilateur qui à nouveau effectue une copie superficielle pour vous.


Réponse 6:

Je vois beaucoup de "anglais" ici, ce qui pourrait être utile pour quelqu'un qui connaît déjà le concept, mais pour quelqu'un qui ne le fait pas, ce ne seront que des textes de charabia. Cependant, le quotient amusant dans les réponses et les métaphores tourne, excuses s'il insulte quelqu'un.

Null Pointer: un pointeur qui contient l'adresse de rien ou dire l'emplacement NULL. Écrire sur cet emplacement est une faute. Ceci est conçu pour empêcher les programmeurs d'écrire accidentellement sur un emplacement mémoire qui pourrait provoquer une erreur de segmentation et / ou un crash. L'idée était de toujours initialiser un pointeur avec NULL et de vérifier NULL avant d'écrire. Considérez ce scénario:

int * p; // en ce moment ce pointeur contient une adresse aléatoire, peut pointer vers n'importe quel emplacement, même hors segment

* p = 10; // cela causera très certainement des fautes.

moyen sûr serait quelque chose comme ceci:

int * p = NULL;

si (p! = NULL)

* p = 10;

Pointeur suspendu: comme son nom l'indique, un pointeur qui ne sait pas où pointer depuis le bloc de mémoire vers lequel il pointait à l'origine est libéré.

Il existe plusieurs façons de faire pendre un pointeur. La façon la plus courante serait de créer, copier et supprimer

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

p = nouveau x;

q = p;

supprimer q; // q et le pointeur de bloc de mémoire de q sont supprimés de la mémoire

// à partir de là, nous avons un pointeur p ayant une adresse qui n'existe pas en mémoire. Si nous essayons d'attribuer une certaine valeur à ce pointeur, nous sommes en difficulté, p voici le pointeur suspendu

* p = 10; //crash

d'autres façons dont vous pouvez probablement créer accidentellement un pointeur suspendu seraient de faire une copie superficielle de l'objet soit par assignation, soit en passant un objet à une méthode, utilisant ainsi le constructeur de copie fourni par le compilateur qui à nouveau effectue une copie superficielle pour vous.


Réponse 7:

Je vois beaucoup de "anglais" ici, ce qui pourrait être utile pour quelqu'un qui connaît déjà le concept, mais pour quelqu'un qui ne le fait pas, ce ne seront que des textes de charabia. Cependant, le quotient amusant dans les réponses et les métaphores tourne, excuses s'il insulte quelqu'un.

Null Pointer: un pointeur qui contient l'adresse de rien ou dire l'emplacement NULL. Écrire sur cet emplacement est une faute. Ceci est conçu pour empêcher les programmeurs d'écrire accidentellement sur un emplacement mémoire qui pourrait provoquer une erreur de segmentation et / ou un crash. L'idée était de toujours initialiser un pointeur avec NULL et de vérifier NULL avant d'écrire. Considérez ce scénario:

int * p; // en ce moment ce pointeur contient une adresse aléatoire, peut pointer vers n'importe quel emplacement, même hors segment

* p = 10; // cela causera très certainement des fautes.

moyen sûr serait quelque chose comme ceci:

int * p = NULL;

si (p! = NULL)

* p = 10;

Pointeur suspendu: comme son nom l'indique, un pointeur qui ne sait pas où pointer depuis le bloc de mémoire vers lequel il pointait à l'origine est libéré.

Il existe plusieurs façons de faire pendre un pointeur. La façon la plus courante serait de créer, copier et supprimer

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

p = nouveau x;

q = p;

supprimer q; // q et le pointeur de bloc de mémoire de q sont supprimés de la mémoire

// à partir de là, nous avons un pointeur p ayant une adresse qui n'existe pas en mémoire. Si nous essayons d'attribuer une certaine valeur à ce pointeur, nous sommes en difficulté, p voici le pointeur suspendu

* p = 10; //crash

d'autres façons dont vous pouvez probablement créer accidentellement un pointeur suspendu seraient de faire une copie superficielle de l'objet soit par assignation, soit en passant un objet à une méthode, utilisant ainsi le constructeur de copie fourni par le compilateur qui à nouveau effectue une copie superficielle pour vous.


Réponse 8:

Je vois beaucoup de "anglais" ici, ce qui pourrait être utile pour quelqu'un qui connaît déjà le concept, mais pour quelqu'un qui ne le fait pas, ce ne seront que des textes de charabia. Cependant, le quotient amusant dans les réponses et les métaphores tourne, excuses s'il insulte quelqu'un.

Null Pointer: un pointeur qui contient l'adresse de rien ou dire l'emplacement NULL. Écrire sur cet emplacement est une faute. Ceci est conçu pour empêcher les programmeurs d'écrire accidentellement sur un emplacement mémoire qui pourrait provoquer une erreur de segmentation et / ou un crash. L'idée était de toujours initialiser un pointeur avec NULL et de vérifier NULL avant d'écrire. Considérez ce scénario:

int * p; // en ce moment ce pointeur contient une adresse aléatoire, peut pointer vers n'importe quel emplacement, même hors segment

* p = 10; // cela causera très certainement des fautes.

moyen sûr serait quelque chose comme ceci:

int * p = NULL;

si (p! = NULL)

* p = 10;

Pointeur suspendu: comme son nom l'indique, un pointeur qui ne sait pas où pointer depuis le bloc de mémoire vers lequel il pointait à l'origine est libéré.

Il existe plusieurs façons de faire pendre un pointeur. La façon la plus courante serait de créer, copier et supprimer

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

p = nouveau x;

q = p;

supprimer q; // q et le pointeur de bloc de mémoire de q sont supprimés de la mémoire

// à partir de là, nous avons un pointeur p ayant une adresse qui n'existe pas en mémoire. Si nous essayons d'attribuer une certaine valeur à ce pointeur, nous sommes en difficulté, p voici le pointeur suspendu

* p = 10; //crash

d'autres façons dont vous pouvez probablement créer accidentellement un pointeur suspendu seraient de faire une copie superficielle de l'objet soit par assignation, soit en passant un objet à une méthode, utilisant ainsi le constructeur de copie fourni par le compilateur qui à nouveau effectue une copie superficielle pour vous.


Réponse 9:

Je vois beaucoup de "anglais" ici, ce qui pourrait être utile pour quelqu'un qui connaît déjà le concept, mais pour quelqu'un qui ne le fait pas, ce ne seront que des textes de charabia. Cependant, le quotient amusant dans les réponses et les métaphores tourne, excuses s'il insulte quelqu'un.

Null Pointer: un pointeur qui contient l'adresse de rien ou dire l'emplacement NULL. Écrire sur cet emplacement est une faute. Ceci est conçu pour empêcher les programmeurs d'écrire accidentellement sur un emplacement mémoire qui pourrait provoquer une erreur de segmentation et / ou un crash. L'idée était de toujours initialiser un pointeur avec NULL et de vérifier NULL avant d'écrire. Considérez ce scénario:

int * p; // en ce moment ce pointeur contient une adresse aléatoire, peut pointer vers n'importe quel emplacement, même hors segment

* p = 10; // cela causera très certainement des fautes.

moyen sûr serait quelque chose comme ceci:

int * p = NULL;

si (p! = NULL)

* p = 10;

Pointeur suspendu: comme son nom l'indique, un pointeur qui ne sait pas où pointer depuis le bloc de mémoire vers lequel il pointait à l'origine est libéré.

Il existe plusieurs façons de faire pendre un pointeur. La façon la plus courante serait de créer, copier et supprimer

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

p = nouveau x;

q = p;

supprimer q; // q et le pointeur de bloc de mémoire de q sont supprimés de la mémoire

// à partir de là, nous avons un pointeur p ayant une adresse qui n'existe pas en mémoire. Si nous essayons d'attribuer une certaine valeur à ce pointeur, nous sommes en difficulté, p voici le pointeur suspendu

* p = 10; //crash

d'autres façons dont vous pouvez probablement créer accidentellement un pointeur suspendu seraient de faire une copie superficielle de l'objet soit par assignation, soit en passant un objet à une méthode, utilisant ainsi le constructeur de copie fourni par le compilateur qui à nouveau effectue une copie superficielle pour vous.


Réponse 10:

Je vois beaucoup de "anglais" ici, ce qui pourrait être utile pour quelqu'un qui connaît déjà le concept, mais pour quelqu'un qui ne le fait pas, ce ne seront que des textes de charabia. Cependant, le quotient amusant dans les réponses et les métaphores tourne, excuses s'il insulte quelqu'un.

Null Pointer: un pointeur qui contient l'adresse de rien ou dire l'emplacement NULL. Écrire sur cet emplacement est une faute. Ceci est conçu pour empêcher les programmeurs d'écrire accidentellement sur un emplacement mémoire qui pourrait provoquer une erreur de segmentation et / ou un crash. L'idée était de toujours initialiser un pointeur avec NULL et de vérifier NULL avant d'écrire. Considérez ce scénario:

int * p; // en ce moment ce pointeur contient une adresse aléatoire, peut pointer vers n'importe quel emplacement, même hors segment

* p = 10; // cela causera très certainement des fautes.

moyen sûr serait quelque chose comme ceci:

int * p = NULL;

si (p! = NULL)

* p = 10;

Pointeur suspendu: comme son nom l'indique, un pointeur qui ne sait pas où pointer depuis le bloc de mémoire vers lequel il pointait à l'origine est libéré.

Il existe plusieurs façons de faire pendre un pointeur. La façon la plus courante serait de créer, copier et supprimer

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

p = nouveau x;

q = p;

supprimer q; // q et le pointeur de bloc de mémoire de q sont supprimés de la mémoire

// à partir de là, nous avons un pointeur p ayant une adresse qui n'existe pas en mémoire. Si nous essayons d'attribuer une certaine valeur à ce pointeur, nous sommes en difficulté, p voici le pointeur suspendu

* p = 10; //crash

d'autres façons dont vous pouvez probablement créer accidentellement un pointeur suspendu seraient de faire une copie superficielle de l'objet soit par assignation, soit en passant un objet à une méthode, utilisant ainsi le constructeur de copie fourni par le compilateur qui à nouveau effectue une copie superficielle pour vous.