Objectifs de la formation 

Inventé au début des années 1970 pour réécrire UNIX, le langage C est un langage de programmation toujours beaucoup utilisé aujourd’hui. On peut le considérer comme un langage de haut niveau “classique” car il en propose tous les mécanismes standards (boucle, test, fonctions, types de base, etc.) et à ce titre il est plutôt facile à apprendre.

À l’issue de cette formation, vous aurez acquis les connaissances et les compétences nécessaires pour :

• Savoir utiliser le langage C afin d’écrire des programmes robustes, portables et conformes à la norme ANSI.

• Comprendre le fonctionnement de la programmation structurée à travers l’exemple du langage C
• Maîtriser la syntaxe du Langage C et les principales fonctions du langage C
• Savoir écrire un programme C modulaire, portable (ANSI) et facile à maintenir
• Maîtriser les mécanismes de gestion de la mémoire lors de la compilation et de l’exécution (classes d’allocation, pile, pointeurs, sécurité)

À qui s’adresse cette formation ?

Public :

Cette formation s’adresse aux développeurs, ingénieurs et informaticiens cherchant à acquérir une expérience pratique du langage C en vue de programmer des applications robustes, portables (ANSI) et performantes.

Prérequis :

Pour suivre cette formation Langage C, il est nécessaire de disposer d’une culture minimum en programmation (variables, boucle, tests, fonction avec passage d’arguments) même si cette formation revient sur ces éléments à travers l’exemple du Langage C.

Contenu du cours 

