Référence imprimable (Ctrl+P) - permise à l'intra et au final

Aide-mémoire C++ pour INF1010

Une section par module : la syntaxe exacte, les signatures à recopier, les règles à vérifier avant de rendre. Sections 1 à 7 : intra. Sections 8 à 10 : final.

1. Classes, constructeurs, allocation dynamique

Déclaration (.h)		Jamais `using namespace std;` dans un .h. Définitions dans le .cpp dans le même ordre (sauf génériques : dans le .h).
Définition (.cpp)		Liste d'initialisation obligatoire pour const, références, attributs objets sans constructeur par défaut, classe de base. Ordre réel = ordre de déclaration des attributs.
Constructeurs	Par défaut `T();` (fourni seulement si aucun constructeur déclaré) ; par paramètres ; par copie `T(const T&);` (appelé par `T b = a;`, `T b(a);`, paramètre par valeur, retour par valeur, `new T(a)`, `push_back(a)`). `explicit T(int n);` interdit la conversion implicite `T t = 5;`.	Pas de type de retour. Un tableau `T t[3]` ou `new T[3]` exige le constructeur par défaut.
Ordre de construction / destruction	Construction : classe(s) de base (ordre de la déclaration de classe), attributs (ordre de déclaration), corps. Destruction : corps du destructeur, attributs (inverse), base. Variables locales détruites à l'accolade fermante, ordre inverse de déclaration. Temporaire : fin de l'expression. Paramètre par valeur : fin de la fonction. Objet dynamique : au `delete` seulement.	À appliquer pour « Donnez l'affichage ».
Pile et tas		Un new = un delete, un seul propriétaire. Erreurs : fuite, pointeur pendant, double delete, delete sur un tableau, delete sur une variable locale.
Agrandir un tableau		Ce que vector fait tout seul.

2. const, passage de paramètres, vector

Méthode const

double get() const; : ne modifie pas *this, ne peut appeler que des méthodes const, ne retourne pas de T& vers un attribut. Seules les méthodes const sont appelables sur un objet const ou une const T&.

Le const fait partie de la signature : à répéter dans le .cpp. Surcharge possible : T& operator[](size_t) et const T& operator[](size_t) const.

Accesseurs, affichage, calculs, comparaisons : const.

Paramètres

Mode	Syntaxe	Copie	Modifie l'original	Usage
valeur	`f(T x)`	oui	non	int, double, bool, copie voulue
référence	`f(T& x)`	non	oui	sortie, swap, flux
réf. constante	`f(const T& x)`	non	non	défaut pour les objets
pointeur	`f(T* x)`	adresse	oui	nullptr possible, propriété, tableaux
unique_ptr par valeur	`f(unique_ptr<T> x)`	transfert	-	appel : `f(std::move(p))`

Retour : par valeur (toujours sûr) ; const T& pour un attribut ; T& = *this pour le chaînage ; jamais une référence vers une variable locale.

Surcharge résolue à la compilation par les types des arguments ; f(T&) et f(T) sont ambiguës entre elles. new T[n] est un T*, new T*[n] un T**.

std::vector Paramètre : const vector<T>&. push_back peut réallouer (pointeurs vers éléments invalidés). Un vector de pointeurs bruts ne détruit pas les objets. Copie de vector = copie profonde des éléments.

3. Composition, agrégation, pointeurs intelligents

Reconnaître la relation

