Notions fondamentales en développement informatique : - Variables, et constantes, - Conversion des types de variables, - Expressions et - Instructions. Opérateurs arithmétiques Opérateurs d’incrémentation et de décrémentation Opérateurs d’affectation Voir comment demander des informations à l'utilisateur et comment les stocker dans la mémoire : - Lecture depuis la console - Afficher la valeur d'une variable Découvrir la directive cmath.h

1. Introduction au langage C++
Chapitre 2
Variables, Expressions et Instructions
Youssouf EL ALLIOUI, youssouf.elallioui@uhp.ac.ma
Université Hassan Premier de Settat
Ce cours est disponible en format électronique sur http://fr.slideshare.net/yelallioui/
Objectif de ce chapitre
 Notions fondamentales en développement informatique :
 Variables, et constantes,
 Conversion des types de variables,
 Expressions et
 Instructions.
 Opérateurs arithmétiques
 Opérateurs d’incrémentation et de décrémentation
 Opérateurs d’affectation
 Voir comment demander des informations à l'utilisateur et comment les stocker
dans la mémoire :
 Lecture depuis la console
 Afficher la valeur d'une variable
 Découvrir la directive cmath.h
Entraînez-vous via
 Exercices applicatifs
 QCM fourni à la fin de la séance
 Les TPs
2016

2. 1 | 16
1 Introduction au langage C++ | Chapitre 2 : Variables, Expressions et Instructions
Sommaire
I. Variables__________________________________________________________2
II. Constantes ________________________________________________________5
III. Références ______________________________________________________6
IV. Expressions______________________________________________________7
V. Instructions_______________________________________________________14
VI. L'en-tête cmath _________________________________________________14
VII. Ce que vous devez retenir ! ________________________________________16
Références
Cours de C/C++ [Ouvrage] / aut. Casteyde Christian. - 2001. - Vol. Version 1.40.1 : p.
501.
Programmez avec le langage C++ [Ouvrage] / aut. Mathieu Nebra et Matthieu
Schaller. - [s.l.] : le Livre du Zéro, 2015.

3. 2 | 16
2 Introduction au langage C++ | Chapitre 2 : Variables, Expressions et Instructions
I. Variables
I. 1. Qu’est-ce qu’une variable ?
J'imagine que vous avez tous déjà utilisé une calculatrice sur laquelle vous trouvez les
touches M+, M-, MC, etc. qui vous permettent de stocker dans la mémoire de la calculatrice
le résultat intermédiaire d'un calcul et de reprendre ce nombre plus tard.
Le principe de base est le même sur votre ordinateur. Il possède aussi des composants
électroniques qui sont capables de contenir une valeur et de la conserver pendant un
certain temps. Nous n'avons absolument pas besoin de comprendre comment cela marche.
La seule et unique chose que vous ayez besoin de savoir, c'est qu'une variable est une
partie de la mémoire que l'ordinateur nous prête pour y mettre des valeurs pour pouvoir
les réutiliser plus tard.
I. 2. Terminologie
Une variable est caractérisée par :
- Son nom : mot composé de lettres ou chiffres, commençant par une lettre (le
caractère « - » tient lieu de lettre),
- Son type : précisant la nature de cette variable (nombre entier, caractère, objet
etc.),
- Sa valeur : qui peut être modifiée à tout instant.
8
Mémoire
Figure 1 : Exemple de la définition des trois caractéristiques d'une variable
I. 3. Noms de variables
En C++, il y a quelques règles qui régissent les différents noms autorisés ou interdits :
- Les noms de variables sont constitués de lettres, de chiffres et du tiret-bas « _ »
uniquement ;
- Le premier caractère doit être une lettre (majuscule ou minuscule) ;
- On ne peut pas utiliser d'accents ;
- On ne peut pas utiliser d'espaces dans le nom.
Exemple : noms valides & noms invalides
Les noms ageBebe, nom_du_Bebe ou encore NOMBRE_DE_BEBES sont tous des noms
valides. ageBébé et _nom_du_Bebe, en revanche, ne le sont pas.
Valeur
(8)Type
(Entier)
Nom
(ageUtilisateur)

