Problème avec les pointeurs.

Version imprimable

Bonjour,
Je débute la programmation en C, et j'en suis aux pointeurs, j'aimerais comprendre pourquoi ceci ne fonctionne pas ?
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 #include <iostream> #include <stdio.h> #include <stdlib.h> //fonction addition void addi(int n) { int resultat = n + 2; //addition int *p_resultat= &resultat; //pointeur } int main() { int nombre = 8; addi(nombre); printf("Le resultat est: %d", *p_resultat); return 0; }
merci d'avance de vos aides (soyez explicite svp, je débute ^^).

Salut,

"ceci ne fonctionne pas" est pour le moins un peu vague. J'ai essayé de compiler ton code.
Code:

1 2 3 4 5 6 C:\codeblocks\dummy\main.c|1|iostream: No such file or directory| C:\codeblocks\dummy\main.c||In function `main':| C:\codeblocks\dummy\main.c|17|error: `p_resultat' undeclared (first use in this function)| C:\codeblocks\dummy\main.c|17|error: (Each undeclared identifier is reported only once| C:\codeblocks\dummy\main.c|17|error: for each function it appears in.)| ||=== Build finished: 4 errors, 0 warnings ===|
Avant de tester le programme, il faut s'assurer qu'il compile, car là, il ne compile pas. Tu inclus iostream qu'un compilateur C n'est pas censé connaitre, et il y a des variables non déclarées. Donc première étape: Configurer le compilateur pour voir le rapport de compilation. Pour la suite, lire le rapport d'erreur est une bonne idée.

A+

Pfeuh

merci d'avoir répondu aussi vite :ccool:, il m'affiche ceci.
Code:

1 2 3 4 5 6 7 ||=== test, Debug ===| E:\CodeBlocks\share\CodeBlocks\Mes projets\test\main.cpp||In function `void addi(int)':| E:\CodeBlocks\share\CodeBlocks\Mes projets\test\main.cpp|10|warning: unused variable 'p_resultat'| E:\CodeBlocks\share\CodeBlocks\Mes projets\test\main.cpp||In function `int main()':| E:\CodeBlocks\share\CodeBlocks\Mes projets\test\main.cpp|17|error: `p_resultat' undeclared (first use this function)| E:\CodeBlocks\share\CodeBlocks\Mes projets\test\main.cpp|17|error: (Each undeclared identifier is reported only once for each function it appears in.)| ||=== Génération finie: 2 erreurs, 1 avertissements ===|
mais je ne comprend pas pourquoi .. ou plutot je ne comprend peut etre pas le fonctionnement des pointeurs :roll:

quand je met le printf () dans la fonction addi(), ca fonctionne, mais alors l'excercice n'a aucun interé :mouarf:

16/08/2010, 13h46
jabbounet
Ce n'est pas un problème de pointeur, mais de portée de ta variable.

Dans cette procédure
Code:

