[Debutant] Transmission de variables.

Bonjour à tou(te)s!
Je viens à vous accompagné d'un souci probablement minime pour la majorité d'entre vous; j'ai commencé à programmer en C il n'y que peu de temps et j'ai encore du mal à cerner et acquérir la "logique" de manière générale.
Internet me facilite cependant grandement la tâche, et sur un des exercices trouvé sur un site que je "pêche":

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

void affiche(long tableau[], long tailletableau); long sommetableau(long tableau[], long tailletableau); int main() { long tableau[4] = {15, 25, 35, 45}, i = 0; affiche(tableau, 4); sommetableau(tableau, 4); return 0;   }   void affiche(long *tableau, long tailletableau) { long i; for (i = 0; i < tailletableau; i++) { printf("%ld\n", tableau[i]); } }   long sommetableau(long tableau[], long tailletableau) {   long i = 0, resultat = 0; for (i = 0; i < tailletableau; i++) { resultat += tableau[i];   } return resultat; printf("%ld", resultat);   }

---

Voilà j'aimerai ajouter les valeurs du tableau les unes aux autres, et afficher cette somme. Après maints essais, je ne m'en sors toujours pas. Les valeurs du tableau s'affichent à la suite, mais pas la somme.
Je n'attends pas un code tout prêt, mais des indices ou des explications sur ce qui ne va pas dans ce bout de code! Merci à ceux et celles qui prendront le temps de passer par là!.

Pour commencer il faudrait que tu penses à indenter ton code pour que celui-ci soit plus lisible.

Exemple :

Code:

---

1 2 3 4 5 6 7 8

void affiche(long *tableau, long tailletableau) { long i; for (i = 0; i < tailletableau; i++) { printf("%ld\n", tableau[i]); } }

---

Ensuite tu dis que tu ne t'en sors pas. Il serait bien que tu expliques ce qui ne vas pas. Tu n'obtiens pas le bon résultat, tu as un problème d'affichage, des erreurs de compilation .........

Puis pour finir j'ai remarqué une erreur dans ta fonction sommetableau. Tu affiches le resultat après avoir fait le return. Hors après le return tu ne te trouves plus dans la fonction et tu ne peux donc pas faire l'affichage. La solution est ou bien de faire l'affichage avant le return ou bien faire l'affichage dans la fonction main.

Voilà bonne continuation.

Bonjour,

Et si tu l'affichais avant de quitter la fonction ?

Cordialement,
DS.

Citation:

---

Envoyé par floflo_2006

Pour commencer il faudrait que tu penses à indenter ton code pour que celui-ci soit plus lisible.

---

L'indentation était peut-être correcte à l'origine...mais il a utilisé la mauvaise balise ("QUOTE" au lieu de "CODE").

ah oui !!!!

désolé c'est surement pour cela.

:roll:

Oups! Désolé pour ces petites erreurs qui ne se reproduiront plus! J'ai expliqué ce qui clochait, les valeurs du tableau s'affichent mais pas la somme.
Le printf avant le return fonctionne merci pour ces explications, et je crois que j'ai vraiment, vraiment mal compris l'utilité de ce "return" :D .
Merci à vous!

Citation:

---

Envoyé par Preez

Oups! Désolé pour ces petites erreurs qui ne se reproduiront plus! J'ai expliqué ce qui clochait, les valeurs du tableau s'affichent mais pas la somme.
Le printf avant le return fonctionne merci pour ces explications, et je crois que j'ai vraiment, vraiment mal compris l'utilité de ce "return"

---

En fait, tu n'as pas compris ce qu'est une fonction C.

C'est une séquence d'instructions définie par un identificateur (le nom de la fonction) suivit d'une paire de parenthèses,

Code:

---

mafonction()

---

un éventuel type de retour (ou void si la fonction ne retourne rien),

Code:

---

1 2	int mafonction() void mafonction()

---

et d'éventuels paramètres typés et nommés (ou void si il n'y a pas de paramètres).

