Pointeur d'initialisation donne segmentation fault

CASE .1

int *a; /* pointer variable declaration */

int b; /* actual variable declaration */

*a=11;//Not valid means you are not owner of the address where a now pointing it is unknown and accessing this will segfault/

a=&b;/* store address of b in pointer variable*/

Cela va être la faute de segmentation car l'adresse que vous utilisez n'est pas une adresse valide et là, vous êtes le stockage de 11, ce qui est illégal.

                               b
      +-------+            +--------+
      |       +            |   11   |
      |Unknown|            |        |
      +---+---+            +---+----+
          |                    |
          |                    |
          +                    +
          a                    a
CASE .2

int *a; /* pointer variable declaration */

int b; /* actual variable declaration */

a=&b;/* store address of b in pointer variable*/

*a=11;

Maintenant sa fonctionne bien parce que l'adresse de b n'est valable un il vous stockez 11 qui est légal.

Aussi des cas ci-dessus ne sont pas de bonne façon de déclaration de pointeur

  int *a  = NUll;
  a = malloc(sizeof(int));
  *a=5;
  free(a);//must

ou

 int *a  = NUll;
 int b;
 a = &b;
 *a=5;

Cela permettra d'éliminer faute de segmentation de nombreuses fois ce qui est difficile à trouver .

OriginalL'auteur pradipta

Une seule ligne: Premier code que vous déréférencement du pointeur non initialisé, qui présente un comportement indéterminé, et dans le deuxième code, vous êtes un déréférencement du pointeur initialisé qui donnera accès à la valeur à l'adresse.

Un peu d'explication:

D'abord, vous devez réaliser qu'un pointeur n'est rien, mais un entier, un avec le *var nous dire au compilateur que nous serons en utilisant le contenu de la variable var (integer) comme une adresse pour récupérer la valeur de cette adresse. Si il y a **var de même nous dire au compilateur que nous allons d'abord utiliser la valeur de la variable var pour aller chercher de la valeur à l'adresse et à nouveau utiliser cette extraites de la valeur que d'une adresse et d'aller chercher la valeur stockée.

Donc dans votre première déclaration, c'est:

           +----------+        +----------+
           |  garbage |        |  garbage |
           +----------+        +----------+
           |    a     |        |    b     |
           +----------+        +----------+
           |  addr1   |        |  addr2   |
           +----------+        +----------+

Puis vous essayez d'utiliser la valeur stockée dans a comme une adresse. a contient des ordures, il peut être n'importe quelle valeur, mais vous n'avez pas accès à tout emplacement de l'adresse. Par conséquent, la prochaine fois vous ne *a il va utiliser la valeur stockée dans a comme une adresse. Parce que la valeur peut être n'importe quoi, tout peut arriver.

Si vous avez la permission d'accéder à l'emplacement , le code continuera à s'exécuter sans erreur de segmentation. Si l'adresse se trouve être d'une adresse dans le segment de la comptabilité de la structure, ou une autre zone de mémoire où le code affecté à partir du segment ou de la pile, puis quand vous ne *a = 10 il sera tout simplement essuyer la valeur existante avec 10 à cet endroit. Cela peut conduire à un comportement indéterminé que maintenant vous avez changé quelque chose sans la connaissance du contexte ayant l'autorité de la mémoire. Si vous n'avez pas la permission de la mémoire, vous obtenez tout simplement une erreur de segmentation. Ceci est appelé le déréférencement d'un pointeur non initialisé.

Prochain relevé de compte que vous ne a = &b qui attribue l'adresse de b dans a. Cela ne vous aide pas, parce que la ligne précédente a déréférencé un pointeur non initialisé.

De code suivant vous avez quelque chose comme ceci après le troisième énoncé:

           +----------+        +----------+
           |  addr2   |---+    |  garbage |
           +----------+   |    +----------+
           |    a     |   +--> |    b     |
           +----------+        +----------+
           |  addr1   |        |  addr2   |
           +----------+        +----------+

La troisième instruction assigne l'adresse de b en a. Avant que a n'est pas déréférencé, par conséquent, la valeur d'ordures stockées dans a avant l'initialisation n'est jamais utilisé comme une adresse. Maintenant, lorsque vous affectez une adresse valide de vos connaissances a, déréférencement a maintenant, vous donnera accès à la valeur pointée par a.

L'extension de la réponse, vous avez besoin de garder un œil, même si vous avez attribué une adresse valide pour un pointeur, vous devez vous assurer au moment de déréférencement du pointeur de la durée de vie de l'adresse pointée par le pointeur n'a pas expiré. Par exemple le retour de variable locale.

int foo (void)
{
  int a = 50;
  return &a;  //Address is valid
}//After this `a' is destroyed (lifetime finishes), accessing this address
 //results in undefined behaviour

int main (void)
{
  int *v = foo ();
  *v = 50; //Incorrect, contents of `v' has expired lifetime.
  return 0;
}

Même dans le cas de l'accès à la mémoire libérée de l'emplacement du tas.

int main (void)
{
  char *a = malloc (1);
  *a = 'A'; //Works fine, because we have allocated memory
  free (a); //Freeing allocated memory
  *a = 'B'; //Undefined behaviour, we have already freed 
            //memory, it's not for us now.
  return 0;
}

OriginalL'auteur phoxis

int une stocke une valeur entière aléatoire. Ce disant en disant *, vous pouvez accéder à un emplacement mémoire qui est en dehors des limites ou non valide. C'est donc un seg fault.

OriginalL'auteur Arvind Haran