BAC PRO CIEL

1. Organisation d'un programme C++

Un programme est constitué d'instructions exécutées dans un ordre déterminé.

int compteur = 0;
compteur = compteur + 1;

Les instructions

Une instruction se termine par un point-virgule.

int temperature = 20;
temperature = temperature + 5;

Les blocs d'instructions

Les accolades { et } regroupent plusieurs instructions dans un même bloc.

if (temperature > 25)
{
    etatVentilateur = true;
    compteur = compteur + 1;
}

L'indentation n'est pas obligatoire pour le compilateur, mais elle rend le programme beaucoup plus lisible.

Les commentaires

Les commentaires permettent d'expliquer le programme. Ils ne sont pas exécutés.

// Déclaration de la température
int temperature = 20;

/*
  Ce programme analyse
  la température du système.
*/

2. Les variables et les constantes

Une variable

Une variable est une zone de mémoire possédant :

• un nom ;
• un type ;
• une valeur qui peut évoluer.

int compteur = 0;

La valeur peut ensuite être modifiée :

compteur = 5;
compteur = compteur + 1;

Une constante

Une constante possède une valeur qui ne doit pas changer pendant l'exécution du programme.

const byte LED_VERTE = 8;
const int SEUIL_TEMPERATURE = 30;

3. Les principaux types de données

Le type indique la nature de l'information stockée.

Les valeurs booléennes

Une variable de type bool ne peut prendre que deux valeurs :

true
false

bool systemeActif = false;
systemeActif = true;

4. L'affectation et les calculs

L'opérateur d'affectation

Le signe = place une valeur dans une variable.

temperature = 25;

La variable temperature reçoit la valeur 25. Ce n'est pas une égalité mathématique.

compteur = compteur + 1;

Cette instruction signifie :

1. lire la valeur de compteur ;
2. ajouter 1 ;
3. enregistrer le résultat dans compteur.

L'instruction peut être raccourcie :

compteur++;

Les opérateurs de calcul

int valeur = 17;
int reste = valeur % 2;

5. Les opérateurs de comparaison

Une comparaison produit une valeur booléenne : true ou false.

temperature > 30

Cette expression vaut :

• true si la température est supérieure à 30 ;
• false dans le cas contraire.

temperature = 30;

temperature == 30

6. Les opérateurs logiques

Les opérateurs logiques permettent d'associer plusieurs conditions.

Opérateur ET

Les deux conditions doivent être vraies.

if (temperature > 20 && temperature < 30)
{
    etat = 1;
}

Opérateur OU

Au moins une condition doit être vraie.

if (mode == 1 || mode == 2)
{
    autorisation = true;
}

Opérateur NON

L'opérateur ! inverse une valeur booléenne.

bool actif = true;
actif = !actif;

etatLed = !etatLed;

7. Les conditions

La structure if

La structure if exécute un bloc seulement si une condition est vraie.

if (temperature > 30)
{
    alarme = true;
}

Si la condition est fausse, le bloc est ignoré.

La structure if...else

if (temperature > 30)
{
    alarme = true;
}
else
{
    alarme = false;
}

Un seul des deux blocs est exécuté.

La structure if...else if...else

Elle permet de choisir entre plusieurs situations.

if (temperature < 15)
{
    etat = 0;
}
else if (temperature < 25)
{
    etat = 1;
}
else
{
    etat = 2;
}

Le programme teste les conditions dans l'ordre. Pour une température de 10 :

• temperature < 15 est vraie ;
• le premier bloc est exécuté ;
• les autres conditions ne sont pas testées.

8. La structure switch...case

La structure switch...case permet d'exécuter des instructions différentes selon la valeur d'une variable.

switch (mode)
{
    case 0:
        etat = 10;
        break;

    case 1:
        etat = 20;
        break;

    case 2:
        etat = 30;
        break;

    default:
        etat = 0;
        break;
}

9. Les boucles

Une boucle permet de répéter plusieurs fois un bloc d'instructions.

La boucle while

while (compteur < 5)
{
    compteur++;
}

Le bloc est répété tant que la condition est vraie.

Risque de boucle infinie

while (compteur < 5)
{
    etat = true;
}

La boucle for

La boucle for est utilisée lorsque le nombre de répétitions est connu.

for (int i = 0; i < 4; i++)
{
    compteur++;
}

10. Les fonctions

Une fonction regroupe plusieurs instructions sous un même nom.

Elle permet :

• d'éviter de répéter du code ;
• de rendre le programme plus lisible ;
• de décomposer un programme complexe ;
• de réutiliser un même traitement.

Fonction sans argument et sans retour

void initialiserCompteur()
{
    compteur = 0;
}

Appel de la fonction :

initialiserCompteur();

Le mot void signifie que la fonction ne renvoie aucune valeur.

Fonction avec argument et sans retour

void modifierCompteur(int nouvelleValeur)
{
    compteur = nouvelleValeur;
}

Appel de la fonction :

modifierCompteur(5);

La valeur 5 est transmise à l'argument nouvelleValeur.

Fonction sans argument et avec retour

int obtenirCompteur()
{
    return compteur;
}

Appel de la fonction :

int valeur = obtenirCompteur();

La fonction renvoie un entier grâce à l'instruction return.

Fonction avec arguments et avec retour

int additionner(int valeur1, int valeur2)
{
    int resultat = valeur1 + valeur2;
    return resultat;
}

Appel de la fonction :

int somme = additionner(4, 3);

Déroulement :

1. valeur1 reçoit 4 ;
2. valeur2 reçoit 3 ;
3. la fonction calcule 7 ;
4. elle renvoie le résultat ;
5. la variable somme reçoit 7.

11. Portée des variables

Variable globale

Une variable déclarée en dehors des fonctions est une variable globale.

int compteur = 0;

void fonction1()
{
    compteur++;
}

void fonction2()
{
    compteur = 10;
}

Elle peut être utilisée par toutes les fonctions du programme.

Variable locale

Une variable déclarée dans une fonction ou dans un bloc est une variable locale.

void calculer()
{
    int resultat = 5;
}

La variable resultat n'existe que dans la fonction calculer().

void fonction1()
{
    int valeur = 10;
}

void fonction2()
{
    valeur = 20; // Erreur : valeur n'existe pas ici
}

12. Les erreurs fréquentes

Oubli du point-virgule

int compteur = 0 // Erreur

Correction :

int compteur = 0;

Confusion entre affectation et comparaison

if (compteur = 5) // Incorrect dans ce contexte

Correction :

if (compteur == 5)

Accolade manquante

if (compteur > 2)
{
    compteur = 0;
// Il manque l'accolade de fermeture

Majuscules et minuscules

Le langage C++ est sensible à la casse :

compteur
Compteur
COMPTEUR

Ces trois noms sont différents.

Variable non initialisée

À éviter :

int compteur;

Il est préférable de donner immédiatement une valeur :

int compteur = 0;