Libérez le potentiel de l’IA générative dans toutes vos fonctions managériales.
Se connecter
Ou creér votre compte
Vous venez d'ajouter à votre sélection
Votre panier est vide, Voir nos formations

Description

En constante évolution, le langage C++ offre des mécanismes tels que la généricité ou la méta programmation qui permettent une conception robuste et très riche. Les récentes normes C++11 et C++14 intègrent une part importante des bibliothèques du projet BOOST et améliorent notablement la Standard Template Library (STL). Cette formation vous permettra d'approfondir la conception en C++ par l'apprentissage des dernières évolutions du langage et l'utilisation effective de la STL.

À qui s'adresse cette formation ?

Pour qui ?

Concepteurs et développeurs d'applications en C++, chefs de projets, architectes logiciels.

Prérequis

Les objectifs de la formation

  • Découvrir les nouveautés apportées par la version C++11
  • Maîtriser la gestion de la mémoire, des pointeurs et des références
  • Implémenter la généricité en C++Découvrir la bibliothèque standard STL
  • Utiliser la librairie BOOST et C++11
  • Programme de la formation

      • Bibliothèques standard du langage : ctype.
      • h, math.
      • h, stdlib.
      • h, time.
      • h.
      • et les autres.
      • Bibliothèques mathématiques avancées : Linpack, Lapack.
      • La gestion de l'allocation dynamique : fonctions calloc(), realloc().
      • Fonctions à nombre d'arguments variables existantes et créées par le programmeur.
      • Travaux pratiques Utilisation de plusieurs bibliothèques de fonctions.
      • Classes d'allocation mémoire.
      • Construction, initialisation, embarquement d'objets.
      • Les fuites mémoire.
      • Constance, le mot-clé mutable, Lazy Computation.
      • Amitié (friendship) C++ et contrôle d'accès.
      • Destruction virtuelle.
      • Stratégie de gestion des exceptions.
      • Les espaces de nommage (namespace).
      • nullptr et autres littéraux.
      • Les directives =delete, =default.
      • Délégation de constructeurs.
      • Les énumérations «type safe».
      • Le mot-clé auto et boucle sur un intervalle.
      • Référence rvalue et impacte sur la forme normale des classes C++.
      • Les lambda-expressions.
      • Travaux pratiques Réécriture d'un code C++ existant en C++11, comparaison des deux implémentations.
      • Opérateurs binaires et unaires.
      • L'opérateur d'indirection, cas d'usage.
      • L'opérateur de référencement.
      • Les opérateurs d'incrémentation/décrémentation préfixés et post-fixés.
      • Les autres opérateurs : comparaison, affectation.
      • La surcharge de l'opérateur [], des opérateurs d'insertion (<<) et d'extraction (>>).
      • Les foncteurs et la surcharge de l'opérateur (), avantage par rapport aux fonctions.
      • Travaux pratiques Création de foncteurs et de proxies (libération mémoire, comptage de références) avec les opérateurs étudiés.
      • Opérateurs de conversion.
      • Constructions implicites, le mot-clé explicit.
      • Les opérateurs de casting const_cast, static_cast, reinterpret_cast.
      • Conversion dynamique et Runtime Type Information.
      • L'opérateur typeid, les exceptions liées.
      • La classe type_info.
      • Contrôle du " downcasting " à l'aide de l'opérateur dynamic_cast.
      • Travaux pratiques Mise en oeuvre des idiomes " is-a " et " is-kind-of " avec dynamic_cast.
      • Introduction aux patrons de classe.
      • Généricité et préprocesseur.
      • Fonction générique.
      • Classe générique.
      • Composition générique.
      • Généralisation générique.
      • Spécialisation partielle et totale.
      • Introduction à la méta-programmation.
      • La généricité, principe fédérateur des librairies STL et BOOST.
      • Travaux pratiques Démarrage de l'étude de cas qui sera complétée avec la STL et BOOST.
      • Mise en oeuvre de la composition et de la généralisation génériques.
      • Création de plug-ins génériques.
      • Composants de la STL : types complémentaires, conteneurs, algorithmes, itérateurs, objets fonctions, les adaptateurs.
      • Les chaînes de caractères STL, la classe template basic_string et ses spécialisations.
      • Les conteneurs séquentiels et associatifs : définition, rôle et critères de choix.
      • Les allocateurs et la gestion de la mémoire des conteneurs.
      • Les méthodes d'insertion, de suppression, d'itération et d'accès aux principaux conteneurs : Vector, List, Set, Stack.
      • Le concept d'itérateur.
      • Parcours d'un conteneur.
      • Les différents groupes d'algorithmes STL : non mutants, mutants, de tri et de fusion, numériques.
      • Manipulation de conteneurs (manipulation, recherche de valeurs.
      • ).
      • Paramétrer les algorithmes génériques par des objets " fonction ".
      • Les " adapteurs " et la modification du comportement d'un composant.
      • La STL et les traitements sur les flux (fichiers, mémoire.
      • ).
      • Principe du RAII : les pointeurs automatiques et la classe auto_ptr.
      • Les exceptions standard de la STL.
      • Travaux pratiques Implémentation des relations avec les collections de la STL.
      • Utilisation d'algorithmes standard quelconques.
      • Evolution historique : Boost --> TR1 --> C++11.
      • Les nouveaux conteneurs : array, forward_list, unordered_set, unordered_map.
      • La classe tuple.
      • Les pointeurs intelligents (smart pointer) : shared_ptr, weak_ptr, unique_ptr.
      • Les nouveaux foncteurs et binders.
      • Introduction à la gestion des threads.
      • Les expressions régulières.
      • Travaux pratiques Mise en oeuvre de la robustesse avec les smart pointers.
      • Utilisation d'expressions régulières.
      • La Pointer Container Library (destruction des données pointées d'un conteneur).
      • Les structures de données boost::any et boost::variant.
      • Programmation événementielle (connexions et signaux).
      • Gestion des processus, mécanismes de communication interprocessus et mémoire partagée.
      • Travaux pratiques Amélioration de l'implémentation de l'étude de cas par l'utilisation la Pointer Container Library.
      • Héritage versus embarquement.
      • Héritage privé.
      • Héritage protégé.
      • Exportation de membres cachés avec la Clause Using.
      • Héritage multiple et gestion des collisions de membres.
      • Héritage en diamant.
      • Héritage virtuel et dynamic_cast.
      • Principes de conception : substitution de Liskov, principe d'ouverture/fermeture, inversion des dépendances.
      • Règles d'implémentation des interfaces en C++.
      • Travaux pratiques Combinaison de l'héritage multiple, privé et de l'exportation pour concevoir des classes robustes et hautement évolutives.
    • 1285
    • 28 h

    Soumettez votre avis