C++

Noyau du langage, gestion de la mémoire, STL et C++ moderne (11/17/20) ; écrire un code rapide, sûr et lisible.

Qu’est-ce que C# ?

C# est un langage à typage statique développé par Microsoft qui combine des fonctionnalités orientées objet et fonctionnelles. Avec .NET 8, il est multiplateforme (Windows, Linux, macOS) et s’utilise pour des API web, des applications de bureau, des services cloud, des tâches en arrière-plan et des jeux (Unity) sur un large éventail.

Écosystème : ASP.NET Core (web), Entity Framework Core (accès aux données), xUnit/NUnit (tests), NuGet (gestion des paquets) et la CLI dotnet (ligne de commande).

TL;DR

C# moderne : records, correspondance de motifs (pattern matching), async/await, et span/memory pour la performance.
Services REST rapides avec Minimal APIs ; CRUD efficace et LINQ avec EF Core.
Architecture en couches + injection de dépendances pour un design testable.

Fondamentaux

Sujets d’introduction au C++ : syntaxe de base, variables, opérateurs, boucles et fonctions.

Qu’est-ce que le C++ ? Premiers pas en programmation

28 mai 2026 • Fondamentaux

Découvrez les bases du langage C++, ses concepts fondamentaux et vos premiers programmes avec des exemples simples.

Bases de C++ C++

Lire →

Installer le compilateur et l’IDE C++ (Visual Studio, GCC, Clang)

28 mai 2026 • Fondamentaux

Apprenez à installer un environnement de développement C++ avec Visual Studio, GCC et Clang étape par étape.

C++ Visual Studio

Lire →

Premier programme en C++ : comment fonctionne « Hello World »

28 mai 2026 • Fondamentaux

Créez votre premier programme C++ et découvrez comment fonctionne « Hello World » avec compilation et exécution.

Bases de C++ C++

Lire →

Variables, types de données et auto en C++

28 mai 2026 • Fondamentaux

Apprenez les variables, types de données et le mot-clé auto en C++ avec des exemples de déduction de type.

Bases de C++ C++ Types de Données Variables

Lire →

Opérateurs en C++ : arithmétiques, comparaisons, logiques

28 mai 2026 • Fondamentaux

Apprenez les opérateurs arithmétiques, logiques et de comparaison en C++ avec des exemples pratiques.

Bases de C++ C++ Opérateurs

Lire →

Instructions conditionnelles en C++ : if, else if, switch

28 mai 2026 • Fondamentaux

Apprenez les instructions conditionnelles en C++ avec if, else if et switch pour contrôler le flux du programme.

C++ Instruction if

Lire →

Boucles en C++ : for, while, do-while

28 mai 2026 • Fondamentaux

Apprenez les boucles en C++ avec for, while et do-while pour répéter des opérations et contrôler le flux du programme.

Boucle for Boucle while C++

Lire →

Introduction aux fonctions en C++ : définition, appel, paramètres

28 mai 2026 • Fondamentaux

Apprenez les fonctions en C++ : définition, appel et paramètres pour créer des programmes modulaires.

Bases de C++ C++

Lire →

Portée (Scope) et durée de vie en C++

28 mai 2026 • Fondamentaux

Apprenez la portée et la durée de vie en C++ pour comprendre la visibilité des variables et la gestion mémoire.

C++

Lire →

Manipulation de chaînes en C++ : C-Style et std::string

28 mai 2026 • Fondamentaux

Apprenez la manipulation de chaînes en C++ avec les chaînes C-Style et std::string à travers des exemples pratiques.

C++ Opérations sur les Chaînes

Lire →

En C++, passer des objets volumineux par référence const permet d’éviter des copies inutiles et d’améliorer les performances.


void print(const std::vector<int>& values)
{
    for (int v : values)
    {
        std::cout << v << std::endl;
    }
}

En C++, il vaut mieux éviter les return true et return false inutiles. Retourner directement la condition rend le code plus clair.


// inutile
bool isPositive(int value)
{
    if (value > 0)
        return true;
    else
        return false;
}

// plus clair
bool isPositive(int value)
{
    return value > 0;
}

En C++, il est important de toujours vérifier le résultat de std::find. Si l’élément n’est pas trouvé, l’itérateur vaut end().


std::vector<int> numbers = {1, 2, 3};

auto it = std::find(numbers.begin(), numbers.end(), 5);

if (it != numbers.end())
{
    std::cout << "Trouvé : " << *it << std::endl;
}
else
{
    std::cout << "Non trouvé" << std::endl;
}

En C++, il est recommandé d’éviter les magic numbers. Utiliser des constantes rend le code plus clair et plus facile à maintenir.


// magic number
if (retryCount > 3)
{
    stop();
}

// meilleure approche
const int maxRetries = 3;
if (retryCount > maxRetries)
{
    stop();
}

En C++, il est préférable d’utiliser nullptr au lieu de NULL. nullptr est sûr au niveau du type et évite les comparaisons ambiguës.


int* ptr = nullptr;

if (ptr == nullptr)
{
    // vérification sûre de null
}

En C++, const auto& est souvent utilisé pour éviter des copies inutiles tout en gardant un code lisible et sûr.


std::vector<std::string> names = {"Alice", "Bob", "Charlie"};

// chaque élément est copié
for (auto name : names)
{
    std::cout << name << std::endl;
}

// aucune copie, plus sûr
for (const auto& name : names)
{
    std::cout << name << std::endl;
}

En C++, éviter les blocs else inutiles rend le code plus lisible en réduisant l’imbrication.


bool isValid = false;

// moins lisible
if (isValid)
{
    std::cout << "Valide";
}
else
{
    return;
}

// plus clair
if (!isValid)
{
    return;
}

std::cout << "Valide";

En C++, la boucle for basée sur une plage rend le code plus lisible en évitant la gestion manuelle des indices ou des itérateurs.


std::vector<int> numbers = {1, 2, 3, 4};

// boucle classique
for (size_t i = 0; i < numbers.size(); i++)
{
    std::cout << numbers[i] << std::endl;
}

// range-based for (recommandé)
for (int value : numbers)
{
    std::cout << value << std::endl;
}

En C++, auto améliore la lisibilité lorsque le type est évident ou très long. Cela permet de se concentrer sur la logique du code.


std::map<int, std::string> users;

// long et peu lisible
std::map<int, std::string>::iterator it = users.begin();

// plus lisible
auto it = users.begin();

En C++, une fonction devrait accomplir une seule tâche. Les fonctions à responsabilité unique sont plus faciles à comprendre.


// fait trop de choses
void processUser(User user)
{
    validate(user);
    saveToDatabase(user);
    sendEmail(user);
}

// mieux : une seule responsabilité
void validateUser(User user);
void saveUser(User user);
void sendWelcomeEmail(User user);