Cours-C++

ENVIRONNEMENT DE DEVELOPPEMENT
Un IDE (Integrated Development Environment) est utilisé pour éditer ET compiler le code.
Les IDE populaires incluent Code :: Blocks, Eclipse et Visual Studio. Ils sont tous gratuits et
peuvent être utilisés à la fois pour éditer et déboguer du code C++.
Nous utiliserons Code :: Blocks dans notre Cours, qui, selon nous, est un bon point de départ.
Vous
pouvez
trouver
la
dernière
sur http://www.codeblocks.org/ . Téléchargez
version
de
le mingw-setup.exefichier,
Codeblocks
qui
l'éditeur de texte avec un compilateur.
Présentation de l’ide code::blocks
Figure 1: Présentation de Codeblock
On distingue dans la fenêtre 4 grandes sections (numérotées dans la figure suivante) :
installera
1. La barre d'outils : elle comprend de nombreux boutons, mais seuls quelques-uns d'entre
eux nous seront régulièrement utiles.
2. La liste des fichiers du projet : c'est à gauche que s'affiche la liste de tous les fichiers source
de votre programme.
3. La zone principale : c'est là que vous pourrez écrire votre code en langage C++ !
4. La zone de notification : aussi appelée la « Zone de la mort », c'est ici que vous verrez les
erreurs de compilation s'afficher si votre code comporte des erreurs.
Prenons un regard sur une section particulière de la barre d'outils. Les boutons suivants sont
disponibles dans l'ordre : Compiler, Exécuter, Compiler & Exécuter et Tout recompiler
Icones de compilation
 Compiler : tous les fichiers source de votre projet sont envoyés au compilateur quise
charge de créer un exécutable. S’il y a des erreurs (ce qui a de fortes chances d’arriver),
l’exécutable n'est pas créé et on vous indique les erreurs en bas de Code::Blocks
 Exécuter : cette icône lance juste le dernier exécutable que vous avez compilé. Cela
vous permet donc de tester votre programme et voir ainsi ce qu’il donne. Dans l’ordre,
si vous avez bien suivi, on doit d’abord compiler puis exécuter le binaire obtenu pour le
tester.
 Compiler & Exécuter : c’est la combinaison des 2 boutons précédents. C’est d’ailleurs
ce bouton que vous utiliserez le plus souvent. Notez que s’il y a des erreurs pendant la
compilation (pendant la génération de l’exécutable), le programme n'est pas exécuté. À
la place, vous avez droit à une liste d’erreurs à corriger.
 Tout reconstruire : quand vous choisissez de Compiler, Code::Blocks ne recompile en
fait que les fichiers modifiés depuis la dernière compilation et pas les autres. Parfois (je
dis bien parfois) vous aurez besoin de demander à Code::Blocks de vous recompiler
tous les fichiers.
Création d’un nouveau projet
Pour créer un nouveau projet il faut suivre les étapes suivantes :
File -> New -> Project.
Figure 2: étape 1 de création d'un projet
Ensuite une fenêtre de console, sélectionner le menu Console application
Figure 3: étape2 de création d'un projet
Cliquer sur Go pour créer votre projet. Un assistant s’ouvre
La première page est inutile donc cliquez sur Next
Figure 4: étape intermédiaire
On vous demande ensuite si vous allez faire du C ou du C++ : répondez C++ (figure suivante).
Figure 5: étape 3 de la création de projet
On vous demande le nom de votre projet et dans quel dossier seront enregistrés les fichiers
source (figure suivante).
Figure 6: étape 5 de la création d'un projet
Enfin, la dernière page vous permet de choisir de quelle façon le programme doit être compilé.
Vous pouvez laisser les options par défaut, cela n'aura pas d'incidence pour ce que nous allons
faire dans l'immédiat. (Veillez à ce qu'au moins Debug ou Release soit coché).
Figure 7: dernière étape de la création d'un projet
Cliquez sur Finish, c'est bon !
Dans le panneau de gauche intitulé Projects, développez l'arborescence en cliquant sur le petit
+ pour afficher la liste des fichiers du projet. Vous devriez avoir au moins un fichier main.cpp
que vous pouvez ouvrir en faisant un double-clic dessus.
Figure 8: fichier du projet
Compiler le programme main.cpp
Figure 9: compilation du fichier main.cpp
LES STRUCTURES BASES
La syntaxe de C++
Décomposons le code suivant pour mieux le comprendre :
#include <iostream>
using namespace std;
int main()
{
cout << "Hello world!" << endl;
return 0;
}
Ligne 1 : #include <iostream> est une bibliothèque de fichiers d'en-tête qui nous permet de
travailler avec des objets d'entrée et de sortie, tels que cout (utilisé à la ligne 5 ou 7). Les fichiers
d'en-tête ajoutent des fonctionnalités aux programmes C++.
Ligne 2 : using namespace std signifie que nous pouvons utiliser des noms d'objets et de
variables de la bibliothèque standard.
Ligne 4 : Une autre chose qui apparaît toujours dans un programme C++, c'est int main(). C'est
ce qu'on appelle une fonction. Tout code à l'intérieur de ses accolades {} sera exécuté.
Ligne 5 : cout est un objet utilisé avec l’opérateur d'insertion (<<) pour sortir/imprimer du
texte. Dans notre exemple, il affichera "Hello World".
Il y a 3 éléments sur cette ligne :
 cout : commande l'affichage d'un message à l'écran ;
 "Hello world!" : indique le message à afficher ;
 endl : crée un retour à la ligne dans la console
Ligne 6 : return 0 termine la fonction principale.
Ligne 7 : N'oubliez pas d'ajouter l'accolade fermante «} » pour terminer la fonction principale.
Remarque :
 Chaque instruction C++ se termine par un point-virgule (;).
 Notez que cout est fourni par iostream. Si vous n'incluez pas iostream au début de votre
