Discussion :

[thima137]

Bonsoir !
Le programme devrait afficher le contenu et les adresses des variable.
Mais à l'exécution, il plante (Version 1)!

A la version 2, quand je modifie le programme, il affiche un résultat.
Pourrais avoir des orientations dans la premiere version ?


Version 1

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
 
int main()
{
    int *a, *b, *c;
 
    *a = 4;
    *b = 5;
 
    printf("contenu *a : %d, addresse a : %p\n", *a, a);
    printf("Contenu *b : %d, addresse b : %p\n", *b, b);
 
    *c = *a;
    *a = *b;
    *b = *c;
 
    printf("Contenu *a : %d, addresse a: %p\n", *a, a);
    printf("Contenu *b : %d, addresse b: %p\n", *b, b);
 
    do{}while(kbhit() == 0);
    return 0;
}

Version 2

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
 
 
int main()
{
    int *a, *b, *c;
 
    *a = 4;
    *b = 5;
 
    printf("contenu *a : %d, addresse a : %p\n", a, a);
    printf("Contenu *b : %d, addresse b : %p\n", b, b);
 
    c = a;
    a = b;
    b = c;
 
    printf("Contenu *a : %d, addresse a: %p\n", a, a);
    printf("Contenu *b : %d, addresse b: %p\n", b, b);
 
    do{}while(kbhit() == 0);
    return 0;
}

[/QUOTE]

[Obsidian]

Bonjour,

