Langage C problème avec fonctions

Statut
N'est pas ouverte pour d'autres réponses.
redband59

redband59

Elite
si quelqu'un peut m'aider, un bete programme avec deux fonctions en fait, je suis arrivé a faire les prototypes mais l'échange des données entre les fonctions foire un peu :/

si quelqu'un peut me dire ce qu'il en pense

Code: 
#include <stdlib.h>
#include <iostream.h>
#include <stdio.h>

//programme principal
void main(void)
{	int obtention();
	int somme(int, int);
   int n1, n2;

   obtention();
   somme(n1,n2);

   printf("somme de vos deux nombres : %d", somme);

}

//début de la fonction obtention
int obtention()
{
int n1, n2;

printf("Veuillez introduire deux nombres entiers svp\n");
scanf("%d\n%d",n1,n2);

return n1, n2;
}


//début de la fonction somme
int somme(int n1, int n2)
{
int somme;

somme=n1+n2;
return somme;

}
 
1er
OP
redband59

redband59

Elite
en fait le vrai problème (sans tenir compte du nombre d'erreur dans mon code) c'est le fait de pouvoir tirer deux variables de ma fonction Obtention et de les réutiliser dans la fonction principale Main
 
S

sigmar

Fanatique
Salut,
Ca fait longtemps que je n'ai plus fait de c mais pour retourner plusieurs valeurs il me semble que tu dois utiliser des pointeurs.

Sinon tu oublies de récupérer les valeurs retournées par tes fonctions.

int sum = somme(n1,n2) par exemple.
 
b00msTicK

b00msTicK

O=(*.*Q)
Code: 
#include <stdlib.h>
#include <iostream.h>
#include <stdio.h>

int* obtention();
int somme(int a, int b);

//programme principal
void main(void)
{	
int num[2];
int sum;

num =obtention();
  sum= somme(num[0],num[1]);

   printf("somme de vos deux nombres : %d \n", somme);

}

//début de la fonction obtention
int* obtention()
{
int num[2];

printf("Veuillez introduire deux nombres entiers svp\n");
scanf("%d\n%d",num[0],num[1]);

return num;
}


//début de la fonction somme
int somme(int n1, int n2)
{
return n1+n2;
}
Voilà, j'ai pas vérifié scanf et je sais pas quel compilateur tu utilises mais ça devrait pas être loin de fonctionner ^^'
 
null

null

ose();
Une fonction ne peut retourner qu'une valeur :

Code: 
//début de la fonction obtention
int obtention()
Tu dois faire "return 3;" par exemple. Tu ne peux pas retourner deux valeurs. Si tu veux faire ça, tu dois jouer avec les pointeurs/références :)

PS: la convention est de sortir les prototypes, comme par exemple :

Code: 
#include <stdlib.h>
#include <iostream.h>
#include <stdio.h>

int obtention();
int somme(int, int);

//programme principal
void main(void)
{
   i...
#edit:

Tout le monde répond en même temps \o/
 
gogoprog

gogoprog

Oprahiste vaudou
Code: 
#include <stdlib.h>
#include <stdio.h>

// protos
int somme(int, int);
int *obtention();

 
//programme principal
int main(void)
{	

	int som;
	int *n = obtention();
	som = somme(n[0],n[1]);

	printf("somme de vos deux nombres : %d \r\n", som);

}

//début de la fonction obtention
int *obtention()
{
	int *n = malloc(sizeof(int) * 2);

	printf("Veuillez introduire deux nombres entiers svp\n\r");
	scanf(" %d  %d",&n[0],&n[1]);

	return n;
}


//début de la fonction somme
int somme(int n1, int n2)
{
	int ret;

	ret=n1+n2;
	return ret;

}
Tiens comme ça, ça fonctionne


Edit : lol tous en même temps!
 
1er
OP
redband59

redband59

Elite
heu ... merci beaucoup :)

mais j'ai un autre problème, les * ca veut bien dire qu'on utilise un pointeur non ?

si oui, ya pas moyen de faire sans ça ?
 
gogoprog

gogoprog

Oprahiste vaudou
b00msTicK a dit:
Code: 
int* obtention()
{
int num[2];

printf("Veuillez introduire deux nombres entiers svp\n");
scanf("%d\n%d",num[0],num[1]);

return num;
}
Cliquez pour agrandir...
C'est pas très correct car tu renvoies l'adresse d'une variable locale, d'ailleurs le compilo fait un warning
 
b00msTicK

b00msTicK

O=(*.*Q)
gogoprog t'es sur que scanf prend des pointeurs en arguments?
 
gogoprog

gogoprog

Oprahiste vaudou
redband59 a dit:
heu ... merci beaucoup :)

mais j'ai un autre problème, les * ca veut bien dire qu'on utilise un pointeur non ?

si oui, ya pas moyen de faire sans ça ?
Cliquez pour agrandir...
Pour pouvoir faire une fonction obtention comme la tienne qui doit retourner plusieurs valeurs, non


b00msTicK a dit:
gogoprog t'es sur que scanf prend des pointeurs en arguments?
Cliquez pour agrandir...
Oui
 
b00msTicK

b00msTicK

O=(*.*Q)
gogoprog a dit:
C'est pas très correct car tu renvoies l'adresse d'une variable locale, d'ailleurs le compilo fait un warning
Cliquez pour agrandir...
ton malloc fait pareil non? l'intérêt du malloc c'est l'allocation dynamique or ici y a pas besoin.
(je peux me tromper hein :-D)
 