programme, le compilateur se plaindra de ne pas connaître cout et vous ne pourrez pas
générer votre programme !
Les Commentaires
Les commentaires n'ont aucun impact sur le fonctionnement de votre logiciel : en fait, le
compilateur ne les lit même pas et ils n'apparaissent pas dans le programme généré. Pourtant,
ces commentaires sont indispensables pour les développeurs : ils leur permettent d'expliquer ce
qu'ils font dans leur code.
Il existe deux types de commentaires :
 Les commentaires cours : // Ceci est un commentaire
 Les commentaires long : /* Le code qui suit est un peu complexe alors je prends mon
temps pour l'expliquer parce que je sais que sinon, dans quelques semaines, j'aurai tout
oublié et je serai perdu pour le modifier */
#include <iostream> // Inclut la bibliothèque iostream (affichage de texte)
using namespace std; // Indique quel espace de noms on va utiliser
/*
Fonction principale "main"
Tous les programmes commencent par la fonction main
*/
int main()
{
cout << "Hello world!" << endl; // Affiche un message
return 0; // Termine la fonction main et donc le programme
}
Sortie C++ (texte d'impression)
L’objet cout, avec l’opérateur <<, est utilisé pour afficher des valeurs/imprimer du texte :
#include <iostream>
using namespace std;
int main() {
cout << "Hello World!";
return 0;
}
Vous pouvez ajouter autant d’objets cout que vous le souhaitez. Cependant, notez qu'il n'insère
pas de nouvelle ligne à la fin de la sortie :
#include <iostream>
using namespace std;
int main() {
cout << "Hello World!";
cout << "I am learning C++";
return 0;
}
Pour insérer une nouvelle ligne, vous pouvez utiliser le \n caractère :
#include <iostream>
using namespace std;
int main() {
cout << "Hello World! \n";
cout << "I am learning C++";
return 0;
}
Astuce : Deux \n caractères l'un après l'autre créeront une ligne vide :
#include <iostream>
using namespace std;
int main() {
cout << "Hello World! \n\n";
cout << "I am learning C++";
return 0;
}
Une autre façon d'insérer une nouvelle ligne est d'utiliser le manipulateur endl :
#include <iostream>
using namespace std;
int main() {
cout << "Hello World!" << endl;
cout << "I am learning C++";
return 0;
}
Les deux \net endl sont utilisés pour couper les lignes. Cependant, \n est le plus utilisé.
Mais \n qu'est-ce que c’est exactement ?
Le caractère de saut de ligne (\n) est appelé une séquence d’échappement, et il force le curseur
à changer sa position au début de la ligne suivante sur l'écran. Il en résulte une nouvelle ligne.
Voici des exemples d'autres séquences d'échappement valides :
\t : Crée un onglet horizontal
#include <iostream>
using namespace std;
int main() {
cout << "Hello World!\t";
cout << "I am learning C++";
return 0;
}
\\ : Insère un caractère barre oblique inverse (\)
#include <iostream>
using namespace std;
int main() {
cout << "Hello World!\\";
cout << "I am learning C++";
return 0;
}
\" : Insère un guillemet double
#include <iostream>
using namespace std;
int main() {
cout << "They call him \"Johnny\".";
return 0;
}
Variables en C++
Les variables sont des conteneurs pour stocker des valeurs de données.
En C++, il existe différents types de variables (définies avec différents mots clés), par
exemple :
 int : stocke des nombres entiers (nombres entiers), sans décimales, comme 123 ou -123
 double : stocke les nombres à virgule flottante, avec des décimales, telles que 19,99 ou
-19,99
 char : stocke des caractères uniques, tels que 'a' ou 'B'. Les valeurs char sont entourées
de guillemets simples
 string : stocke du texte, tel que "Hello World". Les valeurs de chaîne sont entourées de
guillemets doubles
 bool : stocke les valeurs avec deux états : vrai ou faux
Déclarer (créer) des variables
Pour créer une variable, spécifiez le type et attribuez-lui une valeur :
Syntaxe
type variableName = value;
Le signe égal est utilisé pour attribuer des valeurs à la variable.
Exemple
Créez une variable appelée myNum de type intet affectez-lui la valeur 15 :
#include <iostream>
using namespace std;
int main() {
int myNum = 15;
cout << myNum;
return 0;
}
Vous pouvez également déclarer une variable sans affecter la valeur, et affecter la valeur plus
tard :
#include <iostream>
using namespace std;
int main() {
int myNum = 15; // Now myNum is 15
myNum = 10;
// Now myNum is 10
cout << myNum;
return 0;
}
Une démonstration d'autres types de données :
#include <iostream>
using namespace std;
int main()
{
int myNum = 5;
// Integer (nombre entier sans décimales)
double myFloatNum = 5.99;
char myLetter = 'D';
// Floating nombre à virgule flottante (nombre decimal)
// char (Lettre)
string myText = "Hello";
bool myBoolean = false;
// String (Text)
// Booleen (true or false)
cout << myNum << endl ;
cout << myFloatNum << endl ;
cout << myLetter << endl ;
cout << myBoolean << endl ;
}
Variables d'affichage
L’objet cout est utilisé avec l’opérateur << pour afficher les variables.
Pour combiner à la fois du texte et une variable, séparez-les avec l’opérateur << :
#include <iostream>
using namespace std;
int main() {
int myAge = 35;
cout << "I am " << myAge << " years old.";
return 0;
}
Ajouter des variables ensemble
Pour ajouter une variable à une autre variable, vous pouvez utiliser l’opérateur + :
#include <iostream>
using namespace std;
int main() {
int x = 5;
int y = 6;
int sum = x + y;
cout << sum;
return 0;
}
Déclarer plusieurs variables
Pour déclarer plusieurs variables du même type, utilisez une liste séparée par des virgules :
#include <iostream>
using namespace std;
int main() {
int x = 5, y = 6, z = 50;
cout << x + y + z;
return 0;
}
Une valeur à plusieurs variables
Vous pouvez également affecter la même valeur à plusieurs variables sur une seule ligne :
#include <iostream>
using namespace std;
int main() {
int x, y, z;
x = y = z = 50;
cout << x + y + z;
return 0;
}
Identificateurs C++
Toutes les variables C++ doivent être identifiées par des noms uniques.
Ces noms uniques sont appelés identificateurs.
Les identifiants peuvent être des noms courts (comme x et y) ou des noms plus descriptifs (age,
sum, totalVolume).
Remarque : Il est recommandé d'utiliser des noms descriptifs afin de créer un code
compréhensible et maintenable :
#include <iostream>
using namespace std;
int main() {
// Good name
int minutesPerHour = 60;
// OK, but not so easy to understand what m actually is
int m = 60;
cout << minutesPerHour << "\n";
cout << m;
return 0;
}
Les règles générales pour nommer les variables sont :
 Les noms peuvent contenir des lettres, des chiffres et des traits de soulignement
 Les noms doivent commencer par une lettre ou un trait de soulignement (_)
 Les noms sont sensibles à la casse ( myVaret myvarsont des variables différentes)
 Les noms ne peuvent pas contenir d'espaces ou de caractères spéciaux tels que !, #, %,
etc.
 Les mots réservés (comme les mots-clés C++, tels que int) ne peuvent pas être utilisés
comme noms
Constantes
Lorsque vous ne voulez pas que d'autres (ou vous-même) remplacent les valeurs de variables
existantes, utilisez le mot clé - const (cela déclarera la variable comme "constante", ce qui
signifie non modifiable et en lecture seule) :
#include <iostream>
using namespace std;
int main() {
const int myNum = 15; // myNum will always be 15
myNum = 15; // error: assignment of read-only variable 'myNum'
cout << myNum;
return 0;
}
Vous devez toujours déclarer la variable comme constante lorsque vous avez des valeurs peu
susceptibles de changer :
#include <iostream>
using namespace std;
int main() {
const int minutesPerHour = 60;
const float PI = 3.14;
cout << minutesPerHour << "\n";
cout << PI;
return 0;
}
Entrée utilisateur
cin est une variable prédéfinie qui lit les données du clavier avec l'opérateur d'extraction ( >>).
Dans l'exemple suivant, l'utilisateur peut saisir un nombre, qui est stocké dans la variable x. Puis
on imprime la valeur de x:
#include <iostream>
using namespace std;
int main() {
int x;
cout << "Type a number: "; // Type a number and press enter
cin >> x; // Get user input from the keyboard
cout << "Your number is: " << x;
return 0;
}
Dans cet exemple, l'utilisateur doit saisir deux nombres. Puis on imprime la somme en calculant
(additionnant) les deux nombres :
#include <iostream>
using namespace std;
int main() {
int x, y;
int sum;
cout << "Type a number: ";
cin >> x;
cout << "Type another number: ";
cin >> y;
sum = x + y;
cout << "Sum is: " << sum;
return 0;
}
TYPES DE DONNEES C++
Comme expliqué dans le chapitre Variables, une variable en C++ doit être un type de données
spécifié :
#include <iostream>
#include <string>
using namespace std;
int main () {
// Creating variables
int myNum = 5;
// Integer (whole number)
float myFloatNum = 5.99;
// Floating point number
double myDoubleNum = 9.98; // Floating point number
char myLetter = 'D';
bool myBoolean = true;
// Character
// Boolean
string myString = "Hello"; // String
// Print variable values
cout << "int: " << myNum << "\n";
cout << "float: " << myFloatNum << "\n";
cout << "double: " << myDoubleNum << "\n";
cout << "char: " << myLetter << "\n";
cout << "bool: " << myBoolean << "\n";
cout << "string: " << myString << "\n";
return 0;
}
Types de données de base
Le type de données spécifie la taille et le type d'informations que la variable stockera :
Types de
Taille
Description
Boolean
1 byte
Stocke les valeurs vrai ou faux
Char
1 byte
Stocke un seul caractère/lettre/numéro ou des valeurs ASCII
donnée
Int
2 or 4
bytes
Float
4 bytes
Double
8 bytes
Stocke des nombres entiers, sans décimales
Stores fractional numbers, containing one or more decimals.
Sufficient for storing 7 decimal digits
Stores fractional numbers, containing one or more decimals.
Sufficient for storing 15 decimal digits
Types numériques
Utiliser int lorsque vous avez besoin de stocker un nombre entier sans décimales, comme 35 ou
1000, et float/ou doublelorsque vous avez besoin d'un nombre à virgule flottante (avec
décimales), comme 9,99 ou 3,14515.
Int :
#include <iostream>
using namespace std;
int main () {
int myNum = 1000;
cout << myNum;
return 0;
}
Float :
#include <iostream>
using namespace std;
int main () {
float myNum = 5.75;
cout << myNum;
return 0;
}
Double :
#include <iostream>
using namespace std;
int main () {
double myNum = 19.99;
cout << myNum;
return 0;
}
Nombre à virgule
Un nombre à virgule flottante peut aussi être un nombre scientifique avec un "e" pour indiquer
la puissance de 10 :
#include <iostream>
using namespace std;
int main () {
float f1 = 35e3;
double d1 = 12E4;
cout << f1 << "\n";
cout << d1;
return 0;
}
Types booléens
Un type de données booléen est déclaré avec le mot-clé bool et ne peut prendre que les
valeurs true ou false. Lorsque la valeur est renvoyée, true = 1et false = 0.
#include <iostream>
using namespace std;
int main() {
bool isCodingFun = true;
bool isFishTasty = false;
cout << isCodingFun << "\n";
cout << isFishTasty;
return 0;
}
Types de données caractères
char est le type de données est utilisé pour stocker un seul caractère. Le caractère doit être
entouré de guillemets simples, comme 'A' ou 'c' :
#include <iostream>
using namespace std;
int main () {
char myGrade = 'B';
cout << myGrade;
return 0;
}
Vous pouvez également utiliser des valeurs ASCII pour afficher certains caractères :
#include <iostream>
using namespace std;
int main () {
char a = 65, b = 66, c = 67;
cout << a;
cout << b;
cout << c;
return 0;
}
Types de données de chaîne
Le type string est utilisé pour stocker une séquence de caractères (texte). Ce n'est pas un type
intégré, mais il se comporte comme tel dans son utilisation la plus élémentaire. Les valeurs de
chaîne doivent être entourées de guillemets :
#include <iostream>
#include <string>
using namespace std;
int main() {
string greeting = "Hello";
cout << greeting;
return 0;
}
Pour utiliser des chaînes, vous devez inclure un fichier d'en-tête supplémentaire dans le code
source, la bibliothèque <string>.
OPERATEURS
Les opérateurs sont utilisés pour effectuer des opérations sur des variables et des valeurs. Dans
l'exemple ci-dessous, nous utilisons l’opérateur + pour additionner deux valeurs :
#include <iostream>
using namespace std;
int main() {
int x = 100 + 50;
cout << x;
return 0;
}
Bien que l’opérateur + soit souvent utilisé pour additionner deux valeurs, comme dans
l'exemple ci-dessus, il peut également être utilisé pour additionner une variable et une valeur,
ou une variable et une autre variable :
#include <iostream>
using namespace std;
int main() {
int sum1 = 100 + 50;
// 150 (100 + 50)
int sum2 = sum1 + 250;
int sum3 = sum2 + sum2;
// 400 (150 + 250)
// 800 (400 + 400)
cout << sum1 << "\n";
cout << sum2 << "\n";
cout << sum3;
return 0;
}
C++ divise les opérateurs dans les groupes suivants :
 Opérateurs arithmétiques
 Opérateurs d'affectation
 Opérateurs de comparaison
 Opérateurs logiques
 Opérateurs au niveau du bit