Code:

---

1 2 3 4 5

int mafonction(char *p, int i) int mafonction(void) void mafonction(double *a, size_t nb_elem) void mafonction(void)

---

suivit d'une paire d'accolades contenant les instructions

Code:

---

1 2 3 4 5

int mafonction(char *p, int i) { /* ... instructions ... */ }

---

et, si la fonction a un type de retour différent de void, une instruction 'return <valeur du type du retour>'

Code:

---

1 2 3 4 5 6 7

int mafonction(char *p, int i) { /* ... instructions ... */   return valeur; }

---

qui a 2 rôles :

• interrompre l'exécution de la fonction
• renvoyer une valeur à l'appelant.

Cette valeur est récupérable en utilisant l'opérateur d'affectation (=) et une variable du bon type (ou d'un type compatible), en utilisant l'appel suivant :

Code:

---

TYPE var = mafonction(<parametres>);

---

Citation:

---

Envoyé par floflo_2006

ah oui !!!!

désolé c'est surement pour cela.

:roll:

---

Il n'y a pas de mal.

Citation:

---

Envoyé par Preez

Oups! Désolé pour ces petites erreurs qui ne se reproduiront plus! J'ai expliqué ce qui clochait, les valeurs du tableau s'affichent mais pas la somme.
Le printf avant le return fonctionne merci pour ces explications, et je crois que j'ai vraiment, vraiment mal compris l'utilité de ce "return" :D .
Merci à vous!

---

Voir "Définition d'une fonction".

D'accord! Expliqué comme ça c'est beaucoup plus clair. Merci à tous!

Encore bonjour à tou(te)s!
Merci pour ces explications et liens sur les fonctions, qui m'ont correctement éclairé.
Toujours à la poursuite de mon exercice, je cale sur la fonction moyenne censée calculer la moyenne des valeurs du tableau.
Le code:

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

#include <stdio.h> #include <stdlib.h>   //prototype des differentes fonctions void affiche(long *tableau, long tailletableau); long somme(long tableau[], long tailletableau); double moyenne(long tableau[], long tailletableau);   //Fonction principale int main() { long tableau[4] = {10, 15, 10}, i = 0;   affiche(tableau, 4); somme(tableau, 4); moyenne(tableau, 4); return 0; }   void affiche(long *tableau, long tailletableau) { long i; for (i = 0; i < tailletableau; i++) { printf("%ld\n", tableau[i]); } }   //Fonction "Somme" long somme(long tableau[], long tailletableau) { long i = 0; long resultat = 0; for (i=0; i < tailletableau; i++) { resultat += tableau[i]; }   printf("Somme :%ld\n", resultat); return resultat;   }   //Fonction "Moyenne" double moyenne(long tableau[], long tailletableau) { long resultat = somme(tableau, 4); double resultatmoyenne = 0; resultatmoyenne = (resultat / tailletableau) + (resultat % tailletableau); printf("Moyenne :%lf", resultatmoyenne); return resultatmoyenne; }

---

J'obtient dans la console ceci:

Code:

---

1 2 3 4 5 6 7 8

10 15 10 0 Somme :35 Somme :35 Moyenne :11.000000

---

Pourquoi ai-je deux fois "Somme :35"? Je n'appelle pourtant pas la fonction somme(tableau, 4), je demande juste que la valeur de son return (resultat) soit assigné à la valeur de resultat dans la fonction moyenne. De plus, la moyenne devrait être de 8.75, elle est donc erronée dans le programme.
Merci encore de vos réponses et de votre aide, précieuse.

Citation:

---

Pourquoi ai-je deux fois "Somme :35"?

---

T'appelles deux fois la fonction somme donc ca affiche deux fois l'appel au printf pour afficher le résultat de ta somme:
Une fois dans le main:

Code:

---

1 2 3 4 5 6 7 8 9

int main() { long tableau[4] = {10, 15, 10}, i = 0; affiche(tableau, 4); somme(tableau, 4); moyenne(tableau, 4); return 0; }

---

et une fois dans ta fonction moyenne:

Code:

---

1 2 3 4 5 6 7 8

double moyenne(long tableau[], long tailletableau) { long resultat = somme(tableau, 4); double resultatmoyenne = 0; resultatmoyenne = (resultat / tailletableau) + (resultat % tailletableau); printf("Moyenne :%lf", resultatmoyenne); return resultatmoyenne; }

---

Pour remédier à cela, n'affiche pas le résultat dans ta fonction somme mais une fois le paramètre retourné, tu l'affiches à ta guise!

;)

