01 - Introduction
02 - 1. Aborder la syntaxe de base
-
01 - Déclarer les variables (2:30)
-
02 - Déclarer les fonctions non-membres (3:41)
-
03 - Connaître la syntaxe moderne des fonctions (4:42)
-
04 - Tirer parti de l-inférence de type (2:53)
-
05 - Appréhender les types fondamentaux entiers (3:49)
-
06 - Comprendre les types fondamentaux flottants (4:29)
-
07 - Aborder les autres types (3:08)
-
08 - Effectuer des transtypages (4:21)
-
09 - Choisir les différents cycles de vie (4:12)
-
10 - Manipuler des tableaux (4:41)
-
11 - Utiliser les enum et enum class (3:08)
03 - 2. Contrôler le flux
04 - 3. Découvrir les fonctions de C++
-
02 - Discerner les fonctions non-membres ou membres (2:58)
-
01 - Déclarer et définir (3:22)
-
03 - Employer la surcharge et les paramètres des fonctions (4:13)
-
04 - Passer des paramètres par valeur (3:13)
-
05 - Passer des paramètres par pointeur (4:00)
-
06 - Passer des paramètres par référence (3:38)
-
07 - Utiliser CONST en paramètre (3:28)
-
08 - Créer une fonction membre CONST (3:28)
-
09 - Utiliser le qualifieur mutable (2:24)
-
10 - Utiliser les fonctions INLINE (4:36)
-
11 - Utiliser les espaces de nommage (3:06)
05 - 4. Exploiter les types utilisateur CLASS et STRUCT
-
01 - Déclarer une classe (3:03)
-
02 - Déclarer les données et les fonctions membres (3:57)
-
03 - Utiliser STRUCT à la place de CLASS (3:03)
-
04 - Utiliser des objets (3:43)
-
05 - Organiser le code avec les includes de garde (5:06)
-
06 - Inclure ou pas les déclarations anticipées (3:03)
-
07 - Créer des constructeurs (4:06)
-
08 - Chaîner les constructeurs (3:02)
-
09 - Utiliser la ZIM (3:27)
-
10 - Créer un destructeur (3:42)
-
11 - Gérer la sémantique de copy (4:52)
-
12 - Gérer le move (5:12)
06 - 5. Mettre en œuvre la généralisation
-
02 - Connaître les conséquences de l-héritage (4:09)
-
01 - Créer un héritage (3:48)
-
03 - Chaîner les constructeurs de la super classe (3:32)
-
04 - Enchaîner les destructeurs (3:21)
-
05 - Utiliser les fonctions membre virtuelles (4:01)
-
06 - Utiliser les fonctions membre de l-ancêtre (3:00)
-
07 - Utiliser un destructeur virtuel (4:02)
-
08 - Créer une classe abstraite (3:39)
-
09 - Utiliser la visibilité PROTECTED (2:33)
-
10 - Comprendre l-héritage multiple (3:00)
-
11 - Résoudre les collisions (3:20)
-
12 - Démasquer avec USING (3:28)
07 - 6. Utiliser les templates
-
02 - Utiliser un type template (3:37)
-
01 - Créer une classe template (3:18)
-
03 - Créer et utiliser une fonction template (3:42)
-
04 - Utiliser des alias TYPEDEF ou USIN (4:50)
-
05 - Garder les valeurs par défaut sur les types template (2:39)
-
06 - Garder les valeurs par défaut sur les valeurs template (3:17)
-
07 - Effectuer la spécialisation complète d-une fonction template (3:47)
-
08 - Effectuer la spécialisation complète d-une classe template (4:26)
-
09 - Effectuer une spécialisation partielle (3:18)
-
10 - Paramétrer le pack template (3:19)
08 - 7. Gérer les erreurs par exception
-
02 - Créer sa propre classe d-exception (4:04)
-
01 - Utiliser les exceptions TRY, CATCH et THROW (3:59)
-
03 - Tirer parti du polymorphisme des exceptions (3:31)
-
04 - Employer les bonnes pratiques des exceptions (3:26)
-
05 - Effectuer un traitement par défaut TERMINATE (2:58)
-
06 - Mettre en œuvre les exceptions et les objets automatiques (3:16)
-
07 - Utiliser UNIQUE_PTR (2:45)
-
08 - Utiliser SHARED_PTR (3:08)
09 - 8. Utiliser les conteneurs standards
10 - 9. Utiliser des algorithmes standards
-
02 - Utiliser des algorithmes non-modifiants (2:30)
-
01 - Assimiler les règles générales d-utilisation des algorithmes (3:08)
-
03 - Utiliser des algorithmes modifiants (2:28)
-
04 - Utiliser des algorithmes de tri (2:45)
-
05 - Utiliser des algorithmes de recherche (3:17)
-
06 - Appliquer des algorithmes sur des strings (3:24)
11 - 10. Surcharger les opérateurs
12 - 11. Utiliser les flux
13 - Conclusion
fichiers_d_exercice_essentiel_c_plusplus
