L’impression du pointeur sur l’entier provoque une erreur de segmentation. Pourquoi?

#include main() { int *num2=20; printf("\n\n\n%d",num2); } 

Quand je le lance tel quel, il en imprime 20 . Si j’utilise *num2 cela cause une erreur de segmentation. Pourquoi?

Pourquoi imprimer num était correct mais *num entraîné une erreur de segmentation?

Quand vous dites, int *num2=20; . C’est équivalent à

 int *num; /* Type:(int*) num is a pointer to an integer and hence holds address of an integer object. */ num = 20; /* Type of the value assigned to num is (int).*/ 

Vous atsortingbuez int à int * . Vous devriez avoir reçu un

 warning: initialization makes pointer from integer without a cast[enabled by defaut] 

num pointe vers l’adresse ‘ 20 ‘. Vous n’avez aucune idée même si c’est une adresse valide .

Par conséquent, lorsque vous imprimez simplement num vous n’avez aucun problème. Mais en déréférencant, l’adresse ( 20 ) est une lecture de mémoire non valide, provoque un comportement indéfini et entraîne une erreur de segmentation .


Solution:

num doit contenir une adresse valide. Ne prenez pas ce risque en atsortingbuant vous-même une adresse aléatoire.

Evitez ce risque en créant un object de type int et en num à num de son adresse ou simplement en allouant de la mémoire. Comme,

je):

 int var = 20; /* var is a integer object holding the value 20 */ 

& opérateur unaire vous aide à obtenir l’adresse de l’opérande. Utilisez & with var pour obtenir son adresse et puisque var est un entier, stockez-le dans un pointeur d’entier. Dans votre cas, num .

 int *num = &var; /* num is a pointer to var. Holds the address of var. */ 

ii):

 int *num = malloc(sizeof *num); *num = 20; 
 int *num2 = 20; printf("%d", *num2); 

définit un pointeur et l’initialise avec la valeur 20 . Initialiser un pointeur signifie assigner une adresse à laquelle il va pointer, c’est-à-dire que lorsque vous faites *num2 (déréférencer le pointeur num2 ), vous essayez d’accéder à un int stocké à l’adresse 20 , ce qui provoque un comportement indéfini ~ qui se transforme en faute seg.

Essayez ceci à la place:

 int num = 20; int *pNum = # printf("%d", *pNum); 

cela définit une variable num et un pointeur pNum qui pointe sur la variable num . Lorsque vous déréférenciez pNum , vous pouvez récupérer la valeur stockée dans num .

  int *num2=20; 

Ce n’est pas un pointeur sur une valeur entière. C’est une initialisation invalide.

Ceci est un pointeur sur un object int dont la valeur est 20 :

 int *p = &(int) {20}; 

Pour imprimer la valeur du pointeur:

 printf("%p\n", (void *) p); 

Comme d’autres l’ont souligné, votre code contient un bug. Vous confondez un entier avec des pointeurs sur des entiers. Vous vouliez probablement faire quelque chose comme ceci:

 int num2 = 20; int* pnum2 = &num2; 

Utilisez %p pour imprimer la valeur d’un pointeur:

 printf("\n\n\n%p",pnum2); 

Utilisez la chaîne de formatage %p :

 printf("\n\n\n%p",num2); 

Ce n’est pas la bonne approche. Voici comment vous devriez vous y prendre:

 #include int main() { int num1=20; int * num2 = &num1; printf("Number1=%d At Address=%p",*num2,num2); } 

Vous obtiendrez un défaut int *num2=20; lors de la déréférence int *num2=20; comme ceci *num2 . Qu’est-ce que cet int *num2=20; signifie que num2 pointe sur un emplacement de mémoire 20 et NON l’adresse d’un emplacement num2 le nombre entier 20.

Lorsque vous écrivez “printf (“% d “, * num);” Vous essayez d’obtenir la valeur stockée à l’adresse 20 (0x00000014 en hexadécimal). La valeur à l’adresse 20 n’est pas accessible ou pourrait être indésirable. Donc, il provoque une erreur de segmentation. Maintenant, voyez ce code, cela produira le résultat souhaité 20 en déréférencant le pointeur:

 #include int main() { int *num2; int value=20; num2=&value; printf("\n\n\n%d",*num2); }