4. 3 | 16
3 Introduction au langage C++ | Chapitre 2 : Variables, Expressions et Instructions
I. 4. Types de base
Après l’identification du nom de la variable, L'ordinateur doit connaitre ce qu'il a dans
cette variable, il faut donc indiquer quel type (nombre, mot, lettre, ou …) d'élément va
contenir la variable que nous aimerions utiliser.
Voici donc la liste des types de variables que l'on peut utiliser en C++ (Tableau 1) :
Nom du type Ce qu'il peut contenir
bool Une valeur parmi deux possibles, vrai (true) ou faux (false).
char Un caractère.
int Un nombre entier.
unsigned int Un nombre entier positif ou nul.
double Un nombre à virgule.
string Une chaîne de caractères, c'est-à-dire un mot ou une phrase.
Tableau 1 : Types de variables en langage C++
Il existe également d'autres types avec d'autres limites mais ils sont utilisés plus
rarement (Tableau 2). A titre d’exemple, il y a des nombres qui sont trop grands pour
un int. Cela ne devrait donc pas vous poser de problème, sachez tout simplement que ces
limites sont bien assez grandes pour la plupart des utilisations courantes.
Type de donnée Signification Taille (en octets) Plage de valeurs acceptée
char Caractère 1 -128 à 127
unsigned char
Caractère non
signé
1 0 à 255
short int Entier court 2 -32 768 à 32 767
unsigned short int
Entier court non
signé
2 0 à 65 535
int
Entier 2 (sur processeur 16 bits)
4 (sur processeur 32 bits)
-32 768 à 32 767
-2 147 483 648 à 2 147 483 647
unsigned int
Entier non signé 2 (sur processeur 16 bits)
4 (sur processeur 32 bits)
0 à 65 535
0 à 4 294 967 295
long int Entier long 4 -2 147 483 648 à 2 147 483 647
unsigned long int
Entier long non
signé
4 0 à 4 294 967 295
float Flottant (réel) 4 -3.4*10-38
à 3.4*1038
double Flottant double 8 -1.7*10-308
à 1.7*10308
long double
Flottant double
long
10 -3.4*10-4932
à 3.4*104932
bool
Booléen Même taille que le type int,
parfois 1 sur quelques
compilateurs
Prend deux valeurs :
true et false mais une conversion
implicite (valant 0 ou 1) est faite par le
compilateur lorsque l'on affecte un

5. 4 | 16
4 Introduction au langage C++ | Chapitre 2 : Variables, Expressions et Instructions
entier (en réalité toute autre valeur que
0 est considérée comme égale à true).
Tableau 2 : Types de variables en langage C++ (version détaillée)
Le mot unsigned qui précède le nom d’un type entier signifie un entier non signé, c’est à
dire toujours un entier toujours positif (Tableau 1 et Tableau 2).
Le mot bool signifie que la variable ne peut prendre que l’une des deux valeurs, true ou
false. On les utilise par exemple pour stocker des informations indiquant si la lumière
est allumée, si l'utilisateur a le droit d'utiliser une fonctionnalité donnée, ou encore si le
mot de passe est correct. Si vous avez besoin de conserver le résultat d'une question de
ce genre, alors pensez type bool.
I. 5. Déclaration des variables
Avant d’utiliser une variable, il faut indiquer à l'ordinateur le type de la variable que nous
voulons, son nom et enfin sa valeur c.-à-d. les trois caractéristique de la variable (revoir I.
2. Terminologie). En effet, en C++, toute variable doit être déclarée avant d’être utilisée.
Une variable se déclare de la façon suivante (Figure 2) :
type Nom_de_la_variable (valeur) ;
Figure 2 : Syntaxe d'initialisation d'une variable en C++
ou bien utiliser la même syntaxe que dans le langage C (Figure 3).
type Nom_de_la_variable = valeur ;
Figure 3 : Syntaxe d'initialisation d'une variable en C++, héritée de C
Soit l’exemple suivant, dans lequel nous déclarons une variable pour stocker l’âge de
l’utilisateur.
1 #include <iostream>
2 using namespace std;
3 int main()
4 {
5 string nomUtilisateur("Albert Einstein");
6 int ageUtilisateur(16);
7 int nombreAmis(432); //Le nombre d'amis de l'utilisateur
8 double pi(3.14159);
9 bool estMonAmi(true); //Cet utilisateur est-il mon ami ?
10 char lettre('a');
11 return 0;
12 }
Il y a trois choses importantes à remarquer concernant cet exemple :
- les variables de type bool ne peuvent avoir pour valeur que true ou false, c'est
donc une de ces deux valeurs qu'il faut mettre entre les parenthèses.
- pour le type char, il faut mettre la lettre souhaitée entre apostrophes. Il faut
écrire char lettre('a'); et pas char lettre(a);.

