if (Fonctions C++ == danger) {

Une fonction est un sous-programme qui effectue une certaine tâche. Elle peut être paramétrée. Une fonction peut appeler d'autres fonctions (autant de fois que nécessaire) et même s'appeler, on parle alors de fonction recursive.

.....

Déclaration d'une fonction: La déclaration d'une fonction indique le type de retour, le nom ainsi que le type de chaque paramètre de la fonction.

Exemple 1:

float calculTempsTrajet(float vitesse, float distance);

.....

Définition d'une fonction: La définition d'une fonction est l'implémentation, le corps de la fonction.

Exemple 2:

float calculTempsTrajet(float vitesse, float distance) {
	return vitesse/distance;
}

.....

Appel à une fonction: L'appel à une fonction se fait simplement en écrivant le nom de la fonction. Les paramètres (si la fonction en possède) doivent être fournis lors de l'appel. Attention, il faut avoir déclaré ou définit la fonction avant de l'appeler.

Exemple 3:

float calculTempsTrajet(float vitesse, float distance) {
	return vitesse/distance;
}

int main() {
	float duree;
	duree = calculTempsTrajet(120.30, 255.78);
}

Dans l'exemple ci-dessus, nous appelons la fonction calculTempsTrajet avec les deux paramètres 120.3 et 255.78. Ces deux paramètres étant de type float, cela fonctionne correctement.
Nous aurions très bien pu créer deux variables (ou une seule) de type float et appeler la fonction calculTempsTrajet en lui passant ces deux variables:

Exemple 4:

float calculTempsTrajet(float vitesse, float distance) {
	return vitesse/distance;
}

int main() {
	float duree, v = 115.12, d = 362.1;
	duree = calculTempsTrajet(v, d);
}

A partir du moment où les deux paramètres passés lors de l'appel (on appelle ces paramètres les paramètres effectifs) sont de type float, il n'y aura pas de problème (du moins à la compilation. Est-ce que le résultat de la fonction sera celui espéré ? Ça, c'est une autre histoire).

.....

Les paramètres formels: Les paramètres formels d'une fonction sont les paramètres déclarés au moment de la déclaration/définition de la fonction. Dans l'exemple 1, les paramètres vitesse et distance sont des paramètres formels.

.....

Les paramètres effectifs: Les paramètres effectifs d'une fonction sont les paramètres passés à la fonction lors de l'appel à celle-ci. Dans l'exemple 4, les paramètres v et d sont des paramètres effectifs. "Effectif" car, en fonction de leur valeur, ils ont un effet sur le résultat de la fonction.

.....

Que se passe t-il, au niveau des paramètres, quand une fonction est appelée ? Il y a recopie des paramètres effectifs vers les paramètres formels.
Dans l'exemple 4, la paramètre v vaut 115.12 et le paramètre d vaut 362.1. Quand la fonction calculTempsTrajet est appelée (à la ligne 2 de la fonction main), elle est exécutée avec le paramètre vitesse prenant la valeur de v (c'est à dire 115.12) et le paramètre distance prenant la valeur de d (c'est à dire 362.1).
Cette recopie des paramètres implique que les paramètres effectifs ne sont pas accessibles à l'intérieur de la fonction appelée. Par conséquent, si une fonction modifie la valeur d'un paramètre, elle ne modifie que les paramètres formels et non les paramètres effectifs !

.....

À ce stade (en plus des cours que vous avez suivis), vous en savez assez pour faire les exercices ci-dessous. Essayez autant que possible de ne pas regarder les corrigés;s de ces exercices.

Exercice 1

Écrire la fonction ajouterDeux qui ajoute 2 à un entier passé en paramètre et retourne le résultat.

Cliquer pour voir le corrigé

int ajouterDeux(int nombre) {
	return nombre+2;
}

C'était pas compliqué, je vous l'accorde! On aurait pu écrire différemment cette fonction. En fait, il y a une infinité de façons d'écrire une fonction. En voici une autre:

int ajouterDeux(int nombre) {
	int resultat;
	resultat = nombre + 2;
	return resultat;
}

Écrire la fonction ajouterX qui ajoute à un entier passé en paramètre un autre entier également passé en paramètre et retourne le résultat.

Cliquer pour voir le corrigé

int ajouterX(int nombre, int ajout) {
	return nombre+ajout;
}

Alors ?! Même si l'énoncé paraissait plus compliqué, vous voyez qu'il n'en est rien du code de la fonction! Vous voulez voir une autre façon de coder cette fonction ? Ci-dessous:

int ajouterX(int nombre, int ajout) {
	int resultat;
	resultat = nombre + ajout;
	return resultat;
}

Bon, maintenant que nous avons écrit nos fonctions, nous pouvons passer à notre programme principal: la fonction main. Voici ce que je souhaite:

L'utilisateur saisit un nombre (entier).
À ce nombre, je lui ajoute successivement les nombres 1 puis 2 puis 3, ... jusqu'à 100. Bien évidemment, pour ajouter un nombre, vous passerez par l'appel à la fonction ajouterX (on ne l'a pas écrite pour rien !!!).
Pour finir, vous afficherez le résultat final de toutes ces additions.

Cliquer pour voir le corrigé

int main() {
	int n, resultat;
	cout << "Saisir un nombre : ";
	cin >> n;
	resultat = n;
	for(int i=1; i<101; i++) {
		resultat = ajouterX(resultat, i);
	}
	cout << "Le resultat final est " << resultat << endl;
	return 0;
}

Comme je l'ai dit plus haut, il n'y a pas qu'une seule solution pour coder une fonction. Par contre, si vous n'êtes pas passé par une boucle for ou while (à la limite), c'est que votre programme n'est pas optimisé et n'est pas évolutif. Dans ce cas là, il peut être considéré comme incorrect.

Écrire la fonction multiplierPar qui multiplie un entier passé en paramètre par un autre entier également passé en paramètre et retourne le résultat.

Cliquer pour voir le corrigé

int multiplierPar(int nombre, int fois) {
	return nombre*fois;
}

Pas de commentaires...

Ré-écrire cette fonction multiplierPar à la différence, avec la fonction précédente, que cette fonction devra appeler la fonction ajouterX pour effectuer la multiplication.
À vous de jouer !

Cliquer pour voir le corrigé

int multiplierPar(int nombre, int fois) {
	int resultat=0;
	for(int i=1; i<=fois; i++) {
		resultat = ajouterX(resultat, nombre);
	}
	return resultat;
}

Là encore, il faut passer par une boucle for. En effet, la multiplication est une addition répétée n fois.
N'oubliez pas que dès que vous devez effectuer une (ou plusieurs) tâche un nombre connu de fois, vous devez avoir le réflexe d'utiliser une boucle for. Dans les autres cas, on passera par une boucle while.

.....

Toujours là ? Allez, on continue !

Exercice 2

Soit la fonction

void repeter(float nombre, int fois) {
	for(int i=1; i<=fois; i++) {
		cout << nombre << " ";
	}
}

Trouver le résultat des programmes suivants:

int main() {
	repeter(1, 1);
	return 0;
}

Cliquer pour voir le corrigé

1
Process returned 0 (0x0)   execution time : 0.010 s
Press any key to continue.

le nombre 1 est affiché 1 fois !

int main() {
	repeter(5, 10);
	return 0;
}

Cliquer pour voir le corrigé

5 5 5 5 5 5 5 5 5 5
Process returned 0 (0x0)   execution time : 0.012 s
Press any key to continue.

le nombre 5 est affiché 10 fois !

int main() {
	repeter(0, 10);
	return 0;
}

Cliquer pour voir le corrigé

0 0 0 0 0 0 0 0 0 0
Process returned 0 (0x0)   execution time : 0.008 s
Press any key to continue.

le nombre 0 est affiché 10 fois !

int main() {
	repeter(10, 0);
	return 0;
}

Cliquer pour voir le corrigé

Process returned 0 (0x0)   execution time : 0.04 s
Press any key to continue.

Rien n'est affiché ! Vous l'aviez deviné ?

int main() {
	repeter(5, -3);
	return 0;
}

Cliquer pour voir le corrigé

Process returned 0 (0x0)   execution time : 0.015 s
Press any key to continue.

Rien n'est affiché ! Vous l'aviez deviné ?

.....

On complique ?

Exercice 3

Soit la fonction

void afficher(int nombre) {
	cout  << nombre << " ";
	nombre--;
	if(nombre > 0) {
		afficher(nombre);
	}
}

Trouver le résultat des programmes suivants:

int main() {
	afficher(20);
	return 0;
}

Cliquer pour voir le corrigé

20 19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1
Process returned 0 (0x0)   execution time : 0.010 s
Press any key to continue.

Les nombres entiers allant de 20 à 1 sont affichés dans l'ordre décroissant.

```
int main() {
	afficher(1);
	return 0;
}
```

Cliquer pour voir le corrigé

1
Process returned 0 (0x0)   execution time : 0.008 s
Press any key to continue.

Le nombre 1 seulement est affiché.

```
int main() {
	afficher(0);
	return 0;
}
```

Cliquer pour voir le corrigé

0
Process returned 0 (0x0)   execution time : 0.017 s
Press any key to continue.

Le nombre 0 est affiché !!!

int main() {
	afficher(-5);
	return 0;
}

Cliquer pour voir le corrigé

-5
Process returned 0 (0x0)   execution time : 0.016 s
Press any key to continue.

Le nombre -5 est affiché !!! C'est tout...

En voilà assez! Si vous avez répondu brillamment à toutes les questions alors vous pouvez passer au chapitre concernant le différentes façons de passer des paramétres à une fonction.

Si vous avez des questions, vous pouvez me les envoyer par mail en cliquant ici. Merci de m'indiquer vos noms et prénoms.

} else {

return nextChapter;