Code Null
Publié le
2021-11-16

Mis à jour le
2021-11-23

Ma Fonction

fgdsgsd

Il est possible d'écrire notre propre fonction.

À quoi sert une fonction?
Une fonction est un conteneur qui exécute des instructions, ça vous permettra d’effectuer une tâche sans avoir à faire un copier/coller à chaque fois.



Nous avons vu, comment on écrit une fonction qui retourne une valeur avec la fonction "main".
int Main()
{
 return 0;
}
Celle que vous allez définir s'écrit de la même façon que la "main", il suffit juste de changer l'identifiant.
int CalculeDeFacture()
{
return 0;
}
Un bon identifiant doit bien décrire la tâche que vous allez réaliser. Si un identifiant n’est pas clair à sa lecture, il devra être changé, parce qu'après quelques jours, vous allez vous demandez à quoi il peut bien servir.
Il ne faut pas mettre de chiffre au début d'un identifiant.
Il est possible de donner le même nom à plusieurs fonctions. Il faudra avoir un identifiant qui comporte un caractère différent, une lettre minuscule ou majuscule "a, A", un underscore "_" ou encore un chiffre "1, 2".
Chaque fonction qui porte le même nom mais qui comporte un caractère différent, permet la création d'une nouvelle fonction.
int calcule_de_facture() //exemple 1
{
return 0;
}

int Calcule_de_facture() //exemple 2
{
return 0;
}

int CalculeDeFacture() //exemple 3
{
return 0;
}

int CALCULE_DE_FACTURE() //exemple 4
{
return 0;
}

int CALCULE_DE_FACTURE_2() //exemple 5
{
return 0;
}
Un type qui est au début d'une fonction peut être remplacé, car il existe un type qui ne contient pas de valeur de retour.
Pour cette fonction, on utilise le "void" qui crée une fonction de base.
void CalculeDeFacture()
{...}
Nous avons vu à quoi sert l'instruction "return" dans une fonction qui retourne une valeur.
Mais, pour une fonction qui ne prend pas de valeur, on peut écrire seulement "return", qui fera quitter la fonction.


Une fois la fonction quittée, les instructions inscrits après le "return" seront ignorées et le programme continuera l'exécution.
void CalculeDeFacture()
{
return; //quitter la fonction.
}
Le "return" n'est pas obligatoire pour cette fonction, qu'on vient de voir. Il est conçu pour quitter, si vous voulez interrompe son exécution.
Maintenant, que nous savons comment définir une fonction, il faudrait voir comment faire son appel.
À quoi ça sert de faire son appel?
Faire un appel est pour exécuter les instructions contenues dans la fonction. Après, la fonction va être quittée pour continuer l'exécution.


Pour faire son appel, on se place entre les accolades et on écrit l'identifiant de la fonction avec les parenthèses.
N'oubliez pas le point-virgule à la fin de chaque instruction qui se trouve entre les accolades.
void CalculeDeFacture()
{...}

int Main()
{
CalculeDeFacture(); //Appel de fonction.
return 0;
}
Il sera possible de faire son appel autant de fois que vous allez en avoir besoin.
Comment faire un appel si ma fonction est défini après la "main"?
D'abord, une fonction doit être lue pour que votre ordinateur puisse faire sa création.
Si votre fonction est plus loin dans votre programme, il faut informer votre ordinateur qu'une définition de votre fonction existe.
Après, il sera possible de faire son appel.
void Main()
{
return 0;
}

int CalculeDeFacture() //définition
{
/*
Le corps de la fonction est le contenues qui ce trouve entre les parenthèses.
*/
}
Pour que vous comprenez comment on fait, il est important de faire la différence entre une déclaration et une définition:
Une fonction qui ne comprend pas de corps est appelé une déclaration. Elle informe votre ordinateur qu'une fonction existe plus loin dans ton programme.
void CalculeDeFacture(); //déclaration ou prototype.

Mais, la définition est l'écriture complète d'une fonction avec son corps. Les accolades sont le corps de la fonction qui contient les instructions.
void CalculeDeFacture() //définition
{
//corps de la fonction.
}
En conclusion: une fonction qui ne comprend pas de contenu (aucun corps) est appelé une déclaration.
Mais, une fonction qui contient un contenu (avec son corps) est appelé une définition.
void CalculeDeFacture(); //déclaration ou prototype.

void CalculeDeFacture() //définition
{
//corps de la fonction
}
La déclaration d'une fonction est aussi appelée un prototype.
Alors pour faire l'appel d'une fonction qui est plus loin dans votre programme, vous devez faire sa déclaration: on la place au-dessus de la "main" où vous voulez faire son appel.
Après, on écrit le type avec l'identifiant et les parenthèses: vu que cette fonction ne comprend pas de corps, on lui met un point-virgule.

Une fois que vous avez fait sa déclaration, vous avez informé votre ordinateur qu'il existe une définition de cette fonction plus loin dans le programme. C'est aussi simple que ça!
void CalculeDeFacture(); //déclaration ou prototype.

int Main()
{
CalculeDeFacture(); //appel de fonction.
return 0;
}

void CalculeDeFacture()//définition de la fonction.
{...}
Une dernière chose à savoir est la différence entre locale et globale, parce que dans les prochaines parties du cours, ce terme sera souvent utilisé.😁 
Toutes les instructions qui se trouvent entre les accolades "{...}" sont locales, mais une déclaration ou une définition de votre fonction est toujours globales.
void CalculeDeFacture() //Définition d'une fonction(globale).
{
//Instruction(locale).
}

int Main() //Définition de la fonction principale(globale).
{
CalculeDeFacture(); //appel de fonction(locale).
return 0; //valeur de retour(locale).
}
Cette partie sur les fonctions est terminée pour le moment, mais il nous reste encore beaucoup de matière à explorer.
Courage! Avec de la pratique, vous allez mieux comprendre le fonctionnement de ce langage.😉

Allons voir la partie sur les variables. Ensuite, je vais vous expliquer à quoi sert les parenthèses d'une fonction.