Attribut	Relation	Qui détruit
`B b_;`	composition	automatique
`B* b_;` + `new` dans la classe	composition par pointeur	le destructeur de la classe (`delete`)
`B* b_;` reçu de l'extérieur	agrégation	l'extérieur
`B& b_;` (liste d'init. obligatoire)	agrégation	l'extérieur
`unique_ptr<B>`	composition exclusive	automatique
`shared_ptr<B>`	partage	automatique au dernier propriétaire

Composition : « possède », durée de vie liée, pas de partage. Agrégation : « utilise », indépendant, partageable. Héritage : « est un ».

unique_ptr Un attribut unique_ptr rend la classe non copiable par défaut : écrire le constructeur de copie (make_unique<T>(*autre.ptr_)) ou interdire la copie.

shared_ptr Jamais deux pointeurs intelligents depuis le même pointeur brut ; jamais delete p.get(). weak_ptr : observe sans compter (cycles).

4. this, opérateurs, copie et affectation

this	`this` : pointeur vers l'objet courant (`const T` dans une méthode const). `this->x` en cas de conflit de noms ; `return this;` pour le chaînage ; `if (this != &autre)` contre l'auto-affectation.
Signatures des opérateurs		Membre : opérande gauche = objet. Libre/friend : opérande gauche d'un autre type ou commutativité. friend = fonction globale avec accès privé (pas de `T::`). Sans friend : passer par les accesseurs publics. `a + b` → `a.operator+(b)` ou `operator+(a, b)`. Pas de nouveaux opérateurs, priorité inchangée.
Règle des trois		Nécessaire si la classe possède un pointeur brut (new / delete) ou un unique_ptr. Inutile avec string, vector, shared_ptr, types simples (copie membre à membre correcte). Copie superficielle = partage involontaire, pointeur pendant, double delete.
Copie-et-échange (TP2)		unique_ptr dupliqué (copie profonde), shared_ptr copiés (partage).

5. Héritage et polymorphisme

Syntaxe Héritage public = « est un ». Sans appel explicite, le constructeur par défaut de la base est utilisé. Seule la base directe dans la liste. Constructeurs, destructeurs, operator= non hérités.

Liaison

Non virtuelle : choisie à la compilation d'après le type déclaré du pointeur ou de la référence (liaison statique). Virtuelle : choisie à l'exécution d'après le type réel (liaison dynamique), uniquement via pointeur ou référence. Copie par valeur dans le type de base = découpage (slicing), version de la base.

Appel virtuel dans un constructeur/destructeur : version de la classe en cours. override : vérifie la redéfinition (signature et const identiques). final : interdit de redéfinir.

Collection polymorphe : vector<shared_ptr<Base>> ou unique_ptr ; jamais vector<Base>.

Abstraite / interface

Au moins une méthode = 0 → non instanciable (ni par valeur, ni en paramètre par valeur, ni dans vector<Base>). Une dérivée qui ne définit pas toutes les pures reste abstraite. Interface = que des pures + destructeur virtuel.

Erreur « impossible d'instancier une classe abstraite » : pure non redéfinie ou signature différente.

Accès

Membre de Base	Dans Derivee	Depuis main via Derivee
public	oui	oui
protected	oui	non
private	non	non

Héritage protected / private : abaisse les niveaux (public devient protected / private).

6. Conversions

Ascendante	`Base* p = &derivee;` `Base& r = derivee;` `shared_ptr<Base> s = make_shared<Derivee>();` : implicite, toujours valide. `Base b = derivee;` : valide mais découpe.
Descendante		Jamais implicite. Préférer une méthode virtuelle à une chaîne de dynamic_cast. Usage légitime : opération propre à une dérivée (recharger une Batterie).

7. Héritage multiple et généricité

Héritage multiple		Cas sain : une classe concrète + des interfaces.
Fonction générique		Définition dans le .h. Erreurs à l'instanciation (T sans l'opérateur requis). Appel : `filtrerParType<Pince>(liste)`.
Classe générique		Tout dans le .h. Dans la classe, `Liste` = `Liste<T>`. shared_ptr : `==` compare les adresses.

8. STL : conteneurs et itérateurs (final)

Conteneurs

Conteneur	Propriétés	Opérations clés
`vector<T>`	contigu, accès [i] O(1), insertion fin amortie O(1)	push_back, pop_back, [], at, insert, erase
`deque<T>`	comme vector + insertion/suppression au début	push_front, pop_front
`list<T>`	doublement chaînée, pas de [i], insertion/suppression O(1) partout	push_front/back, insert(it), erase(it), sort(), remove(v), splice
`set<T>` / `multiset`	trié (operator<), unique (set), arbre	insert, erase, find, count
`map<K, V>` / `multimap`	paires clé → valeur triées par clé	m[k], at(k), insert({k, v}), find, erase, count ; itérateur : it->first, it->second
`unordered_map / unordered_set`	table de hachage, non trié, O(1) moyen	idem map / set
`stack`, `queue`, `priority_queue`	adaptateurs	push, pop, top / front, back
`pair<A, B>`	deux valeurs	first, second, make_pair

m[k] crée la clé si absente (valeur par défaut) ; find ne crée rien.

Itérateurs Un itérateur = pointeur généralisé : *it, it->, ++it. end() = après le dernier. Catégories : aléatoire (vector, deque), bidirectionnel (list, set, map), avant.

9. STL : algorithmes, foncteurs, lambdas (final)

Algorithmes		b, e = `v.begin(), v.end()`. `remove` ne change pas la taille : il compacte et retourne la nouvelle fin. `list` a ses propres `sort()`, `remove()`, `unique()`.
Foncteur		Un foncteur passe par valeur : `for_each` retourne le foncteur, utile pour récupérer son état.
Lambda		Une lambda = foncteur anonyme généré par le compilateur. Type unique : la recevoir dans un paramètre template ou `std::function`. Capture par valeur figée à la création ; `mutable` pour la modifier.

