Discussion :

[zolafencer]

Bonjour,
je voulais faire un exercice simple en langage C (je débute en fait).
L'exercice est de permuter quatre variable A, B, C et D tels que à la fin de l'exercice A et C seront permutés et D et B seront aussi permutés.
Je voulais faire l’exercice avec un sous programme et en utilisant un pointeur.
Voilà ce que j'ai fait

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
23
24
25
26
27
28
29
30
31
32
33
34
35
#include <stdio.h>
#include <stdlib.h>
 
void permute (int* A,int* B,int* C,int* D)
{
 
 int perm1;
 int perm2;
 
 perm1=*A;
 *A=*C;
 *C=perm1;
 perm2=B;
 *B=*D;
 *D=perm2;
 
 
}
int main()
{
 
 int A,B,C,D;
 printf("donnez la valeur de A\n");
 scanf("%d",A);
 printf("donnez la valeur de B") ;
 scanf("%d", B);
 printf("donnez la valeur de C");
 scanf("%d", C);
 printf("donnez la valeur de D");
 scanf("%d",D);
 printf("les valeurs de\n A=%d\nB=%d\nC=%d\nD=%d", A,B,C,D);
 permute(A,B,C,D);
 printf ("les nouvelles valeurs sont\nA=%d\nB=%d\nC=%d\nD=%d\n");
 return 0;
}

sauf que vous vous en doutez bien ça marche pas et je comprends pas pourquoi.
Merci de m'aider.
Cordialement.

[Sve@r]

Bonjour,
je voulais faire un exercice simple en langage C (je débute en fait).
L'exercice est de permuter quatre variable A, B, C et D tels que à la fin de l'exercice A et C seront permutés et D et B seront aussi permutés.

Salut
Déjà ici il y a un problème de conception. Tu veux permuter 4 variables A, B, C et D ben tu écris une fonction qui permute X et Y et tu appelles ta fonction avec A et B puis avec C et D...

Je voulais faire l’exercice avec un sous programme et en utilisant un pointeur.

C'est d'ailleurs obligé !!!

Voilà ce que j'ai fait

Code c :

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
#include <stdio.h>
#include <stdlib.h>
 
void permute (int* A,int* B,int* C,int* D)
{
 
 int perm1;
 int perm2;
 
 perm1=*A;
 *A=*C;
 *C=perm1;
 perm2=B;
 *B=*D;
 *D=perm2;
}

Pourquoi 2 variables intermédiaires ???

Code c :

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
int main()
{
 
 int A,B,C,D;
 printf("donnez la valeur de A\n");
 scanf("%d",A);
 printf("donnez la valeur de B") ;
 scanf("%d", B);
 printf("donnez la valeur de C");
 scanf("%d", C);
 printf("donnez la valeur de D");
 scanf("%d",D);
 printf("les valeurs de\n A=%d\nB=%d\nC=%d\nD=%d", A,B,C,D);
 permute(A,B,C,D);
 printf ("les nouvelles valeurs sont\nA=%d\nB=%d\nC=%d\nD=%d\n");
 return 0;
}

sauf que vous vous en doutez bien ça marche pas et je comprends pas pourquoi.

Pourtant tu l'as écrit toi-même. Que reçoit ta fonction permute ? 4 "int étoile". Que lui passes-tu ? 4 "int". Un "int" n'étant pas un "int étoile" cela ne peut pas marcher...

Accessoirement je suis étonné que ton premier printf() te donne les bonnes valeurs. Ou s'il ne te les donne pas, je suis étonné que tu ne sois pas plus inquiet que ça parce que c'est exactement le même problème...

[zolafencer]

Pour les pointeurs, ça te parait évident mais moi je vois pas l'utilité ( à vrai dire je maîtrise pas encore les pointeurs donc je ne sais pas quand on doit les utilise exactement).
Pour le sous programme permute je vais faire comme tu l'as dit (avec X et Y), je vais donc faire avec une seule variable.
Pour le premier printf , j'ai pas très bien compris ta remarque. mon programme quand je le compile il me demande la valeur de A, une fois celle ci saisie il plante!!
Merci

[Sve@r]

Pour les pointeurs, ça te parait évident mais moi je vois pas l'utilité ( à vrai dire je maîtrise pas encore les pointeurs donc je ne sais pas quand on doit les utilise exactement).

Ah, on commence à toucher le fond du problème. Vois-tu, avant de voler il faut d'abord apprendre à marcher.

Le problème de base, c'est qu'une fonction ne reçoit qu'une copie de l'élément qu'on lui passe.
Exemple

Code c :

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

1
2
3
4
5
6
7
8
9
10
void fct(int x)
{
    x=18;
}
 
int main()
{
    int a=12;
    fct(a);
}

Ici, la fonction reçoit une copie de la valeur 12 qu'elle stockera dans une variable nommée "x".
Il va de soi qu'ensuite, si tu mets 18 dans x, cela n'a aucune influence sur le contenu de a.

Si la fonction doit modifier a, il faut qu'elle sache où ce trouve ce a donc qu'elle ait non pas une copie du contenu de a mais une copie de son adresse donc qu'on passe à la fonction l'adresse de a