Opérateurs arithmétiques
Les opérateurs arithmétiques sont utilisés pour effectuer des opérations mathématiques
courantes.
Opérateur
Nom
Description
Exemple
+
Addition
Additionne deux valeurs
X+Y
-
Soustraction
Soustrait une valeur d’une autre
X–Y
*
Multiplication
Multiplie deux valeurs
X*Y
/
Division
Divise une valeur par une autre
X/Y
%
Modulo
Renvoie le reste de la division
X%Y
++
Incrémentation
Augmente la valeur d’une variable de 1
++ X
--
Décrémentation
Diminue la valeur d’une variable de 1
--X
Addition
#include <iostream>
using namespace std;
int main() {
int x = 5;
int y = 3;
cout << x + y;
return 0;
}
Soustraction
#include <iostream>
using namespace std;
int main() {
int x = 5;
int y = 3;
cout << x - y;
return 0;
}
Multiplication
#include <iostream>
using namespace std;
int main() {
int x = 5;
int y = 3;
cout << x * y;
return 0;
}
Division
#include <iostream>
using namespace std;
int main() {
int x = 12;
int y = 3;
cout << x / y;
return 0;
}
Modulo
#include <iostream>
using namespace std;
int main() {
int x = 5;
int y = 2;
cout << x % y;
return 0;
}
Incrémentation
#include <iostream>
using namespace std;
int main() {
int x = 5;
++x;
cout << x;
return 0;
}
Décrémentation
#include <iostream>
using namespace std;
int main() {
int x = 5;
--x;
cout << x;
return 0;
}
Opérateurs d'affectation
Les opérateurs d'affectation sont utilisés pour affecter des valeurs aux variables.
Dans l'exemple ci-dessous, nous utilisons l’opérateur d’affectation= () pour affecter la
valeur 10 à une variable appelée x :
#include <iostream>
using namespace std;
int main() {
int x = 10;
cout << x;
return 0;
}
L’opérateur d'affectation d'addition += ( ) ajoute une valeur à une variable :
#include <iostream>
using namespace std;
int main() {
int x = 10;
x += 5;
cout << x;
return 0;
}
Une liste de tous les opérateurs d'affectation :
Opérateur
Exemple
Similitudes
=
X=5
X=5
+=
X += 3
X=X+3
-=
X -= 3
X=X+3
*=
X *= 3
X=X*3
/=
X /= 3
X=X/3
%=
X %= 3
X=X%3
&=
X &= 3
X=X&3
|=
X |= 3
X=X|3
^=
X ^= 3
X = X ^= 3
>>=
X >>= 3
X = X >>3
<< =
Cas 1
#include <iostream>
using namespace std;
int main() {
int x = 5;
cout << x;
return 0;
}
Cas 2
#include <iostream>
using namespace std;
int main() {
int x = 5;
x += 3;
cout << x;
return 0;
}
Cas 3
#include <iostream>
using namespace std;
int main() {
int x = 5;
x -= 3;
X << = 3
X = X << 3
cout << x;
return 0;
}
Cas 4
#include <iostream>
using namespace std;
int main() {
int x = 5;
x *= 3;
cout << x;
return 0;
}
Cas 5
#include <iostream>
using namespace std;
int main() {
double x = 5;
x /= 3;
cout << x;
return 0;
}
Cas 6
#include <iostream>
using namespace std;
int main() {
int x = 5;
x %= 3;
cout << x;
return 0;
}
Cas 7
#include <iostream>
using namespace std;
int main() {
int x = 5;
x &= 3;
cout << x;
return 0;
}
Cas 8
#include <iostream>
using namespace std;
int main() {
int x = 5;
x |= 3;
cout << x;
return 0;
}
Cas 9
#include <iostream>
using namespace std;
int main() {
int x = 5;
x ^= 3;
cout << x;
return 0;
}
Cas 10
#include <iostream>
using namespace std;
int main() {
int x = 5;
x >>= 3;
cout << x;
return 0;
}
Cas 11
#include <iostream>
using namespace std;
int main() {
int x = 5;
x <<= 3;
cout << x;
return 0;
}
Opérateurs de comparaison
Les opérateurs de comparaison sont utilisés pour comparer deux valeurs.
Remarque : La valeur de retour d'une comparaison est soit true (1) soit false (0).
Dans l'exemple suivant, nous utilisons l’opérateur supérieur à> () pour savoir si 5 est supérieur
à3:
#include <iostream>
using namespace std;
int main() {
int x = 5;
int y = 3;
cout << (x > y); // renvoie 1 (vrai) parce que 5 est supérieur à 3
return 0;
}
Une liste de tous les opérateurs de comparaison :
Opérateur
Description
Example
==
Égale à
X == Y
!=
Différent
X!=Y
>
Supérieur à
X>Y
<
Inférieur à
X<Y
>=
Supérieur ou égal
X >= Y
<=
Inférieur ou égal
X <= Y
Egalité
#include <iostream>
using namespace std;
int main() {
int x = 5;
int y = 3;
cout << (x == y); // renvoie 0 (faux) parce que 5 n’est pas égal à 3
return 0;
}
Différence
#include <iostream>
using namespace std;
int main() {
int x = 5;
int y = 3;
cout << (x != y); // renvoie 1 (vrai) parce que 5 n’est pas égal à 3
return 0;
}
Supérieur
#include <iostream>
using namespace std;
int main() {
int x = 5;
int y = 3;
cout << (x > y); // renvoie 1 (vrai) parce que 5 est supérieur à 3
return 0;
}
Inférieur
#include <iostream>
using namespace std;
int main() {
int x = 5;
int y = 3;
cout << (x < y); // renvoie 0 (faux) parce que 5 n’est pas moins de 3
return 0;
}
Supérieur ou égal
#include <iostream>
using namespace std;
int main() {
int x = 5;
int y = 3;
cout << (x >= y); // renvoie 1 (vrai) parce que cinq est supérieur ou égal à 3
return 0;
}
Inférieur ou égal
#include <iostream>
using namespace std;
int main() {
int x = 5;
int y = 3;
cout << (x <= y); // renvoie 0 (faux) parce que 5 n’est ni inférieur ni égal à 3
return 0;
}
Opérateurs logiques
Les opérateurs logiques sont utilisés pour déterminer la logique entre les variables ou les
valeurs :
Opérateur Désignation
Description
Exemple
&&
ET logique
Renvoie true si les deux énoncés sont true
X < 5 && X <10
||
OU logique
Renvoie true si l’un des énoncés est true
X <4 || X <5
!
Non logique
Inverser le résultat, retourne false si le résultat est true ! (X < 5 && X < 10)
Et logique
#include <iostream>
using namespace std;
int main() {
int x = 5;
int y = 3;
cout << (x > 3 && x < 10); // renvoie true (1) parce que 5 est supérieur à 3 ET 5 est inférieur
à 10
return 0;
}
Ou logique
#include <iostream>
using namespace std;
int main() {
int x = 5;
int y = 3;
cout << (x > 3 || x < 4); // retourne true (1) parce que l’une des conditions est true (5 est
supérieure à 3, mais 5 n’est pas inférieure à 4)
return 0;
}
Non logique
#include <iostream>
using namespace std;
int main() {
int x = 5;
int y = 3;
cout << (!(x > 3 && x < 10)); // retourne false (0) car ! (not) est utilisé pour inverser le résultat
return 0;
}
LES CHAINES
Les chaînes sont utilisées pour stocker du texte.
Pour utiliser des chaînes, vous devez inclure un fichier d'en-tête supplémentaire dans le code
source, la bibliothèque <string>.
Une variable string contient une collection de caractères entourés de guillemets :
#include <iostream>
#include <string>
using namespace std;
int main() {
string greeting = "Hello";
cout << greeting;
return 0;
}
Concaténation de chaînes
L'opérateur « + » peut être utilisé entre les chaînes pour les additionner pour créer une nouvelle
chaîne. C'est ce qu'on appelle la concaténation :
#include <iostream>
#include <string>
using namespace std;
int main () {
string firstName = "John ";
string lastName = "Doe";
string fullName = firstName + lastName;
cout << fullName;
return 0;
}
Dans l'exemple ci-dessus, nous avons ajouté un espace après firstName pour créer un espace
entre John et Doe en sortie. Cependant, vous pouvez également ajouter un espace avec des
guillemets (« "ou ' ') :
#include <iostream>
#include <string>
using namespace std;
int main () {
string firstName = "John";
string lastName = "Doe";
string fullName = firstName + " " + lastName;
cout << fullName;
return 0;
}
Ajouter une chaine
Une chaîne en C++ est en fait un objet, qui contient des fonctions pouvant effectuer certaines
opérations sur des chaînes. Par exemple, vous pouvez également concaténer des chaînes avec
la fonction append () :
#include <iostream>
#include <string>
using namespace std;
int main () {
string firstName = "John ";
string lastName = "Doe";
string fullName = firstName.append(lastName);
cout << fullName;
return 0;
}
Ajouter des nombres et des chaînes
C++ utilise l'opérateur « + » pour l’addition et la concaténation. Les numéros sont ajoutés. Les
chaînes sont concaténées. Si vous additionnez deux nombres, le résultat sera un nombre :
#include <iostream>
using namespace std;
int main () {
int x = 10;
int y = 20;
int z = x + y;
cout << z;
return 0;
}
Si vous ajoutez deux chaînes, le résultat sera une concaténation de chaînes :
#include <iostream>
#include <string>
using namespace std;
int main () {
string x = "10";
string y = "20";
string z = x + y;
cout << z;
return 0;
}
Si vous essayez d'ajouter un nombre à une chaîne, une erreur se produit :
Longueur de chaine
Pour obtenir la longueur d'une chaîne, utilisez la fonction length() :
#include <iostream>
#include <string>
using namespace std;
int main() {
string txt = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
cout << "The length of the txt string is: " << txt.length();
return 0;
}
Vous pouvez voir certains programmes C++ qui utilisent la fonction size() pour obtenir la
longueur d'une chaîne. Ceci est juste un alias de length(). C'est à vous de décider si vous
souhaitez utiliser length()ou size():
#include <iostream>
#include <string>
using namespace std;
int main() {
string txt = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
cout << "The length of the txt string is: " << txt.size();
return 0;
}
Chaînes d'accès
Vous pouvez accéder aux caractères d'une chaîne en vous référant à son numéro d'index entre
crochets [].
#include <iostream>
#include <string>
using namespace std;
int main() {
string myString = "Hello";
cout << myString[0]<<endl;
cout << myString[1]<<endl;
cout << myString[2]<<endl;
cout << myString[3]<<endl;
cout << myString[4]<<endl;
return 0;
}
Remarque : Les index de chaîne commencent par 0 : [0] est le premier caractère. [1] est l
deuxième caractère, etc.
Pour modifier la valeur d'un caractère spécifique dans une chaîne, reportez-vous au numéro
d'index et utilisez des guillemets simples :
#include <iostream>
#include <string>
using namespace std;
int main() {
string myString = "Hello";
myString[0] = 'M';
cout << myString;
return 0;
}
Chaînes d'entrée utilisateur
Il est possible d'utiliser l'opérateur d'extraction >> sur cin pour afficher une chaîne saisie par un
utilisateur :
#include <iostream>
#include <string>
using namespace std;
int main() {
string firstName;
cout << "Type your first name: ";
cin >> firstName; // get user input from the keyboard
cout << "Your name is: " << firstName;
// Type your first name: John
// Your name is: John
return 0;
}
Cependant, cin considère un espace (espace blanc, tabulation, etc.) comme un caractère de fin,
ce qui signifie qu'il ne peut afficher qu'un seul mot (même si vous tapez plusieurs mots) :
#include <iostream>
#include <string>
using namespace std;
int main() {
string fullName;
cout << "Type your full name: ";
cin >> fullName;
cout << "Your name is: " << fullName;
// Type your full name: John Doe
// Your name is: John
return 0;
}
Dans l'exemple ci-dessus, vous vous attendriez à ce que le programme imprime "John Doe",
mais il n'imprime que "John". C'est pourquoi, lorsque nous travaillons avec des chaînes, nous
utilisons souvent la fonction getline() pour lire une ligne de texte. Il prend cin comme premier
paramètre, et la variable chaîne comme second :
#include <iostream>
#include <string>
using namespace std;
int main() {
string fullName;
cout << "Type your full name: ";
getline (cin, fullName);
cout << "Your name is: " << fullName;
return 0;
}
Omettre l'espace de noms
Certains programmes C++ peuvent s'exécuter sans la bibliothèque d'espaces de noms
standard. La ligne using namespace std peut être omise et remplacée par le mot-clé std, suivi de
l’opérateur :: pour les objets string() et cout().
#include <iostream>
#include <string>
int main() {
std::string greeting = "Hello";
std::cout << greeting;
return 0;
}
LES FONCTIONS DE BASE EN MATHEMATIQUES
C++ a de nombreuses fonctions qui vous permettent d'effectuer des tâches mathématiques sur
des nombres.
Max et min
La fonction peut être utilisée pour trouver la valeur la plus élevée de x et y :max(x,y)
#include <iostream>
using namespace std;
int main() {
cout << max(10, 5);
return 0;
}
Et la fonction peut être utilisée pour trouver la valeur la plus basse de x et y :min(x,y)
#include <iostream>
using namespace std;
int main() {
cout << min(10, 5);
return 0;
}
En-tête C++ <cmath>
D'autres fonctions, telles que sqrt (racine carrée), round (arrondir un nombre) et log (logarithme
naturel), peuvent être trouvées dans le fichier d'en-tête <cmath> :
#include <iostream>
#include <cmath>
using namespace std;
int main() {
cout << sqrt(64) << "\n";
cout << round(2.6) << "\n";
cout << log(2) << "\n";
cout << abs(-2) << "\n";
return 0;
}
Autres fonctions mathématiques
Une liste d'autres fonctions mathématiques populaires (de la <cmath>bibliothèque) se trouve
dans le tableau ci-dessous :
Function
Description
abs(x)
Renvoie la valeur absolue de x
acos(x)
Renvoie l’arcosinus de x
asin(x)
Renvoie l’arcsinus de x
atan(x)
Renvoie l’arctangente de x
cbrt(x)
Renvoie la racine cube de x
ceil(x)
Renvoie la valeur de x arrondie à son entier le plus proche
cos(x)
Renvoie le cosinus de x
cosh(x)
Returns the hyperbolic cosine of x
exp(x)
Renvoie la valeur de Ex
expm1(x)
Retourne ex -1
fabs(x)
Renvoie la valeur absolue d’une virgule flotante x
fdim(x, y)
Renvoie la différence positive entre x et y
floor(x)
Renvoie la valeur de x arrondie à son entier le plus proche
hypot(x, y)
Retours sqrt (x2 +y2) sans débordement ou sous-débit intermédiaire
fma(x, y, z)
Retours x*y+z sans perte de précision
fmax(x, y)
Renvoie la valeur la plus élevée d’un x et d’un y flottants
fmin(x, y)
Renvoie la valeur la plus basse d’un x et d’un y flottants
fmod(x, y)
Renvoie le reste en virgule flottante de x/y
pow(x, y)
Renvoie la valeur de x à la puissance de y
sin(x)
Renvoie le sinus de x (x est en radians)
sinh(x)
Renvoie le sinus hyperbolique d’une valeur réél
tan(x)
Renvoie la tangente d’un angle
tanh(x)
Renvoie la tangente hyperbolique d’une valeur réél
BOOLEENS C++
Très souvent, en programmation, vous aurez besoin d'un type de données qui ne peut avoir
qu'une des deux valeurs, comme :
 OUI NON
 ALLUMÉ ÉTEINT
 VRAI FAUX