Citation:

---

De plus, la moyenne devrait être de 8.75, elle est donc erronée dans le programme.

---

Pourquoi as tu fait ceci:

Code:

---

resultatmoyenne = (resultat / tailletableau) + (resultat % tailletableau);

---

En transtypant la variable "résultat" en double afin d'obtenir le résultat en décimal et en supprimant la partie en gras, j'obtiens bien 8.75! ;)

Code:

---

resultatmoyenne = ((double)resultat / tailletableau);

---

Citation:

---

Envoyé par Preez

Code:

---

1 2 3 4 5 6 7 8

//Fonction "Moyenne" double moyenne(long tableau[], long tailletableau) { long resultat = somme(tableau, 4); double resultatmoyenne = 0; resultatmoyenne = (resultat / tailletableau) + (resultat % tailletableau); }

---

---

Erreur classique.
Le type de division s'adapte aux opérandes.

Si ceux-ci sont tous des entiers, c'est une division entière.
Si au moins un des opérandes est un flottant, c'est une division flottante.

Comme ici, les deux opérandes sont des long (entiers), la division est entière. Dans ce cas, pour avoir une division flottante, il faut en quelque sorte 'berner' le compilateur en forçant le type d'un des opérandes en flottant (double, par exemple, c'est préférable). On utilise pour ça un typecast (ou transtypage ou cast) de cette façon :

Code:

---

resultatmoyenne = (double) resultat / tailletableau;

---

ou

Code:

---

resultatmoyenne = resultat / (double) tailletableau;

---

Nota : Je n'ai pas compris pourquoi tu ajoutais le reste de la division entière. Pour un calcul de moyenne, c'est inutile.

Je ne pensais pas que l'on pouvait obtenir un résultat décimal avec "/" mais j'ai une fois de plus appris une bonne chose! Suite à ton conseil, j'ai retiré mon printf dans la fonction somme et je l'ai integré dans le main(). Le résultat escompté est présent, je passe à la suite!
Merci!
:aie: :aie: Dur labeur de débuter la prog:aie: :mrgreen: :mouarf:

Edit: pour Emmanuel, merci à toi de m'expliquer encore toutes ces choses. Euh pour l'addition, j'était certain d'avoir lu dans des cours que le "/" retournait un nombre entier, et que le modulo retournait le reste de la division, je pensai donc qu'en ajoutant le nombre entier, puis le reste, ça me donnerait ma moyenne!

Modulo retourne bien le reste de ta division mais le reste entier

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13

#include <stdlib.h> #include <stdio.h>   int main(void) { int q; int r;   q = 17 / 3; r = 17 % 3; printf("17 : 3 = %d r %d", q ,r);   return EXIT_SUCCESS; }

---

Sortie:
17 : 3 = 5 r 2