Code c :

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

1
2
3
4
5
int main()
{
    int a=12;
    fct(&a);
}

Ayant cette adresse en main, la fonction la stockera dans un type capable de stocker des adresses donc un "type étoile". Cette adresse étant l'adresse d'un int, ce sera donc un "int étoile".
Ayant cette adresse, la fonction sera capable d'aller y taper (grâce à l'opérateur "*") pour modifier la valeur qui s'y trouve

Code c :

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

1
2
3
4
void fct(int* x)
{
    *x=18;
}

C'est le même problème pour scanf. Cette fonction doit modifier le contenu de la variable pour y mettre ce qui est tapé au clavier; Il va de soi qu'il ne faut pas lui passer A mais ...

[Tequilapaf]

Bonjour,

Pour ajouter un petit "truc" ... une erreur "d'inattention" s'est également glissée dans ton programme :

Code :

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

printf ("les nouvelles valeurs sont\nA=%d\nB=%d\nC=%d\nD=%d\n");

Ton programme ne va pas réellement trouver quoi mettre à la place de tes %d

Ensuite, le plantage se fait après avoir rentré la valeur de A :
=> printf fonctionne mais pas scanf
=> cherche une erreur sur scanf
=> tu reprends ton tuto (apparemment tu dois pas apprendre le langage via un tuto parceque le scanf est une fonction assez basique)
=> tu regardes la structure d'un scanf
=> si tu comprends pas la structure, tu regardes un exemple
=> tu vois que devant ton A il te manque un caractère
=> tu fais tes modifs et ça marche

Google peut te donner certaine réponses à tes problèmes sans passer par des forum... Ici, tu tapes juste "scanf" et voualaaaaaaaaaaaaaa.

Sinon, bon courage pour ton apprentissage !

TeqPAF

[zolafencer]

merci beaucoup pour vos réponses
Voisi le code correct

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
23
24
25
26
27
28
29
30
31
32
#include <stdio.h>
#include <stdlib.h>
 
void permute1 (int* x, int* y)
{
 
 int perm1;
 
 perm1=*x;
 *x=*y;
 *y=perm1;
}
 
int main()
{
 
 int A,B,C,D;
 printf("donnez la valeur de A\n");
 scanf("%d", &A);
 printf("donnez la valeur de B\n") ;
 scanf("%d", &B);
 printf("donnez la valeur de C\n");
 scanf("%d", &C);
 printf("donnez la valeur de D\n");
 scanf("%d", &D);
 printf("les valeurs de \nA=%d\nB=%d\nC=%d\nD=%d\n", A,B,C,D);
 permute1(&A,&C);
 printf ("les nouvelles valeurs sont\nA=%d\nC=%d\n", A,C);
 permute1(&B,&D);
 printf("les nouvelles valeurs sont\nB=%d\nD=%d\n", B,D);
 return 0;
}

par contre j'ai encore une question: si j'ai bien compris quand on utilise des pointeurs dans une fonction, il faut mettre des & devant les paramètres lors de l'appel de la fonction?
Merci bcp encore

[jeroman]

par contre j'ai encore une question: si j'ai bien compris quand on utilise des pointeurs dans une fonction, il faut mettre des & devant les paramètres lors de l'appel de la fonction?

Eh non, pas forcément.
En fait cela dépend de ce que tu veux faire.

Par exemple, si tu veux allouer un objet sur le tas (et initialiser des données), dans certains cas on peut préférer le faire dans la fonction courante, mais parfois il est préférable voire nécessaire de le faire faire par une autre fonction.

Exemple d'une fonction qui alloue elle-même un tableau, et qui l'initialise via une autre :

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
void initialise_tableau ( int * tableau )
{
	int a ;

	for ( a = 0 ; a < 10 ; a++ )
		tableau[a] = a ;
}
void mafonction ( void )
{
	int * tableau ;
	
	tableau = malloc ( 10 * sizeof *tableau ) ;
	
	if ( tableau == NULL )
		return ;
		
	initialise_tableau ( tableau ) ;
	
	/* ..... */

	free ( tableau ) ;
}

Dans la deuxième ligne en rouge, la fonction envoie l'adresse du premier élément du tableau. Si on avait mis "&tableau", on aurait envoyé non pas l'adresse du premier élément du tableau mais l'adresse du pointeur "tableau", c'est-à-dire l'adresse où est stockée sa valeur, valeur qui est elle-même une adresse et qui correspond à l'adresse du tableau qu'on a alloué via "malloc". [ car ce qu'il faut bien comprendre, c'est qu'une fois un code compilé, les variables sont en fait des cases mémoires, dans lesquelles se trouvent les valeurs correspondantes, soit des nombres -représentant des entiers ou des valeurs flottantes- ou bien des adresses ] *** C'est chaud à expliquer, faut bien s'accrocher pour comprendre ***
Inutile de préciser qu'avec un tel code, le compilateur aurait pleuré. Dans ces circonstances, la fonction appelée devrait avoir pour argument un pointeur de pointeur.

