1. Livres et vidéos
  2. C++ - Les fondamentaux du langage (2e édition)

C++ Les fondamentaux du langage (2e édition)

  • Accès illimité 24h/24, 7J/7
  • Tous les livres en ligne, les vidéos et les cours enregistrés ENI
  • Plus de 10 nouveautés livres et vidéos chaque mois
  • Les nouveautés disponibles le jour de leur sortie
  • Accès 100% en ligne
  • En stock
  • Expédié en 24h00
  • Livraison à partir de 0,01 €
  • Version en ligne offerte
  • 1 h d'accès gratuit à tous nos livres et vidéos pour chaque commande
  • Accessible immédiatement
  • Version HTML
  • Accès illimité 24h/24, 7J/7

Présentation

Ce livre s'adresse à tout développeur désireux d'apprendre le langage C++, dans le cadre de ses études ou pour consolider son expérience professionnelle.

Le premier chapitre présente les bases de la syntaxe du langage ainsi que l'organisation des programmes. Le chapitre suivant est une transition vers C++, il explique les notions clés pour créer ses premières applications : structures, pointeurs, bibliothèques standards… Le troisième chapitre détaille la programmation orientée objet et les mécanismes spécifiques au langage (héritage, modèles de classes…). Vient ensuite l'étude de la STL (Standard Template Library), présentée à travers ses mécanismes les plus importants : les chaînes, les structures de données et les algorithmes. Le chapitre 5 ouvre C++ sur ses univers, comme l'environnement .NET C++ CLI.

Comme illustration des capacités de C++ à créer tout type d'applications, l'auteur propose un exemple complet de tableur graphique, un interprète de langage de script Lab ou encore un gestionnaire IIS de pages web dynamiques EZ-Pages. L'ouvrage se termine par un chapitre consacré à l'optimisation et aux méthodes de conception orientée objet (UML).

Le code source des exemples du livre est disponible en téléchargement sur www.editions-eni.fr. Les exemples sont réalisés avec Visual Studio Community Edition sous Windows et avec Eclipse sous Linux Ubuntu.


Les chapitres du livre :
Avant-propos – Introduction – De C à C++ – Programmation orientée objet – La bibliothèque Standard Template Library – Les univers de C++ – Des programmes C++ efficaces

