Cours de C++ moderne

Création d'applications en C++ moderne par la pratique

• Introduction
• Comment suivre ce cours
• Comment réaliser les exercices de ce cours
• Demander de l'aide et aider les autres
• normes et compilateurs
• autres langages

• Programme C++ minimal
• Hello world
• Les littérales chaînes de caractères
• Introduction à la qualité logicielle
• Les erreurs en programmation

• [Aller plus loin] Un langage vivant
• [Aller plus loin] Explorer la documentation

• Les nombres entiers
• Logique binaire et calcul booléen
• Nombres réels
• string

• [Aller plus loin] L'algèbre de Boole
• complex
• [Aller plus loin] Les nombres à virgule fixe
• [Aller plus loin] Les nombres rationnels

• Utiliser la mémoire avec les variables
• Constantes et énumérations
• La déduction de type
• Manipuler les types
• Obtenir des informations sur les types
• Créer des nouveaux types

• aller plus loin : discussion intialiser ou non par defaut ses variables (membre ou non)

• [Aller plus loin] Les nombres pseudo-aléatoires

• Le concept de collections de données
• Les catégories de collections
• Les fonctionnalités de base des collections
• Introduction aux algorithmes standards
• Les catégories d'algorithmes standards
• Les itérateurs
• Les catégories d'itérateurs

• [Aller plus loin] Les tableaux de bits

• string étendu
• [Aller plus loin] Les expressions régulières 1
• [Aller plus loin] Les expressions régulières 2
• [Aller plus loin] Les expressions régulières 3
• [Aller plus loin] Les expressions régulières 4

• Créer des fonctions
• Les paramètres de fonctions
• Copies, déplacements et indirections
• La surcharge de fonctions et résolution des noms
• Les foncteurs et fonctions lambdas
• Les fonctions génériques

• [Aller plus loin] Manipuler une fonction dans une variable
• [Aller plus loin] Le perfect forwarding
• rvalue, lvalue et leur amis
• [Aller plus loin] Le memoire en detail
• constexpr
• [Aller plus loin] Aliasing et const avec les indirections

• Les instructions conditionnelles
• Les instructions iteratives
• Les fonctions récursives

• [Aller plus loin] Les paires, tuples et structures
• [Aller plus loin] Les classes et fonctions variadiques
• [Aller plus loin] Variables globales et statiques, mémoire static, string table
• [C++17] Structures de controle
• break, continue, goto

• Introduction sur les entrées et sorties
• La ligne de commande
• Entrée console
• Les fichiers

• cout en detail
• variables d'environnement
• signals, abort, exit
• gestion des buffers avec les streams, concepts de latence, debit, cache.

• Les enjeux de la conception logicielle

• Séparer définition et implémentation https://akrzemi1.wordpress.com/2016/11/28/the-one-definition-rule/
• pré-condition et post-condition
• interface publique. “Easy to use correctly, hard to use incorrectly” - Scott Meyers. Design interface : s'adapter aux conventions qui existent. Etre consistant * strong interface, comment le typage fort peut renforcer l'utilisation correcte d'une api
• Gérer les erreurs dans les fonctions
• Contrats et tests unitaires

• macro, pré-processeur, directive de compilation
• Mesurer les performances

https://www.famkruithof.net/uuid/uuidgen

• Concevoir une bibliothèque
• documentation, commentaire, codes d'exemple
• physical design
• namespace, dépendances. l'espace de noms global et anonyme
• modules, conception en couches, utilisation de n-1 et n+1
• abi et C

• variables globales, étude de std::cout

• Les environnement de développement
• Mettre en place une chaîne de compilation
• Les compilateurs
• Les débogueurs
• La validation statique du code
• La validation du style du code
• Créer une documentation
• Les gestionnaires de versions
• Les tests
• Déployer une application
• Le suivi des problèmes

https://github.com/lefticus/cppbestpractices/blob/master/02-Use_the_Tools_Available.md

• poo

• Créer des classes
• Créer et copier des objets
• Surcharger les opérateurs
• Conversion de types http://cpptruths.blogspot.de/2015/11/covariance-and-contravariance-in-c.html
• * allocation et liberation de ressources, raii, association et composition

• [Aller plus loin] Swap
• [Aller plus loin] Les principes SOLID
• [Aller plus loin] Les design patterns
• [Aller plus loin] Les objets-fonctions
• chaining methods

• Classe à sémantique de collection
• Les ranges et vues sur les collections
• Itérateur personnalisé
• Les design patterns Wrapper et Facade
• traits : adapter les type_traits pour fonctionner avec vos classes

• La sémantique d'entité
• L'héritage
• Polymorphisme et substitution
• Fonctions virtuelles
• invariant de classe

• La Pile et le Tas, création et destruction
• théorie des graphes, arbres
• héritage multiple
• pourquoi les manipuler via indirections ? aliasing, smart ptr

• points de variation : comment faire varier le comportement d'un programme ? (directive de compilation, template police/traits, héritage, DP stratégie) Quand utiliser quelle technique ? Impact sur la qualité du code (maintenabilité, évolutivité, etc)
• durée de vie et propriétaire des objets

calculateur de systeme de vote de condorcet

• jeu d'échec
• évaluation de script (if, for, etc)
• article citation format (type medline)
• http://progdupeu.pl/forums/sujet/205/banque-dexercices
• factory. Créer une fonction factory avec switch, avec create, avec allocator
• système de gestion d'événements

• Utiliser une bibliothèque
• internationalisation : ICU
• interface utilisateur : Qt, SFML
• réseau : boost.asio, POCO, QtNetwork
• XML : QtXml
• base de données : QtSql
• web : wt
• script : boost.python, QtScript
• https://cpp.libhunt.com/
• http://fffaraz.github.io/awesome-cpp/
• http://en.cppreference.com/w/cpp/links/libs

• Le C++03
• Les chaînes de caractères style C
• tableaux style C
• Indirections dans les fonctions, surcharge opérateurs d'accès → * &, etc + surcharge opérateur new et delete, pointeur de fonction

• Analyse lexicale et syntaxique
• Évaluation d'expressions
• Gérer des intervalles de valeurs
• Zip et unzip
• Jouons avec les chiffres
• Créer un modèle de document
• XML
• Lire et écrire des feuilles de calculs
• Lire et enregistrer des images
• Sampler
• Jouer au Poker
• Algorithmes d'extraction de sous-chaînes
• Résoudre des intégrammes
• Jouer au Scrabble
• Analyseur simple d'expressions régulières
• imagerie : génération d'arbres avec L-System
• implémenter des générateurs aléatoires cryptographiques
• créer un systeme d'allocation memoire (tas). Allocator, utilisation des espaces libres, défragmentation
• buffer avec vector
• http://martinfowler.com/bliki/CQRS.html
• https://en.wikipedia.org/wiki/Fizz_buzz

Notes:

• conversion implicite et explicite
• indirections, adaptateurs, raw ptr/ref
• “Make interfaces easy to use correctly and hard to use incorrectly” - Scott Meyers

https://sciencetonnante.wordpress.com/2015/10/16/la-machine-a-inventer-des-mots-video/ https://github.com/fffaraz/awesome-cpp https://github.com/rigtorp/awesome-modern-cpp https://www.reddit.com/r/dailyprogrammer/ http://morpheo.inrialpes.fr/people/Boyer/index.php?id=m1-mosig http://www.iquilezles.org/www/index.htm

À suivre...