1 2 3 4 5 6 7 void addi(int n) { int resultat = n + 2; //addition int *p_resultat= &resultat; //pointeur }
p_resultat et resultat n'ont d'existence que à l'intérieur de la procédure addi dans laquelle tu les a déclarée (portée locale). Donc en dehors dans la fonction main par exemple, ces variable n'existent pas.

Pour palier à ce problème et récuperer le résultats des opération effectuées dans addi

1/ Déclarer tes variables en variables global, mais ce n'est pas très propre.
2/ Changer le prototype de ta procédure pour en faire une fonction.
3/ changer le prototype de ta procédure pour fournir un paramètre de retour.
...

http://fr.wikiversity.org/wiki/Langa..._et_constantes

Edit: grilled

C'est plus les portées de variables que tu n'as pas compris. En fait, tout ce qui est déclaré dans un bloc d'instruction est détruit en sortie de ce bloc d'instructions.

Donc, si tu fais
Code:

1 2 3 4 5 6 7 8 9 void func(void){ //i existe uniquement dans ce bloc //cad entre ces deux accolades int i; } //N'importe où ailleur: i n'existe pas ou ne désigne plus celui définis dans func
C'est pour ça que ça passe avec le printf dans ta fonction, puisque i existe. Sortie de cette fonction, tu essayes d'utiliser une variable qui n'existe pas.

merci à vous pour vos réponses :), en fait je vous explique pourquoi je veux faire ça, j'ai simplifié, mais a l'origine je voulais faire une fonction qui fasse addition, soustraction, multiplication et division à laquelle j'envoie deux nombres, et qui me renvoie un résultat par opération, je vais faire un ptit exemple:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 #include <iostream> #include <stdio.h> #include <stdlib.h> //fonction addition void ope(int n1,int n2) { int resultat_add = n1 + n2; //addition int resultat_sous = n1 - n2; //soustraction int resultat_multi = n1 * n2; //multiplication int resultat_div = n1 / n2; //division } int main() { int nombre = 8; //n1 int nombre = 4; //n2 ope(nombre,nombre2); //j'aimerais récuperer les résultat ici dans plusieurs printf return 0; }
alors bien sur tout ça c'est bidon mais c'est pour m'aider à comprendre, j'essaye de faire simple ^^

J'ai vu qu'il y avait une partie débutant, j'aurais du poster dessus désolé.

Un truc du style:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
 
int add(int n1,int n2) {
    return n1 + n2; //addition
}
 
int sub(int n1,int n2) {
    return n1 - n2; //soustraction
}
 
int main() {
  int addition = add(5,3);
  int soustraction = sub(5,3);
  printf("5 + 3 = %d\n",addition);
  printf("5 - 3 = %d\n",soustraction);
  return 0;
}

16/08/2010, 14h15
BRK__

merci pour ta réponse jabbounet, en fait je voulais faire tout dans une seule fonction, mais peut etre que ce n'est pas possible ? en tout cas merci d'avoir perdu de ton temp pour m'aider :)

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
void addsub(int n1, int n2, int *pA, int *pS) {
	*pA = n1 + n2; //addition
	*pS = n1 - n2; //soustraction
}
 
int main() {
	int addition;
	int soustraction;
	addsub(5, 3, &addition, &soustraction);
 
	printf("5 + 3 = %d\n",addition);
	printf("5 - 3 = %d\n",soustraction);
	return 0;
}

Tu peux par exemple utiliser une structure contenant chacun des résultats.

Code:

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
 
#include <stdio.h>
#include <stdlib.h>
 
typedef struct {
  int n1;
  int n2;
  int add;
  int sub;
  int div;
  int mul;
} Operations;
 
Operations evaluate(int n1,int n2) {
  Operations operations;
  operations.n1   = n1;
  operations.n2   = n2;
  operations.add  = n1 + n2;
  operations.sub  = n1 - n2;
  operations.div  = n1 / n2; // problem if n2 = 0
  operations.mul  = n1 * n2;
  return operations;
};                 
int main() {
  Operations op = evaluate(5,3);
  printf("%d + %d = %d\n", op.n1, op.n2, op.add);
  printf("%d - %d = %d\n", op.n1, op.n2, op.sub);
  printf("%d / %d = %d\n", op.n1, op.n2, op.div);
  printf("%d * %d = %d\n", op.n1, op.n2, op.mul);
  return EXIT_SUCCESS;
}

Bonjour,
Tout à fait d'accord avec jabbounet, et je vais proposer une autre version