6. 5 | 16
5 Introduction au langage C++ | Chapitre 2 : Variables, Expressions et Instructions
- Pour le type string,
o il faut ajouter une petite ligne au début de votre programme pour indiquer
au compilateur que nous souhaitons utiliser des strings. Sans cela, il
n'inclurait pas les outils nécessaires à leur gestion. La ligne à ajouter
est #include <string>.
o Un peu comme pour le char, il faut mettre la chaine de caractères entre
guillemets et non pas entre des apostrophes
Si vous avez plusieurs variables du même type à déclarer, vous pouvez le faire sur une
seule ligne en les séparant par une virgule (,). Voici comment :
5 float x(2.33), y(21.6);// déclare deux réels x, y
6 int a(2),b(4),c(-1); //On déclare trois cases mémoires nommées a, b et c et
qui contiennent respectivement les valeurs 2, 4 et
-1
7 string prenom("Albert"), nom("Einstein"); //On déclare deux cases pouvant
contenir des chaînes de caractères
I. 6. Déclaration sans initialisation
Il arrive parfois que l'on ne sache pas quelle valeur donner à une variable lors de sa
déclaration. C++ nous permet alors d'effectuer uniquement l'allocation de la mémoire sans
l'initialisation de la variable. Pour cela, il suffit d'indiquer le type et le nom de la variable
sans spécifier de valeur (Figure 4).
type Nom_de_la_variable = valeur ;
Figure 4 : Déclaration d'une variable sans initialisation
Un exemple de cela est le suivant :
1 #include <iostream>
2 #include <string>
3 using namespace std;
4 int main()
5 {
6 string nomJoueur;
7 int nombreJoueurs;
8 bool aGagne; //Le joueur a-t-il gagné ?
9 return 0;
10 }
II. Constantes
Contrairement aux variables les constantes ne peuvent pas être initialisées après leur
déclaration et leur valeur ne peut pas être modifiée après initialisation. Elles doivent être
déclarées avec le mot clé const et obligatoirement initialisées dès sa définition.
Voyons donc comment déclarer une telle constante (Figure 5).
const <type> <NomConstante> = <valeur>;
Figure 5 : Syntaxe de la déclaration d'une constante en C++

7. 6 | 16
6 Introduction au langage C++ | Chapitre 2 : Variables, Expressions et Instructions
Cela marche bien sûr avec tous les types de variables. Voici un exemple :
6 //exemple de constante caractère
7 const char c ('A');
8 //exemple de constante entière
9 const int i (2016);
10 //exemple de constante rèel
11 const double PI (3.14);
12 //exemple de constante chaine de caractères
13 string const motDePasse("wAsTZsaswQ");
III. Références
Dans la vie quotidienne, on peut mettre plusieurs étiquettes sur un objet donné. Disant
des synonymes comme c’est le cas pour le mot ordinateur qu’est computer qu’est PC. Vous
dites ordinateur ou computer ou PC ça revient au même objet !
En C++, c'est la même chose, on peut coller plusieurs étiquettes à la même case mémoire
(ou variable). On obtient alors un deuxième moyen d'y accéder. On parle parfois d'alias,
mais le mot correct en C++ est référence.
Pour déclarer une référence sur une variable, on utilise une esperluette (&). Voyons cela
avec un petit exemple.
6 int ageUtilisateur(16); //Déclaration d'une variable.
7 int& maVariable(ageUtilisateur); //Déclaration d'une référence nommée
maVariable qui est accrochée à la
variable ageUtilisateur
On peut schématiser ce code comme suit (Figure 6) :
8
Mémoire
Figure 6 : déclaration d'une référence sur une variable
On dit que maVariablefait référence à ageUtilisateur.
Pratiquement, On peut afficher l'âge de l'utilisateur soit via le nom de la variable soit
via une référence sur cette variable.
1 #include <iostream>
2 using namespace std;
3 int main()
4 {
5 int ageUtilisateur(18); //Une variable pour contenir l'âge de
l'utilisateur
6
7 int& maReference(ageUtilisateur); //Et une référence sur la variable
'ageUtilisateur'
8 //On peut utiliser à partir d'ici
9 //'ageUtilisateur' ou 'maReference' indistinctement
ageUtilisateurmaVariable

8. 7 | 16
7 Introduction au langage C++ | Chapitre 2 : Variables, Expressions et Instructions
10 //Puisque ce sont deux étiquettes de la même case en mémoire
11 cout << "Vous avez " << ageUtilisateur << " ans. (via variable)" <<
endl;
12 //On affiche, de la manière habituelle
13 cout << "Vous avez " << maReference << " ans. (via reference)" << endl;
14 //Et on affiche en utilisant la référence
15 return 0;
16 }
Ce qui donne évidemment le résultat escompté.
Une fois qu'elle a été déclarée, on peut manipuler la référence comme si on manipulait la
variable elle-même. Il n'y a aucune différence entre les deux. Mais à quoi est-ce que cela
peut bien servir ?
Pour l'instant, cela vous paraît très abstrait et inutile ? Il faut juste savoir que c'est un
des éléments importants du C++ qui apparaîtra à de très nombreuses reprises dans ce
cours. Il est donc essentiel de se familiariser avec la notion avant de devoir l'utiliser dans
des cas plus compliqués.
IV. Expressions
II. 1. Définition
En combinant des noms de variables, des opérateurs, des parenthèses et des appels de
fonctions (nous allons voir les fonctions dans le chapitre 4), on obtient des expressions.
Une règle simple à retenir :
En C++, on appelle expression tout ce qui a une valeur
II. 2. Opérateurs arithmétiques
Opération Symbole Exemple
Addition + resultat = a + b; Si a=5 et b=2  resultat = 7
Soustaction - resultat = a - b; Si a=5 et b=2  resultat = 3
Multiplication * resultat = a * b; Si a=5 et b=2  resultat = 10
Division / resultat = a / b; Si a=5 et b=2  resultat = 2.5
Modulo % resultat = a % b; Si a=5 et b=2  resultat = 1

