Le juggernaut

Fermé
stephane - 25 nov. 2003 à 16:46
 stephane - 1 déc. 2003 à 10:56
salut
j'ai un grave problème conçernant un programme tout simple en theorie en ansi_c.
Je vous explique;
le programme lance à l'affichage des petites procedures ( il y en a 4, une pour chaque operations addition, soustraction, multiplication et division) une phrase genre:
" entrer un entier", ensuite, "entrer un second entier".
Là, la fonction scanf recupere et formatte la variable grâce à son adresse ( 2 ème argument de cette fonction).
Ensuite, une petite procedure d'affichage GEST_FICH doit ouvrir un fichier en ecriture, mode texte, afin de recuperer les données calculées par le programme à savoir une somme( addition), soustraction(différence), multiplication(resultat) et la division(quotient).
J'ai aussi créer 4 fichiers header avec des definitions de type, un pour chaque operations.

Quand je lance le compilateur de JACOB NAVIA, auteur de Lcc win edit 32 car je compile sous windows2000 avec cet excellent outil, l'outil me génère des warning à tout va!!!


J'ai bien revu mon algorithme, etant debutant en ansi_c, j'ai du omettre des ptis + qui font qu'un programme se lance sans problèmes

J'EN APPELLE DONC AUX BONNES VOLONTES POUR TENTER DE VOIR DANS MON SOURCE CE QUI NE VAS PAS
C TRES IMPORTANT , merci d'avance, voici le source

/*je mets ici le code d'un de mes fichiers header, par ex celui de l'addition*/
Nom du fichier; 'addition.h'

#ifndef ADDITION_H
#define ADDITION_H

extern int addition(int, int);

#endif

les trois autres sont tous créer avec cette 'ossature'

/* programme principal*/

#include<stdlib.h>
#include<stdio.h>


#include "p:\\addition.h"/* p represente un lecteur logique à partir duquel je travaille*/
#include"p:\\soustraction.h"
#include"p:\\multiplication.h"
#include"p:\\division.h"

#define PATH "p:\\Ostream.txt"/*ici le fichier txt qui recevra les resultats des operations*/

/* ici je declare mes prototypes de fonctions*/
int addition(int h, int i);
int soustraction(int k, int l);
int multiplication(int a, int b);
float division(int x, float y);

/*ici je declare mes prototypes de procedures*/
void affichageADDI(void);
void affichageSOUS(void);
void affichageMULTI(void);
void affichageDIVI(void);

/* ici le prototype de la procedure gerant le fichier texte*/
void GEST_FICH(void);