10. Membres statiques, exceptions, Python (final)

static Variable de classe partagée par tous les objets ; existe même sans objet. static const int N = 3; initialisable dans la classe. Fonction libre static : visible dans son fichier seulement. Variable locale static : conserve sa valeur entre les appels.

Exceptions Le reste du bloc try est abandonné ; catch essayés dans l'ordre ; les objets locaux sont détruits (pointeurs intelligents libérés, pointeurs bruts fuient). Non attrapée : std::terminate. Hiérarchie : exception → logic_error (invalid_argument, out_of_range, length_error) et runtime_error (overflow_error, range_error) ; bad_alloc, bad_cast. noexcept : ne lance pas. Un destructeur ne lance jamais.

Python vs C++

C++	Python
`int x = 5; double y = 2.5; string s = "a"; bool b = true;`	`x = 5; y = 2.5; s = "a"; b = True` (typage dynamique)
`if (x > 3) { ... } else if (...) { ... } else { ... }`	`if x > 3:` / `elif ...:` / `else:` (indentation)
`for (int i = 0; i < n; ++i)` ; `for (int v : vec)`	`for i in range(n):` ; `for v in liste:`
`vector<int> v = {1, 2}; v.push_back(3); v.size()`	`v = [1, 2]; v.append(3); len(v)`
`map<string, int> m; m["a"] = 1;`	`m = {}; m["a"] = 1` (dict)
`void f(int a, int b = 2) { return; }`	`def f(a, b=2):` / `return`
`class C : public B { public: C(int x) : B(), x_(x) {} void m() const { ... } };`	`class C(B):` / `def __init__(self, x): super().__init__(); self.x = x` / `def m(self):`
`operator+`, `operator<<`, `operator==`	`__add__`, `__str__` (avec `print`), `__eq__`
`new` / `delete`, pointeurs	ramasse-miettes : tout est référence, pas de delete
`try { } catch (const E& e) { }` ; `throw E();`	`try:` / `except E as e:` ; `raise E()`
`cout << x << endl;` ; `cin >> x;`	`print(x)` ; `x = input()`
`// commentaire` ; `x++` ; `&& \|\| !`	`# commentaire` ; `x += 1` ; `and or not`

Python : pas de types déclarés, pas d'accolades, pas de surcharge de fonctions, polymorphisme par défaut (méthodes « virtuelles »), self explicite, pas de private strict (préfixe _ par convention, __ pour le masquage).

Erreurs de compilation fréquentes et leur cause

Message (clang / MSVC)	Cause probable	Correction
member function not viable: 'this' argument has type 'const T'	méthode non const appelée sur un objet ou une référence const	ajouter `const` à la méthode
cannot assign to non-static data member within const member function	modification d'un attribut dans une méthode const	retirer const (mutateur) ou ne pas modifier
call to deleted constructor of 'unique_ptr'	copie d'un unique_ptr (ou d'une classe qui en contient un)	`std::move`, ou écrire le constructeur de copie
no matching constructor for initialization	constructeur par défaut absent (tableau, vector(n), base non appelée) ou mauvais arguments	appeler la base / fournir le constructeur
variable of abstract class type / impossible d'instancier une classe abstraite (C2259)	objet par valeur d'une classe abstraite, ou pure non redéfinie (signature différente)	pointeur ou référence ; vérifier les signatures avec override
call to 'f' is ambiguous	surcharges indiscernables (`f(T)` et `f(T&)`), ou membre présent dans deux bases	qualifier (`A::x`), retirer une surcharge
undefined reference / symbole externe non résolu (LNK2019)	méthode déclarée mais pas définie ; template défini dans un .cpp ; variable static non définie	définir dans le .cpp (ou le .h pour un template) ; `int T::x_ = 0;`
out-of-line definition does not match any declaration	signature du .cpp différente du .h (const oublié, type de paramètre)	copier la signature exacte
-Wreorder : field 'x_' will be initialized after field 'y_'	liste d'initialisation dans un ordre différent de la déclaration	réordonner la liste
comparison of integers of different signs (-Wsign-compare)	`int i < v.size()`	`size_t i`
'override' : method with override specifier did not override any base class methods	la base n'a pas de méthode virtuelle de cette signature	ajouter virtual dans la base ou corriger la signature
cannot convert 'Base' to 'Derivee'	downcast implicite	`dynamic_cast<Derivee*>`
you cannot assign to a variable that is const (C3892)	écriture via une référence ou un itérateur const	utiliser une version non const