Le quartierC++ C++Pièce 7/7Mémo

C++

Le mémo de C++ moderne : compilation, types, fonctions, conteneurs, références, classes, pointeurs intelligents et algorithmes.

Ce mémo résume les bases de C++ moderne. Chaque section renvoie au cours qui l'explique en détail.

Compiler et lancer

Commande	Effet
`g++ -std=c++17 -Wall -Wextra main.cpp -o prog`	Compile avec g++.
`clang++ -std=c++17 -Wall -Wextra main.cpp -o prog`	Compile avec clang++.
`./prog`	Lance le programme (`.\prog` sous Windows).

Détails : Premier programme.

Types et entrées-sorties

#include <iostream>

int main() {
    int n{4};                 // aussi double, char, bool
    const double tva{0.2};    // non modifiable
    auto duree = 45;          // type déduit
    std::cout << n << "\n";
    std::cin >> n;
}

Détails : Premier programme.

Conditions, boucles, fonctions

if (a > b) { /* ... */ } else { /* ... */ }
for (int i = 0; i < 3; ++i) { /* ... */ }
while (cond) { /* ... */ }
for (int x : collection) { /* range-for */ }

int somme(int a, int b = 0) { return a + b; }

Détails : Conditions, boucles et fonctions.

Chaînes et vecteurs

Code	Effet
`std::string s{"abc"}`	Crée une chaîne.
`s.size()`, `s + t`, `s == t`	Longueur, concaténation, comparaison.
`std::getline(std::cin, s)`	Lit une ligne entière.
`std::vector<int> v{1, 2}`	Crée un vecteur.
`v.push_back(3)`	Ajoute à la fin.
`v.at(i)`	Accès avec vérification.

Détails : std::string et std::vector.

Références et pointeurs

Écriture	Sens
`void f(int x)`	Copie de l'argument.
`void f(int& x)`	Référence, modifie l'original.
`void f(const T& x)`	Référence en lecture seule.
`int* p = &x;`	Pointeur vers `x`.
`*p`, `p->membre`	Déréférencement.
`int* p = nullptr;`	Pointeur vide.

Détails : Références et pointeurs.

Classes et RAII

class Recette {
public:
    Recette(std::string titre, int minutes)
        : titre_{std::move(titre)}, minutes_{minutes} {}
    ~Recette() = default;
    int minutes() const { return minutes_; }
private:
    std::string titre_;
    int minutes_;
};

Principe : acquérir une ressource dans le constructeur, la libérer dans le destructeur. Détails : Classes, constructeurs et RAII.

Mémoire et bibliothèque standard

auto p = std::make_unique<Recette>("Tarte", 60);  // un propriétaire
auto q = std::make_shared<Recette>("Soupe", 30);  // plusieurs
std::sort(v.begin(), v.end());
std::map<std::string, int> notes{{"Tarte", 5}};

Outil	Quand
`std::unique_ptr`	Un seul propriétaire (choix par défaut).
`std::shared_ptr`	Propriété partagée.
`std::sort`, `std::find`	Trier, chercher sur `begin()` à `end()`.
`std::map`	Clés triées associées à des valeurs.

Détails : Mémoire, pointeurs intelligents et bibliothèque standard.

Sources officielles

Ensuite

Premier programme

Compiler et lancer un premier programme C++, puis manipuler variables, types de base et entrées-sorties avec iostream.

Projet: Lignes de code
Niveau: Le quartier
Appartement: C++
Pièce: 7/7
Plan n°: cpp/index