Guide Essentiel C++ : Votre Cheat Sheet Ultime pour un Code Performant

Vous débutez en C++, ou cherchez une référence rapide pour vos projets ? Ce guide concis et pratique est conçu pour vous aider à maîtriser les bases et optimiser votre code, le tout condensé dans un format facile à consulter. Gagnez du temps et boostez votre productivité avec ce cheat sheet C++ !

Créez Votre Premier Programme C++ Facilement

Envie de démarrer rapidement ? Voici un exemple simple pour afficher "Hello World!" et comprendre la structure de base.

#include <iostream>
using namespace std;

int main() {
  cout << "Hello World!";
  return 0;
}

Sortie:

Hello World!

Syntaxe de Base du C++: Une Structure Claire et Efficace

Comprendre la structure de votre code est crucial. Apprenez à organiser votre code C++ pour une meilleure lisibilité et maintenance.

// Inclure les fichiers d'en-tête nécessaires
#include <iostream>

// Utilisation de l'espace de noms std pour simplifier le code
using namespace std;

// La fonction main() est le point de départ de l'exécution du programme
int main() {
  // Ici, écrivez vos instructions de code
  return 0; // Indique que le programme s'est exécuté avec succès
}

Maîtrisez les Commentaires C++ : Simplifiez la Compréhension de Votre Code

Les commentaires sont essentiels pour expliquer votre code et faciliter la collaboration. Découvrez les types de commentaires disponibles et comment les utiliser efficacement.

• Commentaire sur une seule ligne: Utilisez // pour ajouter une explication rapide.

  // Ceci est un commentaire sur une seule ligne cout << "GeeksforGeeks";

• Commentaire multiligne: Utilisez /* et */ pour des explications plus détaillées.

  /* Ceci est un commentaire multiligne. L'instruction ci-dessous affichera GeeksforGeeks. */ cout << "GeeksforGeeks";

Déclarez et Utilisez les Variables C++ avec Confiance

Les variables sont essentielles pour stocker et manipuler les données. Apprenez à les déclarer correctement.

• Déclaration d'une seule variable: data_type var_name;

• Déclaration de plusieurs variables: data_type var1_name, var2_name, var3_name;

Les Types de Données C++ : Choisissez le Type Adapté à Vos Besoins

Le choix du type de données approprié optimise la performance et la gestion de la mémoire.

1. int (Entier) : Stocke les nombres entiers (4 octets).

   int var = 123;

2. char (Caractère) : Stocke un seul caractère (1 octet).

   char var = 'a';

3. float (Virgule flottante) : Stocke les nombres à virgule flottante simple précision (4 octets).

   float num = 1.23;

4. double (Double précision) : Stocke les nombres à virgule flottante double précision (8 octets).

   double num = 1.2345;

5. bool (Booléen) : Stocke les valeurs logiques true ou false.

   bool b = false;

6. string (Chaîne de caractères) : Stocke des séquences de caractères. N'oubliez pas d'inclure <string>.

   string str = "GeeksforGeeks";

Entrées et Sorties C++ : Communiquez Facilement avec l'Utilisateur

Interagissez avec l'utilisateur et affichez des résultats grâce aux flux d'entrée/sortie.

1. Entrée utilisateur (cin):

   int var; cin >> var;

2. Sortie console (cout):

   cout << "Hello World";

3. Sauts de ligne (\n et endl):

   cout << "Hello World!\n"; cout << "Hello World!" << endl;

Conditions en C++ : Contrôlez le Flux de Votre Programme

Les instructions conditionnelles permettent d'exécuter différents blocs de code en fonction de conditions.