Code:

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
#include <stdio.h>
#include <stdlib.h>
float evaluate(int n1, char type, int n2) 
{
/* type est un caractère */   
  float Resultat=0;
  switch (type)
  {
    case '+': Resultat = n1 + n2; break;
    case '-': Resultat = n1 - n2; break;
    case '*': Resultat = n1 * n2; break;
    case '/': Resultat = n1 / n2; break;  /* Division par 0 ?*/
    default: printf("ERREUR DE DONNEES\n"); 
  }
  return Resultat;
};                
int main() 
{      
  float op = evaluate(5,'+',3);  
  printf("5 + 3 = %f\n",op);     
 
  op = evaluate(5,'-',3);
  printf("5 - 3 = %f\n",op);
 
  op = evaluate(5,'/',3);
  printf("5 / 3 = %f\n",op);
 
  op = evaluate(5,'*',3);
  printf("5 * 3 = %f\n",op);
  return EXIT_SUCCESS;      
}

Les deux codes ont un point commun important : la fonction retourne une valeur.
Naturellement ceci n'est pas une application des pointeurs. Pour retourner une valeur modifiée dans une fonction, il faut écrire quelque-chose du genre:

Code:

1
2
3
4
5
6
7
8
9
10
void Echanger(int *px, int *py)
{
  int temp;
  temp = *px;
  *px = *py;
  *py = temp; 
}                                                                                                       /* et l'appel */
  int a = 3;
  int b = 5;
  Echanger(&a, &b);

... ou encore en passant par un pointeur de fonction :

Code:

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>
 
int soustraction(int n1, int n2)
{
	return n1-n2;
}
int addition(int n1, int n2)
{
	return n1+n2;
}
int multiplication(int n1, int n2)
{
	return n1*n2;
}
int division(int n1, int n2) /* renvoit seulement la partie entiere */
{
	return n1/n2;
}
 
int operation(int n1, int n2, int (*fonction_operation)(int,int) )
{
	return fonction_operation(n1,n2) ;
}
 
int main(void)
{
	int n1 = 15 ;
	int n2 = 6 ;
 
	printf("%d + %d = %d\n" , n1 , n2 , operation ( n1 , n2 , addition ) );
	printf("%d - %d = %d\n" , n1 , n2 , operation ( n1 , n2 , soustraction ) );
	printf("%d * %d = %d\n" , n1 , n2 , operation ( n1 , n2 , multiplication ) );
	printf("%d / %d = %d\n" , n1 , n2 , operation ( n1 , n2 , division ) );
	return 0;
}

Le C nous offre plein de solutions en fin de compte. :lol:

16/08/2010, 16h07
Invité

Absolument.
En plus le gros avantage du C est qu'on ne fabrique pas une usine à gaz, et qu'à tout moment on sait exactement ce qu'on fait. Mais naturellement je dis cela d'une façon générale, et je ne fais allusion à aucun autre langage qui aurait su faire session et prendre son indépendance. :P
16/08/2010, 16h20
BRK__

merci à vous, c'est super je crois que j'ai ma réponse, je vais bien étudier ce que vous m'avez montré, merci pour la rapidité, et de m'avoir consacré du temp.

Je viendrais vous embêter plutard ^^, avec d'autres questions j'imagine :D

Citation:

Envoyé par jeroman

... ou encore en passant par un pointeur de fonction :

Code:

...

Le C nous offre plein de solutions en fin de compte. :lol:

Amusant ce post :)
Une variante de jeroman utilisant un tableau de pointeur de fonction

Code:

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
36
37
38
39
40
41
42
43
44
45
46
47
 
#include <stdio.h>
#include <stdlib.h>
 
#define ADDITIONER 0
#define SOUSTRAIRE 1
#define MULTIPLIER 2
#define DIVISER    3
 
int additioner(int n1,int n2) {
  return n1 + n2;
}
 
int soustraire(int n1,int n2) {
  return n1 - n2;
}
 
int multiplier(int n1,int n2) {
  return n1 * n2;
}
 
int diviser(int n1,int n2) {
  return n1 / n2; // ouch if n2 = 0.
}
 
int (*operator[4])(int,int)  = {
  &additioner,
  &soustraire,
  &multiplier,
  &diviser};  
 