Tu déclares des pointeurs (sur des entiers) mais au départ, ceux-ci sont complètement indéfinis et ne pointent donc sur rien de valide (leur valeur dépend de ce qui se trouvait à l'emplacement mémoire qui leur a ensuite été réservé). Quand tu déréférences ensuite ces pointeurs pour affecter une valeur telle que « 3 » ou « 4 », celles-ci vont donc prendre place n'importe où en mémoire et très probablement déclencher une segfault.

En théorie, ton second programme devrait planter comme le premier, sauf que tu limites déjà les dégâts en permutant le contenu des pointeurs eux-mêmes (qui existent bel et bien) et pas ce qu'ils sont censés pointer. Néanmoins, les premières affectation en début de programme restent invalides. Mais s'il se trouve que la valeur initiale des pointeurs renvoie vers l'intérieur de l'espace du processus, alors le système n'y trouvera rien à redire, même s'il y a de fortes chances pour que tu aies corrompu des données de cette façon, qui seront plus tard source de bugs très pénibles à isoler et à corriger.

[thima137]

Obsidian : j'ai pas l'air de bien comprendre tes explications !
Quel lien directe y'a t'il entre la déclaration des pointeurs et lors de l'affectation des valeurs ?
Aussi, avec un peu de débrouillardise, je change la place de b et c, il me semble que le programme donne un meilleur résultat !
Mais j'ai pas d'explications !!!

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
int *a, *c, *b; 
                               
    *a = 4;
    *b = 5;

    printf("contenu de *a : %d, addresse de a : %p\n", *a, a);
    printf("Contenu de *b : %d, addresse de b : %p\n", *b, b);
    printf("\n");
    printf("Après permutation : \n");
    c = a;
    a = b;
    b = c;
    printf("\n");
    printf("Contenu de *a : %d, addresse de a: %p\n", *a, a);
    printf("Contenu de *b : %d, addresse de b: %p\n", *b, b);

[Médinoc]

Tes pointeurs sont non-initialisés, leur déréférencement est donc un comportement indéfini: tout peut arriver.

[Obsidian]

Obsidian : j'ai pas l'air de bien comprendre tes explications !
Quel lien directe y'a t'il entre la déclaration des pointeurs et lors de l'affectation des valeurs ?

Le fait de déclarer un pointeur « *a » ne déclare pas implicitement une variable « b » pointée par lui.

Quand tu fais une affectation avec « *a = 4 », tu n'affectes pas la valeur « 4 » au pointeur lui-même mais à ce qu'il pointe. Et il se trouve qu'au départ, ton pointeur ne pointe rien de valide. Plus précisément, tu déclares un pointeur qui est alors « prêt à être utilisé », c'est-à-dire qui attend que tu le fasses pointer quelque part.

D'autre part, quand tu déclares une variable locale, qu'il s'agisse d'un pointeur ou d'une variable ordinaire, tu ne fais que lui réserver de l'espace (dans la pile). Cela signifie que la valeur initiale d'une variable locale fraîchement créée ne sera pas « 0 » par défaut (contrairement aux variables globales et statiques) mais une valeur complètement indéterminée, correspondant en fait à ce qui se trouve en mémoire à l'endroit réservé. Si tu déréférences le pointeur à ce moment-là et que tu demandes à déposer quelque chose à l'endroit où il pointe, ton programme va donc déposer cette chose à un endroit complètement indéterminé en mémoire. Soit c'est en dehors de l'espace alloué à ton processus et là, le micro-processeur s'en rend compte et déclenche une segfault, soit c'est à l'intérieur et dans ce cas, cela relève de ta propre responsabilité. Tu viens alors de corrompre tes propres données sans même t'en rendre compte, ce qui peut provoquer un comportement indéterminé, parfois bien plus tard.

Voici un exemple simple :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#include <stdio.h>
 
int main (void)
{
    int a;
    int *p;
 
    a = 5;   /* Mets 5 dans a */
    p = &a;  /* Mets l'adresse de a dans p */
 
    printf ("Valeur de a : %d\n",a);
    printf ("Contenu de p : %p\n",p);
    printf ("Valeur de ce qui est pointé par p : %d\n",*p);
 
    *p = 7; /* Modifie ce qui est pointé par p */
 
    printf ("Valeur de a : %d\n",a);
    printf ("Contenu de p : %p\n",p);
    printf ("Valeur de ce qui est pointé par p : %d\n",*p);
 
    return 0;  
}

On obtient :

Valeur de a : 5
Contenu de p : 0x7ffc02412b64
Valeur de ce qui est pointé par p : 5
Valeur de a : 7
Contenu de p : 0x7ffc02412b64
Valeur de ce qui est pointé par p : 7

Maintenant, je supprime volontairement la variable « a » et, par conséquent, je suis obligé de supprimer également toutes les lignes qui s'y réfèrent (le reste du programme est inchangé) :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#include <stdio.h>
 
int main (void)
{
    /* Ligne supprimée */
    int *p;
 
    /* Ligne supprimée */
    /* Ligne supprimée */
 
    /* Ligne supprimée */
    printf ("Contenu de p : %p\n",p);
    printf ("Valeur de ce qui est pointé par p : %d\n",*p);
 
    *p = 7; /* Modifie ce qui est pointé par p */
 
    /* Ligne supprimée */
    printf ("Contenu de p : %p\n",p);
    printf ("Valeur de ce qui est pointé par p : %d\n",*p);
 
    return 0;  
}

À ton avis, quel résultat va-t-on obtenir ?

[Personne.c]

*P = 4; correspond à dire :
P -> ("une variable" = 4)
( -> signifie "pointe sur")

Si tu ne définis pas "une variable", il risque d'y avoir des problème comme te l'indique Obsidian car c'est l'ordinateur qui va le faire à ta place, ce qui est source d'erreur.

[thima137]

Pour ce code :
Je comprends bien que : *p affichera 7, après l'affectation *p=7, c'est juste !!!
Par contre je comprends pas pourquoi pour: *p sans avoir affecté une valeur, il choisit d'afficher 0 ?
Est-ce parce que aucune valeur n'a été pointé vers la variable pointeur *p ?
Si c'est le cas, devrais-je donc comprendre que pour manipuler un pointeur il faudra que je précise une variable pointé ?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#include <stdio.h>
 
int main (void)
{
    /* Ligne supprimée */
    int *p;
 
    /* Ligne supprimée */
    /* Ligne supprimée */
 
    /* Ligne supprimée */
    printf ("Contenu de p : %p\n",p);
    printf ("Valeur de ce qui est pointé par p : %d\n",*p);
 
    *p = 7; /* Modifie ce qui est pointé par p */
 
    /* Ligne supprimée */
    printf ("Contenu de p : %p\n",p);
    printf ("Valeur de ce qui est pointé par p : %d\n",*p);
 
    return 0;  
}