D'accord, je comprends mieux mon erreur. j'ai retenu l'histoire d'assigner en "double" l'une des valeurs, je m'en sors mieux dans mes tableaux.
Pour la suite de mes exos, je m'étais promis de faire ça sans vous, mais apparament vous m'êtes trop précieux, ' peux pas se passer de vous! :mouarf:
-De quel côté dois-je me diriger pour tronquer une chaîne? Ma moyenne fait 8.750000, j'aimerai ne garder que les deux décimales après la virgule. J'ai cherché du côté de <string.h> mais j'ai vu que ce n'était que pour les chaînes de caractères.
-Je dois à présent copier un tableau dans un autre, à la base vide. Je n'ai aucune idée sur la façon de faire. Je commence par initialiser mon second tableau (destiné à recevoir le contenu du premier), j'ai ensuite essayé de programmer une sorte de "tableauoriginal = tableaucopie" mais ça ne correspond pas avec la taille du tableau, je dois la rentrer manuellement et ce n'est pas le but recherché à mon avis.
-Est-ce que tout ça me servira par la suite? Ca fait trois/quatre jours que je me suis mis dans la tête d'apprendre le C, et j'aimerai tellement, mais tellement passer à la SDL tout de suite, et faire mon morpion :mouarf: :mouarf: , enfin, je ne me décourage pas, mais je voudrai juste confirmation que tout ce que je fais en ce moment me servira, par la suite!
Merci à vous!

Citation:

---

De quel côté dois-je me diriger pour tronquer une chaîne? Ma moyenne fait 8.750000, j'aimerai ne garder que les deux décimales après la virgule.

---

Je pense que tu désires afficher deux décimales:

Citation:

---

printf("Moyenne :%.02lf", resultatmoyenne);

---

EDIT: Pour tronquer, tu peux toujours dans un premier temps convertir ton nombre en chaine de caractères à l'aide de sprintf ou snprintf.

Citation:

---

Je dois à présent copier un tableau dans un autre, à la base vide. Je n'ai aucune idée sur la façon de faire

---

Utilise la fonction memcpy() après avoir au préalable alloué l'espace mémoire pour le tableau recevant la copie.

Citation:

---

Est-ce que tout ça me servira par la suite? Ca fait trois/quatre jours que je me suis mis dans la tête d'apprendre le C

---

Ca te servira forcément! ;)

Ouch! merci à toi homeostasie, ça fait beaucoup de choses inconnues pour moi!
Je viens d'essayer le "%.02lf" et mon resulatmoyenne est de 9, ça l'a arrondi à l'entier superieur, ca vient des différences C/C++?
Je vais chercher pour sprintf() et memcpy() mais pour l'allocation de mémoire, ce n'est que plus loin dans les cours. En tout cas merci pour tout ça!
(et merci de la rapidité des réponses, balèze :mrgreen: )

Edit:
-

Citation:

---

La fonction memcpy() copie n octets depuis la zone mémoire src vers la zone mémoire dest. Les deux zones ne doivent pas se chevaucher. Si c'est le cas, utilisez plutôt memmove

---

Voilà ce que je viens de trouver. Je n'y comprends rien du tout. Tu m'as surestimé Homeostasie:mouarf: !
Plus sérieusement, comment obtenir le nombre d'octets de mon premier tableau? Les zones mémoires src et dest, avec un pointeur ça suffit?

-Pour la moyenne c'est bon, la virgule n'était pas à la bonne place. Merci!

Citation:

---

Envoyé par Preez

Plus sérieusement, comment obtenir le nombre d'octets de mon premier tableau?

---

Si tu as un tableau définit statiquement, c'est à dire par exemple comme suit:

Code:

---

char buffer[10] = {0};

---

alors tu peux utilisé la fonction sizeof() qui retournera la taille totale de ton tableau en octets.
Par contre, si ton tableau est alloué dynamiquement, sizeof() te retournera la taille du pointeur sur ton tableau et non la taille de celui ci.

Citation:

---

Envoyé par Preez

Les zones mémoires src et dest, avec un pointeur ça suffit?

---

Si tu as définit tes tableaux src et dest statiquement, ca suffit de passer un pointeur sur tes tableaux.

Si tu bosses dynamiquement, alors il est indispensable d'allouer au préalable l'espace mémoire avant d'utiliser cette fonction.
Pour allouer dynamiquement un espace mémoire, il faut te pencher du côté de la fonction malloc().