1. if (Si):

   if (condition) { // Code exécuté si la condition est vraie }

2. if-else (Si-Sinon):

   if (condition) { // Code exécuté si la condition est vraie } else { // Code exécuté si la condition est fausse }

3. else if (Sinon si):

   if (condition1) { // Code exécuté si condition1 est vraie } else if (condition2) { // Code exécuté si condition2 est vraie } else { // Code exécuté si toutes les conditions sont fausses }

4. Opérateur Ternaire (Si-Alors-Sinon concis):

   (condition) ? expression1 : expression2;

5. switch (Sélection multiple):

   switch (expression) { case value1: // Code exécuté si expression == value1 break; case value2: // Code exécuté si expression == value2 break; default: // Code exécuté si aucune correspondance break; }

Boucles en C++ : Répétez des Actions Efficacement

Les boucles permettent de répéter un bloc de code plusieurs fois.

1. for (Pour):

   for (initialization; test; update) { // Code à répéter }

2. while (Tant que):

   while (condition) { // Code à répéter update_condition; }

3. do-while (Faire-Tant que):

   do { // Code à répéter } while (condition);

Tableaux en C++ : Stockez des Collections de Données

Les tableaux permettent de stocker une séquence d'éléments du même type.

1. Déclaration d'un tableau:

   dataType array_name[size];

   Exemple :

   #include <iostream>
   #include <string>
   using namespace std;
   int main(){
   // Déclarer et initialiser un tableau de chaînes de caractères
   string fruits[] = {"Apple","Banana","Orange","Grapes"};
   // Accéder et afficher chaque élément du tableau
   for(int i = 0; i < 4; i++){
   cout << "Fruit à l'index " << i <<": " << fruits[i] << endl;
   }
   return 0;
   }
   

2. Tableaux multidimensionnels:

   dataType array_name[size1][size2]....[sizeN];

   Exemple :

   #include <iostream>
   using namespace std;
   int main()
   {
   // Déclaration et initialisation d'un tableau 2D
   int arr[3][4] = {{1, 2, 3, 4},
                   {5, 6, 7, 8},
                   {9, 10, 11, 12}};
   // Accéder aux éléments du tableau 2D
   // Sortie: 1
   cout << "Element à arr[0][0]: " << arr[0][0] << endl;
   return 0;
   }
   

Vecteurs en C++ : Manipulez des Tableaux Dynamiques avec Facilité

Les vecteurs offrent une alternative flexible aux tableaux, avec une taille variable.

Syntaxe pour déclarer un Vecteur

vector vector_name;

Fonctions Vector couramment utilisées

• push_back() – Il est utilisé pour insérer les éléments à la fin du vecteur.
• pop_back() – Il est utilisé pour extraire ou supprimer des éléments de la fin du vecteur.
• clear() – Il est utilisé pour supprimer tous les éléments du vecteur.
• empty() – Il est utilisé pour vérifier si le vecteur est vide.
• at(i) – Il est utilisé pour accéder à l'élément à l'indice spécifié ‘i’.
• front() – Il est utilisé pour accéder au premier élément du vecteur.
• back() – Il est utilisé pour accéder au dernier élément du vecteur.
• erase() – Il est utilisé pour supprimer un élément à une position spécifiée.

Exemple

#include <iostream>
#include <vector>
using namespace std;
int main()
{
    // Créer un vecteur vide
    vector<int> nombres;
    // push_back()
    nombres.push_back(10);
    nombres.push_back(20);
    nombres.push_back(30);
    // Accéder aux éléments en utilisant at()
    // Output: 10
    cout << "Element at index 0: " << nombres.at(0) << endl;
    // Output: 30
    cout << "Element at index 2: " << nombres.at(2) << endl;
    // pop_back()
    nombres.pop_back();
    // Output: 2
    cout << "Vector size after pop_back(): " << nombres.size() << endl;
    // clear()
    nombres.clear();
    // Output: Vector is empty
    if (nombres.empty()) {
        cout << "Vector is empty" << endl;
    }
    return 0;
}

Références et Pointeurs en C++ : Maîtrisez la Gestion de la Mémoire

Comprenez les références et les pointeurs pour une gestion efficace de la mémoire.

Références

Une référence est un alias pour une variable existante. Elle partage la même adresse mémoire que la variable d'origine.

Exemple

int var = 12;

// Une variable référence à var

int& ref = var;

ref est une référence à var.

Pointeurs

Un pointeur est une variable qui stocke l'adresse mémoire d'une autre variable. Il peut être créé en utilisant l'opérateur * et l'adresse d'une autre variable peut être assignée en utilisant l'opérateur d'adresse &.

Exemple

int i = 3;

// Un pointeur vers la variable i ou "stocke l'adresse de i"

*int ptr = &i;

Fonctions en C++ : Organisez Votre Code en Blocs Réutilisables

Les fonctions permettent de diviser votre programme en blocs logiques réutilisables.

Syntaxe pour la déclaration de fonction

return_type function_name(parameters);

Syntaxe pour la définition de fonction

return_type function_name(parameters) {

// corps de la fonction

// code à exécuter

// instruction de retour (si applicable)

}

return_type: C'est le type de données de la valeur qu'une fonction renvoie.

function_name: C'est le nom de la fonction.

parameters: Les paramètres sont les valeurs d'entrée fournies lorsque la fonction est appelée. Les paramètres sont facultatifs.

Exemple

Programme pour additionner deux nombres.

#include <iostream>
using namespace std;
// Déclaration de la fonction
int sum(int a, int b);
// Définition de la fonction
int sum(int a, int b){
  return a + b;
}
int main()
{
  // Appel de la fonction
  int result = sum(3, 4);
  cout << "La somme est: " << result << endl;
  return 0;
}

Fonctions de Chaîne C++ : Manipulez le Texte avec Précision

Les fonctions de chaîne offrent une variété d'outils pour manipuler les chaînes de caractères.

1. length() Fonction

Elle est utilisée pour trouver la longueur d'une chaîne donnée.

Syntaxe

string_name. length();

Exemple

#include <iostream>
#include <string>
using namespace std;
int main() {
  string str = "GeeksforGeeks";
  cout << "La longueur de la chaîne est : " << str.length();
}

2. substr() Fonction

Elle est utilisée pour extraire une sous-chaîne d'une chaîne donnée.

Syntaxe

string substr(size_t pos, size_t len) const;

pos: Position du premier caractère à copier.

len: Longueur de la sous-chaîne.

size_t: C'est un type intégral non signé.

Exemple

#include <iostream>
#include <string>
using namespace std;
int main()
{
 string str = "GeeksforGeeks";
 // Extrait une sous-chaîne commençant à
 // l'index 7 avec une longueur de 5
 string sub = str.substr(7, 5);
 cout << "Sous-chaîne: " << sub << endl;
 return 0;
}

3. append() Fonction

Elle est utilisée pour ajouter une chaîne à la fin d'une autre chaîne.

Syntaxe

string_name. append(string& str);

Exemple

#include <iostream>
#include <string>
using namespace std;
int main(){
  string str = "Geeksfor";
  str.append("Geeks");
  cout << "Chaîne ajoutée: " << str << endl;
  return 0;
}

4. compare() Fonction

Elle est utilisée pour comparer deux chaînes.

Syntaxe

string_name. compare(string& str);

Exemple

#include <iostream>
#include <string>
using namespace std;
int main(){
  string str1 = "Geeks";
  string str2 = "for";
  string str3 = "Geeks";
  int result1 = str1.compare(str2);
  cout << "Résultat de la comparaison: " << result1 << endl;
  return 0;
}

5. empty() Fonction

Elle est utilisée pour vérifier si une chaîne est vide ou non.

Syntaxe

string_name. empty();

Exemple

#include <iostream>
#include <string>
using namespace std;
int main(){
  string str1 = "GeeksforGeeks";
  string str2 = "";
  if(str1.empty()){
    cout << "str1 est vide" << endl;
  }
  else{
    cout << "str1 n'est pas vide" << endl;
  }
  if(str2.empty()){
    cout << "str2 est vide" << endl;
  }
  else{
    cout << "str2 n'est pas vide" << endl;
  }
  return 0;
}

Concepts Avancés de Programmation Orientée Objet (POO) en C++ : Construisez des Applications Robustes

Comprenez les principes fondamentaux de la POO pour développer des applications complexes et maintenables.

1. Classe

Elle est une collection de variables membres et de fonctions membres. Elle peut être définie en utilisant le mot-clé class.

2. Objet

Un objet est une instance d'une classe.

3. Polymorphisme

Le polymorphisme est la capacité d'un objet à prendre plusieurs formes. Ou, en d'autres termes, le polymorphisme signifie qu'une tâche peut être effectuée de différentes manières.

Types de Polymorphisme

• Polymorphisme au moment de la compilation
• Polymorphisme au moment de l'exécution

Le polymorphisme au moment de la compilation peut être réalisé en utilisant :

• Surcharge d'opérateur
• Surcharge de fonction

Le polymorphisme au moment de l'exécution peut être réalisé en utilisant :

• Redéfinition de fonction
• Fonctions virtuelles

4. Héritage

L'héritage consiste à dériver les propriétés d'une classe (classe Parent) vers une autre classe (classe Enfant). Il est utilisé pour la réutilisabilité du code.

Types d'héritage :

• Héritage Simple : Lorsqu'une classe dérivée hérite des propriétés d'une seule classe de base, on parle d'Héritage Simple.
• Héritage Multiple : Lorsqu'une classe dérivée hérite des propriétés de plusieurs classes de base, on parle d'Héritage Multiple.
• Héritage Multi-niveau : Lorsqu'une classe dérivée hérite des propriétés d'une autre classe dérivée, on parle d'Héritage Multi-niveau.
• Héritage Hiérarchique : Lorsqu'une classe de base est héritée par plusieurs classes dérivées, on parle d'Héritage Hiérarchique.