Une variable booléenne est déclarée avec le mot clé bool et ne peut prendre que les valeurs true
(1) ou false (0) :
#include <iostream>
using namespace std;
int main() {
bool isCodingFun = true;
bool isFishTasty = false;
cout << isCodingFun << "\n";
cout << isFishTasty;
return 0;
}
Expression booléenne
Une expression booléenne est une expression C++ qui renvoie une valeur booléenne : 1(true)
ou 0(false).
Vous pouvez utiliser un opérateur de comparaison, tel que l'opérateur supérieur à ( >) pour
savoir si une expression (ou une variable) est vraie :
#include <iostream>
using namespace std;
int main() {
int x = 10;
int y = 9;
cout << (x > y); //renvoie 1 (vrai), parce que 10 est supérieur à 9
return 0;
}
Ou encore plus simple :
#include <iostream>
using namespace std;
int main() {
cout << (10 > 9);
return 0;
}
Dans les exemples ci-dessous, nous utilisons l’opérateur égal à (==) pour évaluer une
expression :
#include <iostream>
using namespace std;
int main() {
int x = 10;
cout << (x == 10);
return 0;
}
Un autre cas
#include <iostream>
using namespace std;
int main() {
int x;
int y;
x=10;
y=15;
cout << (x == y);
return 0;
}
LES CONDITIONS
L'instruction if (SI)
L’instruction if permet de spécifier un bloc de code C++ à exécuter si une condition est vérifiée.
Figure 10: shéma synoptique de la condition SI
Syntaxe
if (condition) {
// block of code to be executed if the condition is true
}
Notez qu’if c'est en lettres minuscules. Les lettres majuscules (If ou IF) généreront une erreur.
#include <iostream>
using namespace std;
int main() {
if (20 > 18) {
cout << "20 is greater than 18";
}
return 0;
}
On peut aussi tester des variables :
#include <iostream>
using namespace std;
int main() {
int x = 20;
int y = 18;
if (x > y) {
cout << "x is greater than y";
}
return 0;
}
L’instruction else (SINON)
L’instruction else pour spécifier un bloc de code à exécuter si la condition est false.
Figure 11: shéma synoptique de l'instruction sinon
Syntaxe
if (condition) {
// block of code to be executed if the condition is true
} else {
// block of code to be executed if the condition is false
}
Exemple :
#include <iostream>
using namespace std;
int main () {
// local variable declaration:
int a = 10;
// check the boolean condition
if( a < 20 ) {
// if condition is true then print the following
cout << "a is less than 20;" << endl;
} else {
// if condition is false then print the following
cout << "a is not less than 20;" << endl;
}
cout << "value of a is : " << a << endl;
return 0;
}
L'instruction else if (Sinon si)
L’instruction else if pour spécifier une nouvelle condition si la première condition est false.
Syntaxe
if (condition1) {
// block of code to be executed if condition1 is true
} else if (condition2) {
// block of code to be executed if the condition1 is false and condition2 is true
} else {
// block of code to be executed if the condition1 is false and condition2 is false
}
Figure 12: shéma synoptique de sinonsi
#include <iostream>
using namespace std;
int main ()
{
// local variable declaration:
int a = 40;
// check the boolean condition
if( a == 10 ) {
// if condition is true then print the following
cout << "Value of a is 10" << endl;
} else if( a == 20 ) {
// if else if condition is true
cout << "Value of a is 20" << endl;
} else if( a == 30 ) {
// if else if condition is true
cout << "Value of a is 30" << endl;
} else {
// if none of the conditions is true
cout << "Value of a is not matching" << endl;
}
cout << "Exact value of a is : " << a << endl;
return 0;
}
Opérateur ternaire
Il existe également un raccourci if else, connu sous le nom d’opérateur ternaire car il se
compose de trois opérandes. Il peut être utilisé pour remplacer plusieurs lignes de code par une
seule ligne. Il est souvent utilisé pour remplacer les instructions simples if else.
Syntaxe
variable = (condition) ? expressionTrue : expressionFalse;
Au lieu d'écrire :
#include <iostream>
using namespace std;
int main() {
int time = 20;
if (time < 18) {
cout << "Good day.";
} else {
cout << "Good evening.";
}
return 0;
}
Vous pouvez simplement écrire :
#include <iostream>
#include <string>
using namespace std;
int main() {
int time = 20;
string result = (time < 18) ? "Good day." : "Good evening.";
cout << result;
return 0;
}
Commutateur
L’instruction switch est utilisée pour sélectionner l'un des nombreux blocs de code à exécuter.
Figure 13: shéma de l'instruction switch
Voilà comment cela fonctionne :
 L'expression switch est évaluée une fois
 La valeur de l'expression est comparée aux valeurs de chaque case
 S'il y a correspondance, le bloc de code associé est exécuté
