Pointeurs valeurs inattendues

Version imprimable

24/04/2009, 17h01
gbsatti

Pointeurs valeurs inattendues
Bonjour,

J'ai un problème avec le programme suivant :
Code:

1 2 3 4 5 6 7 8 9 10 11 main() { int A = 1; int B = 2; int C = 3; int *P1, *P2; P1=&A; P2=&C; *P1=(*P2)++; printf("%d\n",A); }
D'après moi A=4 et C reste égal à 3.
En effet *P1=(*P2)++; équivaut à :
A=C+1;
donc A=4 et C ne change pas...
Pouvez-vous m'expliquer pourquoi on obtient A=3 et C=4 ?
:bug:

Merci par avance ;)
24/04/2009, 17h07
Invité(e)
Bonjour,

Code:

*P1=(*P2)++;

++ a la priorité sur =, mais ++ est un post incrément : il s'effectuera après l'instruction dans laquelle il est.

Donc
Code:

1 2 Pas 1 : *P1 = *P2; -> A = 3; Pas 2 : *P2++; -> C =4;
24/04/2009, 17h16
gbsatti

salut mabu,
mais ici, il n'y a pas de boucle for ou while ?
Moi je pensais que i++ était équivalent à i+1 (notre prof nous à dis ça un jour)
peut-être que ce n'est pas tout le temps valable ^^
24/04/2009, 17h45
jeroman
Citation:

mais ici, il n'y a pas de boucle for ou while ?

Quel rapport ?

Citation:

Moi je pensais que i++ était équivalent à i+1 (notre prof nous à dis ça un jour)

Non, l'opérateur ++ incrémente de 1 la variable (ou le pointeur, si c'en est un).

Les deux instructions sont équivalentes :
Code:

1 2 i++; i=i+1;

i++ n'est pas équivalent à i+1.

Ce serait équivalent à une fonction qui fait ceci:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
int PostIncrementInt(int *pi)
{
	int ret = *pi;
	*pi = *pi + 1;
	return ret;
}
 
int main(void)
{
	int a = 1;
	int b;
	b = PostIncrementInt(&a);
 
	printf("%d %d\n", a, b);
	return 0;
}

On voit avec cette traduction que l'opérateur ++ retourne l'ancienne valeur de i.

Voyons ce que ça donnerait dans ton code:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
int PostIncrementInt(int *pi)
{
	int ret = *pi;
	*pi = *pi + 1;
	return ret;
}
 
int main(void)
{
	int A = 1;
	int B = 2;
	int C = 3;
	int *P1 = &A;
	int *P2 = &C;
 
	*P1 = PostIncrementInt(&(*P2)); /* ou plus simplement PostIncrementInt(P2) */
	printf("%d %d %d\n", A, B, C);
	return 0;
}

24/04/2009, 17h48
fomazou

Citation:

Moi je pensais que i++ était équivalent à i+1 (notre prof nous à dis ça un jour)
peut-être que ce n'est pas tout le temps valable ^^

:bug:

ça ne serai pas pour le bohneur des programmeur qu'une expression change de sens selon l'endroit.

i++ n'est même pas équivalent à i=i+1 on peut dire pseudoequivalent. puisque i++ et ++i sont différents et pour incrémente tous de 1 comme i=i+1.
la diff est que i++ et ++i sont des expressions(donc peuvent faire partir d'une instruction) l'un est évaluer avant d'être incrémenté et l'autre incrémenté avant d'être évalué
24/04/2009, 18h09
gbsatti

Merci à vous, je vais étudier tout ça :)

Ça y est j'ai compris la post-incrémentation,mais j'obtiens toujours des valeurs inattendues dans le code suivant :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
main()
{
 
	int A[50];
	int *p1,*p2;
	int N;
	int temp;
	printf("combien d'element aura le tableau (max:50)");
	scanf("%d",&N);
	/*affichage*/
	for (p1=A;p1<A+N;p1++)
		printf("resultat %d %d  %d\n\n",p1-A,p1,A);
}

voici ce que j'obtiens :

Code:

1
2
3
4
5
              p1-A        p1        A
 
resutat       0      1244828   1244828  (ça fonctionne)
resultat      1       1244832   1244828  (ça fonctionne plus)
resultat      2       1244836   1244828

c'est difficile :cry:

Citation:
Envoyé par gbsatti
voici ce que j'obtiens :
Code:

1 2 3 4 5 p1-A p1 A resutat 0 1244828 1244828 (ça fonctionne) resultat 1 1244832 1244828 (ça fonctionne plus) resultat 2 1244836 1244828
c'est difficile :cry:
Oui et ? Qu'est-ce qui te choque dans le résultat ?

Au passage, pour afficher une adresse il ne faut pas utiliser %d mais %p (et convertir le pointeur en void*)

24/04/2009, 23h53
gbsatti

ce qui me choque c'est que si l'on fait :
1244832-1244828, on ne trouve plus 1 ...
25/04/2009, 00h11
jeroman

Quand on incrémente de 1 un pointeur, cela ajoute en fait la taille du type de l'objet pointé.
Comme là, il s'agit d'un int, cela ajoute 4 à chaque fois qu'on incrémente de 1.

Dans ton tableau, tu as 50 éléments de type int.
Si tu as un pointeur qui pointe sur le 1er élement d'un tableau, et que tu l'incrémente de 1, il va pointer sur le second élement du tableau. Or, un élément a une certaine taille, qui dépend du type de donnée. Donc, pour accéder à chaque élément suivant, on ajoute la taille du type.
Ce système de calcul entre dans le domaine de l' "arithmétique des pointeurs".
25/04/2009, 00h14
gbsatti