9. 8 | 16
8 Introduction au langage C++ | Chapitre 2 : Variables, Expressions et Instructions
Le Modulo représente le reste de la division entière. Cet opérateur n'existe que pour les
nombres entiers !
Dans les expressions, les règles de priorité sont les règles usuelles des mathématiciens.
Par exemple, l’expression 5 + 3 * 2 a pour valeur 11 et non 16. En cas de doute, il ne faut
pas hésiter à mettre des parenthèses.
1 int a(2), b(4), c(5), d; //Quelques variables
2 d = ((a+b) * c ) - c; //Un calcul compliqué !
II. 3. Opérateurs d’incrémentation et de décrémentation
Opérateur d’incrémentation (++)
En pratique, nous retrouvons souvent des affectations comme : i = i + 1. Pensez par
exemple aux cas suivants :
- Passer du niveau 4 au niveau 5 d’une application de jeu
- Incrémenter le nombre des inscrits ou bien le nombre de téléchargement de notre
application, …
Les créateurs du C++ ont inventé un opérateur d’incrémentation raccourcie pour ajouter
1 à une variable. Il s’agit de l’opérateur ++. Voici comment.
6 //Notre application est téléchargée 100 fois
7 int nombreDeTelechargement(100);
8 ++nombreDeTelechargement;
9 //à partir d'ici, le nombre de téléchargement est 101
Opérateur de décrémentation (--)
La décrémentation est l'opération inverse, soustraire 1 à une variable. Il s’agit donc de
l’opérateur --.
Autres opérateurs
Opérateur Signification Exemple
+= ajouter à a += 2 équivalent à a = a + 2
-= diminuer de a -= 2 équivalent à a = a - 2
*= multiplier par a *= 2 équivalent à a = a * 2
/= diviser par a /= 2 équivalent à a = a / 2
%= modulo a %= 2 équivalent à a = a % 2
II. 4. Opérateurs d’affectation
La forme générale de l’expression d’affectation est la suivante :
variable = expression
Fonctionnement :