Les mots clés break et default sont facultatifs et seront décrits plus loin dans ce chapitre
L'exemple ci-dessous utilise le numéro du jour de la semaine pour calculer le nom du jour de
la semaine :
#include <iostream>
using namespace std;
int main() {
int day;
cout << "Type a number: ";
cin >> day;
switch (day) {
case 1:
cout << "Monday";
break;
case 2:
cout << "Tuesday";
break;
case 3:
cout << "Wednesday";
break;
case 4:
cout << "Thursday";
break;
case 5:
cout << "Friday";
break;
case 6:
cout << "Saturday";
break;
case 7:
cout << "Sunday";
break;
}
return 0;
}
Le mot clé break (pause)
Lorsque C++ atteint un mot- break clé, il sort du bloc switch.
Cela arrêtera l'exécution de plus de code et de tests de cas à l'intérieur du bloc.
Lorsqu'une correspondance est trouvée et que le travail est terminé, il est temps de faire une
pause. Il n'y a pas besoin de plus de tests.
Un break peut faire gagner beaucoup de temps d'exécution car il "ignore" l'exécution de tout le
reste du code dans le bloc switch.
Le mot- clé default
Le mot- clé default spécifie du code à exécuter s'il n'y a pas de correspondance de casse :
#include <iostream>
using namespace std;
int main() {
int day;
cout << "Type Number of day : ";
cin >> day;;
switch (day) {
case 6:
cout << "Today is Saturday";
break;
case 7:
cout << "Today is Sunday";
break;
default:
cout << "Looking forward to the Weekend";
}
return 0;
}
LES BOUCLES
Une instruction de boucle nous permet d'exécuter une instruction ou un groupe d'instructions
plusieurs fois. Les boucles sont pratiques car elles permettent de gagner du temps, de réduire
les erreurs et de rendre le code plus lisible.
Figure 14:diagramme d'une boucle
Boucle While (Tant que)
La boucle while parcourt un bloc de code tant qu'une condition spécifiée est vérifiée.
Syntaxe :
while (condition) {
// code block to be executed
}
Figure 15:diagramme de la boucle while
Dans l'exemple ci-dessous, le code de la boucle s'exécutera encore et encore tant qu'une variable
(i) est inférieure à m :
#include <iostream>
using namespace std;
int main() {
int i =0 ;
int m ;
cout << "Type Number : ";
cin >> m;
while (i < m) {
cout << i << "\n";
i++;
}
return 0;
}
Remarque : N'oubliez pas d'augmenter la variable utilisée dans la condition, sinon la boucle
ne se terminera jamais !
La boucle do…while (Faire…… Tant que)
La boucle do…while est une variante de la boucle while. Cette boucle exécutera le bloc de code
une fois, avant de vérifier si la condition est vraie, puis elle répétera la boucle tant que la
condition est vraie.
Syntaxe
do {
// code block to be executed
}
while (condition);
Figure 16: diagramme dela boucle do...while
L'exemple ci-dessous utilise une boucle do/while. La boucle sera toujours exécutée au moins
une fois, même si la condition est fausse, car le bloc de code est exécuté avant que la condition
ne soit testée :
#include <iostream>
using namespace std;
int main() {
int i =0 ;
int m ;
cout << "Type Number : ";
cin >> m;
do{
cout << i << "\n";
i++;
}
while (i < m);
return 0;
}
Boucle For (Pour …Faire)
Une boucle for est une structure de contrôle de répétition qui vous permet d'écrire efficacement
une boucle qui doit s'exécuter un nombre spécifique de fois.
Lorsque vous savez exactement combien de fois vous voulez parcourir un bloc de code, utilisez
la boucle for au lieu d'une boucle while :
Syntaxe
for (instruction 1; instruction 2; instruction 3) {
// bloc de code à exécuter
}
 L’instruction 1 est exécutée (une fois) avant l'exécution du bloc de code.
 L’instruction 2 définit la condition d'exécution du bloc de code.
 L’instruction 3 est exécutée (à chaque fois) après l'exécution du bloc de code
Figure 17:diagramme de la boucle for
#include <iostream>
using namespace std;
int main() {
for (int i = 0; i < 5; i++) {
cout << i << "\n";
}
return 0;
}
Exemple expliqué
 L'instruction 1 définit une variable avant le début de la boucle (int i = 0).
 L'instruction 2 définit la condition d'exécution de la boucle (i doit être inférieur à 5). Si
la condition est vraie, la boucle recommencera, si elle est fausse, la boucle se terminera.
 L'instruction 3 augmente une valeur (i++) chaque fois que le bloc de code dans la boucle
a été exécuté.
Autre Exemples :
#include <iostream>
using namespace std;
int main() {
for (int i = 0; i <= 10; i = i + 2) {
cout << i << "\n";
}
return 0;
}
Interrompre et Continuer
L’instruction break ou interruption
L’instruction break a les deux utilisations suivantes en C++
 Lorsque l’instruction break est rencontrée à l'intérieur d'une boucle, la boucle est
