Trinity Pro - Fondamentaux C++

1. Introduction au C++

Qu'est-ce que C++?

C++ est un langage de programmation créé par Bjarne Stroustrup en 1979 comme une extension du langage C. Il ajoute des fonctionnalités orientées objet au C, tout en conservant sa puissance et sa flexibilité. C++ est un langage compilé, ce qui signifie que le code source est transformé en code machine avant l'exécution.

Caractéristiques principales:

Langage multi-paradigme (procédural, orienté objet, générique)
Performance élevée et contrôle précis de la mémoire
Portabilité sur différentes plateformes
Riche bibliothèque standard (STL)
Compatibilité avec le code C

Applications du C++

Le C++ est utilisé dans de nombreux domaines:

Développement de systèmes d'exploitation
Développement de jeux vidéo
Applications hautes performances
Systèmes embarqués
Outils de sécurité informatique et hacking éthique
Intelligence artificielle et apprentissage automatique

Pourquoi apprendre C++? Sa maîtrise vous donne une compréhension profonde du fonctionnement des ordinateurs et vous permet de développer des applications performantes. Dans le domaine du hacking éthique et de la sécurité, C++ est souvent utilisé pour créer des outils d'analyse et d'exploitation.

2. Environnement de développement

Installation d'un compilateur

Pour programmer en C++, vous avez besoin d'un compilateur. Voici les options les plus populaires:

Sous Windows:

Visual Studio Community - IDE complet avec compilateur MSVC
MinGW-w64 - Port de GCC pour Windows
Clang - Compilateur moderne basé sur LLVM

Sous Linux:

GCC (g++) - Le compilateur GNU C++
Clang - Alternative à GCC

Sous macOS:

Xcode - IDE d'Apple avec compilateur Clang
Homebrew + GCC/Clang - Installation via le gestionnaire de paquets

Premier programme

Voici un exemple du fameux "Hello, World!" en C++:

#include <iostream>

int main() {
    std::cout << "Hello, World!" << std::endl;
    return 0;
}

Compilation et exécution:

# Avec g++
g++ -o hello hello.cpp

# Avec clang++
clang++ -o hello hello.cpp

# Exécution
./hello

Conseil: Utilisez des options de compilation comme -Wall -Wextra -std=c++17 pour activer les avertissements et utiliser les fonctionnalités modernes du C++.

3. Syntaxe de base

Structure d'un programme C++

Un programme C++ typique contient les éléments suivants:

Directives de préprocesseur - Commencent par # (ex: #include)
Fonction main() - Point d'entrée du programme
Déclarations - Variables, fonctions, classes
Instructions - Actions à exécuter
Commentaires - Documentation du code

Exemple commenté:

// Inclusion de la bibliothèque d'entrée/sortie
#include <iostream>

// Définition d'une constante
#define PI 3.14159

// Fonction principale - point d'entrée du programme
int main() {
    // Déclaration de variable
    double rayon = 5.0;
    
    // Calcul et affichage
    double aire = PI * rayon * rayon;
    std::cout << "L'aire du cercle est: " << aire << std::endl;
    
    // Valeur de retour (0 = succès)
    return 0;
}

Commentaires et bonnes pratiques

Les commentaires sont essentiels pour documenter votre code:

// Commentaire sur une ligne

/* Commentaire
   sur plusieurs
   lignes */

Bonnes pratiques:

Utilisez des noms de variables descriptifs
Indentez votre code de manière cohérente
Commentez les parties complexes ou non évidentes
Suivez une convention de nommage cohérente
Limitez la portée des variables

4. Variables et Types

Types de données fondamentaux

C++ offre plusieurs types de données intégrés:

Type	Description	Exemple
`int`	Entier signé	`int age = 25;`
`float`	Nombre à virgule flottante (simple précision)	`float prix = 19.99f;`
`double`	Nombre à virgule flottante (double précision)	`double pi = 3.14159;`
`char`	Caractère	`char grade = 'A';`
`bool`	Booléen (vrai/faux)	`bool estActif = true;`

Modificateurs:

short, long, long long - Modifient la taille
signed, unsigned - Modifient la plage

unsigned long long grandNombrePositif = 18446744073709551615ULL;

Hiérarchie des Types en C++:

Déclaration et initialisation

Il existe plusieurs façons de déclarer et initialiser des variables:

// Déclaration simple
int compteur;

// Initialisation
int valeur = 42;

// Initialisation uniforme (C++11 et plus)
int nombre{100};

// Déclaration multiple
int x = 1, y = 2, z = 3;

// Inférence de type avec auto (C++11 et plus)
auto resultat = x + y;

Constantes:

// Constante nommée
const double PI = 3.14159;

// Constante symbolique (préprocesseur)
#define MAX_UTILISATEURS 100

// Énumération
enum Couleur { ROUGE, VERT, BLEU };

Attention: Les variables non initialisées contiennent des valeurs indéterminées. Toujours initialiser vos variables!

5. Opérateurs

Opérateurs arithmétiques

Les opérations mathématiques de base:

Opérateur	Description	Exemple
`+`	Addition	`a + b`
`-`	Soustraction	`a - b`
`*`	Multiplication	`a * b`
`/`	Division	`a / b`
`%`	Modulo (reste)	`a % b`