Cette fois, un autre exemple, qui illustre ce que je viens d'expliquer. Ici on réserve un tableau via une autre fonction, qui l'initialisera également :

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
void creation_et_initialisation_tableau ( int ** ptableau )
{
	int a ;

	*ptableau = malloc ( 10 * sizeof **ptableau ) ;

	if ( *ptableau != NULL )
	{
		for ( a = 0 ; a < 10 ; a++ )
			(*ptableau)[a] = a ;
	}
}
void mafonction ( void )
{
	int * tableau ;

	creation_et_initialisation_tableau ( &tableau ) ;

	/* ..... */

	free ( tableau ) ;
}

"mafonction" envoie à "creation_et_initialisation_tableau" non pas la valeur de "tableau" mais l'adresse où sa valeur est stockée, dans le but justement de la modifier "à distance" (via la fonction appelée). Sa valeur correspondra à l'adresse où le tableau sera alloué (à ce stade, ce tableau n'est pas encore créé).
La fonction appelée a donc comme argument un pointeur de pointeur, car "ptableau" a pour valeur l'adresse où est stocké le pointeur "tableau", qui donc peut lui-même être déréférencé, d'où la double étoile. Pour modifier la valeur de "tableau", il faut donc déréférencer "ptableau".
Pour résumer :
ptableau -> correspond à l'adresse où est stocké le pointeur "tableau", c'est-à-dire l'adresse où est stockée sa valeur.
*ptableau -> correspond à la valeur de "tableau" (on peut la modifier via une autre fonction, comme on le fait ici)
**ptableau -> correspond au premier élément du tableau alloué. S'il n'est pas alloué, le simple accès provoque un crash.
*((*ptableau)+n) ou (*ptableau)[n] -> correspondent à l'élément "n" du tableau (1er élément : n=0 ). Là, pareil : tableau pas alloué = crash.

Pour conclure, on peut dire qu'un pointeur est tout simplement une variable dont sa valeur est une adresse. Mais c'est une variable particulière, car on peut déréférencer ce pointeur grâce à l'étoile placée devant, afin d'accèder à l'objet pointé (en lecture ou en écriture). Mais cet objet pointé peut tout à fait être lui aussi un autre pointeur (notre 2ème exemple), qu'on peut lui-même déréférencer, d'où un nombre spécifique d'étoiles (deux, dans notre exemple).

Mes explications sont un peu brouillon, je ne sais pas si ça t'a permis de t'aider.
En tout cas, les pointeurs, c'est certainement l'une des notions les plus compliquées en C. Mais une fois qu'on a compris le truc, ça roule, on est libéré d'un poids.

[Sve@r]

par contre j'ai encore une question: si j'ai bien compris quand on utilise des pointeurs dans une fonction, il faut mettre des & devant les paramètres lors de l'appel de la fonction?

Uniquement si le paramètre n'est pas déjà un pointeur

Reprenons mon premier exemple. J'ai une variable "a" de type int et je veux que ma fonction "finale()" la modifie. Il faudra que je passe alors l'adresse de "a" à ma fonction. Toutefois, il se trouve que pour cet exemple, je suis forcé de passer par une fonction intermédiaire "milieu()".
Donc c'est à "milieu" que je passe l'adresse de "a"

Code c :

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

1
2
3
4
5
int main()
{
    int a=12;
    milieu(&a);
}

La fonction "milieu" recevra une adresse d'un int et la stockera donc dans un type capable de stocker l'adresse d'un int => un int*

Code c :

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

void milieu(int* pt):

La fonction finale aura la même caractéristique

Code c :

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

1
2
3
4
void finale(int* pt)
{
    *pt=20;
}

Maintenant, la fonction milieu devra passer ce pointeur à la fonction finale. Or qu'est-ce qu'attend la fonction finale ? Un "int *". Et où est-ce que la fonction "milieu" stocke son adresse reçue du main() ? Dans un "int *".
Donc pt étant de type "int*", et "finale()" attendant un "int *", suffira de passer ce "pt" à la fonction finale. Et le code entier devient

Code c :

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 main()
{
    int a=12;
    milieu(&a);
}
 
void milieu (int* pt)
{
    finale(pt);
}
 
void finale(int* pt)
{
    *pt=20;
}

Donc c'est pas parce qu'une fonction attend un "int *" qu'il faut te forcer à mettre du "&" de partout.
Tout ce qui compte, c'est que tu passes à la fonction le type qu'elle attend. Et si ta variable est déjà du bon type, alors tu passes juste la variable.

D'ailleurs, c'est quoi le type de "a" ???
Eh ben pour répondre, on peut utiliser l'image suivante
1) "a" est de type "int"
2) comme "&" et "*" sont des opérateurs opposés et qu'ils s'annulent, on peut donc les mettre sans rien changer => "*(&a)" est de type "int"
3) et donc si j'isole "&a" et qu'il me reste l'étoile dont je ne sais pas quoi faire, ben comme je ne peux pas la perdre je dois la placer de l'autre coté => "&a" est de type "int *"