Table des matières

  • Avant-propos
    • 1. Objectifs de ce livre
    • 2. Travaux pratiques
      • 2.1 Le langage de script Lambda Basic
      • 2.2 Le tableur InCell
      • 2.3 Les pages web dynamiques EZ-Pages
    • 3. À qui s’adresse ce livre ?
  • Introduction
    • 1. Notions clés
      • 1.1 Principales caractéristiques du langage C++
      • 1.2 Programmation orientée objet
      • 1.3 Environnement de développement et fichier makefile
        • 1.3.1 Choix d'un EDI
        • 1.3.2 Construction d'un fichier makefile
      • 1.4 Organisation d'un programme C++
        • 1.4.1 Codes sources
        • 1.4.2 Modules objets
        • 1.4.3 Bibliothèques (librairies)
        • 1.4.4 Exécutable
      • 1.5 Préprocesseur
      • 1.6 Choix d'un compilateur
      • 1.7 Éditeur de liens
    • 2. Bases de la programmation C++
      • 2.1 Déclaration de variables
        • 2.1.1 Utilité des variables
        • 2.1.2 Portée des variables
        • 2.1.3 Syntaxe de déclaration
        • 2.1.4 Types de données
      • 2.2 Instructions de tests et opérateurs
        • 2.2.1 Instructions de tests
        • 2.2.2 Opérateurs
      • 2.3 Instructions de boucle
        • 2.3.1 La boucle for
        • 2.3.2 La boucle while
        • 2.3.3 La boucle do
        • 2.3.4 Les instructions de débranchement
      • 2.4 Tableaux
      • 2.5 Fonctions et prototypes
        • 2.5.1 Déclaration d'une fonction
        • 2.5.2 Fonctions et procédures
        • 2.5.3 Appel des fonctions
        • 2.5.4 Gestion des variables locales
        • 2.5.5 Définition de fonctions homonymes (polymorphisme)
        • 2.5.6 Fonctions à nombre variable d’arguments
        • 2.5.7 Attribution de valeurs par défaut aux arguments
        • 2.5.8 Fonctions en ligne
        • 2.5.9 Fonctions externes de type C
        • 2.5.10 Fonctions récursives
        • 2.5.11 La fonction main()
      • 2.6 Pointeurs
        • 2.6.1 Pointeurs sur des variables
        • 2.6.2 Pointeurs et tableaux
        • 2.6.3 Allocation de mémoire
        • 2.6.4 Arithmétique des pointeurs
        • 2.6.5 Pointeurs de pointeurs
        • 2.6.6 Pointeurs de fonctions
      • 2.7 Références
      • 2.8 Constantes
        • 2.8.1 Constantes symboliques
        • 2.8.2 Le type void
        • 2.8.3 Les alias de type : typedef
        • 2.8.4 Constantes et énumérations
    • 3. Exceptions
      • 3.1 Les approches de bas niveau
        • 3.1.1 Drapeaux et interruptions
        • 3.1.2 Traitement des erreurs en langage C
      • 3.2 Les exceptions plus sûres que les erreurs
      • 3.3 Propagation explicite
      • 3.4 Types d'exceptions personnalisés
        • 3.4.1 Définition de classes d'exception
        • 3.4.2 Instanciation de classes
        • 3.4.3 Classes d'exception dérivées
      • 3.5 Prise en charge d'une exception et relance
      • 3.6 Exceptions non interceptées
      • 3.7 Acquisition de ressources
    • 4. Travaux pratiques
      • 4.1 Prise en main de l'interprète Lab
        • 4.1.1 Structure de la solution
        • 4.1.2 Le dossier framework
        • 4.1.3 Le dossier langage
        • 4.1.4 Le dossier scriptboxes
        • 4.1.5 Utiliser l'interprète
      • 4.2 Le code de la boucle principale
      • 4.3 Affichage dans Labshow
  • De C à C++
    • 1. Programmation structurée
      • 1.1 Structures
        • 1.1.1 Constitution d'une structure
        • 1.1.2 Instanciation de structures
        • 1.1.3 Instanciation avec l'opérateur new
        • 1.1.4 Pointeurs et structures
        • 1.1.5 Organisation de la programmation
      • 1.2 Unions
      • 1.3 Copie de structures
      • 1.4 Création d'alias de types de structure
      • 1.5 Structure et fonction
        • 1.5.1 Passer une structure par valeur comme paramètre
        • 1.5.2 Passer une structure par référence comme paramètre
        • 1.5.3 Passer une structure par adresse comme paramètre
        • 1.5.4 De la programmation fonctionnelle à la programmation objet
    • 2. Gestion de la mémoire
      • 2.1 Alignement des données
      • 2.2 Allocation de mémoire interprocessus
    • 3. La bibliothèque standard du C
      • 3.1 Les fonctions communes du langage C <stdlib.h>
      • 3.2 Chaînes <string.h>
      • 3.3 Fichiers <stdio.h>
    • 4. Travaux pratiques
      • 4.1 Chargement de scripts dans Lab
      • 4.2 Supprimer les erreurs liées à la librairie non sécurisée
  • Programmation orientée objet
    • 1. Classes et instances
      • 1.1 Définition de classe
        • 1.1.1 Les modificateurs d'accès
        • 1.1.2 Organisation de la programmation des classes
      • 1.2 Instanciation
      • 1.3 Constructeur et destructeur
        • 1.3.1 Constructeur
        • 1.3.2 Le pointeur this
        • 1.3.3 Destructeur
        • 1.3.4 Destructeur virtuel
      • 1.4 Allocation dynamique
      • 1.5 Constructeur de copie
    • 2. Héritage
      • 2.1 Dérivation de classe (héritage)
        • 2.1.1 Exemple de dérivation de classe
        • 2.1.2 Héritage public, protégé et privé
        • 2.1.3 Appel des constructeurs
      • 2.2 Polymorphisme
        • 2.2.1 Méthodes polymorphes
        • 2.2.2 Conversions d'objets
      • 2.3 Méthodes virtuelles et méthodes virtuelles pures
      • 2.4 Héritage multiple
        • 2.4.1 Notations particulières
        • 2.4.2 Conséquences sur la programmation
    • 3. Autres aspects de la POO
      • 3.1 Conversion dynamique
        • 3.1.1 Conversions depuis un autre type
        • 3.1.2 Opérateurs de conversion
        • 3.1.3 Conversions entre classes dérivées
      • 3.2 Champs et méthodes statiques
        • 3.2.1 Champs statiques
        • 3.2.2 Méthodes statiques
      • 3.3 Surcharge d'opérateurs
        • 3.3.1 Syntaxe
        • 3.3.2 Surcharge de l'opérateur d'indexation
        • 3.3.3 Surcharge de l'opérateur d'affectation
        • 3.3.4 Surcharge de l'opérateur de conversion
      • 3.4 Fonctions amies
      • 3.5 Adressage relatif et pointeurs de membres
        • 3.5.1 Notations
        • 3.5.2 Construction d'un middleware orienté objet
      • 3.6 Programmation générique
        • 3.6.1 Modèles de fonctions
        • 3.6.2 Modèles de classes
    • 4. Travaux pratiques
      • 4.1 Utilisation de l'héritage de classes dans l'interprète Lab
      • 4.2 Des pointeurs de membres pour des fonctions callback
  • La bibliothèque Standard Template Library
    • 1. Introduction
    • 2. Organisation des programmes
      • 2.1 Espaces de noms
        • 2.1.1 Utilisation complète d'un espace de noms
        • 2.1.2 Espace de noms réparti sur plusieurs fichiers
        • 2.1.3 Relation entre classe et espace de noms
        • 2.1.4 Déclaration de sous-espaces de noms
      • 2.2 Présentation de la STL
    • 3. Flux C++ (entrées-sorties)
      • 3.1 Généralités
      • 3.2 Flux intégrés
      • 3.3 État d'un flux
      • 3.4 Mise en forme
      • 3.5 Flux de fichiers
      • 3.6 Flux de chaînes
      • 3.7 Paramètres locaux
    • 4. Classe string pour la représentation des chaînes de caractères
      • 4.1 Représentation des chaînes dans la STL
      • 4.2 Mode d'emploi de la classe string
        • 4.2.1 Fonctions de base
        • 4.2.2 Intégration dans le langage C++
        • 4.2.3 Fonctions spécifiques aux chaînes
    • 5. Conteneurs dynamiques
      • 5.1 Conteneurs
        • 5.1.1 Insertion d'éléments et parcours
        • 5.1.2 Itérateurs
        • 5.1.3 Opérations applicables à un vecteur
      • 5.2 Séquences
        • 5.2.1 Conteneurs standards
        • 5.2.2 Séquences
        • 5.2.3 Adaptateurs de séquences
        • 5.2.4 Conteneurs associatifs
      • 5.3 Algorithmes
        • 5.3.1 Opérations de séquence sans modification
        • 5.3.2 Opérations de séquence avec modification
        • 5.3.3 Séquences triées
        • 5.3.4 Algorithmes de définition
        • 5.3.5 Minimum et maximum
      • 5.4 Calcul numérique
        • 5.4.1 Limites des formats ordinaires
        • 5.4.2 Fonctions de la bibliothèque
        • 5.4.3 Fonctions de la bibliothèque standard etclasse valarray
    • 6. Travaux pratiques
      • 6.1 La classe Variant
      • 6.2 La méthode to_string
      • 6.3 Prise en charge des tableaux dans Lab
  • Les univers de C++
    • 1. L'environnement Windows
      • 1.1 Les programmes Win32
      • 1.2 Choix du mode de compilation
    • 2. L'environnement .NET
      • 2.1 Le code managé et la machine virtuelle CLR
      • 2.2 Les adaptations du langage C++ CLI
        • 2.2.1 La norme CTS
        • 2.2.2 La classe System::String
        • 2.2.3 Le garbage collector
        • 2.2.4 Construction et destruction d'objets
        • 2.2.5 La référence de suivi % et le handle ^
        • 2.2.6 Le pointeur interne et les zones épinglées
        • 2.2.7 Les tableaux et les fonctions à nombre variabled'arguments
        • 2.2.8 Les propriétés
        • 2.2.9 Les délégués et les événements
        • 2.2.10 Les méthodes virtuelles
        • 2.2.11 Les classes abstraites et les interfaces
      • 2.3 Le framework .NET
        • 2.3.1 Les références d'assemblages
        • 2.3.2 L'espace de noms System::IO
        • 2.3.3 L'espace de noms System::Xml
        • 2.3.4 L'espace de noms System::Data
        • 2.3.5 L'espace de noms System::Collections
        • 2.3.6 L'espace de noms System::Collections::Generic
        • 2.3.7 Le portage de la STL pour le C++ CLI
      • 2.4 Les relations avec les autres langages : C#
    • 3. Travaux pratiques
      • 3.1 Une application en C++ pour .NET : le tableur InCell
        • 3.1.1 Architecture du tableur
        • 3.1.2 La feuille de calcul
        • 3.1.3 L'ordonnanceur de calcul
        • 3.1.4 Zoom sur l'évaluateur
        • 3.1.5 L'interface graphique
      • 3.2 Les pages web dynamiques EZ-Pages
        • 3.2.1 Fonctionnement des pages web dynamiques
        • 3.2.2 Implémentation de BufferBox
        • 3.2.3 Réalisation du gestionnaire web EZHandler
        • 3.2.4 Tests
        • 3.2.5 Pour aller plus loin
  • Des programmes C++ efficaces
    • 1. Dépasser ses programmes
      • 1.1 Oublier les réflexes du langage C
      • 1.2 Gestion de la mémoire
      • 1.3 Concevoir des classes avec soin
      • 1.4 Y voir plus clair parmi les possibilités de l’héritage
      • 1.5 Analyser l’exécution d’un programme C++
    • 2. La conception orientée objet (COO)
      • 2.1 Relation entre la POO et la COO
        • 2.1.1 L'approche initiale de C++
        • 2.1.2 UML et C++
      • 2.2 Les design patterns
      • Index