Opérateurs d'incrémentation/décrémentation:

int a = 5;
a++;    // Post-incrémentation: a = 6
++a;    // Pré-incrémentation: a = 7
a--;    // Post-décrémentation: a = 6
--a;    // Pré-décrémentation: a = 5

Opérateurs de comparaison et logiques

Pour les expressions conditionnelles:

Opérateurs de comparaison:

a == b    // Égalité
a != b    // Inégalité
a < b     // Inférieur à
a > b     // Supérieur à
a <= b    // Inférieur ou égal à
a >= b    // Supérieur ou égal à

Opérateurs logiques:

a && b    // ET logique
a || b    // OU logique
!a        // NON logique

Note: Les opérateurs logiques utilisent l'évaluation en court-circuit. Dans a && b, si a est faux, b n'est pas évalué.

Opérateurs bit à bit et d'affectation

Pour les manipulations au niveau des bits:

Opérateurs bit à bit:

a & b     // ET bit à bit
a | b     // OU bit à bit
a ^ b     // OU exclusif bit à bit
~a        // NON bit à bit
a << b    // Décalage à gauche
a >> b    // Décalage à droite

Opérateurs d'affectation composés:

a += b    // a = a + b
a -= b    // a = a - b
a *= b    // a = a * b
a /= b    // a = a / b
a %= b    // a = a % b
a &= b    // a = a & b
a |= b    // a = a | b
a ^= b    // a = a ^ b
a <<= b   // a = a << b
a >>= b   // a = a >> b

6. Structures de contrôle

Instructions conditionnelles

Pour exécuter du code en fonction de conditions:

if-else:

if (condition) {
    // Code exécuté si condition est vraie
} else if (autre_condition) {
    // Code exécuté si autre_condition est vraie
} else {
    // Code exécuté si aucune condition n'est vraie
}

Opérateur ternaire:

// condition ? valeur_si_vrai : valeur_si_faux
int max = (a > b) ? a : b;

switch-case:

switch (expression) {
    case valeur1:
        // Code pour valeur1
        break;
    case valeur2:
        // Code pour valeur2
        break;
    default:
        // Code par défaut
}

Attention: N'oubliez pas le break dans chaque case du switch, sinon l'exécution continue aux cases suivantes!

Boucles

Pour répéter des instructions:

Boucle for:

// for (initialisation; condition; incrémentation)
for (int i = 0; i < 10; i++) {
    std::cout << i << " ";
}

// for basé sur une plage (C++11)
int tableau[5] = {1, 2, 3, 4, 5};
for (int valeur : tableau) {
    std::cout << valeur << " ";
}

Boucle while:

// Vérifie la condition avant d'exécuter
while (condition) {
    // Code répété tant que condition est vraie
}

Boucle do-while:

// Exécute au moins une fois, puis vérifie la condition
do {
    // Code exécuté au moins une fois
} while (condition);

Contrôle de boucle:

// Sortir d'une boucle
break;

// Passer à l'itération suivante
continue;

Conseil: Choisissez la boucle appropriée selon votre besoin. for pour un nombre connu d'itérations, while pour une condition d'arrêt, do-while quand le code doit s'exécuter au moins une fois.

7. Fonctions

Définition et appel de fonctions

Les fonctions permettent de structurer et réutiliser le code:

Syntaxe de base:

// Déclaration (prototype)
type_retour nom_fonction(type_param1 param1, type_param2 param2);

// Définition
type_retour nom_fonction(type_param1 param1, type_param2 param2) {
    // Corps de la fonction
    return valeur;  // Retourne une valeur du type spécifié
}

// Appel
resultat = nom_fonction(arg1, arg2);

Exemple:

// Prototype
int additionner(int a, int b);

// Définition
int additionner(int a, int b) {
    return a + b;
}

// Utilisation
int somme = additionner(5, 3);  // somme = 8

Fonctionnalités avancées

C++ offre plusieurs fonctionnalités avancées pour les fonctions:

Paramètres par défaut:

void afficher(std::string message, bool newline = true) {
    std::cout << message;
    if (newline) std::cout << std::endl;
}

// Appels
afficher("Hello");        // Avec saut de ligne
afficher("Hello", false); // Sans saut de ligne

Surcharge de fonctions:

// Plusieurs fonctions avec le même nom mais des paramètres différents
int multiplier(int a, int b) {
    return a * b;
}

double multiplier(double a, double b) {
    return a * b;
}

Fonctions inline:

// Suggestion au compilateur d'insérer le code de la fonction
// directement à l'endroit de l'appel
inline int carre(int x) {
    return x * x;
}

Fonctions récursives:

// Fonction qui s'appelle elle-même
int factorielle(int n) {
    if (n <= 1) return 1;
    return n * factorielle(n - 1);
}

Note: La récursion peut être élégante mais consomme plus de mémoire (pile d'appels). Utilisez-la avec précaution pour les problèmes qui s'y prêtent naturellement.

8. Tableaux et Chaînes

Tableaux

Les tableaux permettent de stocker plusieurs valeurs du même type:

Fondamentaux C++

Table des matières