1. Première approche pratique

   Organisation d’un programme structuré en C

    

   Vue générale d’un programme C basique (main)
   Composants de base du langage
   Types et constantes de base
   Stockage et passage de paramètres
   Variables globales et locales
   Arguments de fonction : passage par valeur
   Code de retour des fonctions 
   Entrées/sorties formatées (scanf, printf)
   Utilisation élémentaire de la chaîne de production (compilation, build)

    

   Travaux pratiques (à titre indicatif)Objectifs : Prendre en main son environnement et écrire un premier programme simple qui permet d’introduire la syntaxe de base mais aussi un premier contact avec les aspects mémoires nécessaire pour bien comprendre les pointeurs par la suite.
   Description : On affiche la taille des différents types de données standards en mémoire (int, char, float, …) en utilisant les éléments fondamentaux du langage (compilation, main, printf, …) autour de problématique mémoire (sizeof, types de données).

   Variables, adresses, pointeurs

   Schéma générale de la mémoire (différentes zones)
   Le rôle du compilateur par rapport à la mémoire
   Vie de la mémoire durant l’exécution d’un programme C (pile, tas, zone d’allocation statique, appel fonction, etc.)
   Opérateurs d’adressage (&)
   Passage d’arguments par adresse
   L’exemple de scanf … et ses pièges
   Ne pas confondre pointeur, adresse et entire

    

   Travaux pratiques (à titre indicatif)Objectifs : Comprendre le fonctionnement de l’allocation mémoire des variables dans la pile (locales, arguments) et le mécanisme d’adressage pour introduire les pointeurs et la problématique du passage par valeur (variable non modifiée) 
   Description : Écriture d’une fonction permutant deux variables

    

   1.  

   Mécanismes et syntaxe du langage

   Opérateurs, expressions numériques et opérations sur les nombresOpérateurs arithmétiques
   Mécanismes d’évaluation des expressions
   Post et pré-incrémentation de décrémentation
   Précédence et associativité des opérateurs

    

   Opérateurs de base et expressions logiquesAffectations
   Boucles (for, while)
   Mécanismes de fonctionnement des expressions logiques
   Opérateurs de comparaison
   Gestion du flux d’entrée/sortie standard
   Prototype de filtre
   Instruction if
   Opérateurs logiques

    

   Compléments sur les types de donnéesMaîtrise des types complexes
   Implémentation des types en mémoire selon les normes 
   Conversion explicite de types : casting
   Les types numériques composés.
   Règle de conversion dans les expressions mixtes
   Initialisation des variables
   Formats d’entrée/sortie associés aux types numériques

    

   Travaux pratiques (à titre indicatif)Objectifs : Compléter sa maîtrise de la syntaxe. Maîtriser les règles d’analyse syntaxique en C, les opérateurs et les conversions de types implicites et explicites (cast). 
   Description : Écriture de fonctions de contrôles et de comparaisons de variables. 
   Opérations numériques sur des variables de différents types (moyenne, somme, etc.).

   Compléments sur les opérateurs

   Opérateurs binaires (ET, OU, OU exclusif, complément à 1)
   Décalages binaires
   Opérateur ternaire d’alternative
   L’instruction switch
   L’instruction do while
   Instructions associées aux boucles

   Travaux pratiques (à titre indicatif)Objectifs : Savoir manipuler les opérateurs bas niveau. Traduire les normes de façon concrète pour le développeur en insistant sur les différences d’implémentation entre les différents types (int, float, etc.) et les problèmes de bug ou de portabilité qui peuvent en découler
   Description : Visualisation détaillée du format d’un float 32 bits en mémoire selon la norme IEEE754 en affichant sa structure binaire (010100010….) grâce aux opérateurs unaires combinés dans des fonctions. Écriture d’une fonction de test de la valeur du bit x d’une variable y. Écriture de fonctions de calcul puissantes s’appuyant sur les propriétés de décalage binaire.

    

   2.  

   Tableaux, pointeurs et chaîne de caractères

    

   Compléments sur les pointeurs

   Différences entre pointeur et adresse d’une variable
   Manipulations de différents types de pointeur (int*, char*, float*, …)
   A quoi correspond void* ?
   Les pièges (oubli du &, écriture dans une zone non allouée, etc.)
   L’allocation dynamique de mémoire (malloc)
   Les pointeurs vers des structures de données 
   Arithmétiques sur les pointeurs

    

   Tableaux et chaînes de caractères

   Définition et utilisation classique des tableaux
   Équivalences pointeurs/tableaux
   Chaînes de caractères
   Bien comprendre le sens et les différences des symboles comme ‘a’, ʺaʺ’, ’\0’, 0, 1, ‘1’, 
   Initialisation des tableaux
   Exemples de manipulation de chaînes de caractères

    

   Travaux pratiques (à titre indicatif)Objectifs :

   Comprendre l’implémentation des tableaux en mémoire et leur interprétation par le compilateur.
   Savoir manipuler les tableaux et maîtriser la gestion des chaînes de caractère (char*)
   Description : (RE)écriture des fonctions standards de manipulations des chaînes de caractères (strcpy, strlen, strcmp, strncmp). Fonction permettant de rendre « propre » une chaîne de caractères en terme de contenu (liste de caractères interdits) et de longueur maximale. Fonction générant des mots de passe aléatoire à partir de notre propre dictionnaire de symboles (tableau de caractères), un niveau de complexité et une taille passée en argument.

   Les structures

   Philosophie
   Accès aux éléments d’une structure
   Passage d’une structure en argument de fonction
   Adresse, mémoire, pointeurs et structures
   Les structures emboîtées
   Les structures anonymes (depuis C11)
   Les champs de bits
   Quand utiliser des unions ?
   Liste de valeurs « fermées » et « numérisable » (enum)
   La libération de la mémoire
   Introduction aux structures chaînées (listes, arbres, …)
   Comparaison des différentes structures de données (tableau de structures, tableau de pointeurs, liste chaînée) en terme d’occupation mémoire, de performances et de complexité

    

   Travaux pratiques (à titre indicatif)Objectifs :

    Maîtriser l’utilisation des structures de données (initialisation, accès aux éléments, passage en argument à une fonction, etc.)
   Description : Création d’une structure PERSONNE, écriture de fonctions de saisie et d’affichage mono personne. Création d’un tableau de PERSONNE et écriture de nouvelles fonctions pour manipuler ce type de tableau en réutilisant les fonctions précédentes. Mise en œuvre d’une liste chaînée de PERSONNE.
   Fonction de cryptage (et décryptage) utilisant des clefs stockées dans des structures.

    

   3.  

   Industrialiser ses développements

    

   Compilation séparée, classe d’allocation

   Mécanisme de fonctionnement de la chaîne de production
   Utilisation de bibliothèque de sources
   Différents cas de figure de la compilation séparée
   Notion d’objet externe
   Cas des données globales et statiques
   Cas des données locales
   Règle de visibilité
   Cas des fonctions
   Compléments sur les fonctions et les initialisations

    

   Travaux pratiques (à titre indicatif)Objectifs : Architecturer son code en modules et comprendre le rôle des fichiers d’en tête (.h)
   Description : Création d’un module regroupant les fonctions de manipulations des chaînes de caractères du TP déjà effectué (chaînes.h, chaînes.c) et compilations séparées des différents modules

   Le macro processeur, la portabilité

   Vue générale des directives de compilation 
   Les constantes symboliques (#define)
   Intérêts et limites des fonctions macros
   Les inclusions de fichiers (#include)
   La compilation conditionnelle (#ifdef, #ifndef, etc.)
   Construction de surtypes : typedef

    

   Travaux pratiques (à titre indicatif)Objectifs : Utiliser les possibilités du précompilateur pour faciliter la maintenance de son code et sa portabilité
   Description : Parcours commenté des en-têtes standard de la bibliothèque (stdio.h, stdlib.h, etc.). Ecriture de ses propres fichiers d’en-têtes pour se protéger de l’inclusion multiple, définir ses pseudos constantes et ses prototypes de fonctions.

    

   Outils associés à la chaîne de productionPrincipes de la gestion de version avec Git
   Options de compilation
   Gérer les briques logicielles et les dépendances (makefile)
   Construire une application avec Gradle (build)

    

   Travaux pratiques (à titre indicatif)Objectifs : Comprendre en détail les mécanismes de compilation, build et automatisation dans la création d’une application ou d’une bibliothèque C.
   Description : Mise en œuvre de l’automatisation avec Gradle et/ou makefile en fonction de l’environnement souhaité par les participants.

    

   4.  

   Les entrées /sorties 

   Principes généraux des I/O
   Ouverture et fermeture d’un fichier ou d’un périphérique
   Écriture et lecture formatée (exemple avec fscanf et fprintf)
   Écriture et lecture d’un caractère (getc)
   Écriture et lecture d’une chaîne de caractères
   Écriture et lecture d’un format binaire (fread, fwrite)
   Accès direct à un endroit du fichier
   Conseils sur la bufferisation des I/O (performances)

    

   Travaux pratiques (à titre indicatif)Objectifs : Maîtriser les différents modes d’accès aux données en lecture et en écriture (caractère, paragraphe, binaire) ainsi que les possibilités de formatage (%s, %c, etc.).
   Description : Chargement d’un fichier texte en mémoire, traitement, sauvegarde, rechargement (pour tester).
   Chargement d’un fichier texte pour remplir un tableau de pointeurs (char*) pour disposer d’une structure souple de manipulation de texte (tableau de paragraphes). Passage d’arguments sur la ligne de commande (nom du fichier à charger). Manipulation de flux binaire sous la forme d’enregistrement d’un tableau de mesures (structures de l’un des TP précédents) dans un fichier, chargement de ce fichier dans un autre tableau, tri, puis sauvegarde pour proposer un cycle complet d’un flux : mémoire / traitement / disque. Manipulations de flux de données formatées.

   Aspect avancés du langage C

   Quels traitements utilisent les tableaux multidimensionnels (matrices) ?
   Tableau de pointeurs et structures dérivées
   Passage d’arguments en ligne de commandes (argc, argv)
   Intérêt des pointeurs de fonctions
   Fonctions à nombre variable d’arguments
   Synthèse des différences avec le C++ (au-delà de la dimension objet)

   Travaux pratiques (à titre indicatif)Objectifs : Comprendre l’intérêt de passer une fonction en argument à une autre fonction en mettant en œuvre les pointeurs de fonction
   Description : fonction de tri d’un tableau de structures de PERSONNE avec passage en argument de la fonction de tri

Objectifs de la formation 

Cette formation, vous permettra de compléter vos connaissances en langage C par une formation approfondie sur les mécanismes fondamentaux de fonctionnement.

À qui s’adresse cette formation ?

Public :

Cette formation langage C s’adresse à toute personne amenée à programmer, à superviser ou à modifier des logiciels écrits en langage C.

Prérequis :

Afin de suivre ce stage il est demandé aux participants de connaître les bases du langage C.

Contenu du cours 

1. 1.

   Rappels sur le langage C

   Les différentes variables, type statique
   Variables statiques et variables registres
   Les conversions implicites/explicites

   Structures en langage C

   Présentation, intérêt des structures
   Syntaxe de définition, de déclaration et d’accès aux éléments des structures
   Exemples : copie de structures
   Structures avancées, unions, tableaux, champs binaires, drapeaux

   Fonctions de saisies, affichage (printf/scanf)

   Options avancées de printf
   Mise en forme paramétrée
   Saisie avancée
   Rappel du principe : décomposition du flux d’entrée
   Les types ‘ensemble’

   Les opérateurs

   Rappels sur les opérateurs de calculs
   Opérateurs logiques, opérateurs binaires

   Travaux pratiques : 

   Mise en oeuvre des opérateurs de décalage
   Priorité des opérateurs

   les fonctions aspects avancés 

   Pointeurs sur les fonctions
   Applications aux interpréteurs

   Allocation dynamique de la mémoire

   Principe d’allocation mémoire
   Syntaxe de malloc et free
   Les pièges classiques
   Travaux pratiques de mise en oeuvre
   Fonctions avancées (calloc et realloc) : intérêt et applications

   Autres aspects avancés

   Les listes chaînées, les arbres binaires
   Applications à l’organisation des données

   Techniques de programmation prefectionnement

   Bien comprendre les différents phases de compilation : précompilation , assemblage, édition de liens
   Définition des constantes
   Contrôle de compilation
   Les macro-instructions
   Conventions de nommage
   Comparaison avec les fonctions
   Les fichiers inclus : #include

   Bibliothèques

   Méthode, syntaxe
   Les bibliothèques standards : libc.a, libm.a, libcur.a
   Fonctions disponibles dans la bibliothèque mathématique

   Les entrées/sorties (I/O)

   Mécanisme de stockage des fichiers
   Méthode d’accès, les descripteurs de fichiers
   Fonctions open/close

   Travaux pratiques :

   Ecriture d’une fonctions permettant de tester l’existence d’un fichier
   Fonctions read/write
   Mise en oeuvre avec lecture/écriture de structures
   Modes d’ouvertures spécifiques : avec positionnement dans le fichier, avec création du fichier, …
   Options : O_TRUNC, o_SYNC, O_NDELAY
   Le type FILE : mise en oeuvre de fprintf, fscanf, fgets, fputs

Objectifs de la formation 

Cette formation C++ vous permettra de mettre en œuvre tous ces éléments en respectant la syntaxe, y compris celle de l’importante norme C++ 11, afin de livrer un code portable et sécurisé. Vous apprendrez à produire un code de qualité qui respecte les bonnes pratiques professionnelles en matière de conception et de développement objet.

À l’issue de cette formation, vous aurez acquis les connaissances et les compétences nécessaires pour :

• Concevoir et mettre en œuvre une application C++ performante selon une approche objet.

• Concevoir l’architecture d’une application C++ en utilisant ses propres classes ou des classes existantes
• Savoir programmer objet en C++ (classe, méthode, propriétés, constructeur, instance, etc.)
• Maîtriser la syntaxe du C++
• Maîtriser son environnement de développements (outils, compilation, build, etc.)
• Connaître la norme C++ 11 et les nouveautés introduites par cette version et les suivantes

À qui s’adresse cette formation ?

Public :

Ce cours C++ s’adresse prioritairement à un public technique comme les développeurs qui souhaitent développer ou maintenir des applications ou modules écrits en C++.

Prérequis :

Cette formation C++ demande de savoir développer dans au moins un langage de programmation (C, PHP, Java, C#, Python, etc.)

Contenu du cours 

1. 1.

   Les concepts de la Programmation objet essentiels pour bien commencer en C++

   Les paradigmes de la P.O.O.
   La classification
   Contrôler l’accès aux données (encapsulation)
   Introduction aux diagrammes de classes UML2
   Les associations entre classes : l’association directe, l’agrégation, la composition
   L’héritage, la dérivation
   Fournir les informations essentielles (abstraction)

    

   Travaux pratiques (à titre indicatif)Objectifs : Valider que les concepts objets fondamentaux sont maîtrisés par tout le monde
   Présenter le modèle objet que l’on va utiliser en fil rouge dans la formation (il ne sera pas unique afin de bien comprendre les manipulations communes à toutes les classes et ce qui est spécifique à chacune)
   Description : Quizz qui valide dans un premier temps que tout le monde dispose du vocabulaire objet, que ce vocabulaire est commun à tous participants et au formateur, mais aussi que tout le monde a compris en profondeur chaque concept.

   C++, le langage

   Les types de données, les opérateurs
   Les pointeurs bruts 
   Le type référence lvalue 
   Les structures de contrôles
   Les fonctions et la surcharge
   L’opérateur de résolution de portée
   Liaison C – C++
   Les paramètres par défaut des fonctions
   Les fonctions ” inline “
   Les espaces de noms
   Les énumérations

    

   Travaux pratiques (à titre indicatif)Objectifs : Valider que tout le monde est à l’aise avec son environnement de développement et prend en main la syntaxe de base du C++ (opérateurs, types, tests, etc.).
   Description : Réalisation du programme types.cpp, qui définit et initialise une variable de chacun des types primitifs disponibles (bool, char, int, etc…). Chacune des variables est ensuite affichée en utilisant l’objet cout
   Saisie d’un nombre décimal, calcul, affichage du résultat
   Réalisation du programme celcius.cpp qui demande la saisie au clavier d’une température en degrés Fahrenheit, puis calcule et affiche la température correspondante en degrés Celsius en interdisant les valeurs hors plage

    

   1. .

   Les classes en C++

   Définition d’une classe
   Les qualificateurs ” public ” et ” private “
   Instanciation d’une classe
   Les constructeurs par défaut
   Les constructeurs surchargés
   Le constructeur de copie
   Surcharge de l’opérateur d’affectation
   Le destructeur
   Le mot-clé this
   Les méthodes const
   Les membres static
   Fonctions amies
   Surcharges d’opérateurs

    

   Travaux Pratiques (à titre indicatif)Objectifs : Maîtriser la création de classe, l’instanciation, les constructeurs et la surcharge des méthodes
   Description : Création d’un classe « counter » permettant de créer un objet qui génère une séquence de nombres (incrémentation, valeur actuelle, affichage, etc.)
   Surcharges du constructeur en y passant un nombre ou un objet (pour s’initialiser sur cet objet)

    

   2.  

   Relations entre classe (association, composition, héritage)

   Traduction en C++ d’une association, d’une composition
   Importance de la liste d’initialisation dans les constructeurs
   L’héritage public simple
   Ordre d’exécution des constructeurs et destructeurs
   Les règles de conversion
   Le qualificateur d’accès protected
   Les héritages privé et protégé
   L’héritage multiple répété et ses difficultés de mise en oeuvre

    

   Travaux Pratiques (à titre indicatif)Objectifs : Comprendre comment mettre en œuvre une association directe, puis une composition entre classes. Savoir spécialiser une classe existante par héritage pour ne pas tout réécrire en maîtrisant l’impact hiérarchique dans la syntaxe (classe mère et descendance.)
   Description : Mise en œuvre d’une relation d’association puis de composition entre deux classes. Construction d’une hiérarchie de classes à trois niveaux. Manipulation d’objets de ces classes. Mise en œuvre d’un héritage multiple répété

   Le polymorphisme

   Les méthodes virtuelles
   Intérêt du polymorphisme
   Mise en œuvre du polymorphisme
   Les classes abstraites et les méthodes virtuelles pures
   Les destructeurs virtuels

    

   Travaux Pratiques (à titre indicatif)Objectifs : Savoir mettre en œuvre le polymorphisme, 
   Description : Mise en œuvre du polymorphisme dans le Design Pattern Factory Method : obtenir un objet d’une sous-classe dans une hiérarchie de classes avec héritage multiple comportant une classe abstraite pure

    

   3.  

   La gestion des exceptions

   Principe du traitement des anomalies
   Utilisation des mot-clés try, catch et throw
   Traiter les exceptions sur place
   Propager les exceptions
   Lever une exception
   Créer ses propres classes d’exception

    

   Travaux Pratiques (à titre indicatif)Objectifs : comprendre comment gérer les exceptions dans une application effectuant des entrées-sorties
   Description : Calcul de la somme des soldes mensuels d’un compte bancaire par lecture d’un fichier CSV avec mise en œuvre d’un traitement sur place d’exceptions puis en propageant les exceptions à la fonction appelante

   Les templates en C++

   Principe des templates
   Avantages/inconvénients
   Paramètres template
   Syntaxe des templates de fonctions
   Syntaxe des templates de classes
   Syntaxe des templates de méthodes
   Instanciation des templates de fonctions
   Instanciation des templates de classes
   Instanciation implicite vs instanciation explicite

    

   Travaux Pratiques (à titre indicatif)Objectifs : Comprendre et mettre en œuvre la généricité des types dans une fonction grâce aux templates 
   Description : Création d’un template de fonction (fonction rendant le « plus petit » de 2 objets passés en argument indépendamment de leur type). Création d’un template de classe (tableau redimensionnable automatiquement)

    

   4.  

   Les pointeurs intelligents (smart pointers C++11)

   Principe de la gestion RAII des ressources
   Danger des pointeurs bruts
   Intérêt des smart pointers
   Raisons de l’obsolescence de auto_ptr
   Mise en œuvre de unique_ptr, shared_ptr, weak_ptr
   Utilisation de make_unique et make_shared

    

   Travaux Pratiques (à titre indicatif)Objectifs : Comprendre la mise en œuvre des smart pointers pour la gestion des ressources
   Description : Mise en oeuvre, dans une petite application, de la technique RAII par remplacement des pointeurs bruts par des pointeurs intelligents

   Outils de développement

   Présentation des IDE courants
   Options de compilation
   Cross-compilateurs
   Génération d’un exécutable, fichiers objets
   Utilisation des fonctionnalités de debug
   Commande make sous Linux, makefile
   Utilisation de git

   Travaux Pratiques (à titre indicatif)Objectifs : Savoir debugguer une application et modifier les options de compilation. Savoir packager une application C++.
   Description : Recherche de bugs dans une application et correction. Mise en œuvre d’une chaîne de build automatisée.

   Aperçu de la librairie STL

   Présentation, documentation
   Les conteneurs
   Les itérateurs
   Les algorithmes
   Les entrées-sorties
   L’espace de noms chrono

    

   Démonstration (à titre indicatif)Objectifs : comprendre l’intérêt d’un conteneur pour y stocker des objets et le rôle d’un itérateur. Savoir lire-écrire dans un fichier texte
   Description : lecture d’un fichier texte ligne par ligne, création des objets représentés par les chaînes de caractères, mise en œuvre d’un vector pour y stocker les objets et parcours à l’aide d’un itérateur pour supprimer certains objets, tri du vector à l’aide d’un algorithme de tri et d’un foncteur

   Présentation des principales nouveautés apportées par C++11/14/17/20

   Mot-clé auto
   Boucle for-each
   Le mot-clé noexcept 
   Références rvalue et applications
   Expressions lambdas et applications
   Initialisation uniforme
   Méthodes par défaut et supprimées
   Concepts et contraintes
   ModulesDémonstration (à titre indicatif)Objectifs : comprendre les simplifications apportées par le mot-clé auto, la boucle for-each et les expressions lambdas
   Description : ré-écriture de l’exemple précédent en utilisant une boucle for-each et auto pour afficher le contenu du vector, utilisation d’une expression lambda dans l’algorithme de tri

Objectifs de la formation 

Cette formation C++ Approfondissement a pour objectif de consolider une formation de base en C++.

À l’issue de cette formation, vous aurez acquis les connaissances et les compétences nécessaires pour :

• Réactualiser ses connaissances sur C++ et en maîtriser les aspects les plus avancés.

• Consolider vos connaissances sur la syntaxe de base de C++ (création et manipulation de classes…)
• Mettre en œuvre l’héritage et le polymorphisme
• Élaborer des pointeurs intelligents
• Gérer les exceptions dans C++
• Connaître et créer des templates en C++
• Décrire et mettre en œuvre la bibliothèque STL

À qui s’adresse cette formation ?

Public :

Cette formation C++ s’adresse aux développeurs qui souhaitent revisiter les concepts clés du C++, approfondir la syntaxe du langage

Prérequis :

Pour tirer pleinement profit de cette formation de préparation à l’examen de certification, il est nécessaire d’avoir au préalable de bonnes bases en programmation C++

Contenu du cours 

1. 1

   Rappels sur la syntaxe de base

   Création de tableaux
   Anatomie d’une classe
   Spécificateurs d’accès private et public
   Création d’objets
   Constructeurs, méthodes d’instance, méthodes static
   Surcharge de fonctions et de méthodes
   Paramètres par défaut
   Passage d’arguments aux fonctions et aux méthodes: par valeur, par adresse, par référence
   Le constructeur de copie
   Surcharge de l’opérateur d’affectation
   Le destructeur
   Les méthodes const
   Les membres static

   Travaux Pratiques :

   Création de quelques classes avec constructeurs et méthodes surchargés
   Manipulation d’instances de ces classes

   Mise en œuvre de l’héritage et du polymorphisme

   Usage du mot-clé protected
   Distinction surcharge/redéfinition
   Manipulation d’instances de sous-classes
   Spécificateur protected
   Types d’héritage : public, protégé, private
   Utiliser les classes abstraites
   Déclaration de méthodes virtuelles et virtuelles pures
   Développer du code mettant en œuvre le polymorphisme, redéfinir des méthodes
   Mise en œuvre de l’héritage multiple

   Travaux Pratiques :

   Parcours d’une hiérarchie d’objets sans, puis avec polymorphisme

   Les pointeurs intelligents (smart pointers C++11)

   Danger des pointeurs nus
   Principe de la gestion de ressources
   Intérêt des smart pointers
   Raisons de l’obsolescence de auto_ptr
   Mise en œuvre de unique_ptr, shared_ptr

   Travaux Pratiques :

   Remplacement, dans une application, de pointeurs nus par des pointeurs intelligents

   Gestion des exceptions

   Décrire les avantages de la gestion d’exceptions
   Créer un bloc try-catch et déterminer comment les exceptions modifient le déroulement normal du programme
   Lancer une exception
   Propager une exception
   Créer ses propres classes d’exception

   Travaux Pratiques :

   Mise en œuvre d’une gestion d’exception dans une application, en remplacement d’un code d’erreur

   Les templates en C++

   Principe des templates
   Avantages/inconvénients
   Syntaxe des templates de fonctions
   Syntaxe des templates de classes
   Instanciation des templates de fonctions
   Instanciation des templates de classes

   Travaux Pratiques :

   Création d’un template de fonction
   Création d’un template de classe

   La bibliothèque STL

   Présentation de la Standard Template Library
   Les conteneurs
   Les itérateurs
   Les algorithmes
   Les entrées-sorties

   Travaux Pratiques :

   Mise en œuvre de quelques conteneurs, d’algorithmes et template d’entrées-sorties

Objectifs de la formation 

Cette formation C++ Programmation Avancée Expert vous permettra de maîtriser le langage C++ .

 À l’issue de cette formation, vous aurez acquis les connaissances et les compétences nécessaires pour :

• Savoir maîtriser le langage C++.

• Maîtriser les meilleures pratiques concernant l’utilisation des classes
• Comprendre le besoin et les pièges des conversions (cast)
• Comprendre l’intérêt du Run-time type information (RTTI)
• Maîtriser l’utilisation des pointeurs (sur membres, smart pointers, etc.)
• Programmer efficacement les exceptions
• Savoir utiliser les templates et les design patterns
• Gérer un objet qui se comporte comme une fonction (foncteur)
• Utiliser la puissance de la bibliothèque STL (Standard Template Library)
• Savoir construire des idiomes
• Découvrir les possibilités de la bibliothèque Boost

Connaître les principales nouveautés du C++11

À qui s’adresse cette formation ?

Public :

Cette formation C++ s’adresse aux développeurs.

Prérequis :

Une expérience de développeur en programmation C++ est essentielle pour tirer pleinement profit de cette formation

Contenu du cours 

1. 1.

   Les classes en C++

   Constructeurs et allocation mémoire
   Forme canonique d’une classe
   Rôle du constructeur de copie
   Surcharge de l’opérateur d’affectation
   Intérêt d’un destructeur virtuel
   Pièges à éviter

   Travaux Pratiques :

   Exécution d’exemples pédagogiques illustrant les concepts présentés

   Les conversions en C++

   Présentation des conversions, syntaxe
   Utilisation du const_cast pour enlever un caractère const
   Utilisation du static_cast pour effectuer une conversion standard
   Utilisation du reinterpret_cast pour effectuer une conversion forte
   Utilisation du dynamic_cast dans une hiérarchie de classes

   Travaux Pratiques :

   Choix du type de cast et mise en œuvre dans différentes situations 

   L’identification de type à l’exécution (RTTI)

   Principe et cas d’utilisation
   Utilisation du dynamic_cast pour effectuer un downcast dans une hiérarchie de classes
   Utilisation de l’opérateur typeid et de la classe type_info

   Travaux Pratiques :

   Mise en œuvre de RTTI pour effectuer un affichage spécifique d’un objet faisant partie d’une hiéarchie de classes

   Les pointeurs sur membres de classes

   Syntaxe des pointeurs sur membres de classes
   Mise en œuvre

   Travaux Pratiques :

   Utilisation de pointeurs sur méthodes pour effectuer des calculs mathématiques

   Les pointeurs intelligents (smart pointers C++11)

   Danger des pointeurs nus
   Principe de la gestion de ressources
   Intérêt des smart pointers
   Raisons de l’obsolescence de auto_ptr
   Mise en œuvre de unique_ptr, shared_ptr et weak_ptr

   Travaux Pratiques :

   Remplacement, dans une application, de pointeurs nus par des pointeurs intelligents

   La gestion des exceptions

   Principe des exceptions
   Les classes d’exceptions
   Comment lever une exception
   Gestionnaires d’exceptions
   Liste d’exceptions
   Hiérarchies d’exceptions
   Classes d’exceptions standards
   Constructeurs et exceptions
   Exceptions et gestion des ressources
   Bonnes pratiques

   Travaux Pratiques :

   Mise en place d’une gestion d’exceptions dans une application effectuant des entrées-sorties

   Les templates

   Présentation
   Avantages/inconvénients
   Syntaxe des templates de fonctions
   Syntaxe des templates de classes
   Syntaxe des templates de méthodes
   Instanciation des templates de fonctions
   Instanciation des templates de classes
   Spécialisation partielle ou totale des templates

   Travaux Pratiques :

   Mise en œuvre d’une fonction template
   Mise en œuvre d’une classe template
   Mise en œuvre d’une classe template template

   Introduction aux Design Patterns (avec zoom sur certains)

   Présentation des patterns du GoF
   Patterns de création
   Patterns de structure
   Patterns de comportement

   Travaux Pratiques :

   Mise en œuvre des patterns Singleton, Factory Method, Abstract Factory
   Mise en œuvre des patterns Visitor, Proxy

   Les foncteurs

   Présentation
   Intérêt des foncteurs
   Foncteurs prédéfinis dans la bibliothèque standard
   Utilisation d’adaptateurs de fonctions unaires et binaires

   Travaux Pratiques :

   Mise en œuvre d’un foncteur avec l’algorithme for_each pour afficher le contenu d’un vector

   La bibliothèque STL

   Présentation de la Standard Template Library
   Les conteneurs
   Les allocateurs
   Les itérateurs
   Les algorithmes
   Les entrées-sorties

   Travaux Pratiques :

   Mise en œuvre de quelques conteneurs, d’algorithmes et template d’entrées-sorties

   Les idiomes

   Traits
   Policy
   SFINAE (Substitution Failure Is Not An Error)
   CRTP (Curiously Recurring Template Pattern) : pour le polymorphisme statique

   Travaux Pratiques :

   Mise en œuvre de chacun des idiomes

   La méta-programmation

   Comment exécuter à la compilation
   Avantages/inconvénients
   Optimisations

   Travaux Pratiques :

   Mise en œuvre de la méta-programmation pour effectuer des calculs mathématiques par le compilateur

   La bibliothèque Boost

   Présentation
   static_assert
   property_map
   smart_ptr
   tuple
   any
   variant
   threads
   interprocess
   mpl (méta programming language)

   Travaux Pratiques :

   Mise en œuvre de quelques templates de Boost

   Nouveautés essentielles du C++11 

   Mot-clés auto, decltype et constexpr
   Définition des rvalue références
   Application des rvalue références : déplacement et transfert parfait
   Bonne utilisation de std::move et std::forward
   Les fonctions lambda
   Les variadic templates

   Travaux Pratiques :

   Mise en œuvre des mot-clés auto, decltype et constexpr
   Mise en œuvre des références rvalue pour la création et la copie d’objet par déplacement
   Mise en œuvre des expressions lambda en remplacement des foncteurs
   Mise en œuvre des variadic templates

   Autres nouveautés du C++11 

   Initialisation des données membres non-statiques
   Alias de template
   Constructeurs délégués
   Déclarations étendues de l’amitié
   Surcharge explicite de la virtualité
   La constante nullptr
   « Range-based » for
   Définition des rvalue références
   Les opérateurs de conversion explicites
   Les types POD (Plain Old Data) revisités
   Les types locaux et non nommés comme arguments template
   Les énumérations à typage fort
   Les fonctions par défaut et supprimées (=default, =delete)
   Les espaces de nom inline
   La propagation des exceptions (dans le cadre du multithreading)

   Travaux Pratiques :

   Mise en œuvre d’une partie de ces nouveautés dans une application existante

   Performances

   Introduction
   Résumé des bonnes pratiques

Objectifs de la formation 

Cette formation  vous présentera sous un angle conceptuel et opérationnel les nouveautés du langage C++ depuis la version 2011 et plus généralement, au-delà des nouveautés, vous disposerez d’une vue complète sur le langage C++.

À l’issue de cette formation, vous aurez acquis les connaissances et les compétences nécessaires pour :

• Mettre en œuvre les nombreuses nouveautés du C++ 11 au C++ 17

• Maitriser les nouveaux mots-clés du langage
• Mettre en oeuvre les pointeurs intelligents
• Connaitre la sémantique de mouvement
• Comprendre la notion de transfert parfait
• Maitriser les expressions lambdas
• Mettre en oeuvre les threads
• Connaitre les nouvelles API de la STL

À qui s’adresse cette formation ?

Public :

Cette formation C++ s’adresse aux développeurs d’applications.

Prérequis :

Bonnes connaissances du langage C++.

Contenu du cours 

1. 1.

   Bref historique des versions de C++ passées, présentes, futures

   C++98, C++03, C++0x, C++11, C++14, C++17

   Les outils de développement

   Les versions de GCC
   Les versions d’Eclipse
   Les versions de Visual Studio
   Les librairies BOOST et STL : convergence ?

   Travaux pratiques : 

   Test de la version installée

   Les nouveautés du langage C++ 11/C++ 17

   Les espaces de nom inline
   Les chaînes litérales brutes et Unicode
   Les types POD (Plain Old Data) revisités
   La constantes nullptr
   Les expressions constantes généralisées (constexpr)
   Le « range-based » for
   Les déclarations étendues de l’amitié
   Les litéraux définis par l’utilisateur
   Les énumérations fortement typées
   L’inférence de type : auto et decltype
   Tableaux statiques : std ::array
   Nouvelle syntaxe pour le type de retour des fonctions
   Le mot-clé noexcept en remplacement de throw

   Travaux pratiques : 

   Mise en œuvre des nouveautés

   Les nouveautés au niveau des classes en C++11/C++ 17

   Initialisation des données membres non-statiques
   Constructeurs délégués
   Les initialiseurs de conteneurs et de données membres
   Les rvalues-reference et la sémantique de déplacement (move constructeur et surcharge de l’opérateur d’affectation par déplacement)
   Les directives =delete et =default
   La surcharge explicite de la virtualité (override)
   Les méthodes et les classes « final »

   Travaux pratiques :

   Forme canonique d’une classe avec la sémantique de déplacement

   Vers la programmation fonctionnelle en C++11/C++ 17

   Les lambda-expressions : syntaxe, typage, utilisation
   Intérêt de « auto » et « decltype » avec les lambda-expressions
   La gestion des fermetures (closures) liées au contexte

   Travaux pratiques : 

   Mise en œuvre des lambda-expressions

   Nouveautés dans les templates avec C++11/C++ 17

   Alias de template (using)
   Nombre d’arguments variables (variadic template)
   Les types locaux et non nommés comme arguments template

   Nouveautés dans la STL

   Nouveaux conteneurs : unordered_XXX, forward_list, array
   Nouveaux algorithmes  

   Gestion mémoire et STL

   Les pointeurs intelligents : unique_ptr (auto_ptr est obsolète) , weak_ptr, shared_ptr.
   Utilisation avec la STL

   Travaux pratiques : 

   Mise en œuvre des pointeurs intelligents

   Le namespace chrono

   Les classes duration et time_point
   Les horloges system_clock, steady_clock et high_resolution_clock
   Les traits : treat_as_floating_point, duration_values, common_type (duration)
   Les fonctions duration_cast et time_point_cast
   Les typedefs d’instantiation de la classe duration : hour, minute, etc.

   Travaux pratiques : 

   Mise en œuvre

   Utilisation des threads

   Le mot-clé thread_local
   Déclarer et exécuter un thread. Utilisation de join
   Fonctions gérant le thread courant : yield , get_id , sleep_for, sleep_until
   Exclusion mutuelle : mutex, timed_mutex, etc.
   Gestion des mutex : lock_guard, unique_lock, etc.
   Algorithmes génériques de verrou : try_lock, lock
   Appel de fonction unique : once_flag, call_once
   Les variables conditionnelles
   Futures/Asynchronisme : promise, packaged_task, future, shared_future, async, etc.
   Future errors
   La fonction hardware_concurrency

   Travaux pratiques : 

   Mise en œuvre des threads

Objectifs de la formation 

Cette formation C++11/C++20 vous présente sous un angle conceptuel et opérationnel les nouveautés du langage C++ depuis la version 2011. Plus généralement, au-delà des nouveautés, vous disposerez d’une vue complète sur le langage C++.

À l’issue de cette formation C++11/C++20, vous serez en mesure de :

• Connaître les nouveaux mots-clés du langage
• Mettre en œuvre les pointeurs intelligents
• Maîtriser la sémantique de mouvement
• Comprendre la notion de transfert parfait
• Connaître les expressions lambdas
• Mettre en œuvre les threads et les coroutines
• Connaître les nouvelles API de la STL

À qui s’adresse cette formation ?

Public :

Ce cours C++11/C++20 s’adresse principalement aux développeurs d’applications.

Prérequis :

Pour suivre cette formation C++11/C++20, il est nécessaire d’avoir de bonnes connaissances en langage C++.

Contenu du cours 

1. 1.

   Bref historique des versions de C++ passées, présentes et futures

   C++98, C++03, C++0x, C++11, C++14, C++17, C++20

   Les outils de développement

   Les versions de GCC
   Les versions d’Eclipse
   Les versions de Visual Studio

   Travaux pratiques

   Test de la version installée

   Les nouveautés du langage C++11/C++17

   Les espaces de nom inline
   Les chaînes littérales brutes et Unicode
   Les types POD (Plain Old Data) revisités
   La constantes nullptr
   Les expressions constantes généralisées (constexpr)
   Le « range-based » for
   Les déclarations étendues de l’amitié
   Les littéraux définis par l’utilisateur
   Les énumérations fortement typées
   L’inférence de type : auto et decltype
   Tableaux statiques : std :array
   Nouvelle syntaxe pour le type de retour des fonctions
   Le mot-clé noexcept en remplacement de throw

   Travaux pratiques :

   Mise en œuvre des nouveautés

   Les nouveautés au niveau des classes en C++11/C++17

   Initialisation des données membres non-statiques
   Constructeurs délégués
   Les initialiseurs de conteneurs et de données membres
   Les rvalues-reference et la sémantique de déplacement (move constructeur et surcharge de l’opérateur d’affectation par déplacement)
   Les directives =delete et =default
   La surcharge explicite de la virtualité (override)
   Les méthodes et les classes « final »

   Travaux pratiques

   Forme canonique d’une classe avec la sémantique de déplacement

   Vers la programmation fonctionnelle en C++11/C++17

   Les lambda-expressions : syntaxe, typage, utilisation
   Intérêt de « auto » et « decltype » avec les lambda-expressions
   La gestion des fermetures (closures) liées au contexte

   Travaux pratiques

   Mise en œuvre des lambda-expressions

   Nouveautés dans les templates avec C++11/C++17

   Alias de template (using)
   Nombre d’arguments variables (variadic template)
   Les types locaux et non nommés comme arguments template

   Nouveautés dans la STL

   Nouveaux conteneurs : unordered_XXX, forward_list, array
   Nouveaux algorithmes  

   Gestion mémoire et STL

   Les pointeurs intelligents : unique_ptr (auto_ptr est obsolète) , weak_ptr, shared_ptr.
   Utilisation avec la STL

   Travaux pratiques

   Mise en œuvre des pointeurs intelligents

   Le namespace chrono

   Les classes duration et time_point
   Les horloges system_clock, steady_clock et high_resolution_clock
   Les traits : treat_as_floating_point, duration_values, common_type (duration)
   Les fonctions duration_cast et time_point_cast
   Les typedefs d’instanciation de la classe duration : hour, minute, etc.

   Travaux pratiques

   Mise en œuvre

   Utilisation des threads

   Le mot-clé thread_local
   Déclarer et exécuter un thread. Utilisation de join
   Fonctions gérant le thread courant : yield , get_id , sleep_for, sleep_until
   Exclusion mutuelle : mutex, timed_mutex, etc.
   Gestion des mutex : lock_guard, unique_lock, etc.
   Algorithmes génériques de verrou : try_lock, lock
   Appel de fonction unique : once_flag, call_once
   Les variables conditionnelles
   Futures/Asynchronisme : promise, packaged_task, future, shared_future, async, etc.
   Future errors

   Travaux pratiques

   Mise en œuvre des threads

   Les nouveautés du langage C++20

   Coroutines
   Modules
   Contraintes et Concepts
   Nouvel opérateur de comparaison
   Initialiseurs désignés
   Mots-clés consteval et constinit
   Mots-clés no_unique_adress, likely et unlikely
   Nouveautés dans la librairie STL

   Travaux pratiques

   Mise en œuvre des co-routines
   Mise en œuvre des modules

Objectifs de la formation 

Qt5 est un Framework destiné au développement d’applications graphiques en C++. Sa facilité de mise en œuvre et sa polyvalence le rendent incontournable.

Qt5 permet de créer des applications compatibles sur Windows, Mac OS et Linux, mais aussi sur Android et IOS, en s’appuyant sur les éléments graphiques de tous ces systèmes.

À l’issue de cette formation, vous aurez acquis les connaissances et les compétences nécessaires pour :

• Créer des écrans et gérer les évènements
• Créer des widgets personnalisés
• Utiliser l’éditeur graphique QtCreator pour concevoir une application
• Connaître les notions avancées de Qt

À qui s’adresse cette formation ?

Public :

Cette formation Qt s’adresse principalement aux développeurs.

Prérequis :

Une expérience de développement en programmation C++, même légère, est souhaitable pour tirer pleinement profit de cette formation.

Contenu du cours 

1. 1.

   C++ et Qt

   Historique de Qt
   Évolution des versions jusqu’à Qt 5
   Plateformes supportées
   Qt Widgets vs QML
   Gestion des licences

   Premiers pas avec Qt

   Présentation de l’IDE QtCreator et QtDesigner
   Le modèle objet particulier de Qt
   Rôle du pré-processeur MOC (Meta Object Compiler)
   Classes principales : QMainWindow, QDialog, types, conversions…
   Boîtes de messages
   Principaux composants graphiques, menus et barres d’outils
   Gestion du positionnement avec les layouts
   Zones d’affichage et d’impression

   Travaux Pratiques :

   Création d’une IHM simple avec champs de texte, menus et boîtes de dialogues

   Gestion d’évènements

   Principe des signaux et slots
   Rôle de la macro Q_OBJECT
   Filtres d’évènements
   Utilisation de QSignalMapper

   Travaux Pratiques :

   Ajout d’une gestion d’évènements à l’application déjà développée

   Création de widgets personnalisés

   Hériter de QWidget
   Structure, évènements
   Intégration de widgets dans QtDesigner

   Travaux Pratiques :

   Création d’un widget représentant un formulaire

   QtQuick et QML

   Présentation
   Syntaxe du langage et principaux concepts
   Différences clés avec les widgets
   Présentation des principaux composants textuels et graphiques
   Créer des composants réutilisables
   Positionner ses éléments
   Fonctionnement du property binding

   Travaux Pratiques :

   Création en QML d’une IHM simple avec champs de texte, menus et boîtes de dialogues

   Autres API Qt

   Collections: conteneurs et algorithmes
   Manipulation de fichiers
   Connexions aux bases de données
   Mise en œuvre du multi-threading
   Communication entre threads
   Connexions réseau en TCP, HTTP, FTP
   Manipulation de flux XML

   Travaux Pratiques :

   Ajout d’un accès base de données à l’application, ainsi qu’un mécanisme de log dans un fichier
   Ajout d’un accès réseau pour transmettre les données de l’application à un serveur distant

   Notions avancées

   Mise en œuvre du Drag & Drop
   Personnalisation du Look & Feel
   Gestion des graphismes 2D et 3D
   Internationalisation
   Création de plugins
   Scripting avec JavaScript

   Travaux Pratiques :

   Mise en œuvre de l’internationalisation de l’application