merci , mais dans ce cas pourquoi à t-on p1-A=1 ?
25/04/2009, 01h45
jeroman

Citation:

merci , mais dans ce cas pourquoi à t-on p1-A=1 ?

Car la soustraction de deux pointeurs pointant vers des éléments d'un même tableau renvoie un entier signé correspondant à la différence des deux indices correspondants, c'est-à-dire au nombre d'éléments qui les sépare. Ce qui est le cas de ton exemple.

Par contre, si tu soustraits ces mêmes pointeurs castés tous les deux en un autre type identique (i.e. pointeur sur void, sur char, etc), cela modifie donc le résultat car le résultat dépend aussi de la longueur du type.

Maintenant, si on soustrait deux pointeurs pointant ailleurs que sur un tableau, il me semble que le comportement est indéfini. Je lutte un peu pour comprendre les explications données dans la norme ISO/IEC 9899:1990 à ce sujet, à la fin du chapitre 6.3.6.
Si quelqu'un pouvait confirmer ou infirmer ?...
25/04/2009, 15h27
diogene

fomazou :

Citation:

i++ n'est même pas équivalent à i=i+1 on peut dire pseudoequivalent. puisque i++ et ++i sont différents et pour incrémente tous de 1 comme i=i+1.
la diff est que i++ et ++i sont des expressions(donc peuvent faire partir d'une instruction) l'un est évaluer avant d'être incrémenté et l'autre incrémenté avant d'être évalué.

Cela ne forme pas une différence entre i=i+1, i++ et++i :
i=i+1 est aussi une expression.
C'est pour cela qu'on peut écrire j = i = i+1;

jeroman :

Citation:

Maintenant, si on soustrait deux pointeurs pointant ailleurs que sur un tableau, il me semble que le comportement est indéfini. Je lutte un peu pour comprendre les explications données dans la norme ISO/IEC 9899:1990 à ce sujet, à la fin du chapitre 6.3.6.

C'est vrai qu'en plus, le résultat n'aurait pas grand sens. (ils doivent en plus pointer sur des éléments d'un même tableau)
Toutefois, les pointeurs peuvent pointer sur l'élément (fictif) situé après le tableau (qui n'appartient pas en fait au tableau). Donc, il est possible d'écrire en toute sécurité si tab est un tableau de N élements

Code:

for(p = tab; p < tab+N; p++)....

Naturellement, on ne peut écrire *(tab+N) ni par conséquent tab[N]

Citation:

Envoyé par gbsatti

J'ai un problème avec le programme suivant :

Code:

1
2
3
4
5
6
7
8
9
10
11
main()
   {
      int A = 1;
      int B = 2;
      int C = 3;
      int *P1, *P2;
      P1=&A;
      P2=&C;
      *P1=(*P2)++;
	printf("%d\n",A);
}

D'après moi A=4 et C reste égal à 3.
En effet *P1=(*P2)++; équivaut à :
A=C+1;
donc A=4 et C ne change pas...
Pouvez-vous m'expliquer pourquoi on obtient A=3 et C=4 ?

Ton code est incomplet...

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
 
-------------- Build: Debug in hello ---------------
 
Compiling: main.c
Linking console executable: bin\Debug\hello.exe
C:\dev\hello\main.c:2: warning: return type defaults to `int'
C:\dev\hello\main.c:2: warning: function declaration isn't a prototype
C:\dev\hello\main.c: In function `main':
C:\dev\hello\main.c:10: warning: implicit declaration of function `printf'
C:\dev\hello\main.c:4: warning: unused variable `B'
C:\dev\hello\main.c:11: warning: control reaches end of non-void function
Output size is 17.05 KB
Process terminated with status 0 (0 minutes, 1 seconds)
0 errors, 5 warnings

Ceci est complet, mais incorrect :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
 
#include <stdio.h>
 
int main (void)
{
   int A = 1;
   int B = 2;
   int C = 3;
   int *P1, *P2;
   P1 = &A; /* OK */
   P2 = &C; /* OK */
   *P1 = (*P2)++; /* Comportement indéfini. on ne sait pas quand est evalue le ++ */
   printf ("%d\n", A);
 
   return 0;
}

Le code correct est probablement :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
 
#include <stdio.h>
 
int main (void)
{
   int A = 1;
   int B = 2;
   int C = 3;
   int *P1, *P2;
   P1 = &A; /* OK */
   P2 = &C; /* OK */
   (*P2)++;
   *P1 = *P2;
   printf ("%d\n", A);
 
   return 0;
}

qui donne 4.

Nota : B n'est pas utilisée.

Pour avoir un comportement clair, le mieux est de n'utiliser ++ ou -- que dans une expression unaire (i++; --i; etc.)

26/04/2009, 15h50
Médinoc

Sauf qu'à ma connaissance, ce comportement-là n'est PAS indéfini: Il n'y a qu'un seul ++, la même variable n'est pas modifiée deux fois dans l'expression, donc le résultat est garanti.
26/04/2009, 18h18
diogene

Code:

*P1 = (*P2)++; /* Comportement indéfini. on ne sait pas quand est evalue le ++ */

Citation:

Envoyé par Médinoc

Sauf qu'à ma connaissance, ce comportement-là n'est PAS indéfini: Il n'y a qu'un seul ++, la même variable n'est pas modifiée deux fois dans l'expression, donc le résultat est garanti.

+1 (sauf si P1 et P2 pointent sur le même objet)
26/04/2009, 20h57
gbsatti

Merci à vous j'ai compris ça :D
a+ :)