immédiatement terminée et le contrôle du programme reprend à l'instruction suivante
suivant la boucle.
 Il peut être utilisé pour terminer un cas dans l’instruction switch (traitée dans le chapitre
suivant).
Si vous utilisez des boucles imbriquées (c'est-à-dire une boucle à l'intérieur d'une autre boucle),
l'instruction break arrêtera l'exécution de la boucle la plus interne et commencera à exécuter la
ligne de code suivante après le bloc.
Syntaxe
La syntaxe d'une instruction break en C++ est -
break;
Figure 18: schéma de l'instruction break
Cas de la boucle do…while
#include <iostream>
using namespace std;
int main () {
// Local variable declaration:
int a = 10;
// do loop execution
do {
cout << "value of a: " << a << endl;
a = a + 1;
if( a > 15) {
// terminate the loop
break;
}
} while( a < 20 );
return 0;
}
Cas de la boucle for
#include <iostream>
using namespace std;
int main() {
for (int i = 0; i < 10; i++) {
if (i == 4) {
break;
}
cout << i << "\n";
}
return 0;
}
Cas de la boucle While
#include <iostream>
using namespace std;
int main() {
int i = 0;
while (i < 10) {
cout << i << "\n";
i++;
if (i == 4) {
break;
}
}
return 0;
}
L’instruction continue
L’instruction continue fonctionne un peu comme l'instruction break. Au lieu de forcer la
terminaison, cependant, continue force la prochaine itération de la boucle à avoir lieu, en sautant
tout code entre les deux.
Pour la boucle for, continue entraîne l'exécution des parties de test conditionnel et
d'incrémentation de la boucle. Pour les boucles while et do...while , le contrôle du
programme passe aux tests conditionnels.
Syntaxe
La syntaxe d'une instruction continue en C++ est continue;
Figure 19: schéma de l'instruction continue
Cas de la boucle do…while
#include <iostream>
using namespace std;
int main () {
// Local variable declaration:
int a = 10;
// do loop execution
do {
if( a == 15) {
// skip the iteration.
a = a + 1;
continue;
}
cout << "value of a: " << a << endl;
a = a + 1;
}
while( a < 20 );
return 0;
}
Cas de la boucle for
#include <iostream>
using namespace std;
int main() {
for (int i = 0; i < 10; i++) {
if (i == 4) {
continue;
}
cout << i << "\n";
}
return 0;
}
Cas de la while
#include <iostream>
using namespace std;
int main() {
int i = 0;
while (i < 10) {
if (i == 4) {
i++;
continue;
}
cout << i << "\n";
i++;
}
return 0;
}
Les imbrications
Instructions if imbriquées
Il est toujours légal d’imbriquer des instructions if-else, ce qui signifie que vous pouvez utiliser
une instruction if ou else if dans une autre instruction if ou else if.
Syntaxe
La syntaxe d'une instruction if imbriquée est la suivante :
if( boolean_expression 1) {
// Executes when the boolean expression 1 is true
if(boolean_expression 2) {
// Executes when the boolean expression 2 is true
}
}
Vous pouvez imbriquer else if...else de la même manière que vous avez imbriqué l’instruction
if.
#include <iostream>
using namespace std;
int main () {
// local variable declaration:
int a = 100;
int b = 200;
// check the boolean condition
if( a == 100 ) {
// if condition is true then check the following
if( b == 200 ) {
// if condition is true then print the following
cout << "Value of a is 100 and b is 200" << endl;
}
}
cout << "Exact value of a is : " << a << endl;
cout << "Exact value of b is : " << b << endl;
return 0;
}
Instruction switch imbriquée
Il est possible d'avoir un commutateur dans le cadre de la séquence d'instructions d'un
commutateur externe. Même si les constantes de casse des commutateurs interne et externe
contiennent des valeurs communes, aucun conflit ne surviendra.
C++ spécifie qu'au moins 256 niveaux d'imbrication sont autorisés pour les instructions switch.
Syntaxe
La syntaxe d'une instruction switch imbriquée est la suivante :
switch(ch1) {
case 'A':
cout << "This A is part of outer switch";
switch(ch2) {
case 'A':
cout << "This A is part of inner switch";
break;
case 'B': // ...
}
break;
case 'B': // ...
}
Exemple :
#include <iostream>
using namespace std;
int main () {
// local variable declaration:
int a = 100;
int b = 200;
switch(a) {
case 100:
cout << "This is part of outer switch" << endl;
switch(b) {
case 200:
cout << "This is part of inner switch" << endl;
}
}
cout << "Exact value of a is : " << a << endl;
cout << "Exact value of b is : " << b << endl;
return 0;
}
Instruction de boucle for imbriquée
La syntaxe d'une instruction de boucle for imbriquée en C++ est la suivante :
for ( init; condition; increment ) {
for ( init; condition; increment ) {
statement(s);
}
statement(s); // you can put more statements.
}
Exemple
Le programme suivant utilise une boucle for imbriquée pour trouver les nombres premiers de 2
à 100
#include <iostream>
using namespace std;
int main () {
int i, j;
for(i = 2; i<100; i++) {
for(j = 2; j <= (i/j); j++)
if(!(i%j)) break; // if factor found, not prime
if(j > (i/j)) cout << i << " is prime\n";
}
return 0;
}
Un exemple d’initialisation d’une matrice à deux dimensions à l’aide de boucles for imbriquées.
Chaque niveau de boucle imbriquée traite une seule ligne de la matrice, nous avons donc deux
niveaux dans cet exemple. Notez que nous imprimons également les éléments après
l’affectation de l’entier aléatoire à la position donnée. La dernière étape sera effectuée
séparément dans des scénarios du monde réel, mais cet exemple de code est uniquement à des
fins éducatives.
#include <iostream>
#include <iomanip>
using std::cout;
using std::endl;
using std::setw;
constexpr int ROW = 4;
constexpr int COL = 3;
int main() {
int *matrix = new int[ROW * COL];
for (int i = 0; i < ROW; ++i) {
for (int j = 0; j < COL; ++j) {
matrix[j * ROW + i] = rand() % 100;
cout << setw(2) << matrix[j * ROW + i] << "; ";
}
cout << endl;
}
delete [] matrix;
return EXIT_SUCCESS;
}
Instruction de boucle while imbriquée
La syntaxe d'une instruction de boucle while imbriquée en C++ est la suivante :
while(condition) {
while(condition) {
statement(s);
}
statement(s); // you can put more statements.
}
Utiliser la boucle imbriquée while pour initialiser la matrice bidimensionnelle
#include <iostream>
#include <iomanip>
using std::cout;
using std::endl;
using std::setw;
constexpr int ROW = 4;
constexpr int COL = 3;
int main() {
int *matrix = new int[ROW * COL];
int j, i = 0;
while (i < ROW) {
j = 0;
while (j < COL) {
matrix[j * ROW + i] = rand() % 100;
cout << setw(2) << matrix[j * ROW + i] << "; ";
j++;
}
i++;
cout << endl;
}
delete [] matrix;
return EXIT_SUCCESS;
}
Instruction de boucle imbriquée do...while
La syntaxe d'une instruction de boucle imbriquée do...while en C++ est la suivante :
do {
statement(s); // you can put more statements.
do {
statement(s);
} while( condition );
} while( condition );
Utiliser la boucle imbriquée do..while pour initialiser la matrice bidimensionnelle
#include <iostream>
#include <iomanip>
using std::cout;
using std::endl;
using std::setw;
constexpr int ROW = 4;
constexpr int COL = 3;
int main() {
int *matrix = new int[ROW * COL];
int j, i = 0;
do {
j = 0;
do {
matrix[j * ROW + i] = rand() % 100;
cout << setw(2) << matrix[j * ROW + i] << "; ";
j++;
} while (j < COL);
i++;
cout << endl;
} while (i < ROW);
delete [] matrix;
return EXIT_SUCCESS;
}
LES TABLEAUX
Les tableaux sont utilisés pour stocker plusieurs valeurs dans une seule variable, au lieu de
déclarer des variables distinctes pour chaque valeur.
Tous les tableaux sont constitués d'emplacements de mémoire contigus. L'adresse la plus basse
correspond au premier élément et l'adresse la plus haute au dernier élément.
Déclaration d’un tableau
Pour déclarer un tableau, définissez le type de la variable, précisez le nom du tableau suivi de
crochets et précisez le nombre d'éléments qu'il doit stocker :
type arrayName [ arraySize ];
Exemple :
string cars[4];
Nous avons maintenant déclaré une variable qui contient un tableau de quatre chaînes. Pour y
insérer des valeurs, nous pouvons utiliser un tableau littéral - placez les valeurs dans une liste
séparée par des virgules, à l'intérieur d'accolades :
string cars[4] = {"Volvo", "BMW", "Ford", "Mazda"};
Pour créer un tableau de trois entiers, vous pouvez écrire :
int myNum[3] = {10, 20, 30};
Accéder aux éléments d'un tableau
Vous accédez à un élément de tableau en vous référant au numéro d'index entre crochets [].
Cette instruction accède à la valeur du premier élément dans cars :
#include <iostream>
#include <string>
using namespace std;
int main() {
string cars[4] = {"Volvo", "BMW", "Ford", "Mazda"};
cout << cars[0];
return 0;
}
Remarque : Les index de tableau commencent par 0 : [0] est le premier élément. [1] est le
deuxième élément, etc.
Modifier un élément de tableau
Pour modifier la valeur d'un élément spécifique, reportez-vous au numéro d'index :
cars[0] = "Opel";
Exemple :
#include <iostream>
#include <string>
using namespace std;
int main() {
string cars[4] = {"Volvo", "BMW", "Ford", "Mazda"};
cout << cars[3];
return 0;
}
Boucle dans un tableau
Vous pouvez parcourir les éléments du tableau avec la boucle for .
L'exemple suivant affiche tous les éléments du tableau cars :
#include <iostream>
#include <string>
using namespace std;
int main() {
string cars[4] = {"Volvo", "BMW", "Ford", "Mazda"};
for (int i = 0; i < 4; i++) {
cout << cars[i] << "\n";
}
return 0;
}
L'exemple suivant génère l'index de chaque élément avec sa valeur :
#include <iostream>
#include <string>
using namespace std;
int main() {
string cars[4] = {"Volvo", "BMW", "Ford", "Mazda"};
for (int i = 0; i < 4; i++) {
cout << i << ": " << cars[i] << "\n";
}
return 0;
}
Omettre la taille du tableau
Vous n'avez pas à spécifier la taille du tableau. Mais si vous ne le faites pas, il ne sera aussi
grand que les éléments qui y sont insérés :
string cars[] = {"Volvo", "BMW", "Ford"}; // size of array is always 3
C'est tout à fait bien. Cependant, le problème se pose si vous voulez de l'espace supplémentaire
pour les futurs éléments. Ensuite, vous devez écraser les valeurs existantes :
string cars[] = {"Volvo", "BMW", "Ford"};
string cars[] = {"Volvo", "BMW", "Ford", "Mazda", "Tesla"};
Si vous spécifiez la taille cependant, le tableau réservera l'espace supplémentaire :
string cars[5] = {"Volvo", "BMW", "Ford"}; // size of array is 5, even though it's only three
elements inside it
Vous pouvez maintenant ajouter un quatrième et un cinquième élément sans écraser les autres :
#include <iostream>
#include <string>
using namespace std;
int main() {
string cars[5] = {"Volvo", "BMW", "Ford"};
cars[3] = "Mazda";
cars[4] = "Tesla";
for(int i = 0; i < 5; i++) {
cout << cars[i] << "\n";
}
return 0;
}
Omettre des éléments sur la déclaration
Il est également possible de déclarer un tableau sans spécifier les éléments lors de la déclaration,
et de les ajouter ultérieurement :
#include <iostream>
#include <string>
using namespace std;
int main() {
string cars[5];
cars[0] = "Volvo";
cars[1] = "BMW";
cars[2] = "Ford";
cars[3] = "Mazda";
cars[4] = "Tesla";
for(int i = 0; i < 5; i++) {
cout << cars[i] << "\n";
}
return 0;
}
Obtenir la taille d'un tableau
Pour obtenir la taille d'un tableau, vous pouvez utiliser l’opérateur sizeof():
#include <iostream>
using namespace std;
int main() {
int myNumbers[5] = {10, 20, 30, 40, 50};
cout << sizeof(myNumbers);
return 0;
}
Pourquoi le résultat s'affiche-t-il au 20lieu de 5, alors que le tableau contient 5 éléments ?
C'est parce que l' opérateur sizeof() renvoie la taille d'un type en octets . Vous avez appris du
chapitre Types de données qu'un int type est généralement de 4 octets, donc d'après l'exemple
ci-dessus, 4 x 5 (4 octets x 5 éléments) = 20 octets. Pour connaître le nombre d'éléments d'un
tableau, il faut diviser la taille du tableau par la taille du type de données qu'il contient :
#include <iostream>
using namespace std;
int main() {
int myNumbers[5] = {10, 20, 30, 40, 50};
int getArrayLength = sizeof(myNumbers) / sizeof(int);
cout << getArrayLength;
return 0;
}
Les tableaux multidimensionnels
C++ autorise les tableaux multidimensionnels. Voici la forme générale d'une déclaration de
tableau multidimensionnel. Un tableau multidimensionnel est un tableau de tableaux.
Déclaration
Pour déclarer un tableau multidimensionnel, définissez le type de variable, spécifiez le nom du
tableau suivi de crochets qui spécifient le nombre d'éléments du tableau principal, suivis d'un
autre ensemble de crochets qui indique le nombre d'éléments des sous-tableaux :
type name[size1][size2]...[sizeN];
Exemple :
string letters[2][4];
Tableaux bidimensionnels
La forme la plus simple du tableau multidimensionnel est le tableau à deux dimensions. Un
tableau à deux dimensions est, par essence, une liste de tableaux à une dimension. Pour déclarer
un tableau d'entiers à deux dimensions de taille x, y, vous écririez quelque chose comme suit type arrayName [ x ][ y ];
Un tableau à deux dimensions peut être considéré comme un tableau, qui aura un nombre x de
lignes et un nombre y de colonnes.
Initialisation de tableaux à deux dimensions
Les tableaux multidimensionnels peuvent être initialisés en spécifiant des valeurs entre
parenthèses pour chaque ligne. Voici un tableau avec 3 lignes et chaque ligne a 4 colonnes.
int a[3][4] = {
{0, 1, 2, 3} , /* initializers for row indexed by 0 */
{4, 5, 6, 7} , /* initializers for row indexed by 1 */
{8, 9, 10, 11} /* initializers for row indexed by 2 */
};
Les accolades imbriquées, qui indiquent la ligne voulue, sont facultatives. L'initialisation
suivante est équivalente à l'exemple précédent int a[3][4] = {0,1,2,3,4,5,6,7,8,9,10,11};
Comme avec les tableaux ordinaires, vous pouvez insérer des valeurs avec un littéral de tableau
- une liste séparée par des virgules à l'intérieur d'accolades. Dans un tableau multidimensionnel,
chaque élément d'un littéral de tableau est un autre littéral de tableau.
string letters[2][4] = {
{ "A", "B", "C", "D" },
{ "E", "F", "G", "H" }
};
Chaque ensemble de crochets dans une déclaration de tableau ajoute une autre dimension à un
tableau. Un tableau comme celui ci-dessus est dit à deux dimensions. Les tableaux peuvent
avoir n'importe quel nombre de dimensions. Plus un tableau a de dimensions, plus le code
devient complexe. Le tableau suivant a trois dimensions :
string letters[2][2][2] = {
{
{ "A", "B" },
{ "C", "D" }
},
{
{ "E", "F" },
{ "G", "H" }
}
};
Accéder aux éléments d'un tableau multidimensionnel
Pour accéder à un élément d'un tableau multidimensionnel, spécifiez un numéro d'index dans
chacune des dimensions du tableau. Cette instruction accède à la valeur de l'élément dans la
première ligne (0) et la troisième colonne (2) du tableau de lettres.
#include <iostream>
using namespace std;
int main() {
string letters[2][4] = {
{ "A", "B", "C", "D" },
{ "E", "F", "G", "H" }
};
cout << letters[1][3];
return 0;
}
Modifier les éléments d'un tableau multidimensionnel
Pour changer la valeur d'un élément, se référer au numéro d'index de l'élément dans chacune
des dimensions :
#include <iostream>
using namespace std;
int main() {
string letters[2][4] = {
{ "A", "B", "C", "D" },
{ "E", "F", "G", "H" }
};
letters[0][0] = "Z";
cout << letters[0][0];
return 0;
}
Boucle à travers un tableau multidimensionnel
Pour parcourir un tableau multidimensionnel, vous avez besoin d'une boucle pour chacune des
dimensions du tableau. L'exemple suivant affiche tous les éléments du tableau de lettres :
#include <iostream>
using namespace std;
int main() {
string letters[2][4] = {
{ "A", "B", "C", "D" },
{ "E", "F", "G", "H" }
};
for(int i = 0; i < 2; i++) {
for(int j = 0; j < 4; j++) {
cout << letters[i][j] << "\n";
}
}
return 0;
}
Cet exemple montre comment parcourir un tableau à trois dimensions :
#include <iostream>
using namespace std;
int main() {
string letters[2][2][2] = {
{
{ "A", "B" },
{ "C", "D" }
},
{
{ "E", "F" },
{ "G", "H" }
}
};
for(int i = 0; i < 2; i++) {
for(int j = 0; j < 2; j++) {
for(int k = 0; k < 2; k++) {
cout << letters[i][j][k] << "\n";
}
}
}
return 0;
}
Pourquoi des tableaux multidimensionnels ?
Les tableaux multidimensionnels sont parfaits pour représenter des grilles. Cet exemple montre
une utilisation pratique pour eux. Dans l'exemple suivant, nous utilisons un tableau
multidimensionnel pour représenter une petite partie de Battleship :
#include <iostream>
using namespace std;
int main() {
// On met "1" pour indiquer qu’il y a un vaisseau.
bool ships[4][4] = {
{ 0, 1, 1, 0 },
{ 0, 0, 0, 0 },
{ 0, 0, 1, 0 },
{ 0, 0, 1, 0 }
};
// Gardez une trace du nombre de coups que le joueur a et combien de tours qu’ils ont joué
dans ces variables
int hits = 0;
int numberOfTurns = 0;
// Permettre au joueur de continuer jusqu’à ce qu’ils aient frappé les quatre navires
while (hits < 4) {
int row, column;
cout << "Selecting coordinates\n";
// Demandez au joueur une rangée
cout << "Choisissez un numero de ligne entre 0 et 3 : ";
cin >> row;
// Demander une colonne au joueur
cout << "Choisissez un numero de colonne entre 0 et 3 : ";
cin >> column;
// Vérifiez si un navire se trouve dans ces coordonnées.
if (ships[row][column]) {
// Si le joueur frappe un vaisseau, supprimez-le en mettant la valeur à zéro.
ships[row][column] = 0;
// Augmenter le compteur de coups
hits++;
// Dites au joueur qu’il a heurté un navire et combien de navires restent
cout << "toucher! " << (4-hits) << " left.\n\n";
} else {
// Dites au joueur qu’il a manqué
cout << "rater\n\n";
}
// Compter le nombre de tours que le joueur a pris
numberOfTurns++;
}
cout << "succès!\n";
cout << "vous avez gagne!!!" << numberOfTurns << " turns";
return 0;
}
Les Structures de donneés
Les structures (également appelées structures) sont un moyen de regrouper plusieurs variables
liées en un seul endroit. Chaque variable de la structure est connue comme un membre de la
structure. Contrairement à un tableau, une structure peut contenir de nombreux types de
données différents (int, string, bool, etc.).
Créer une structure
Pour créer une structure, utilisez le struct mot clé et déclarez chacun de ses membres à l'intérieur
d'accolades. Après la déclaration, précisez le nom de la variable de structure ( maStructure dans
l'exemple ci-dessous) :
struct {
// Structure declaration
int myNum;
// Member (int variable)
string myString; // Member (string variable)
} myStructure;
// Structure variable
Accéder aux membres de la structure
Pour accéder aux membres d'une structure, utilisez la syntaxe à points ( .) :
#include <iostream>
#include <string>
using namespace std;
int main() {
struct {
int myNum;
string myString;
} myStructure;
myStructure.myNum = 1;
myStructure.myString = "Hello World!";
cout << myStructure.myNum << "\n";
cout << myStructure.myString << "\n";
return 0;
}
Une structure en plusieurs variables
Vous pouvez utiliser une virgule (,) pour utiliser une structure dans plusieurs variables :
struct {
int myNum;
string myString;
} myStruct1, myStruct2, myStruct3; // Multiple structure variables separated with commas
Cet exemple montre comment utiliser une structure dans deux variables différentes :
Utilisez une structure pour représenter deux voitures :
#include <iostream>
#include <string>
using namespace std;
int main() {
struct {
string brand;
string model;
int year;
} myCar1, myCar2; // We can add variables by separating them with a comma here
// Put data into the first structure
myCar1.brand = "BMW";
myCar1.model = "X5";
myCar1.year = 1999;
// Put data into the second structure
myCar2.brand = "Ford";
myCar2.model = "Mustang";
myCar2.year = 1969;
// Print the structure members
cout << myCar1.brand << " " << myCar1.model << " " << myCar1.year << "\n";
cout << myCar2.brand << " " << myCar2.model << " " << myCar2.year << "\n";
return 0;
}
Structures nommées
En donnant un nom à la structure, vous pouvez la traiter comme un type de données. Cela
signifie que vous pouvez créer des variables avec cette structure n'importe où dans le
programme et à tout moment.
Pour créer une structure nommée, mettez le nom de la structure juste après le mot- clé struct :
struct myDataType { // This structure is named "myDataType"
int myNum;
string myString;
};
Pour déclarer une variable qui utilise la structure, utilisez le nom de la structure comme type de
données de la variable :
myDataType myVar;
Exemple
Utilisez une structure pour représenter deux voitures :
#include <iostream>
#include <string>
using namespace std;
// Declare a structure named "car"
struct car {
string brand;
string model;
int year;
};
int main() {
// Create a car structure and store it in myCar1;
car myCar1;
myCar1.brand = "BMW";
myCar1.model = "X5";
myCar1.year = 1999;
// Create another car structure and store it in myCar2;
car myCar2;
myCar2.brand = "Ford";
myCar2.model = "Mustang";
myCar2.year = 1969;
// Print the structure members
cout << myCar1.brand << " " << myCar1.model << " " << myCar1.year << "\n";
cout << myCar2.brand << " " << myCar2.model << " " << myCar2.year << "\n";
return 0;
}
REFERENCES
Création de références
Une variable de référence est une "référence" à une variable existante, et elle est créée avec
l’opérateur & :
string food = "Pizza"; // food variable
string &meal = food;
// reference to food
Maintenant, nous pouvons utiliser soit le nom de la variable food ou soit le nom de la référence
meal pour faire référence à la variable food :
#include <iostream>
#include <string>
using namespace std;
int main() {
string food = "Pizza";
string &meal = food;
cout << food << "\n";
cout << meal << "\n";
return 0;
}
Adresse mémoire
Dans l'exemple de la page précédente, l’opérateur & a été utilisé pour créer une variable de
référence. Mais il peut aussi être utilisé pour obtenir l'adresse mémoire d'une variable ; qui est
l'emplacement où la variable est stockée sur l'ordinateur.
Lorsqu'une variable est créée en C++, une adresse mémoire est affectée à la variable. Et lorsque
nous attribuons une valeur à la variable, elle est stockée dans cette adresse mémoire.
Pour y accéder, utilisez l’opérateur &, et le résultat représentera l'endroit où la variable est
stockée :
#include <iostream>
#include <string>
using namespace std;
int main() {
string food = "Pizza";
cout << &food;
return 0;
}
Remarque : L'adresse mémoire est au format hexadécimal (0x..). Notez que vous n'obtiendrez
peut-être pas le même résultat dans votre programme.
Et pourquoi est-il utile de connaître l'adresse mémoire ?
Les références et les pointeurs (que vous découvrirez dans le chapitre suivant) sont importants
en C++, car ils vous permettent de manipuler les données dans la mémoire de l'ordinateur, ce
qui peut réduire le code et améliorer les performances.
Les Pointeurs
Création de pointeurs
Vous avez appris du chapitre précédent, que nous pouvons obtenir l’adresse mémoire d'une
variable en utilisant l'opérateur & :
#include <iostream>
#include <string>
using namespace std;
int main() {
string food = "Pizza";
cout << food << "\n";
cout << &food << "\n";
return 0;
}
Cependant, un pointeur est une variable qui stocke l'adresse mémoire comme sa valeur.
Une variable de pointeur pointe vers un type de données (comme int ou string) du même type
et est créée avec l’opérateur *. L'adresse de la variable avec laquelle vous travaillez est assignée
au pointeur :
#include <iostream>
#include <string>
using namespace std;
int main() {
string food = "Pizza"; // A string variable
string* ptr = &food; // A pointer variable that stores the address of food
// Output the value of food
cout << food << "\n";
// Output the memory address of food
cout << &food << "\n";
// Output the memory address of food with the pointer
cout << ptr << "\n";
return 0;
}
Exemple expliqué
Créez une variable de pointeur avec le nom ptr, qui pointe vers une variable string, en utilisant
le signe astérisque *(string* ptr). Notez que le type du pointeur doit correspondre au type de la
variable avec laquelle vous travaillez. Utilisez l’opérateur & pour stocker l'adresse mémoire de
la variable appelée food et affectez-la au pointeur. Maintenant, ptr contient la valeur de food de
l'adresse mémoire.
Astuce : Il existe trois manières de déclarer des variables de pointeur, mais la première est
préférable :
string* mystring; // Preferred
string *mystring;
string * mystring;
Déréférencement (Obtenir l'adresse et la valeur de la mémoire)
Dans l'exemple de la page précédente, nous avons utilisé la variable pointeur pour obtenir
l'adresse mémoire d'une variable (utilisée avec l’opérateur & de référence). Cependant, vous
pouvez également utiliser le pointeur pour obtenir la valeur de la variable, en utilisant
l’opérateur * (l’opérateur de déréférencement)
#include <iostream>
#include <string>
using namespace std;
int main() {
string food = "Pizza"; // Variable declaration
string* ptr = &food;
// Pointer declaration
// Reference: Output the memory address of food with the pointer
cout << ptr << "\n";
// Dereference: Output the value of food with the pointer
cout << *ptr << "\n";
return 0;
}
Notez que le signe * peut prêter à confusion ici, car il fait deux choses différentes dans notre
code :
 Lorsqu'il est utilisé dans une déclaration (string* ptr), il crée une variable de pointeur.
 Lorsqu'il n'est pas utilisé dans une déclaration, il agit comme un opérateur de
déréférencement.
Modifier la valeur du pointeur
Vous pouvez également modifier la valeur du pointeur. Mais notez que cela changera également
la valeur de la variable d'origine :
#include <iostream>
#include <string>
using namespace std;
int main() {
string food = "Pizza";
string* ptr = &food;
// Output the value of food
cout << food << "\n";
// Output the memory address of food
cout << &food << "\n";
// Access the memory address of food and output its value
cout << *ptr << "\n";
// Change the value of the pointer
*ptr = "Hamburger";
// Output the new value of the pointer
cout << *ptr << "\n";
// Output the new value of the food variable
cout << food << "\n";
return 0;
}