Bonjour et bienvenue à nouveau.
Dans cette conférence, je veux aller à travers une
démonstration de solution de notre défi précédent qui était de
créer certaines fonctions, principalement la fonction GCD et un fonction de couple, fonction de valeur absolue et
fonction de racine carrée.
Je vais créer un projet, et Je
vais probablement nommer les fonctions du projet, je vais pour fermer mon projet existant ici.
Va être un autre application de la console.
Nous n'avons pas vraiment eu dans des bibliothèques ou tout type de
programmation graphique.
Ça va être comme ça à propos de quelques fonctions.
Habituellement, vous voulez avoir un bon nom là-bas, mais c'est juste
à des fins d'apprentissage.
Donc nous sommes en quelque sorte juste fournir des fonctions génériques.
Si c'était un programme GCD, je écrivez le plus grand diviseur commun.
Mais la première chose que nous allons faire allons-nous mettre en œuvre
notre plus grand programme commun de diviseurs.
Cela va être une fonction qui trouve le plus grand diviseur commun
entre deux entiers non négatifs valeurs, puis renvoie les résultats.
Nous devrions fournir la fonction prototypes aussi pour que nous puissions les
appeler et placer les n'importe où dans la fonction.
Alors faisons ça.
Pour la première fonction, ce est une déclaration de fonction.
Pourquoi faisons-nous une fonction déclaration, afin que
nous puissions l'invoquer n'importe où dans le programme.
Nous n'avons pas à réellement implémentez cette
fonction au-dessus de la fonction principale lorsque nous l'appelons.
Et c'est juste une bonne pratique, c'est très facile de voir clairement ce
qui se passe dans le programme avec tous les déclarations de fonction en haut.
Cela va retourner un int.
Alors rappelez-vous, l'en-tête de fonction le premier ce que vous faites est de spécifier le type de données qui
va être retourné.
GCD va renvoyer un int.
Il va alors nommer la fonction qui est GCD.
Et puis à l'intérieur des parenthèses se trouvent données transmises au GCD.
Et cela va être aussi int.
Nous allons passer deux éléments de données.
Nous les séparons donc par des virgules.
Nous spécifions le type de données pour chacun et le nom de la variable.
Je vais juste dire en u et v.
Et puis j'ai le point-virgule pour terminer la définition de la fonction.
Maintenant, je peux définir ma fonction ci-dessous le principal et je peux toujours l'invoquer et
ne pas avoir de problèmes.
Alors maintenant, quand tu veux vraiment définir
la fonction l'implémenter, vous faites la même fonction header int valeur de retour GCD.
Il doit correspondre à la déclaration en termes de types.
Tu pourrais lui donner un autre nom comme int x pour les noms, mais
nous allons être cohérents.
Nous allons juste dire int v.
Nous savons que c'est la fonction définition car il y a
des crochets qui définissent le corps.
Ceci est le code d'implémentation.
L'algorithme actuel pour le GCD est assez simple.
Tout ce que vous avez à faire est d'écrire une boucle et parcourez la boucle et regardez les
valeurs de température basées sur les restes.
Alors je vais créer un local variable dans ma fonction GCD.
Comment savons-nous que c'est local parce que c'est à l'intérieur des crochets pour 12 à 14.
Cette variable n'est pas accessible à l'intérieur de la fonction principale.
C'est seulement local à ce bloc.
Ici, je vais juste appelez temp car il est local.
Je vais aussi maintenant créer ma boucle.
Je vais utiliser une boucle while.
Et ma boucle while va juste aller jusqu'à v, ce qui serait notre
plus grand diviseur commun.
Rappelez-vous, le plus grand commun le diviseur prend deux paramètres.
Cela prendrait un paramètre.
Et sur la base de ces deux paramètres, il a un algorithme à créer pour
trouver le plus grand diviseur commun.
Donc si nous essayons de trouver le diviseur,
nous devons nous assurer que v n'est pas égal à zéro, notre deuxième paramètre.
C'est juste standard parties de l'algorithme.
Alors que le v n'est pas égal à zéro, nous allons mettre
des crochets pour la boucle.
Ce que nous allons faire, c'est que nous va
d'abord affecter la température à la valeur des modules de u mod v.
Nous allons ensuite vous mettre égal à v, et nous allons
définir v égal à temp.
Et puis nous voulons revenir données de cette fonction.
Alors, comment renvoyer les données de une fonction? nous utilisons le mot-clé
return, et nous renvoyons simplement le les données que nous voulons renvoyer.
Dans ce cas, nous voulons retourner u.
Rappelez-vous maintenant que si cette fonction n'a renvoyé aucune donnée, nous devions
changer le type en void.
Et puis nous pourrions juste avoir un retour sans données.
Mais cela renvoie des données.
Nous devons donc correspondre.
Et voici que nous le ferions dites revenir à nouveau u.
Aussi si nous ne transmettions pas de données à cette fonction,
nous pourrions mettre vide comme paramètres ou nous pourrions les garder vides et cela voudrait
dire que la fonction ne prend aucune donnée mais nous passons deux variables.
Et ces variables u et v sont variables locales à la fonction GCD.
Nous pouvons les utiliser dans la fonction.
Et c'est ce que nous faisons.
Ce sont tous les traits d'une fonction.
La valeur de retour, les données qui vous transmettez, en utilisant des
variables locales, puis en renvoyant des données.
Toutes ces choses font attention à la syntaxe avec les crochets puis aussi avec
la déclaration en haut.
Maintenant nous voulons essayer de testez cette fonction.
Nous voulons donc le tester pour tous sortes de choses différentes.
Allons-y et rappelons-nous que ceci fonction retourne des données donc nous voulons probablement créer
une variable locale dans notre principal, nous l'appellerons simplement résultat.
Nous pouvons l'initialiser à zéro.
Et puis nous voulons appelez essentiellement la fonction.
Comment invoquer une fonction?
Nous spécifions juste la fonction nom suivi des données qui lui
sont transmises.
Parce que cette fonction retourne data, je vais dire que le résultat est
égal, puis le nom de la fonction.
Le nom de la fonction est GCD.
Et je vais passer 150 pour mon premier test et 35.
Je vais faire deux autres tests pour juste passer des nombres différents, mais ce que je veux
faire c'est que je veux pour imprimer les données renvoyées
par le résultat.
Alors je vais dire printf, et je suis va dire que le GCD de 150 et 35 est un saut
de ligne pour cent et ensuite le résultat.
À droite. La ligne 10 est donc importante.
Nous récupérons les données de GCD alors nous l'attribuons à une variable.
Et nous pouvons appeler la fonction passant en deux constantes ici, 150 et 35.
Nous pourrions également passer des variables.
La façon dont nous invoquons la fonction avec les données qui lui
sont passées entre parenthèses, nous mettons les valeurs séparés par des virgules, puis le point-virgule
se trouve à la fin.
Je veux faire plusieurs tests.
Je vais donc copier les lignes 10 et 11 et insérez simplement d'autres données.
Je vais mettre 1026 et 405 et puis aussi 83.
Et en fait, ce que nous pourrions faire est au lieu de renvoyer
la variable, nous pourrions en fait simplement la mettre appel de la
fonction à l'intérieur du printf et l'imprimer ici, nous n'avons même pas besoin de le sauvegarder.
Nous pourrions donc simplement dire GCD 83, 240.
Il faudrait changer ce
nous imprimons ici en termes de valeurs codées en dur, disons 1026, 405 puis 240 et 83.
Alors allons-y et compilons ça.
Assurons-nous d'obtenir aucune erreur ou avertissement.
Nous n'avons aucune erreur ni avertissement.
Alors allons-y.
Quand nous l'exécutons, nous devrions voir le plus grand diviseur
commun trois fois pour certains nombres.
Nous voyons donc que le GCD de 150 et 35 est de 5.
Le GCD de 1026 et 405 est de 27.
Et le GCD de 83 et 240 est 1.
Le plus grand diviseur commun signifie le facteurs qui entrent dans ces deux nombres,
quel est le facteur le plus élevé.
Donc 5 va dans 35, et 5 va dans 150.
Et c'est le plus élevé.
27 entre également dans 405 et 1026, c'est le plus élevé entre les deux.
On dirait donc que ça marche.
Et nous avons couvert les bases de transmettre des données et renvoyer des données.
Maintenant nous voulons pratiquer un couple d'autres choses en termes d'algorithmes
et de résolution de problèmes.
Créons une autre fonction appelée valeur absolue.
La fonction de valeur absolue va pour retourner un flotteur et prendre un flotteur.
Ça va être un fonction très simple.
Alors nous allons déclarer la fonction sur la ligne cinq.
Nous allons dire float absolu value, c'est un nom suivi des paramètres, et nous sommes juste
va dire float x, puis nous allons terminer
par un point-virgule.
Encore une fois, remarquez la fonction déclaration, la valeur de retour,
les paramètres spécifient avec les types de données puis le nom de la fonction.
Nous pouvons alors aller de l'avant et définir cette fonction sous la
fonction GCD et ça va être très simple.
Nous définissons la fonction avec le type qui va être retourné, le nom
et ensuite le paramètre, tout comme le déclaration sauf que maintenant nous avons des crochets
pour démarrer le bloc de code.
C'est facile car tout ce que nous avons à faire est de vérifier le paramètre
qui passe et de vérifier s'il est inférieur à zéro.
Si c'est moins de zéro, alors nous allons simplement lui attribuer
l'inverse qui serait un moins x.
Donc, si c'est une valeur négative, il va se multiplier
par un moins retourner un positif.
Et nous voulons renvoyer ces données.
Nous allons donc dire return x.
Maintenant, une chose que j'ai mentionnée dans le des
conférences dont je n'ai pas eu l'occasion de donner un exemple si vous renvoyez des données tout au long.
Parce que nous pourrions avoir un tas de if instructions, et nous pourrions être de retour dans
chaque instruction if.
Et ainsi votre fonction peut, en théorie, ont de nombreuses instructions de retour si elles sont à
l'intérieur de ifs ou de boucles.
Et puis tu pourrais en avoir un en bas.
Le problème avec ceci est c'est vraiment difficile à suivre.
Si vous devez retourner différents des parties de votre code, en gros, stockez simplement
les données dans une variable et renvoyez-le en bas.
Mais ici, c'est une fonction simple.
Nous retournons juste une valeur.
Allons-y et essayons d'utiliser cette fonction et c'est vraiment sympa qu'elle prenne des flotteurs
pour qu'on puisse utilisez-le avec des nombres entiers et des flottants.
Alors je vais créer quelques variables ici que
nous allons passer.
Et je vais aussi pour créer un entier.
Je vais faire ça en haut de mon principal.
Je vais créer un flotteur pour F1 F2 F3.
Et je vais créer un entier I1.
Et je vais en créer un autre variable qui stocke le résultat mais qui doit
être un flottant.
Alors je vais devoir
créer une autre variable et
cela va juste dire le résultat de la valeur absolue, et je l'initialiserai
à 0. 0.
Maintenant, je vais invoquer le fonction et imprimez les résultats.
Alors je vais copier et collez du code ici.
Je peux appeler la fonction et stocker les données qui sont retournées ou je peux simplement
les transmettre à la fonction printf.
Je veux probablement faire quelques commentaires ici pour
tester la fonction de valeur absolue.
Et lorsque vous utilisez les astérisques sur un seul ligne, ça le met un peu en valeur.
Alors ici j'ai collé juste un tas d'appels à l'absolu fonction de valeur et ensuite affiché quelques résultats.
Alors ici en 24, j'appelle valeur absolue avec f1.
N'oubliez pas que f1 est un flotteur.
C'est égal à moins 15. 5.
Je vais formater le résultat et imprimez-le.
Et puis je suis aussi va imprimer f1.
Nous allons donc voir si le résultat change
en appelant la fonction que l'original.
Alors je vais imprimer le résultat de l'appel de la fonction
puis la valeur d'origine.
Cela nous dira si ça a changé du tout.
Si c'était négatif à l'origine et changé en positif.
Faire ça sur plusieurs lignes pour plusieurs tests.
Et puis à la ligne 37, le seul
la différence ici est qu'au lieu de stocker la valeur dans une variable, Je vais simplement l'imprimer.
Donc je dois changer les résultats ici à la bonne variable.
Alors faisons ça et.
Donc ici, je veux faire ça.
Quand j'ai écrit le programme, je les ai écrits séparément.
J'espère donc que je ne fais aucune erreur ici.
Et change tous ceux dont j'ai besoin changer et cela devrait le faire.
Les autres ne le sont pas en fait imprimer les résultats de
toutes les variables, uniquement celles de la ligne 26.
Sinon, nous sommes juste montrant les résultats.
Le premier montre juste que il a changé parce que
f1 est une valeur négative.
Eh bien, construisons ça.
Nous n'avons aucune erreur ou aucun avertissement.
La sortie que nous voulons prêter attention à la
sortie de la valeur absolue.
Alors il vaudrait peut-être mieux ajouter en fait des sauts de ligne.
Après avoir affiché notre dernier, ajoutons quelques sauts de ligne.
Plus facile à lire et à exécuter.
Alors maintenant, nous voyons que le résultat est 15. 5.
Donc ça l'a changé d'un négatif à un positif car f1 était
à l'origine de 15. 5.
Et tous les autres résultats sont également des valeurs positives.
La dernière instruction d'impression ne s'est pas imprimée le résultat, il a juste
imprimé la valeur renvoyée par la fonction.
On dirait que ça marche.
La dernière fonction que je voulais définir était une fonction racine carrée.
Ce serait une fonction qui calcule la racine carrée d'un nombre.
Et si un argument négatif est passé, un message sera affiché et
la valeur négative 1 sera renvoyée.
Définissons donc la déclaration de cette fonction en tant que racine carrée
flottante et prend un flottant avec n'importe quel nom.
Et la racine carrée va réellement pour utiliser la fonction de valeur absolue.
On peut donc le définir ci-dessus et l'utilisez toujours à cause de
la déclaration de fonction.
Alors définissons-le, et il prend un flotteur.
Nous devenons donc assez utiles pour définition de ces fonctions, type de données
pour les paramètres de retour, crochets.
Nous allons créer un couple variables locales ici.
Ceux-ci ne peuvent être que accessible à l'intérieur du bloc.
Cela va juste aider avec notre algorithme de racine carrée.
Vous remarquerez ici aux lignes 59, J'ai créé une variable constante.
Nous n'en avons pas parlé, mais c'est juste un moyen de créer
une constante plutôt que d'utiliser un define.
Nous avons créé une variable flottante nommée epsilon, c'est. 001, cela aide avec notre calcul
de racine carrée à faire sûr que c'est dans une plage donnée.
Nous avons une estimation qui vaut 1. 1 et une déclaration de valeur absolue ici.
Nous n'avons pas vraiment besoin de fournir la déclaration parce que nous l'avons définie
en haut, donc je peux m'en débarrasser.
Souviens-toi maintenant que nous devons vérifiez les paramètres, nous voulons faire la
validation des paramètres.
Si le paramètre est inférieur
à zéro, nous voulons imprimer un commentaire et renvoyer une valeur négative.
Donc, si x est inférieur à zéro, imprimez out argument négatif à la racine carrée
et renvoie un argument négatif.
Voici où nous allons avoir plusieurs valeurs de retour,
et je vais vous montrer comment vous pouvez revenir une fois et mettez-le simplement en bas.
Sinon, nous avons notre algorithme pour la racine carrée.
Je ne vais pas expliquer le algorithme parce qu'il n'est pas pertinent par rapport à
ce que nous apprenons.
Mais en gros, pour trouver le carré racine d'un nombre, on en obtient la
valeur absolue en multipliant il et puis moins dans le x.
Donc, la supposition est que nous allons deviner.
Donc, à l'origine, nous allons deviner et puis vérifiez s'il
s'agit de l'algorithme, vérifiez s'il se situe dans une certaine plage.
Et si c'est le cas, alors nous allons pour définir notre estimation à quelque chose et le diviser
par deux et c'est parti être la supposition que nous revenons.
Donc tout en bas, nous dirait revenir deviner.
Et donc nous utilisons le fonction de valeur absolue.
Il est défini en dessous de nous, mais nous avons notre déclaration en
haut, donc c'est bien.
Une chose ici est que nous avons plusieurs déclarations de retour.
C'est parfaitement légal, mais cela devrait être évité car il est plus difficile
de comprendre ce qui se passe.
Donc ce que je ferais ici, c'est que je le ferais stocker probablement ce négatif dans une
variable autre que suppose, mais voyons ici comment nous pouvons faire cela.
Alors ce que je ferais c'est deviner est initialisé à 1. 0, et nous retournons
un négatif.
Je créerais probablement juste un autre variable appelée valeur de retour flottante.
Nous pouvons définir ceci à 0. 0.
Et puis avant de le renvoyer ici parce
que cela saute hors de la fonction mathématique, je peux juste dire que la valeur de retour est
égale à moins 1. 0 au lieu d'avoir le retour.
Ensuite, je peux vérifier et je peux dire si la valeur de retour n'est pas égale à
un 1 négatif. 0 parce que je ne le
fais pas je veux l'exécuter si j'ai déjà mon numéro invalide, nombre non valide, et je pourrais envelopper cela dans une
instruction if.
Et puis à l'intérieur de la déclaration while, Je peux dire que la valeur de retour est égale à deviner.
De cette façon, je retourne le bon chose si c'était une entrée valide.
Et puis au lieu de revenir devinez ce que je fais est
de renvoyer la valeur de retour.
Et ce code est un peu plus propre car
il ne revient qu'une fois en bas et c'est plus facile à suivre.
Donc, la valeur de retour est soit négative un si c'est un argument invalide ou ça
va être le carré réel root si ce n'est pas un argument invalide.
Et nous pourrions même faire c'est simple en ne vérifiant même pas la
valeur de retour ici serait probablement plus facile de
dire autre chose et de rendre le sinon une partie de l'original si.
Donc, si c'est un nombre positif serait même le rendre plus propre de cette façon,
vous n'avez pas cette déclaration if.
Maintenant, nous devons le tester.
Allons-y et testons ceci.
Nous allons simplement appeler le fonctionner plusieurs fois.
Nous dirons tester la racine carrée.
Je ne vais pas en faire impression de fantaisie ici.
Je vais juste m'assurer que je peut ajouter un tas de sauts de ligne pour
qu'il soit plus facile à lire.
Appuyez sur le bouton d'insertion là-bas.
Très bien. Alors maintenant, je vais juste faire un tas
de printfs où j'enverrai des données valables et valables et des données invalides et je le formaterai de la même manière.
Disons simplement le premier appel sera la racine carrée de ce qui est de bonnes
racines carrées valides.
Eh bien, nous allons d'abord vérifier avec un nombre négatif.
Donc nous allons juste dire négatif 3 qui devrait imprimer une erreur.
Sinon, nous allons le tester avec quelques nombres valides.
Nous allons donc dire la racine carrée de 16, et nous passerons juste un int, ils seront convertis,
je pourrais avoir des avertissements.
Eh bien, je ne veux pas en avoir avertissements, et nous ferons 165.
Maintenant, exécutons ceci et testons-le.
Espérons qu'il se compilera.
J'ai une faute d'orthographe avec float.
Maintenant, quand je l'exécute, j'espère nous obtiendrons une bonne sortie de racine carrée.
Nous en avons donc ici un négatif.
Et nous avons en fait imprimé un négatif scores d'argument, donc c'est bien.
Et puis les autres sont, je croyez, les racines carrées correctes.
Donc, il ressemble à la la fonction fonctionne plutôt bien.
Nous avons fait racine carrée de 16 qui est 4, 25 qui est 5, 9 qui est
3, 165 est 12. 85.
J'ai donc fait une erreur de calcul là-bas.
J'essayais de penser à 15 fois 15, soit 225.
Donc, si je mets 225 ici, ce serait revient à 15 en tant que racine carrée.
Je vais fournir ce code source pour
vous afin que vous puissiez l'analyser, mais comprendre les déclarations de fonctions,
comprendre comment définir une fonction avec le type de retour
et le paramètres transmettant des données, comprendre les variables locales, comprendre comment pour revenir une seule fois en bas.
L'algorithme lui-même n'est pas si important.
J'espère que cela a aidé. Merci.