Auteur

Brice-Arnaud GUÉRINEn savoir plus

Ingénieur ESIEA, Brice-Arnaud Guérin est Directeur de programmes chez Kantar. Ses compétences en développement et son désir de partager ses connaissances l'ont naturellement conduit à l'écriture d'ouvrages consacrés à la réalisation d'applications (.NET, PHP, C++) et à la conduite de projets.

Caractéristiques

  • Niveau Initié à Confirmé
  • Nombre de pages 378 pages
  • Parution octobre 2016
    • Livre (broché) - 17 x 21 cm
    • ISBN : 978-2-409-00440-7
    • EAN : 9782409004407
    • Ref. ENI : RI2CPP
  • Niveau Initié à Confirmé
  • Parution octobre 2016
    • HTML
    • ISBN : 978-2-409-00564-0
    • EAN : 9782409005640
    • Ref. ENI : LNRI2CPP

Téléchargements

En complétant ce formulaire, vous acceptez d'être contacté afin de recevoir des informations sur nos produits et services ainsi que nos communications marketing. Vous aurez la possibilité de vous désabonner de nos communications à tout moment. Pour plus d'informations sur notre politique de protection des données, cliquez ici.
  • Des fichiers complémentaires_1 (48,5 Mo)
  • Des fichiers complémentaires_2 (25,5 Mo)