Conditions, boucles et fonctions

Ce que tu vas apprendre

• Choisir entre plusieurs chemins avec if et switch.
• Répéter des instructions avec for et while.
• Écrire et appeler tes propres fonctions.

if et else

Une condition est une expression qui vaut vrai ou faux. L'instruction if exécute un bloc seulement si elle est vraie :

int duree{45};

if (duree <= 30) {
    std::cout << "Recette rapide\n";
} else if (duree <= 60) {
    std::cout << "Recette moyenne\n";
} else {
    std::cout << "Recette longue\n";
}

Les comparaisons sont ==, !=, <, <=, > et >=. On combine les conditions avec && (et), || (ou) et ! (non).

switch

Quand on compare une même valeur entière à plusieurs cas, switch est plus lisible :

char choix{'v'};

switch (choix) {
    case 'v':
        std::cout << "Végétarien\n";
        break;
    case 'p':
        std::cout << "Poisson\n";
        break;
    default:
        std::cout << "Autre\n";
}

Chaque case doit finir par break. Sans lui, l'exécution continue dans le cas suivant.

La boucle for

Une boucle répète un bloc. Le for classique regroupe trois éléments : départ, condition, pas.

for (int i = 1; i <= 3; ++i) {
    std::cout << "Étape " << i << "\n";
}

++i ajoute 1 à i. La boucle s'arrête quand la condition i <= 3 devient fausse.

while et do while

while répète tant que la condition est vraie. Utilise-le quand tu ne sais pas à l'avance combien de tours il faut :

int saisie{};
while (saisie <= 0) {
    std::cout << "Nombre de personnes (positif) : ";
    std::cin >> saisie;
}

do { ... } while (condition); exécute le bloc au moins une fois avant de tester.

Le for sur une collection

Depuis C++11, on parcourt directement les éléments d'un conteneur, sans compteur. C'est le range-for :

#include <vector>

std::vector<int> temps{10, 25, 40};
for (int t : temps) {
    std::cout << t << " min\n";
}

On détaille std::vector au cours 03. Retiens la forme for (type element : collection).

Écrire une fonction

Une fonction est un bloc de code nommé, réutilisable. Elle déclare le type de sa valeur de retour, son nom et ses paramètres :

int tempsTotal(int preparation, int cuisson) {
    return preparation + cuisson;
}

int main() {
    std::cout << tempsTotal(15, 30) << " min\n";
}

Les valeurs passées à l'appel sont les arguments. return renvoie le résultat à l'appelant et quitte la fonction.

Une fonction qui ne renvoie rien a pour type de retour void :

void afficherTitre() {
    std::cout << "=== Recettes ===\n";
}

Déclarer avant d'utiliser

Le compilateur lit le fichier de haut en bas. Une fonction doit donc être connue avant son appel. Soit tu la définis au-dessus de main, soit tu écris son prototype (sa signature suivie d'un point-virgule) :

int tempsTotal(int preparation, int cuisson);  // prototype

int main() {
    std::cout << tempsTotal(15, 30) << "\n";
}

int tempsTotal(int preparation, int cuisson) {
    return preparation + cuisson;
}

Valeurs par défaut et surcharge

Un paramètre peut avoir une valeur par défaut, placée en fin de liste :

double prixPortion(double total, int portions = 4) {
    return total / portions;
}

Appeler prixPortion(12.0) utilise 4 portions. Appeler prixPortion(12.0, 6) en utilise 6.

C++ autorise aussi la surcharge : plusieurs fonctions de même nom, avec des paramètres différents. Le compilateur choisit selon les arguments.

void afficher(int n)    { std::cout << "entier " << n << "\n"; }
void afficher(double x) { std::cout << "réel " << x << "\n"; }

À retenir

• if, else if, else choisissent un chemin ; switch convient aux cas multiples d'une valeur entière.
• Attention à = (affectation) et == (comparaison).
• for répète un nombre connu de fois, while tant qu'une condition tient.
• Le range-for for (int x : collection) parcourt une collection sans compteur.
• Une fonction a un type de retour, un nom et des paramètres ; elle doit être déclarée avant son appel.
• Valeurs par défaut et surcharge évitent de multiplier les noms.