int main() {
 
  int op = (*operator[ADDITIONER])(5,3);
  printf("5 + 3 = %d\n",op);
 
  op = (*operator[SOUSTRAIRE])(5,3);
  printf("5 - 3 = %d\n",op);
 
  op = (*operator[MULTIPLIER])(5,3);
  printf("5 * 3 = %d\n",op);
 
  op = (*operator[DIVISER])(5,3);
  printf("5 / 3 = %d\n",op);
 
  return EXIT_SUCCESS;
}

Citation:
Envoyé par jabbounet
Amusant ce post :)
Une variante de jeroman utilisant un tableau de pointeur de fonction
Code:

1 2 3 4 5 int (*operator[4])(int,int) = { &additioner, &soustraire, &multiplier, &diviser};
Le "&" n'est pas utile. Le nom d'une fonction est déjà un pointeur
Code:

1 2 3 4 5 int (*operator[4])(int,int) = { additioner, soustraire, multiplier, diviser};
Toutefois, ton code m'a donné envie de rajouter ma patte. En fait, comme je trouvais dommage de répéter les nombres 1) dans l'opération et 2) dans l'affichage ; ben j'ai décidé d'intégrer dans chaque fonction une zone dédiée à recevoir le message à afficher. Ensuite, il ne reste qu'à afficher ledit message.

De plus, j'étais embêté par l'association obligatoire entre tes typedef et l'ordre des opérations. Une permutation dans le tableau et plus rien ne fonctionne. Et un enum ne changeait rien.
J'ai donc créé une association entre un signe et l'opération qui va bien. Plus une fonction qui, à partir du signe, appelle l'opération appropriée. Ainsi, l'ordre des opérations n'a plus d'importance
Code:

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 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 #include <stdio.h> #include <stdlib.h> int additioner(int n1,int n2, char *txt) { int res=n1 + n2; if (txt) sprintf(txt, "%d + %d = %d", n1, n2, res); return res; } int soustraire(int n1,int n2, char *txt) { int res=n1 - n2; if (txt) sprintf(txt, "%d - %d = %d", n1, n2, res); return res; } int multiplier(int n1,int n2, char *txt) { int res=n1 * n2; if (txt) sprintf(txt, "%d * %d = %d", n1, n2, res); return res; } int diviser(int n1,int n2, char *txt) { int res=n1 / n2; // ouch if n2 = 0. if (txt) sprintf(txt, "%d / %d = %d", n1, n2, res); return res; } typedef struct { int (*op)(int, int, char*); char lettre; } t_operator; int operation(t_operator *tab, char lettre, int n1, int n2, char *txt) { t_operator *pt; for (pt=tab; pt->op != NULL; pt++) if (pt->lettre == lettre) return ((pt->op)(n1, n2, txt)); if (txt) sprintf(txt, "%d %c %d: opération inconnue", n1, lettre, n2); return 0; } int main() { t_operator tabOp[]={ {additioner, '+'}, {soustraire, '-'}, {multiplier, '*'}, {diviser, '/'}, {NULL, '\0'}, }; char msg[512]; operation(tabOp, '+', 5, 3, msg); printf("%s\n", msg); operation(tabOp, '-', 5, 3, msg); printf("%s\n", msg); operation(tabOp, '*', 5, 3, msg); printf("%s\n", msg); operation(tabOp, '/', 5, 3, msg); printf("%s\n", msg); return EXIT_SUCCESS; }
Et voilà comment on remplace de simples opérations par exactement la même chose... mais en plus "fun" 8-)8-)8-)

PS: on peut éviter de déporter la zone "txt" dans les fonctions d'opérations... mais en le laissant ça permet aussi d'appeler les fonctions de façon directe en leur passant aussi la zone dédiée à recevoir le message...:ccool:

Citation:

Envoyé par Sve@r

Le "&" n'est pas utile. Le nom d'une fonction est déjà un pointeur

