Langage C problème avec fonctions

Discussion dans 'Web, design' créé par redband59, 5 Janvier 2008.

Statut de la discussion:
Fermée.
  1. Offline
    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;
    
    }
    
    redband59, 5 Janvier 2008
    #1
  2. Offline
    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
    redband59, 5 Janvier 2008
    #2
  3. Offline
    sigmar Touriste
    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.
    sigmar, 5 Janvier 2008
    #3
  4. Offline
    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 :p'
    b00msTicK, 5 Janvier 2008
    #4
  5. Offline
    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/
    null, 5 Janvier 2008
    #5
  6. Offline
    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!
    gogoprog, 5 Janvier 2008
    #6
  7. Offline
    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 ?
    redband59, 5 Janvier 2008
    #7
  8. Offline
    gogoprog Oprahiste vaudou
    C'est pas très correct car tu renvoies l'adresse d'une variable locale, d'ailleurs le compilo fait un warning
    gogoprog, 5 Janvier 2008
    #8
  9. Offline
    b00msTicK O=(*.*Q)
    gogoprog t'es sur que scanf prend des pointeurs en arguments?
    b00msTicK, 5 Janvier 2008
    #9
  10. Offline
    gogoprog Oprahiste vaudou
    Pour pouvoir faire une fonction obtention comme la tienne qui doit retourner plusieurs valeurs, non


    Oui
    gogoprog, 5 Janvier 2008
    #10
  11. Offline
    b00msTicK O=(*.*Q)
    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, 5 Janvier 2008
    #11
  12. Offline
    b00msTicK O=(*.*Q)
    ok prends la version de gogoprog alors red, moi j'ai même pas essayé de compiler :-'
    b00msTicK, 5 Janvier 2008
    #12
  13. Offline
    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
    redband59, 5 Janvier 2008
    #13
  14. Offline
    gogoprog Oprahiste vaudou
    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
    gogoprog, 5 Janvier 2008
    #14
  15. Offline
    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.
    null, 5 Janvier 2008
    #15
  16. Offline
    b00msTicK O=(*.*Q)
    c'est toute la difficulté du C. Une fois que tu as compris ça, tu as quasiment tout compris.
    b00msTicK, 5 Janvier 2008
    #16
  17. Offline
    b00msTicK O=(*.*Q)
    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.
    b00msTicK, 5 Janvier 2008
    #17
  18. Offline
    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)
    null, 5 Janvier 2008
    #18
  19. Offline
    eSb` That's Poker!
    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)
    eSb`, 5 Janvier 2008
    #19
  20. Offline
    k o D Belge !
    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
    k o D, 5 Janvier 2008
    #20
Statut de la discussion:
Fermée.