b00msTicK

b00msTicK

O=(*.*Q)
gogoprog a dit:
Pour pouvoir faire une fonction obtention comme la tienne qui doit retourner plusieurs valeurs, non




Oui
Cliquez pour agrandir...
ok prends la version de gogoprog alors red, moi j'ai même pas essayé de compiler :-'
 
1er
OP
redband59

redband59

Elite
bon ben quelqu'un peut me dire a quoi servent les pointeurs, en deux trois phrases maxi :cool:

c'est la matière du deuxième quadrimestre en fait

edit : le sizeof on n'a pas encore vu non plus ... :p
 
gogoprog

gogoprog

Oprahiste vaudou
b00msTicK a dit:
ton malloc fait pareil non? l'intérêt du malloc c'est l'allocation dynamique or ici y a pas besoin.
(je peux me tromper hein :-D)
Cliquez pour agrandir...
Bin avec malloc, l'espace sera bien alloué et "protégé" si je puis dire.
Avec ton code, il se pourrait que les variables soient modifiées
 
null

null

ose();
C'est pour passer l'adresse mémoire de ta variable "pointée". De cette manière, il n'y a pas copie de valeurs à l'appel de la fonction et quand tu modifies dans cette fonction, c'est direct modifié dans le code appelant vu que c'est la même zone mémoire qui est modifiée.
 
b00msTicK

b00msTicK

O=(*.*Q)
redband59 a dit:
bon ben quelqu'un peut me dire a quoi servent les pointeurs, en deux trois phrases maxi :cool:
Cliquez pour agrandir...
c'est toute la difficulté du C. Une fois que tu as compris ça, tu as quasiment tout compris.
 
b00msTicK

b00msTicK

O=(*.*Q)
gogoprog a dit:
Bin avec malloc, l'espace sera bien alloué et "protégé" si je puis dire.
Avec ton code, il se pourrait que les variables soient modifiées
Cliquez pour agrandir...
Je suis pas convaincu là. Si tu déclares ton tableau de taille fixe, la mémoire est allouée pour ce tableau et pour rien d'autre normalement.
Enfin si c'est pas le cas je vois pas l'intérêt d'une déclaration pareille, or elle est utilisée.
 
null

null

ose();
Voici ton code propre :

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

void obtention(int *, int *);
int somme(int, int);

/*programme principal*/
int main(int argc, char* argv[])
{
	int n1, n2;

	obtention(&n1, &n2);

	printf("somme de vos deux nombres : %d", somme(n1,n2));
	scanf("%d");
	return 1;
}

/*début de la fonction obtention*/
void obtention(int *n1, int *n2)
{
	printf("Veuillez introduire deux nombres entiers svp\n");
	scanf("%d\n%d",n1,n2);
}

/*début de la fonction somme*/
int somme(int n1, int n2)
{
	return n1+n2;
}
1. Les prototypes sont sortis des déclarations de fonctions (plus tard tu verras les .h)

2. Tu n'as pas besoin de l'include du "iosteam.h" (c'est du C++ d'ailleurs)

3. En C ANSI (le nom de la norme), le prototype du main est :

Code: 
int main(int argc, char* argv[])
4. En C ANSI, il n'y a pas les commentaires "//", tu dois toujours utiliser le "/* */"

5. Dans le main, je passe les adresses de "n1" et "n2" dans "void obtention(int *n1, int *n2)". Dedans je joue avec des pointeurs. C'est beaucoup plus simple que faire des malloc (qui d'ailleurs ne sont pas déssaloué dans le code de gogoprog)
 
eSb`

eSb`

That's Poker!
b00msTicK a dit:
Je suis pas convaincu là. Si tu déclares ton tableau de taille fixe, la mémoire est allouée pour ce tableau et pour rien d'autre normalement.
Enfin si c'est pas le cas je vois pas l'intérêt d'une déclaration pareille, or elle est utilisée.
Cliquez pour agrandir...
Pour moi, l'intérêt du malloc c'est de réserver une taille de mémoire variable à un moment précis du programme et ensuite de libérer la mémoire.

int *n = malloc(sizeof(int) * 2);

Fait comme ça, je vois moyennement l'intérêt, un int n[2] ferait la même chose, non ?

Si ça avait été int *n = malloc(sizeof(int) * N); avec un N variable, là, ça me parait plus intéressant; ça permet de créer un "tableau" de la bonne taille dès le départ sans utiliser trop de ressources. (si tu fais un n[2], et que tu ne mets qu'un nombre, tu auras réservé 'x' octets en trop qui resteront vides)
 
k o D

k o D

Elite
redband59 a dit:
heu ... merci beaucoup :)

mais j'ai un autre problème, les * ca veut bien dire qu'on utilise un pointeur non ?

si oui, ya pas moyen de faire sans ça ?
Cliquez pour agrandir...
Oui mais utilise plus simplement dans ton cas le tableau (qui est en fait un pointeur masqué)

int variable [2]
variable[0] = lll
variable[1] = pppp


EDIT: la solution de null est réellement la plus propre... maintenant c'est à toi de voir si tu veux jouer avec des pointeurs ou pas :-D
 
Statut
N'est pas ouverte pour d'autres réponses.
Haut