Toutefois, ton code m'a donné envie de rajouter ma patte. En fait, comme je trouvais dommage de répéter les nombres 1) dans l'opération et 2) dans l'affichage ; ben j'ai décidé d'intégrer dans chaque fonction une zone dédiée à recevoir le message à afficher. Ensuite, il ne reste qu'à afficher ledit message.

joli, :)
merci pour ta remarque sur le pointeur de fonction, moi aussi cela m'avait donné d'autres idées, parfois hors sujet car n'utilisant pas de pointeurs.

voici l'une d'elle à base de macro en fait, beaucoup plus compacte et pas forcement aussi lisible.
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 #include <stdio.h> #include <stdlib.h> #define OPERATOR(result,operand1,operator,operand2,fmt) \ result = (operand1) operator (operand2); \ printf("operation: " #fmt " %3s " #fmt " = " #fmt "\n", \ operand1,#operator,operand2,result); int main() { int result1; OPERATOR(result1, 5 + 3 , - , 3 , %-3.0d); OPERATOR(result1, 5 + 3 , * , 3 , %-3.0d); OPERATOR(result1, 5 , == , 3 , %d); float result2; OPERATOR(result2, 5.0 , / , 3.0 , %3.1f); OPERATOR(result2, 5.0 , == , 3.0 , %3.1f); OPERATOR(result2, 5.0 , != , 3.0 , %3.1f); return EXIT_SUCCESS; }
Cela donne le resultat suivant

Citation:

-*- mode: compilation; default-directory: "~/" -*-
Compilation started at Thu Aug 19 00:56:16

gcc testOperator.c -o test && ./test
operation: 8 - 3 = 5
operation: 8 * 3 = 24
operation: 5 == 3 = 0
operation: 5.0 / 3.0 = 1.7
operation: 5.0 == 3.0 = 0.0
operation: 5.0 != 3.0 = 1.0

Compilation finished at Thu Aug 19 00:56:16

bref, rien à voir mais puisque le sujet intéresse de nouvelles personnes :)

19/08/2010, 01h05
jabbounet
Ceci dit elle à ses limites :aie:

Avec
Code:

1 2 3 int result1 = 3; OPERATOR(result1, 5 + 3 , * , result1++ , %-3.0d);
j'ai

Citation:

operation: 8 * 193 = 194

Citation:
Envoyé par jabbounet
joli, :)
merci pour ta remarque sur le pointeur de fonction, moi aussi cela m'avait donné d'autres idées, parfois hors sujet car n'utilisant pas de pointeurs.

voici l'une d'elle à base de macro en fait, beaucoup plus compacte et pas forcement aussi lisible.
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 #include <stdio.h> #include <stdlib.h> #define OPERATOR(result,operand1,operator,operand2,fmt) \ result = (operand1) operator (operand2); \ printf("operation: " #fmt " %3s " #fmt " = " #fmt "\n", \ operand1,#operator,operand2,result); int main() { int result1; OPERATOR(result1, 5 + 3 , - , 3 , %-3.0d); OPERATOR(result1, 5 + 3 , * , 3 , %-3.0d); OPERATOR(result1, 5 , == , 3 , %d); float result2; OPERATOR(result2, 5.0 , / , 3.0 , %3.1f); OPERATOR(result2, 5.0 , == , 3.0 , %3.1f); OPERATOR(result2, 5.0 , != , 3.0 , %3.1f); return EXIT_SUCCESS; }
bref, rien à voir mais puisque le sujet intéresse de nouvelles personnes :)
Bigre. J'ai mis du temps avant de piger :mouarf:
Citation:
Envoyé par jabbounet
Ceci dit elle à ses limites :aie:

Avec
Code:

1 2 3 int result1 = 3; OPERATOR(result1, 5 + 3 , * , result1++ , %-3.0d);
Arf. Un "++" dans une macro (qui, en plus, répète la variable) => c'est la cata assurée :cry::cry::cry: