Programmation Avancée, Spécificités du  C++

Organisation :

• Créneaux organisés les jeudis et vendredi après-midi quand les alternants sont en entreprise.
  
• Il y a 7 groupes de TPs (AA, BB, CC, DD, EE, FF, GG). Vous trouverez votre groupe dans TOMUSS. Merci de respecter votre affectation.
  
• Les CMs et les TPs sont en présentiel.  Il s'agit d'une UE exigeante en ce qui concerne votre implication et votre participation.
  
• Evaluation :
• Un TP noté à la toute dernière séance de TP de l'UE, sur un sujet surprise, le jeudi 30 novembre 2023, pour évaluer vos capacité de prise en main d'un sujet en temps limité. Vous n'aurez probablement pas le temps de tout faire. Pour ce TP, les seuls documents autorisés seront les slides du cours et les sujets de TP, mais pas les corrections fournies. Cela pourra vous être utile pour les questions de syntaxe, puisque vous n'aurez pas droit à une documentation en ligne.
  
• Une interrogation sur feuille portant sur le même sujet que celui du TP noté aura lieu le jeudi 21 décembre.Vous aurez eu le temps d'approfondir le sujet et vous aurez à répondre à quelques questions, pour illustrer votre compréhension du sujet et votre capacité d'aller plus loin. Attention : le sujet de TP noté vous sera redonné sous forme papier, mais vous n'aurez pas droit à l'archive que vous aurez rendue à la fin du TP noté.
• Un exam. Vous pouvez vous entraîner à faire celui qui est placé sur la page web du cours. Cela correspondra à un QCM  ainsi qu'une ou deux questions supplémentaires où vous devrez répondre sur feuille. Là encore, vous n'aurez droit à aucun document.
  

Cours :

• Objectifs du cours
• Premières différenciations entre C++ et Java
• Retour sur la notion de référence &
  
• Introduction à la notion de value-ness (lvalue, rvalue, xvalue)
  
• Héritage comme outil de spécialisation
• Différents types d'héritages (public, protected, private) et leur intérêt
• upcast implicite et downcast explicite (static_cast) dans une hiérarchie de classes
  
• Mot clé using
  
• Nuance avec l'héritage en Java
  

• Héritage comme outil de spécialisation
• Mot clé using
• Constructeurs des classes dérivées (=default,=delete)
  
• Destructeur et affectation (operator=) des classes dérivées
• Capsules RAII
  
• Exploitation des xvalues
• rvalue reference &&
• Constructeur par déplacement, affectation par déplacement
  
• changement de sémantique du  move
  
• Rule of 3, Rule of 5
  

• Quelques compléments sur les classes et leurs éléments de contrôle  
• Fonctions et classes amies friend
  
• Qualificatif explicit
  

• Redéfinition de fonction et polymorphisme en Java
• Redéfinition de fonction membre vs. surcharge, override en C++
  
• Principe du masquage en C++
  
• Type statique vs. type dynamique
• Généricité dynamique en C++
  
• mot clef virtual 
• analyse statique et liaison dynamique
• nuance entre fonction membre et méthode

• Coût du polymorphisme
• table des fonctions virtuelles
• Mot clé final (Java, C++)
• constructeurs non polymorphes, fonctions membres virtuelles de clonage
  
• Polymorphisme et destructeurs
• fonctions virtuelles pures et classes abstraites
• Surcharge, redéfinition et masquage en Java
  
• Interfaces vs. classes abstraites
  
• RTTI
  
• typeid et dynamic_cast

• limites du polymorphisme, polymorphisme sur plusieurs arguments
• Retour sur les opérateurs de transtypage du C++  (static_cast, dynamic_cast, const-cast, reinterpret-cast)     
• Fonctions et classes template
• Specialisation totale (classes et fonctions template) ou partielle (classes template uniquement)
  
• Fonctions et données membres statiques

• Difference entre les template Java et les template C++

• Rappels sur tous les éléments qui peuvent être définis dans le scope d'une classe (template ou non)
• Mot clé using comme une alternative à typedef
  
• Présentation de la STL et explications sur son implémentation interne
• Concept de Conteneur
• Conteneur séquentiel
• Conteneur associatif
  
• Concept d'Adaptateur
• Objets Fonctions de la STL
  
• Concept d'Itérateur
  
• Opérateurs associés à un itérateur
• Itérateurs de parcours des conteneurs séquentiels
  
• Itérateur d'insertion
  
• Itérateur de flot
• Concept d'Algorithme générique
• Indépendance au conteneur
• Algorithmes génériques de la STL

• Surcharge de new et delete
  
• Allocateur d'une classe
• Principe et implémentation des pointeurs intelligents
  
• auto_ptr, unique_ptr, scoped_ptr,
  
• shared_ptr, intrusive_ptr,
  
• weak_ptr,

• Héritage multiple : gestion par le langage C++
                                   Héritage virtuel (Slides 13 à 17), polymorphisme et héritage virtuel
  
• Exceptions : gestion par le langage C++ assez similaire à ce qui est fait en Java.
  

• Possibilités offertes par le compilateur (en complément preuve de Turing completude des template C++)
• Mise en oeuvre d'un métaprogramme (enum et constantes statiques dans des classes, fonctions templates, constexpr, inline)
• Template numérique, Listes de Types, 
• CRTP principe et exemples d'utilisations
  
• Génération automatique d'une hiérarchie de types Visiteur (difficile)
  
• static_assert
  
• Concept depuis C++20
  

• Retour sur certains des apports de C++11, C++14  et C++17.
  
• Inférence de type, auto, decltype
  
• Valueness, référence universelle
• std::move, std::forward,  std::ref
  
• Template variadique, tuple
• Lambda expression
• Alias template

• Concept checking : Notion de concept (C++20) évoquée dans le cours 05
  
  
• Les éléments qu'on aurait également pu voir  :

• Namespace
  
• Construction de nouvelles fonctions par binding de fonctions existantes
  
• Illustration de decltype (C++14) dans des cas où on ne pourrait pas s'en passer

TPs : 

• TP01 : Rappels constructeurs, destructeurs, surcharges opérateurs et conversions
  

• LaClasse.cpp (accorder un soin particulier à cet exercice). Eléments de correction pour comprendre ce qui se passe à chaque instruction.
  Pour compléter :  possibilités d'optimisation permises par la standardisation.
  
  
• Premières différences entre Java et C++ concernant les classes de bases (éléments de correction ici).
  
• Pour ceux qui n'auraient pas encore installé de compilateur C++, voici un compilateur en ligne : http://cpp.sh/
• Pour ceux qui n'auraient pas encore installé d'interpréteur JAVA, voici un compilateur en ligne : https://www.jdoodle.com/online-java-compiler
• Pour ceux qui n'ont aucun compilateur : connaissez-vous Godbolt? J'adore ;-)
  
• Pour réaliser des mesures de temps vous pouvez utiliser la commande time avec le nom de votre exécutable en argument. Sinon vous pouvez recourir à la bibliothèque chrono du C++ (classe std::chrono::time_point pour faire des mesures en microsecondes) et à la méthode System.currentTimeMillis() en Java (exemple).

• TP02 : Constructeurs, destructeurs, capsule RAII, déplacement,
           affectation des classes dérivées, upcast et downcast, écriture d'une classe String
  
  
• Attention, pour écrire la classe String, vous aurez besoin d'allocation dynamique de la mémoire.
• Eléments de correction sur la dérivation de LaClasse et l'ajout de mécanismes de déplacement (constructeurs et affectation par déplacement)
  

• Petit aide mémoire concernant les opérateurs du C++
  
• Pour compléter, vous pouvez vous documenter sur les flots d'ES en C++ 
  

• TP03 : Objets fonctions, Polymorphisme
  
  
  • Fin des TPs précédents
    
  • Codage d'un objet fonction
    
  • Retour sur la classe Image et le comparatif de performance C++ et Java

• TP04 : Polymorphisme
  
  
  • Hiérarchie de classe expression  (éléments de solution)
  • Fonction membre virtuelle de clonage
  • Codage d'un objet fonction
  
  
• TP05 : Template
  
  
• Fonctions template (éléments de correction)
• Class Template Tableau  (éléments de correction, éléments de correction supplémentaires avec la possibilité de traiter conjointement des tableaux avec des agrandissements de taille différente)

• TP06 : Template, itérateurs et STL
  
  
• Class Template ListeTriee
  
• Iterateur sur Tableau
  
• Utilisation de la STL et de ses algorithmes (éléments de correction)
  

• TP07 : Template, itérateurs, Inserteurs, déplacement
  
  
• Class Template Tableau (voir éléments de correction du TP05) et ListeTriee
  
• Iterateur sur tableau et sur ListeTriee (éléments de correction)
  
• Inserteur sur tableau et sur ListeTriee (éléments de correction sur les slides du cours sur la STL) 
  
• Déplacement dans la hiérarchie de classe expression (éléments de correction : avec constructeur par copie et par déplacement, ou sans).
• Ceux qui ont tout terminé peuvent s'attaquer à l'exemple de sujet de TP noté fourni plus bas.
  

• TP08 : Métaprogrammation, Const_cast
  
  
• Listes de types et métafonctions permettant de les manipuler (correction en utilisant le mécanisme basique des template du compilateur C++, correction utilisant les template variadiques offerts par C++ depuis C++11)
  
• Mieux comprendre l'utilité des const et utilisation de const_cast (correction).
  
• Métaprogrammation pour la génération de hiérarchie de classes polymorphes (exercice difficile et facultatif).
  

• TP Noté (voir instructions plus bas).
  Exemple de  sujet portant sur les Arbres Binaires de Recherches et leurs itérateurs

Examen :

TP noté :

Bibliographie :

Enseignants :

• Cours
• Chaine Raphaëlle
  
  
• Chargés de TP 
     
  
• Chaine Raphaëlle (raphaelle.chaine -- liris.cnrs.fr)
• Doignies Bastien  (bastien.doignies(à)liris.cnrs.fr)
• Gisbert Guillaume (guillaume.gisbert(à)liris.cnrs.fr)
• Iehl Jean-Claude (jean-claude.iehl(à)liris.cnrs.fr)
• Pitois François
• Saillant Bastien (bastien.saillant(à)liris.cnrs.fr)
• Schott Hugo (hugo.schott(à)liris.cnrs.fr)