10. 9 | 16
9 Introduction au langage C++ | Chapitre 2 : Variables, Expressions et Instructions
1) L’expression est d’abord évaluée ; cette valeur donne la valeur de l’expression
d’affectation
2) Effet de bord : la variable reçoit ensuite cette valeur
1 int unNombre(0); //Je crée une case mémoire nommée 'unNombre' et qui contient
le nombre 0
2
3 unNombre = 5; //Je mets 5 dans la case mémoire 'unNombre'
On peut aussi directement affecter le contenu d'une variable à une autre.
1 int a(4), b(5); //Déclaration de deux variables
2
3 a = b; //Affectation de la valeur de 'b' à 'a'
On peut d'ailleurs afficher le contenu des deux variables pour vérifier.
1 #include <iostream>
2 using namespace std;
3
4 int main()
5 {
6 int a(4), b(5); //Déclaration de deux variables
7
8 cout << "a vaut : " << a << " et b vaut : " << b << endl;
9
10 cout << "Affectation !" << endl;
11 a = b; //Affectation de la valeur de 'b' à 'a'.
12
13 cout << "a vaut : " << a << " et b vaut : " << b << endl;
14
15 return 0;
Le résultat de l’exécution de ce programme est le suivant :
II. 5. Conversion de type
L’expression d’affectation peut provoquer une conversion de type. Par exemple, supposons
la déclaration de deux variables i de type entier et x de type réel :
1 int i;
2 float x;
Alors, si i vaut 3, l’expression x = i donne à x la valeur 3.0 (conversion entier → réel).
Inversement, si x vaut 4.21, l’expression i = x donne à i la valeur 4, partie entière de x
(conversions réel → entier).
Voici un exemple justifiant ce que je viens d’expliquer :

11. 10 | 16
10 Introduction au langage C++ | Chapitre 2 : Variables, Expressions et Instructions
1 #include <iostream>
2 using namespace std;
3 int main()
4 {
5 int i;
6 double x;
7 i = 3;
8 x = i;
9 cout << "conversion entier vers reel :" << endl;
10 cout << "i = " << i << endl;
11 cout << "x = " << x << endl;
12 x = 4.21;
13 i = x;
14 cout << "conversion reel vers entier :" << endl;
15 cout << "x = " << x << endl;
16 cout << "i = " << i << endl;
17 return 0;
18 }
Le résultat obtenu après exécution est le suivant :
On peut également provoquer une conversion de type grâce à l’opérateur () (type casting).
Avec x comme ci-dessus, l’expression (int)x est de type int et sa valeur est la partie
entière de x. Nous allons voir cette astuce en détail dans les TPs.
II. 6. Opérateurs d’entrées-sorties
Ce sont les opérateurs << et >>, utilisés en conjonction avec des objets prédéfinis cout
et cin déclarés dans <iostream.h> (ne pas oublier la directive #include en début de
fichier).
Forme pour afficher la valeur d’une expression :
cout << expression // affichage à l’écran de la valeur de
expression
Forme pour la lecture d’une valeur depuis la console :
cin >> variable //lecture au clavier de la valeur de variable
Voyons ce que cela donne avec ce premier exemple.
1 #include <iostream>
2 using namespace std;

12. 11 | 16
11 Introduction au langage C++ | Chapitre 2 : Variables, Expressions et Instructions
3
4 int main()
5 {
6 cout << "Quel age avez-vous ?" << endl;
7
8 int ageUtilisateur(0); //On prepare une case mémoire pour stocker un
entier
9
10 cin >> ageUtilisateur; //On fait entrer un nombre dans cette case
11
12 cout << "Vous avez " << ageUtilisateur << " ans !" << endl; //Et on
l'affiche
13
14 return 0;
15 }
Si vous testez ce programme. Voici ce que cela donne avec mon âge :
Pour bien comprendre une astuce qui concerne les variables de type string dans ce
contexte, je vous invite à tester le programme suivant pour bien comprendre en détail ce
qui se passe.
1 #include <iostream>
2 #include <string>
3 using namespace std;
4
5 int main()
6 {
7 cout << "Quel est votre prenom ?" << endl;
8 string nomUtilisateur("Sans nom"); //On crée une case mémoire pour
contenir une chaine de caractères
9 cin >> nomUtilisateur; //On remplit cette case avec ce qu'écrit
l'utilisateur
10
11 cout << "Combien vaut pi ?" << endl;
12 double piUtilisateur(-1.); //On crée une case mémoire pour stocker un
nombre réel
13 cin >> piUtilisateur; //Et on remplit cette case avec ce qu'écrit
l'utilisateur
14
15 cout << "Vous vous appelez " << nomUtilisateur << " et vous pensez que
pi vaut " << piUtilisateur << "." << endl;
16
17 return 0;
18 }

13. 12 | 16
12 Introduction au langage C++ | Chapitre 2 : Variables, Expressions et Instructions
Regardons ce que cela donne !
Vous voyez que l'ordinateur n'a rien demandé pour la variable pi et le nom de famille a
disparu !
C'est un problème d'espaces. Quand on appuie sur la touche Entrée, l'ordinateur copie ce
qui a été écrit par l'utilisateur dans la case mémoire. Mais il s'arrête au
premier espace ou retour à la ligne. Quand il s'agit d'un nombre, cela ne pose pas de
problème puisqu'il n'y a pas d'espace dans les nombres.
Pour les string, la question se pose. Il peut très bien y avoir un espace dans une chaîne
de caractères. Et donc l'ordinateur va couper au mauvais endroit, c'est-à-dire après le
premier mot. Et comme il n'est pas très malin, il va croire que le nom de famille correspond
à la valeur de pi !
En fait, il faudrait pouvoir récupérer toute la ligne plutôt que seulement le premier mot.
Et si je vous le propose, c'est qu'il y a une solution pour le faire !
Il faut utiliser la fonction getline(). Nous verrons plus loin ce que sont exactement les
fonctions mais, pour l'instant, voyons comment faire dans ce cas particulier.
Il faut remplacer la ligne cin >> nomUtilisateur; par un getline().
1 #include <iostream>
2 #include <string>
3 using namespace std;
4
5 int main()
6 {
7 cout << "Quel est votre nom ?" << endl;
8 string nomUtilisateur("Sans nom"); //On crée une case mémoire pour
contenir une chaine de caractères
9 getline(cin, nomUtilisateur); //On remplit cette case avec toute la
ligne que l'utilisateur a écrit
10
11 cout << "Combien vaut pi ?" << endl;
12 double piUtilisateur(-1.); //On crée une case mémoire pour stocker un
nombre réel
13 cin >> piUtilisateur; //Et on remplit cette case avec ce qu'écrit
l'utilisateur
14
15 cout << "Vous vous appelez " << nomUtilisateur << " et vous pensez que
pi vaut " << piUtilisateur << "." << endl;

14. 13 | 16
13 Introduction au langage C++ | Chapitre 2 : Variables, Expressions et Instructions
16
17 return 0;
18 }
Cette fois le nom ne sera pas tronqué lors de la lecture.
Mais quand même il reste un petit problème ! Si on utilise d'abord cin
>> puis getline(), par exemple pour demander la valeur de pi avant de demander le nom,
le code ne fonctionne pas. L'ordinateur ne demande pas son nom à l'utilisateur et affiche
n'importe quoi. Vous pouvez essayer ça !
Pour pallier ce problème, il faut ajouter la ligne cin.ignore() après l'utilisation des
chevrons. En effet, Quand on mélange l'utilisation des chevrons et de getline(), il faut
toujours placer l'instruction cin.ignore() après la ligne cin >> a. C'est une règle à
apprendre.
1 #include <iostream>
2 #include <string>
3 using namespace std;
4
5 int main()
6 {
7 cout << "Combien vaut pi ?" << endl;
8 double piUtilisateur(-1.); //On crée une case mémoire pour stocker un
nombre réel
9 cin >> piUtilisateur; //Et on remplit cette case avec ce qu'écrit
l'utilisateur
10
11 cin.ignore();
12
13 cout << "Quel est votre nom ?" << endl;
14 string nomUtilisateur("Sans nom"); //On crée une case mémoire pour
contenir une chaine de caractères
15 getline(cin, nomUtilisateur); //On remplit cette case avec toute la
ligne que l'utilisateur a écrit
16
17 cout << "Vous vous appelez " << nomUtilisateur << " et vous pensez que
pi vaut " << piUtilisateur << "." << endl;
18
19 return 0;
20 }

15. 14 | 16
14 Introduction au langage C++ | Chapitre 2 : Variables, Expressions et Instructions
V. Instructions
Les instructions sont généralement identifiées par le point-virgule. C’est ce caractère qui
marque la fin d’une instruction. Il existe deux types d’instructions, qui permettent de
réaliser des opérations variées. Il y a l’instruction-expression et l’instruction-bloc.
III. 1. Instruction-expression
Elle a en générale la forme suivante :
< expression > ;
Les instructions les plus courantes sont sans doute les instructions qui effectuent des
opérations, c’est-à-dire les instructions qui contiennent des expressions utilisant des
opérateurs d’affectation, arithmétique, ou autres.
III. 2. Instruction-bloc
Ce type d’instruction a la forme suivante :
{
< Déclarations et expressions >
}
Il consiste à regrouper plusieurs expressions dans un seul bloc. Ce bloc d’instructions est
considéré comme une instruction unique. Il est donc inutile de mettre un point-virgule
pour marquer l’instruction, puisque le bloc lui-même est une instruction.
Exemple :
4 {
5 int i;
6 double x;
7 i = 3;
8 x = i / 2;
18 }
VI. L'en-tête cmath
Pour avoir accès à plus de fonctions mathématiques, il suffit d'ajouter une ligne en tête
de votre programme.
1 #include <cmath>
Comme il y a beaucoup de fonctions1
, je vous propose de tout ranger dans un tableau.
Nom de la fonction Symbole Fonction Mini-exemple
puissance Pow (x, y) Pow() resultat = pow(valeur1, valeur2);
Racine carrée
Sqrt(x)
sqrt() resultat = sqrt(valeur);
1
http://www.cplusplus.com/reference/cmath/

16. 15 | 16
15 Introduction au langage C++ | Chapitre 2 : Variables, Expressions et Instructions
Sinus
sin(x)
sin() resultat = sin(valeur);
Cosinus
cos(x)
cos() resultat = cos(valeur);
Tangente
tan(x)
tan() resultat = tan(valeur);
Exponentielle
ex
exp() resultat = exp(valeur);
Logarithme népérien
lnx
log() resultat = log(valeur);
Logarithme en base 10
log10x
log10() resultat = log10(valeur);
Valeur absolue
|x|
fabs() resultat = fabs(valeur);
Les fonctions trigonométriques (sin(), cos(),… ) utilisent les radians comme unité
d'angles.
Je crois qu'on a enfin toutes les clés en main pour réaliser notre premier vrai
programme. Il s’agit d’un programme qui utilise la fonction pow() pour effectuer le calcul
de ab
. Il serait bien mieux de demander à l'utilisateur les valeurs de a et de b !
Voici ma version :
1 #include <iostream>
2 #include <cmath> //Ne pas oublier !
3 using namespace std;
4
5 int main()
6 {
7 double a(0), b(0); //Déclaration des variables utiles
8
9 cout << "Bienvenue dans le programme de calcul de a^b !" << endl;
10
11 cout << "Donnez une valeur pour a : "; //On demande le premier nombre
12 cin >> a;
13
14 cout << "Donnez une valeur pour b : "; //On demande le deuxième nombre
15 cin >> b;
16
17 double const resultat(pow(a, b)); //On effectue l'opération
18 //On peut aussi écrire comme avant :
19 //double const resultat = pow(a,b);
20 //Souvenez-vous des deux formes possibles
21 //De l'initialisation d'une variable
22
23 cout << a << " ^ " << b << " = " << resultat << endl;
24 //On affiche le résultat
25
26 return 0;
27 }
Voici le résultat que cela donne.

17. 16 | 16
16 Introduction au langage C++ | Chapitre 2 : Variables, Expressions et Instructions
VII. Ce que vous devez retenir !
 Une variable est une information stockée en mémoire.
 il existe différents types de variables en fonction de la nature de l'information à
stocker : int, char, bool…
 Une variable doit être déclarée avant qu’elle soit utilisée.
 La valeur d'une variable peut être affichée à tout moment avec cout.
 Les références sont des étiquettes qui permettent d'appeler une variable par un
autre nom.
 Pour demander à l'utilisateur de saisir une information au clavier, on utilise cin
>> uneVariable;. La valeur saisie sera stockée dans la variable uneVariable.
 Il ne faut pas confondre le sens des chevrons cout << et cin >>.
 On peut faire toutes sortes d'opérations mathématiques de base en C++ : addition,
soustraction, multiplication… Exemple : x = 2 * (a + b) / 3;
 Les constantes sont des variables qu'on ne peut pas modifier une fois qu'elles ont
été créées. On utilise le mot const pour les définir.
 Pour ajouter 1 à la valeur d'une variable, on effectue ce qu'on appelle une
incrémentation : variable++;. L'opération inverse, appelée décrémentation,
existe aussi.
 Si vous souhaitez utiliser des fonctions mathématiques plus complexes, comme la
racine carrée, il faut inclure l'en-tête <cmath> dans votre code et faire appel à la
fonction adéquate comme dans cet exemple : resultat = sqrt(100);