Version imprimable
Bonjour a toutes et a tous ,
Lors de la conception d'un programme , il faut dabord reflechir et concevoir les fonctions et ensuite le main ou le contraire . Avec ce que peux retourner une fonction et les arguments qu'elle peut prendre , j'avoue ne pas savoir par quel bout commencer ...
Merci de votre aide
J'ai envie de répondre "ni l'un ni l'autre" mais en fait ce que je vais dire va s'approcher de la réponse 2 "penser au main". Mais j'aime pas trop cette formulation, elle est ultra-réductrice.
Quand tu conçois un programme, tu dois définir ses fonctionnalités : quelles données prend t-il en paramètres ? va t-il interagir avec l'utilisateur en cours d'exécution ? quels résultats va t-il produire ? quelles contraintes de performances, de compacité, de portabilité a t-il ? Tu vas alors commencer à réfléchir aux traitements, définir des blocs qui fournissent certaines fonctionnalités, imaginer comment ses blocs interagissent, etc.
Ce n'est qu'après, quand tu vas commencer l'implémentation, que tu vas commencer à penser fonctions, et main() est une fonction.
Je rejoins ce que dit Bktero , ça dépend du programme , mais techniquement tu as créer des fonctions suivant des besoins , pareil pour les arguments , tout dépend de la volonté de manipulation de ta fonction ;)
Mais en général toutes les fonctions doivent être très ciblé , éviter une fonction qui doit faire 10 000 truc !
Bonjour
Essaye alors de le commencer manuellement. Comment tu t'y prendrais avec un crayon. Quelles actions semblent revenir assez souvent => ces actions pourront alors devenir des fonctions. etc...Citation:
Envoyé par chris7522
> je veux faire un jeu en 2d vue de dessus
>> je dois pouvoir afficher un sprite
>>> je veux pouvoir déplacer le sprite
>>> je veux pouvoir animer ce sprite
>> je veux pouvoir afficher un background
>>> je veux pouvoir afficher plusieurs éléments par-dessus le background
>>>> je vais avoir plusieurs couches d'affichage
>> je veux déplacer un personnage en cliquant à la souris
>>> et avec les flèches directionnelles
>>>> et pouvoir réassigner les touches de déplacement
>> je veux ouvrir un menu en appuyant sur échap
>>> je veux afficher des éléments intéractifs pour faire le menu
>>>> je dois pouvoir cliquer sur les boutons du menu
>>>> je veux me déplacer dans le menu avec les touches directionnelles
...
généralement un verbe = une action = une fonction
un nom = un objet = une structure
Merci . J'y vois + claire a présent .
Si je prends l'exemple d'un certain nombre de note que je veux moyenner , je peux peut etre dabord faire une fonction pour demander le nombre de note . Tout de suite apres , je vais ecrire dans la fonction main pour stocker le resultat de la fonction dans une variable . Ensuite j'ecris une nouvelke fonction pour demander de rentrer les notes en question suivi d'un petit tour dans le main pour l'appel de la nouvelle fonction avec les arguments qui vont bien
Et ainsi de suite ... j'avance comme ca .
Ca se fait ca ?
scanf()...:aie:Citation:
Envoyé par chris7522
On ne se ballade pas entre fonctions et main. C'est plutôt "fonction initiale (le "main) appelle fonction2 et attend son résultat". Mais si "fonction2" est assez complexe, alors dans son traitement il y aura probablement "appel fonction3 et attente du résultat". Le "main" c'est un peu le Battlestar Galactica. Il a besoin d'un truc, il envoie un Viper et attend son retour. Mais s'il a besoin d'un truc plus complexe, alors il enverra un Rapace et attend son retour mais le Rapace pourra lui envoyer des drones et attendre leur retour pour faire son travail. Bref un genre de poupées russes...Citation:
Envoyé par chris7522
Prenons donc ton exemple d'un certain nombre de notes qu'on veut moyenner. Moi j'écrirais une fonction permettant de faire saisir une note unique. Mais je l'écrirais vraiment robuste, avec contrôle de ce qui est saisi et redemande tant que la note n'est pas correcte. Puis une fois que la note est correcte, alors la fonction la retourne à l'appelant (et à ce niveau elle s'en bat le steak de savoir qui est cet appelant).
Ensuite, je définis une fonction qui calculera la moyenne d'un tableau de notes. Elle n'a pas besoin de savoir comment sont obtenues les notes, elle se contente juste de les additionner et retourner le résultat.
Et enfin dans le main je définis un tableau de notes. J'appelle la fonction de saisie autant de fois qu'il faut pour remplir tout le tableau puis j'appelle la fonction de calcul de moyenne en lui donnant le tableau à bouffer.
En faisant ainsi, je reste simple et je colle à la réalité (parce que dans la réalité, quand on calcule une moyenne, on se contente de prendre les notes et les additionner à la calculatrice). Mais aussi je me prépare pour l'avenir. Peut-être que demain, les notes ne seront plus saisies au clavier mais lues depuis un fichier. Il faudra juste alors écrire une fonction qui lit le fichier et charge le tableau mais la fonction qui calcule la moyenne ne change pas. Peut-être aussi que après-demain il y aura des coefficients aux notes. Il suffira alors de créer une structure contenant la note et son coeff et modifier la fonction de saisie pour qu'elle saisisse la note+le coeff. Il faudra aussi modifier la fonction de calcul de moyenne mais l'articulation du code, elle, ne changera pas (boucle de saisie et calcul).
Merci a tous de votre aide ☺