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; }