/*fonction principale*/
int
main(int argc, char*argv[])
{
int A, S, M;
float D;

affichageADDI();
A=addition(h, i);
printf("premiere operation [ADDITION] egale a %d\n", A);
printf("\n");

affichageSOUS();
S=soustraction(k, l);
printf("deuxieme operation [SOUSTRACTION] egale a%d\n", S);
printf("\n");


affichageMULTI();
M=multiplication(a, b);
printf("troisieme operation [MULTIPLICATION] egale a
%d\n",M);
printf("\n");

affichageDIVI();
D=division(x, y);
printf("quatrieme operation [DIVISION] egale a
%d\n",D);
printf("\n");

GEST_FICH();

return EXIT_SUCCESS;
}


/*viens ensuite la definition des fonctions, procedures*/

int addition(int h, int i)
{
int somme;
somme =h+i;
return somme;
}

int soustraction(int k, int l)
{
int soustract;
soustract=k-1;
return soustract;
}

int multiplication(int a, int b)
{
int result;
result=a*b;
return result;
}

float division(int x, float y)
{
float quotient;
quotient=x/y;
return quotient;
}





void affichageADDI(void);
{
int h, i;
printf("\aENTRER UN ENTIER\n");
scanf("%d", &h);
printf("\aENTRER UN SECOND ENTIER\n");
scanf("%d", &i);
}

void affichageSOUS(void);
{
int k, l;
printf("\aENTRER UN ENTIER\n");
scanf("%d", &k);
printf("\aENTRER UN SECOND ENTIER\n");
scanf("%d", &l);
}


void affichageMULTI(void);
{
int a, b;
printf("\aENTRER UN ENTIER\n");
scanf("%d",&a);
printf("\aENTRER UN SECOND ENTIER\n");
scanf("%d", &b);
}


void affichageDIVI(void);
{
int x, y ;
printf("\aENTRER UN ENTIER\n");
scanf("%d", &x);
printf("\aENTRER UN SECOND ENTIER\n");
scanf("%F", &y);
}



/* definition de la procedure qui doit s'occuper du fichier txt ou seront copier les resultats des 4 operations elementaires*/

void GEST_FICH(void)
{
int A, S, M;
float D;
FILE*ptr;
ptr=fopen(PATH,"w");
if(ptr==NULL)
fprintf(stderr,"\aERREUR D'OUVERTURE EN ECRITURE\n!!!");
exit(-1);

fprintf(ptr,"resultat des operations elemntaires calculées : %d
%d %d %f \n", A, S, M, D);
}


Voilà, j'ai tenter d'etre le plus clair possible meme si je c que, je faits beaucoup d'erreur pour un programme aussi simplet.
je vous prie de m'aider

salut
steph

ps> je viens ts les jours afin de verifier si une personne a su trouver mes erreurs de logiques ou de syntaxe, ou de conception....

20 réponses

J'attends toujours une aide sur ce programme
@+@+
0
J'ai remodifier le code source, enfin ,l'algorithme de mon programme
J'avais definis la procedure d'affichage apres la fonction main , mais apres les fonctions, alors que dans le programme principale, dans la fonction main, la procedure est appelée avant.
j'ai retenter de compiler, les warnings ont largement diminuer mais j'en ai toujours pas mal.
je tente de vs mettre le principal message d'erreur
> " warning: possible usage of 'i' before definition "
ici, i represente la variable.

voilà,
0
salut
je n'ai toujours pas de propositions
c'est vraiment inquietant moi qui pensait que ici, on trouvait des experts

j'attends toujours car je cherche aussi de mon cote mais toujours en vain
les memes warnings
a+stephane*
0
Lepu
Messages postés
32
Date d'inscription
lundi 24 novembre 2003
Statut
Membre
Dernière intervention
19 décembre 2003
1
26 nov. 2003 à 10:45
Hello,
Ca fait bien quatre ans que je n'ai pas programmé une ligne de C/C++ (je suis passé au Java depuis).

J'ai quand même jeté un coup d'oeil à ton code source et il y a un truc qui m'intrigue :
A un moment dans ta fonction main tu fais :
affichageADDI();
A=addition(h, i); 

Où h et i sont des variables déclarées dans la fonction affichageADDI(), elles ont donc une portée locale à la fonction. Ce qui veut dire que lorsque tu fais :
A = addition(h,i); 

tu devrais avoir une erreur, puisque les variables h et i ne devraient pas exister dans la portée de la fonction main()

Et ça devrait être pareil pour toutes les autres fonctions... non ?
Enfin.. je ne sais pas, à premier coup d'oeil c'est ce que je vois.

Peut être que tu devais modifier ta fonction affichageADDI() de sorte qu'elle reçoive deux paramètres par référence (h et i) et du devrais déclarer h et i au niveau de la fonction main, ensuite seulement t'aura le droit de faire :
A = addition(h,i)


Tu devrais mettre les messages d'erreurs que t'envoie le compilateur pour avoir plus de détails sur les problèmes.
0

Vous n’avez pas trouvé la réponse que vous recherchez ?

Posez votre question
Bonjour.
Dans les fonctions de calcul (+,-,* et /), la variable resul ne sert à rien et bouffe de la mémoire.
Moi j'écrirai 'return a+b;' de suite après le prototype.

Dans la fonction GEST_FICH :
if(ptr==NULL)
fprintf(stderr,"\aERREUR D'OUVERTURE EN ECRITURE\n!!!");
exit(-1);
Ces instructions sont correctes, mais il faut savoir que cela signifie que exit(-1) est exécuté tout le temps.
Il faut mettre des {}.
La dernière instruction
fprintf(ptr,"resultat des operations elemntaires calculées : %d %d %d %f \n", A, S, M, D);
n'est donc jamais exécutée car le exit( tue le processus en cours avec un code de retour égal à -1 (exit(-2) => code de retour -2)

Après cela, j'ai regardé le commentaire de Lepu.
Il a raison de dire ce qu'il a dit à propos de
affichageADDI();
A=addition(h, i);
Pour faire ce que tu fais, affichageADDI devrait prendre en paramètre des pointeurs sur des entiers afin que dans l'appelant, on puisse récupérer les valeurs saisies au clavier.
Cela se nomme le passage de paramètres par référence.
Si tu ne met pas de pointeur, tu ne fais qu'un passage par valeur, et là, les valeurs de ton appelant ne sont pas modifiées par l'appelé (afficheADDI).
C'est ce que préconise Lepu.

Par contre, je ne peux pas t'aider plus si tu ne me file pas les fichiers sources.
donne les moi sur jr_c_2001fr@yahoo.fr
Je verrai ce que je peux faire.
@+
Roulito
0
Bonjour,
déjà JE VEUX REMERCIER LES DEUX PERSONNES QUI M'ONT REPONDU SI AIMABLEMENT, merci les gars

je vais donc tenter de revoir mon algo en integrant le passage de valeur par reference, donc avec des pointeurs
Je declarerai donc ces pointeurs dans la fonction main en les faisant ' pointer ' vers les variables concernées

je supprimerai aussi ce que m'as dis roulito, la valeur de retour de la fonction exit() et la remplacant par un return 1
je vais tenter de retravailler car ceci est mon premier programme est je veux absolument le reussir

je reste à votre ecoute si d'autres ont plus de choses a me dire pour m'aider

ENCORE MERCI

steph
" apprendre, comprendre, progresser ensembles "
0
voila ce que jai modifier les gars

dans la procedure d'affichage

void affichageADDI(*Ph, *Pi)
{
int h, i;
int*Ph, *Pi;
Ph=&h;
Pi=&i;

printf("\a ENTRER UN ENTIER");
scanf("%d", &h);
printf("\a ENTRER UN SECOND ENTIER");
scanf("%d", &i);
}

ensuite dans main , j'ai mis
apres le main bien sur


int A, h, i;

affichageADDI(*Ph, *Pi);
A=addition(h, i);

printf(" premiere operation [ADDITION] egale à %d", A);

dans l'esprit, ai je compris??
la procedure qui doit afficher les lignes correspondantes aux deux entiers pour l'addition a comme arguments deux pointeurs qui sont ' diriges ' vers ' les variables h, i, avec lesquels ils sont initialises dans la definition de cette procedure.

Donc, dans main, on obtient donc les valeurs entrees au clavier par reference, comme vs me l'avez conseiller, afin de les rendre disponibles dans main.

l'appelant est donc la fonction d'addition et l'appelé est la fonction d'affichage si j'ai compris messieurs

donc, la fonction d'addition ne peut effectuer son role que si elle connait les valeurs entrees auparavant dans la fonction d'affichage
seulement en les recuperant par referencage, grace aux deux pointeurs que vs m'avez conseille d'integrer dans affichageADDI

voila ce que j'ai compris dans vos explications

c'est assez complexe pour moi car je suis debutant dans ce langage comme je vs l'ai dis et donc, il a fallut que j'apprenne la theorie des pointeurs qui es pas evidente du tout je dois dire
(d'ailleurs, ces pointeurs servent tils a acceder a des données uitilisées par d'autres programmes pour un gain de place en memoire????)

@+
0
Marden
Messages postés
1072
Date d'inscription
dimanche 11 février 2001
Statut
Membre
Dernière intervention
29 janvier 2006
208
27 nov. 2003 à 12:50
Je ne vois pas en quoi le passage par valeurs des opérandes serait interdit, il suffit de respecter la cohérence entre définition et appel.
Dans le cas d'un passage par référence, il n'est pas utile d'encombrer le programme en utilisant des variables intermédiaires, la notation "&val" suffit.
Pour la division, il est parfois utile de prévoir le cas de la division par 0.
Petit conseil supplémentaire, il n'est pas nécessaire de nous passer tout le code, une des opérations, au choix, aurait pu suffire (et dans ce cas, utiliser le format "code", qui respecte l'indentation). Cà évite aussi de décourager les lecteurs qui auraient pu intervenir.
0
salut
déjà merci de m'avoir repondu
mais bon, ce que je voulais savoir, ce sont des pertinences au ni veau des reponses, toi tu me donnes ton avis( tu aurais du indenter, tu aurais du mettre qu'une seule fonction, etc etc)
moi je veux du concret!!
JE LE SAIS QUE JE SUIS DEBUTANT OK
y'a que roulito qui maide pour le moment

merci quand meme

steph
0
Salut à tous.
MArden, le passage par valeur n'est pas interdit, mais en C, pour modifier des paramètres, comme écrire une fonction faisant la saisie de deux valeurs qui sont retournées dans les paramètres d'appel, il faut passer par les pointeurs. Le choix du mode de passage dépend de ce qu'on fait dans la fonction.

Par contre, je pense que d'écrire ceci est mieux que ce que tu as fait steph :
void affichageADDI(int * Ph, int * Pi)
{
int h, i; /* ne servent à rien */
int*Ph, *Pi; /* ne sert à rien car recouvre les valeurs des paramètres */
/*Ph=&h; => ne sert à rien;
Pi=&i; => ne sert à rien */

printf("\a ENTRER UN ENTIER");
scanf("%d", Ph); /*Ph est déjà une adresse vers un entier */
printf("\a ENTRER UN SECOND ENTIER");
scanf("%d", pi); /* pi est déjà une adresse vers un entier */
/* au final, le scanf écrit directement, pour simplifier les choses, dans les zones mémoires des entiers du programme appelant */
}

Ensuite, on appelle dans main :
int h,i;
void affichageADDI(&Ph, &Pi)

Rien de bien compliqué.
Mais je comprends lorsque c'est la première fois qu'on programme en C.
Je ne veux pas t'imposer ma façon de programmer. C'est à toi de choisir la tienne en comprenant ce que tu écris.
De toute façon, l'optimisation ne viendra que lorsque tu auras fini ton programme, pour qu'il puisse aller plus vite si besoin.
@+
Roulito
0
OK LES GARS
Donc, je vois que maintenant, d'apres ce que vs m'avez ecrits, j'ai rien piger au film en ce que j'avais lu sur les pointeurs, ca c une chose
donc, pour etre plus coherent , je vais bosser sur la theorie des pointeurs
comprendre ce que vs ecriver sur les notions de passage par la valeur et par l'adresse
je trouve cela vraiment genial de pouvoir evoluer avec des pros qui ne vs jugent pas parce que vs etes des debutants.

je vais retenter le programme avec une seule des fonctions , tenter de compiler et ensuite je vous tiens au courant


j'ai une autre question

j'ai faits un fichier header addition.h pour la definition de type de la fonction addition( pour m'initier à la modularisation de programme, je dis bien' initer'), dois je en faire un egalement pour la procedure d'affichage ??? genre affichageaddi.h
avec

#ifndef _affichageaddi_
#define _affichageaddi_

extern void affichageaddi(int*, int*);

#endif

?
steph
0
j'ai obsverver void affichageadi(&var, &var2)
est ce que j'aurai pû remplacer ces deux adresses par les pointeurs
> void affichageadi(int*var, int*var2);
?

est ce à cause de la notion de portabilité locale et globale que je sois obliger de me servir de la theorie des pointeurs...?
il faut m'excuser mais j'ai besoin de solides bases pour pouvoir de faire la programmation mon taf
si j'atteinds un certain niveau en ayant des bases construites sur des marecages......
merci encore pour votre aide
steph
0
Salut.
LES FICHIERS .H :
Ces fichiers sont en fait les en-têtes. Tu mets ce que tu veux dedans, mais pas de code, juste des déclarations.
En général, pour décomposer un programme, on le décompose en partie qui travaillent chacune sur un type particulier, ou bien qui fournissent un évantail de fonctionnalités du même domaine (du genre les fonctions mathématiques).
Dans ton cas, les quatre fonctionnalités sont +,-,/ et*.
Ensuite, tu crées un fichier .C (ou .CPP en C++).
Dans ces fichiers, tu mets le code des fonctions définies dans le fichier .H. Cela permet de compiler (gcc -c fichier.c) et de vérifier s'il n'y a pas d'erreur de syntaxe ou d'inclusion de de fichier. (#INCLUDE fichier).

Après, tu crées ton .C qui contient la fonction main, tu compiles et linkes en incluant le fichier .O obtenu après compilation de ta bibliothèque
gcc -o exécutable exécutable.c biblio.o
ou alors gcc -o ex"cutable exécutable.c biblio.c
Suivant les messages d'erreurs éventuels, tu corriges.

En fait, avec ton .H, tu as ainsi formé une "bibliothèque", une palette de fonctions que tu vas pouvoir utiliser dans ton programmes, mais surtout dans d'autres programmes sans se faire chier à tout ré-écrire. Tu crées ton 2ème prog, tu mets #include, tu compiles avec les bons fichiers, et hop, c'est terminé.

En ce qui concerne les pointeurs, il faut savoir que :
int * i; permet de dire que *i est un entier, mais que i n'est que l'adresse mémoire d'un entier.
Je te conseille de revoir ce qui est dit à propos de la mémoire dynamique et des pointeurs en général car c'est super utilisé en C. Si tu maitrises cela, tu maitrises pas mal de choses en C.

@+
Roulito
0
je te remercie pour les explications
donc, tu dis que quand le fichier header est fait, je créer ma biblio, le header + la definition de la fonction, c bien cela??
quand j'aurai compiler ce fichier.c, ce sera un file object qui sera linker ensuite dans le programme principal et qui donnera un executable??

declaration des f et p dans .H
definition dans le .c( biblio)
programme principal

>> programmation modulaire, c 'est bien cela roulito??

de suite, la, je vais taper le programme qui me tracasse avec les modifs pointeurs

donc le ptit truc que toi tu as trouve, c t de passer en arguments de la procedure d'affichage les adresses des nombres a et b destines a etre lus au clavier par scanf, et ensuite, de les retournes par referencage a la fonction de calcul de laddition en ecrivant lors de l'appel de la procedure d'affichage et ce, dans main, :

affichageaddi(&a,&b), comme ca, comme ces adresses contiennent les valeurs saisies dans la procedure, la fonction addition a plus qu'à recuperer les valeurs de ces variables grace a leur adresse.
voila

c vraiment cool de comprendre grace a des gars comme toi ( marden lui se contente de me dire> indente ton code, mets seulement le code la fonction addition etc etc...donc aucune utilité d'espoir pour progresser avec des " juges " comme lui!)


steph
0
voici donc ce que j'ai taper, ici, je mets juste le source des differents files propre à l'operation addition

/* le header de l'addition*/
#ifndef _ADDITION_
#define _ADDITION_

extern int addition(int, int);

#endif


/*programme principal, principal.c*/


#include <stdio.h>
#include "p:\\addition.h"

void affichageaddi(void);
int addition(int a, int b);


int
main(int argc, char*argv[])
{

int a, b, C;

affichageaddi(&a, &b);
C=addition(a, b);

printf("premiere operation [ADDITION] egale a%\n", C);

return 0;
}

/*definition de la procedure et de la fonction*/

void affichageaddi(void)
{
int a, b;

printf("\aENTRER UN ENTIER");
scanf("%d", a);

printf("\aENTRER UN SECOND ENTIER");
scanf("%d", b);
}


int addition( int a, int b)
{
return a+b;
}


Je n'ai pas mis la procedure GEST_FICH

je me suis concentrer uniquement sur la partie du blem> les pointeurs
je tenterai le code ce soir
je repasse demain pour dire si oui ou non le compilo LccWin edit32 me sort le .exe

salut
bonne soirée

steph

( encore merci à roulito qui prend le temps de m'aider....)
0
Salut.
Je pense qu'il y a un PB lorque tu définis ta fonction afficheaddi(void).
Si tu ne mets pas de paramètres, elle ne portera pas de modifications dans le contexte de l'appelant, et donc ne servira à rien.
Il faut donc que tu passes en paramètres de afficheaddi des pointeurs sur des entiers.
void afficheaddi(int * a, int * b);
Lorsque tu appelles cette fonction, tu fais :
int x,y;
....
....
afficheaddi(&x,&y);

La fonction saisie les nombres, et comme elle connait l'adresse de x et y, elle va directement modifier le contenue dans la mémoire. L'adresse ne change pas mais la valeur que référence l'adresse a changé. Pour le programme principal, il ne sait pas que afficheaddi change son contexte car il voit que afficheaddi ne modifie pas les adresses.
Donc, tout le monde est content.
Après, il faut que tu fasse les bonnes instructions dans les corps des fonctions mais là, il vaut mieux que tu la fasses car sinon, cela ne serait pas t'aider que de te donner la solution toute faite.

De +:
Dans addition.h, tu mets tout ce qui atrait à l'addition, donc les fonction de saisie, mais aussi les fonctions de calcul.

Pour ma part, je regrouperai toute les fonctions +,-,* et / dans un même fichier opérations math.h

@+
0
salut
je voudrais juste te redire merci pour ton aide
aussi, j'ai compris pour le fonctionnement des pointeurs
c 'est vrai que ct totalement absurde de ma part de me servir de affichageaddi avec comme arguments des adresses des deux entiers sans les avoir declarer en tant que parametres pointeurs et ce,dans la definition et la declaration de affichage addi
vraiment stupide c clair

tu sais roulito, j'insiste parce que j'adore les reseaux, et comme je me suis a
0
salut
je voudrais juste te redire merci pour ton aide
aussi, j'ai compris pour le fonctionnement des pointeurs
c 'est vrai que ct totalement absurde de ma part de me servir de affichageaddi avec comme arguments des adresses des deux entiers sans les avoir declarer en tant que parametres pointeurs et ce,dans la definition et la declaration de affichage addi
vraiment stupide c clair

tu sais roulito, j'insiste parce que j'adore les reseaux, et comme je me suis a
0
salut roulito
encore merci de ton aide (apparement, sur les milliers et les milliers de personnes qui visitent ce site, peu sont indulgents envers les debutants mais bon...;petit, esperons le, deviendra grand grâce aux Grands..)
roulito.

C'estvrai que c t stupide de ma part de me servir de affichageaddi avec deux arguments etant des adresses et d'avoir defini et declarer le prototype sans des parametres pointeurs correspondant aux deux entiers en memoire, quelle connerie de ma part, je vais rectifier car le programme fonctionne toujours pas

j'ai l'air de pas lacher, c vrai, mais je lacherai pas tant que j'aurai pas faits fonctionner ce .....de programme, c'est mon premier, il est tout simple , mais pas pour un debutant
les solides bases font les grands edifices


merci
steph
0
j'ai une autre question comme dirailt l'autre, faisant zemblant de s'y interesser...
est ce que les variables que l'on declare dans la definition d'une fonction ou d'une procedure, et qui renvoie des resultats dans la fonction main doivent se nommer differement ??
0
J'ai bosse toute la matinée à tenter de comprendre la notion de passage de valeur par l'adresse, donc par les pointeurs
c complexe pour moi c clair

j'arrive pas a piger pourquoi il faut que les variables declarées localement dans une fonction doivent porter un autre nom dans le contexte de l'appelant, ' main '??

par exemple, ma procedure qui doit afficher les deux lignes de saisies des deux entiers dans main, definie avec les variables a, et b, pourquoi dans la fonction main, elles doivent se nommer autrement??? par ex, int x, y;
0
Les variables ne sont pas obligées de s'appeler pareil. Il faut savoir que lors de l'appel à la fonction, il y a une recopie des valeurs de a et b dans les valeurs x et y des la fonctions. La fonction affecte alors des valerus dans les copies et non dans les vraies variables.
Le nom, il s'en fou. C'est juste pour toi de savoir qui est qui sachant que la fonction ne travaille qu'avec les copies locales.
Avec cela, j'espère que tu comprends mieux l'intérêt des pointeurs. On passe en paramètre une adresse mémoire. Il ne change pas la valeur car il travaille sur une copie locale, mais peut en changer le contenu, c'est à dire directement dans la mémoire.
J'espère que c'est plus clair maintenant.
@+
Roulito
0
messieurs dames bonjour
deja, tres bon mois de decembre a tt le monde

de deux
j'ai reussi a trouver mon erreur dans mon premier programme c, cela m'as pris du temps mais grace a roulito, le seul qui ma aider ici, j'ai revu mon source et trouver da
0
messieurs dames bonjour
deja, tres bon mois de decembre a tt le monde

de deux
j'ai reussi a trouver mon erreur dans mon premier programme c, cela m'as pris du temps mais grace a roulito, le seul qui ma aider ici, j'ai revu mon source et trouver dans la theorie les erreurs que j'avais


voila ce que j'ai comme source
je c, les puristes me diront " tu as encore des erreurs ici et la" mais bon, excusez , pour un debutant

J'ai juste mis pour l'operation d'addition car ds le programme du debut, j'avais les 4 operations


/* fichier header, mathematiques.h*/

#ifndef _ADDI_H
#define _ADDI_H

extern int addi(int , int);

#endif

#ifndef _AFFICHAGE_H
#define _AFFICHAGE_H

extern void affichage(int*, int*);

#endif


/* principal*/
#include <stdio.h>
#include <stdlin.h>
#include "p:\\mathematiques"

/* prototypes*/
void affichage(int*a, int*b);
int addi(int x, int y);

int
main(int argc, char*argv[])
{
int C, r, u;
affichage(&r, &u);
C=addi(r, u);

printf(" resultat%d\n", C);

return EXIT_SUCCESS;
}


void affichage( int*a, int*b)
{

printf(" enter one int ");
scanf("%d", a);

printf(" enter second int");
scanf("%d", b);
}

int addi(int x, int y)
{
return x+y;
}


voilà voilà
j'ai vraiment eu du mal a comprendre que deja, les noms des variables devaient pas etre les memes dans la fonction main et dans les definitions propres a chaque fonction et procedure

de deux, j'ai eu du mal a piger le principe du passage de parametres par l'adresse
c vrai que comme la fonction scanf a deja en deuxieme argument un operateur d'adresse de ce que l'on entre au clavier, dans le contexte de l'appelant, la fonction affichage devait avoir comme argument les deux operateurs d'adresse des variables entrees au clavier dans le contexte de l'appelée, car la definition de la fonction d'affichage a en argument deux pointeurs sur les variables entrées au clavier, donc, leur adresse en memoire..

vraiment c genial la programmation, c vraiment ce quel'on pense qui se passe, si il a erreur, c ns sur ns qu'il fo reporter la faute

c cool
je vais encore programmer de plus belle

encore merci a roulito

salut
steph
0