C++ : Un langage de programmation puissant, Study Guides, Projects, Research of Computer science

Download C++ : Un langage de programmation puissant and more Study Guides, Projects, Research Computer science in PDF only on Docsity!

informaticie... mehdidou

La programmation en C++ moderne

6 mars 2021

Bienvenue dans ce cours sur l’apprentissage de la programmation avec le langage C++. Vous débutez complètement et n’avez qu’une vague idée de ce que peut bien être la programmation? On vous a dit d’en apprendre plus sur le C++? Alors ce tutoriel est fait pour vous. Pour rendre ce cours pédagogique , nous alternerons entre théorie, explications et détails

• I. Remerciements
• II. Le début du voyage
• II.1. Le C++, qu’est-ce que c’est?
  • II.1.1. Petite mise au point
    • II.1.1.1. Développer, un métier à part entière
    • II.1.1.2. Votre part du travail
    • II.1.1.3. Les mathématiques, indispensables?
    • II.1.1.4. L’anglais, indispensable?
  • II.1.2. Tour d’horizon du C++
    • II.1.2.1. L’histoire du C++
    • II.1.2.2. Pourquoi apprendre le C++?
  • II.1.3. La documentation
    • II.1.3.1. En résumé
• II.2. Le minimum pour commencer
  • II.2.1. Des outils en ligne
  • II.2.2. Des outils plus poussés
    • II.2.2.1. Visual Studio Community
    • II.2.2.2. Qt Creator
    • II.2.2.3. Pour les autres outils
  • II.2.3. Un mot concernant Windows
  • II.2.4. Un mot concernant GNU/Linux
    • II.2.4.1. Un éditeur de texte
    • II.2.4.2. Un compilateur
    • II.2.4.3. En résumé
• II.3. Rencontre avec le C++
  • II.3.1. Compilons notre premier programme
  • II.3.2. Démystification du code
    • II.3.2.1. Inclure des fonctionnalités déjà codées
    • II.3.2.2. Le point d’entrée
    • II.3.2.3. Voici mes instructions…
  • II.3.3. Les commentaires
    • II.3.3.1. La syntaxe
    • II.3.3.2. En résumé
      • Contenu masqué
• II.4. Une super mémoire Table des matières
  • II.4.1. Les littéraux
    • II.4.1.1. Les caractères
    • II.4.1.2. Les nombres
  • II.4.2. Les variables
    • II.4.2.1. Comment créer des variables en C++?
    • II.4.2.2. Un peu de constance, voyons!
    • II.4.2.3. Manipulation de variables
  • II.4.3. Qu’en déduisez-vous?
    • II.4.3.1. Avec const
    • II.4.3.2. Le cas de std::string
    • II.4.3.3. Les avantages
  • II.4.4. Les entrées
    • II.4.4.1. Gestion des erreurs
    • II.4.4.2. En résumé
      • Contenu masqué
• II.5. Le conditionnel conjugué en C++
  • II.5.1. Les booléens
  • II.5.2. if—Si, et seulement si…
    • II.5.2.1. À portée
  • II.5.3. else—Sinon…
  • II.5.4. else if—La combinaison des deux précédents
  • II.5.5. Conditions imbriquées
  • II.5.6. [T.P] Gérer les erreurs d’entrée—Partie I
  • II.5.7. La logique booléenne
    • II.5.7.1. AND—Tester si deux conditions sont vraies
    • II.5.7.2. OR—Tester si au moins une condition est vraie
    • II.5.7.3. NOT—Tester la négation
  • II.5.8. Tester plusieurs expressions
    • II.5.8.1. Évaluation en court-circuit
  • II.5.9. Exercices
    • II.5.9.1. Une pseudo-horloge
    • II.5.9.2. Score
    • II.5.9.3. XOR—Le OU exclusif
    • II.5.9.4. En résumé
      • Contenu masqué
• II.6. Des boucles qui se répètent, répètent, répètent…
  • II.6.1. while—Tant que…
  • II.6.2. Exercices
    • II.6.2.1. Une laverie
    • II.6.2.2. PGCD
    • II.6.2.3. Somme de nombres de 1 à n
  • II.6.3. do while—Répéter … tant que
  • II.6.4. [T.P] Gérer les erreurs d’entrée—Partie II
  • II.6.5. for—Une boucle condensée
  • II.6.6. Boucles imbriquées
  • II.6.7. Convention de nommage Table des matières
  • II.6.8. Contrôler plus finement l’exécution de la boucle
    • II.6.8.1. break—Je m’arrête là
    • II.6.8.2. continue—Saute ton tour!
    • II.6.8.3. En résumé
      • Contenu masqué
• II.7. Au tableau!
  • II.7.1. Un tableau c’est quoi?
  • II.7.2. std::vector—Mais quel dynamisme!
    • II.7.2.1. Déclarer un std::vector
    • II.7.2.2. Manipuler les éléments d’un std::vector
• II.8. Accès aux éléments
  • II.8.1. Exercices
    • II.8.1.1. Calcul de moyenne
    • II.8.1.2. Minimum et maximum
    • II.8.1.3. Séparer les pairs des impairs
    • II.8.1.4. Compter les occurrences d’une valeur
  • II.8.2. std::array—Le tableau statique
    • II.8.2.1. Déclarer un std::array
    • II.8.2.2. Remplir un tableau
    • II.8.2.3. Accéder aux éléments
    • II.8.2.4. Connaître la taille
    • II.8.2.5. Vérifier si le tableau est vide
  • II.8.3. std::string—Un type qui cache bien son jeu
    • II.8.3.1. Connaître la taille d’une chaîne
    • II.8.3.2. Accéder à un caractère
    • II.8.3.3. Premier et dernier caractère
    • II.8.3.4. Vérifier qu’une chaîne est vide
    • II.8.3.5. Ajouter ou supprimer un caractère à la fin
    • II.8.3.6. Supprimer tous les caractères
    • II.8.3.7. Boucler sur une chaîne
    • II.8.3.8. En résumé
      • Contenu masqué
• II.9. Déployons la toute puissance des conteneurs
  • II.9.1. Le socle de base: les itérateurs
    • II.9.1.1. Déclaration d’un itérateur
    • II.9.1.2. Début et fin d’un conteneur
    • II.9.1.3. Accéder à l’élément pointé
    • II.9.1.4. Se déplacer dans une collection
• II.10. Déplacement vers l’élément suivant - II.10.0.1. const et les itérateurs - II.10.0.2. Itérer depuis la fin - II.10.0.3. Utilisation conjointe avec les conteneurs
  • II.10.1. Des algorithmes à gogo!
    • II.10.1.1. std::count—Compter les occurrences d’une valeur
    • II.10.1.2. std::find—Trouver un certain élément Table des matières
    • II.10.1.3. std::sort—Trier une collection
    • II.10.1.4. std::reverse—Inverser l’ordre des éléments d’une collection
    • II.10.1.5. std::remove—Suppression d’éléments
    • II.10.1.6. std::search—Rechercher un sous-ensemble dans un ensemble
    • II.10.1.7. std::equal—Vérifier l’égalité de deux ensembles
    • II.10.1.8. Et tant d’autres
  • II.10.2. Personnalisation à la demande
    • II.10.2.1. Le prédicat, à la base de la personnalisation des algorithmes
    • II.10.2.2. Trier une liste dans l’ordre décroissant
    • II.10.2.3. Somme et produit
    • II.10.2.4. Prédicats pour caractères
  • II.10.3. Exercices
    • II.10.3.1. Palindrome
    • II.10.3.2. string_trim—Suppression des espaces
    • II.10.3.3. Couper une chaîne
    • II.10.3.4. En résumé
      • Contenu masqué
• II.11. Des flux dans tous les sens
  • II.11.1. Avant-propos
    • II.11.1.1. Prendrez-vous une extension?
    • II.11.1.2. Vois sur ton chemin…
    • II.11.1.3. Un mot sur Windows
    • II.11.1.4. Pas d’interprétation, on est des brutes
  • II.11.2. std::ofstream—Écrire dans un fichier
    • II.11.2.1. Ouvrir le fichier
    • II.11.2.2. Écriture
    • II.11.2.3. Ouvrir sans effacer
  • II.11.3. std::ifstream—Lire dans un fichier
    • II.11.3.1. Ouvrir le fichier
    • II.11.3.2. Lecture
    • II.11.3.3. Tout lire
  • II.11.4. Exercice
    • II.11.4.1. Statistiques sur des fichiers
  • II.11.5. Encore plus de flux!
    • II.11.5.1. Un flux c’est quoi?
    • II.11.5.2. Un buffer dites-vous?
    • II.11.5.3. Les modificateurs de flux
    • II.11.5.4. Même les chaînes y passent!
    • II.11.5.5. En résumé
      • Contenu masqué
• III. On passe la deuxième! Table des matières
• III.1. Découpons du code— Les fonctions
  • III.1.1. Les éléments de base d’une fonction
    • III.1.1.1. Une fonction, c’est quoi?
    • III.1.1.2. Une fonction bien connue
    • III.1.1.3. Les composants d’une fonction
• III.2. Schéma d’une fonction
  • III.2.1. Exercices
    • III.2.1.1. Afficher un rectangle
    • III.2.1.2. Distributeur d’argent
    • III.2.1.3. Parenthésage
  • III.2.2. Quelles sont vos références?
    • III.2.2.1. La problématique
    • III.2.2.2. Les références
    • III.2.2.3. Paramètres de fonctions
    • III.2.2.4. Valeur de retour
    • III.2.2.5. Un mot sur la déduction de type
  • III.2.3. Nos fonctions sont surchargées!
  • III.2.4. [T.P] Gérer les erreurs d’entrée—Partie III
  • III.2.5. Dessine-moi une fonction
    • III.2.5.1. Le problème
    • III.2.5.2. La solution
    • III.2.5.3. Utilisons les prototypes
    • III.2.5.4. En résumé
      • Contenu masqué
• III.3. Erreur, erreur, erreur…
  • III.3.1. L’utilisateur est un idiot
  • III.3.2. À une condition… ou plusieurs
    • III.3.2.1. Contrats assurés par le compilateur
• III.4. Le typage - III.4.0.1. Vérifier nous-mêmes
  • III.4.1. Le développeur est un idiot
    • III.4.1.1. Préconditions et assertions
  • III.4.2. Les tests unitaires à notre aide
    • III.4.2.1. Pourquoi tester?
    • III.4.2.2. Un test unitaire, qu’est-ce que c’est?
    • III.4.2.3. Écrire des tests unitaires
    • III.4.2.4. Les tests unitaires et les postconditions
  • III.4.3. [T.P] Gérer les erreurs d’entrée—Partie IV
  • III.4.4. L’exception à la règle
    • III.4.4.1. La problématique
    • III.4.4.2. C’est quoi une exception?
    • III.4.4.3. Lancement des exceptions dans 3, 2, 1…
    • III.4.4.4. Attends que je t’attrape!
    • III.4.4.5. Attrapez-les tous!
    • III.4.4.6. Un type pour les gouverner tous et dans le catch les lier Table des matières
  • III.4.5. [T.P] Gérer les erreurs d’entrée—Partie V
    • III.4.5.1. En résumé
      • Contenu masqué
• III.5. Des fonctions somme toute lambdas
  • III.5.1. Une lambda, c’est quoi?
    • III.5.1.1. Pourquoi a-t-on besoin des lambdas?
  • III.5.2. Syntaxe
    • III.5.2.1. Quelques exemples simples
  • III.5.3. Exercices
    • III.5.3.1. Vérifier si un nombre est négatif
    • III.5.3.2. Tri par valeur absolue
  • III.5.4. On va stocker ça où?
  • III.5.5. Paramètres génériques
  • III.5.6. [T.P] Gérer les erreurs d’entrée—Partie VI
  • III.5.7. [T.P] Gérer les erreurs d’entrée—Partie VII
  • III.5.8. Capture en cours…
    • III.5.8.1. Capture par valeur
    • III.5.8.2. Capture par référence
    • III.5.8.3. En résumé
      • Contenu masqué
• III.6. Envoyez le générique!
  • III.6.1. Quel beau modèle!
    • III.6.1.1. La bibliothèque standard: une fourmilière de modèles
    • III.6.1.2. Un point de vocabulaire
  • III.6.2. [T.P] Gérer les erreurs d’entrée - Partie VIII
  • III.6.3. Instanciation explicite
  • III.6.4. Ce type là, c’est un cas!
    • III.6.4.1. En résumé
      • Contenu masqué
• III.7. De nouvelles structures de données
  • III.7.1. struct—Un agrégat de données
    • III.7.1.1. Stockage d’informations personnelles
    • III.7.1.2. Analyse de l’exercice
    • III.7.1.3. Introduction aux structures
    • III.7.1.4. Exercice
  • III.7.2. std::tuple—Une collection hétérogène
    • III.7.2.1. Déclaration
    • III.7.2.2. Accès aux éléments
    • III.7.2.3. std::tuple et fonctions
    • III.7.2.4. Équations horaires
  • III.7.3. std::unordered_map—Une table associative
    • III.7.3.1. Un dictionnaire de langue Zestienne
    • III.7.3.2. Toujours plus de clés
    • III.7.3.3. Cette clé est unique!
    • III.7.3.4. Cherchez un élément
    • III.7.3.5. Un exemple concret Table des matières
  • III.7.4. std::unordered_set—Représenter un ensemble
    • III.7.4.1. Inscription sur Zeste de Savoir
  • III.7.5. Un peu d’ordre, voyons!
  • III.7.6. Une longue énumération
    • III.7.6.1. En résumé
      • Contenu masqué
• III.8. Reprendrez-vous un peu de sucre syntaxique?
  • III.8.1. Ce type est trop long!
  • III.8.2. Décomposons tout ça
    • III.8.2.1. En pleine décomposition
    • III.8.2.2. Et avant, on faisait comment?
  • III.8.3. La surcharge d’opérateurs
    • III.8.3.1. Le problème…
    • III.8.3.2. …et la solution
    • III.8.3.3. Cas concret—Les fractions
• III.9. Les opérateurs arithmétiques - III.9.0.1. Et la bibliothèque standard? - III.9.0.2. Exercice—Calculs avec des durées - III.9.0.3. Sur le bon usage de la surcharge - III.9.0.4. En résumé - Contenu masqué
• III.10. [T.P] Un gestionnaire de discographie
  • III.10.1. L’énoncé
    • III.10.1.1. Ajout de morceaux
    • III.10.1.2. Affichage de la discographie
    • III.10.1.3. Enregistrement et chargement d’une discographie
    • III.10.1.4. Quitter le programme
    • III.10.1.5. Gestion des erreurs
    • III.10.1.6. Dernières remarques
  • III.10.2. Guide de résolution
    • III.10.2.1. Analyse des besoins
    • III.10.2.2. Attaquons le code!
  • III.10.3. Corrigé complet
  • III.10.4. Conclusion et pistes d’améliorations
    • III.10.4.1. En résumé
      • Contenu masqué
• III.11. Découpons du code— Les fichiers
  • III.11.1. Le principe
    • III.11.1.1. Le fichier d’en-tête
    • III.11.1.2. Le fichier source
    • III.11.1.3. Créons un lien
  • III.11.2. La sécurité, c’est important
  • III.11.3. Découpons le TP!
  • III.11.4. Les avantages du découpage en fichiers Table des matières
    • III.11.4.1. Une structure de projet plus visible
    • III.11.4.2. Une meilleure abstraction
    • III.11.4.3. Une meilleure modularité
  • III.11.5. Le cas des templates
    • III.11.5.1. En résumé
      • Contenu masqué
• IV. Interlude - Être un développeur
• IV.1. Avant-propos
  • IV.1.1. Ce que nous avons appris
  • IV.1.2. Différents paradigmes
    • IV.1.2.1. Le paradigme impératif
    • IV.1.2.2. Le paradigme fonctionnel
    • IV.1.2.3. Le paradigme générique
    • IV.1.2.4. La programmation par contrat
  • IV.1.3. Brancher le cerveau avant tout
  • IV.1.4. Savoir se débrouiller
    • IV.1.4.1. En résumé
• IV.2. Mais où est la doc?
  • IV.2.1. Lire une page de doc
    • IV.2.1.1. À l’arrivée
    • IV.2.1.2. vector − Retour sur le plus célèbre des conteneurs
• IV.3. Présentation - IV.3.0.1. Les algorithmes - IV.3.0.2. Les chaînes de caractère au grand complet
  • IV.3.1. Exercices
    • IV.3.1.1. Remplacer une chaîne de caractère par une autre
    • IV.3.1.2. Norme d’un vecteur
    • IV.3.1.3. Nombres complexes
    • IV.3.1.4. Transformations
  • IV.3.2. Documenter son code avec Doxygen
    • IV.3.2.1. Installation des outils
    • IV.3.2.2. Écrire la documentation
  • IV.3.3. Quelques bonnes pratiques
    • IV.3.3.1. Ce qu’il faut documenter
    • IV.3.3.2. Les fichiers d’en-tête ou source?
    • IV.3.3.3. Commentaire vs documentation
    • IV.3.3.4. En résumé
      • Contenu masqué
• IV.4. Compilation en cours…
  • IV.4.1. Le préprocesseur
    • IV.4.1.1. Inclure des fichiers
    • IV.4.1.2. Conditions
    • IV.4.1.3. Debug ou release? Table des matières
  • IV.4.2. La compilation
    • IV.4.2.1. Les templates
    • IV.4.2.2. constexpr
    • IV.4.2.3. La compilation à proprement parler
    • IV.4.2.4. Une étape intermédiaire cachée
    • IV.4.2.5. Influer sur la compilation
  • IV.4.3. Le linker
    • IV.4.3.1. Une question de symboles
  • IV.4.4. Schéma récapitulatif
    • IV.4.4.1. En résumé
• IV.5. Chasse aux bugs!
  • IV.5.1. Le principe
  • IV.5.2. Un code d’exemple
  • IV.5.3. Visual Studio
    • IV.5.3.1. Interface
    • IV.5.3.2. Pas-à-pas
    • IV.5.3.3. Point d’arrêt conditionnel
  • IV.5.4. Qt Creator
    • IV.5.4.1. Interface
    • IV.5.4.2. Pas-à-pas
    • IV.5.4.3. Point d’arrêt conditionnel
    • IV.5.4.4. Aller plus loin
  • IV.5.5. En ligne de commande avec gdb
    • IV.5.5.1. Poser un point d’arrêt
    • IV.5.5.2. Supprimer des points d’arrêt
    • IV.5.5.3. Désactiver des points d’arrêt
    • IV.5.5.4. Afficher l’état d’une variable
    • IV.5.5.5. Pas-à-pas
    • IV.5.5.6. Conditions
    • IV.5.5.7. Aller plus loin
    • IV.5.5.8. En résumé
• IV.6. Une foule de bibliothèques
  • IV.6.1. Quelles bibliothèques choisir?
    • IV.6.1.1. Boost
    • IV.6.1.2. SFML
  • IV.6.2. Généralités
    • IV.6.2.1. Statique ou dynamique?
    • IV.6.2.2. Debug ou release?
  • IV.6.3. Installer Boost
    • IV.6.3.1. GNU/Linux
    • IV.6.3.2. Windows
    • IV.6.3.3. Tester l’installation
  • IV.6.4. Installer SFML
    • IV.6.4.1. GNU/Linux
    • IV.6.4.2. Windows
    • IV.6.4.3. Tester l’installation Table des matières
    • IV.6.4.4. En résumé
• IV.7. Améliorer ses projets
  • IV.7.1. git—Sauvegarder et versionner son code
    • IV.7.1.1. La problématique
    • IV.7.1.2. Installation
    • IV.7.1.3. Initialiser git
    • IV.7.1.4. Créer un dépôt
    • IV.7.1.5. Connaître l’état de ses fichiers
    • IV.7.1.6. Ajouter un fichier
    • IV.7.1.7. Valider les modifications
    • IV.7.1.8. Voir l’historique
    • IV.7.1.9. Bloquer certains fichiers
    • IV.7.1.10. Aller plus loin
    • IV.7.1.11. Visual Studio
  • IV.7.2. GitHub—Partager son code
    • IV.7.2.1. La problématique
    • IV.7.2.2. Création d’un projet
    • IV.7.2.3. Récupérer localement les modifications
    • IV.7.2.4. Pousser nos modifications
    • IV.7.2.5. Aller plus loin
  • IV.7.3. CMake—Automatiser la compilation de nos programmes
    • IV.7.3.1. La problématique
    • IV.7.3.2. Un exemple simple
    • IV.7.3.3. Lier des bibliothèques externes
    • IV.7.3.4. Définir des variables au lancement
    • IV.7.3.5. Aller plus loin
  • IV.7.4. Aller plus loin
    • IV.7.4.1. TravisCI—De l’intégration continue
    • IV.7.4.2. CppCheck—Vérification du code
    • IV.7.4.3. StackOverflow—La réponses à quasiment toutes les questions
    • IV.7.4.4. En résumé
      • Contenu masqué
• V. La Programmation Orientée Objet
• V.1. Premiers pas avec la POO
  • V.1.1. Le principe: des objets bien serviables
    • V.1.1.1. Le principe
• V.2. Penser en terme de données… - V.2.0.1. Exemple concret
  • V.2.1. Un peu de vocabulaire
  • V.2.2. En C++, ça donne quoi?
    • V.2.2.1. Penser services
    • V.2.2.2. Penser tests
    • V.2.2.3. Définition de la classe
• V.3. Fonctions membres Table des matières
  • V.3.1. Désolé, cet objet n’est pas modifiable
  • V.3.2. On ne fait pas d’exception
  • V.3.3. Découpage en fichiers
  • V.3.4. Exercices
    • V.3.4.1. Cercle
    • V.3.4.2. Informations personnelles
    • V.3.4.3. En résumé
      • Contenu masqué
• V.4. Qui c’est qui va construire tout ça?
  • V.4.1. Encapsulation et invariants
    • V.4.1.1. Cette classe, c’est open bar
    • V.4.1.2. Tout est question d’invariant
    • V.4.1.3. Encapsulons tout ça
    • V.4.1.4. Modifier sa visibilité
  • V.4.2. On cherche un constructeur
    • V.4.2.1. La syntaxe
  • V.4.3. Constructeur par défaut
    • V.4.3.1. Initialiser une instance par défaut a du sens
    • V.4.3.2. Initialiser une instance par défaut n’a pas de sens
  • V.4.4. Soyons explicites
  • V.4.5. En toute amitié
    • V.4.5.1. Attributs publics
    • V.4.5.2. Accesseurs
    • V.4.5.3. La troisième, c’est la bonne
  • V.4.6. Exercices
    • V.4.6.1. Un autre constructeur pour la classe Fraction
    • V.4.6.2. Pile
    • V.4.6.3. En résumé
      • Contenu masqué
• V.5. Une classe de grande valeur
  • V.5.1. Une histoire de sémantique
  • V.5.2. La sémantique de valeur, c’est quoi?
  • V.5.3. Égalité
    • V.5.3.1. Libre ou membre?
    • V.5.3.2. Soyons intelligents, réutilisons
  • V.5.4. Le retour des opérateurs
    • V.5.4.1. Les opérateurs d’affectation intégrés
    • V.5.4.2. Du deux en un
    • V.5.4.3. Les opérateurs de manipulation des flux
    • V.5.4.4. Quelques bonnes pratiques
    • V.5.4.5. Les autres opérateurs
  • V.5.5. Copier des objets
    • V.5.5.1. Constructeur de copie
    • V.5.5.2. Opérateur d’affectation par copie
    • V.5.5.3. En résumé
• V.6. [T.P] Entrons dans la matrice! Table des matières
  • V.6.1. Qu’est-ce qu’une matrice?
    • V.6.1.1. Addition
    • V.6.1.2. Multiplication par un nombre
    • V.6.1.3. Transposition
    • V.6.1.4. Multiplication de deux matrices
    • V.6.1.5. D’autres propriétés
  • V.6.2. L’énoncé
    • V.6.2.1. Les services
    • V.6.2.2. Détails d’implémentation
    • V.6.2.3. Les tests
  • V.6.3. Correction détaillée
    • V.6.3.1. Les services
      • Contenu masqué
• V.7. Constructeurs - V.7.0.1. Les détails d’implémentation
• V.8. Fichiers d’en-tête standards
  • V.8.1. Aller plus loin
    • V.8.1.1. Le plus grand nombre
    • V.8.1.2. Des polynômes
    • V.8.1.3. En résumé
• V.9. La sémantique de déplacement
• V.10. Classes à sémantique d’entités
• V.11. Le besoin de handles
• V.12. [T.P] Le Javaquarium
• V.13. Oh, le bel héritage
• V.14. Les piliers de la POO
• V.15. Classes templates
• V.16. [T.P] Des polynômes génériques
• VI. Annexes
• VI.1. Index

Première partie

Remerciements

I. Remerciements

Car ce cours n’aurait jamais pu voir le jour sans l’aide et le soutien de plusieurs personnes.

— Un merci particulier à @gbdivers pour son cours Débuter en C++ moderne qui aura été une source d’inspiration pour l’écriture du présent cours, à qui nous avons emprunté plusieurs passages très bien écrits et qui n’aura cessé de nous aider à améliorer ce cours par ses nombreuses remarques et suggestions. — Tous les membres qui ont participé à la bêta et qui ont grandement aidé à améliorer la qualité de ce tutoriel, par leurs nombreuses remarques, suggestions et corrections. Toutes vos participations, petites et grandes, nous ont été extrêmement précieuses et utiles pour produire un cours meilleur. — Toute l’équipe de Zeste de Savoir; en particulier, un grand merci à @Taurre et @Glordim qui se sont chargés de la validation. — Et l’ensemble des lecteurs, pour avoir choisi ce cours.

À venir La partie POO est toujours en rédaction. Les mises à jour viendront au fil de l’eau.

II. Le début du voyage

Vous y voilà. Grâce au tutoriel sur les bases de la programmation , vous en savez un peu plus sur le merveilleux monde de la programmation. Maintenant, vous avez hâte d’appliquer tout ça concrètement. Le but de cette première partie est de vous introduire aux concepts de bases de la programmation. Ce que vous y apprendrez vous permettra de faire des programmes assez utiles. Bien entendu, votre apprentissage ne s’arrêtera pas de si tôt.

II.1. Le C++, qu’est-ce que c’est?

Voilà, vous êtes décidés, vous voulez apprendre à programmer à l’aide du langage C++. Mais vous devez toujours avoir quelques questions qui trottent dans votre esprit.

— Concrètement, C++, c’est quoi? — Et puis pourquoi commencer par C++? — Que vais-je savoir faire en sortant de ce tutoriel? — Il y a-t-il des conditions, des prérequis, pour pouvoir suivre ce cours?

II.1.1. Petite mise au point

J’ai indiqué en introduction que le seul prérequis était de lire l’introduction à la programmation et c’est vrai. Mais si peu de connaissances sont nécessaires pour comprendre tout ce qui sera dit, cela ne veut pas dire pour autant que ce sera du tout cuit, prémâché, directement dans la bouche. C’est pour cela que je veux prendre quelques minutes pour clarifier ceci.

II.1.1.1. Développer, un métier à part entière

Eh oui! Créer des logiciels, c’est un métier. D’ailleurs, il y a mêmes des écoles et des études spécialisées pour ça. C’est que développer, ce n’est pas simplement écrire du code. Il y a aussi des phases de réflexion, de conceptions, d’écriture, de validation, de tests, de réécriture d’anciennes portions, etc.

Par ailleurs, même si cela n’est pas directement lié à la programmation, peut également s’ajouter à cela: la gestion de base de données, l’usage du réseau, le management, la gestion de projet, etc. En bref, être développeur c’est beaucoup de compétences différentes dans des domaines variés.

La cruelle vérité qui se cache derrière tout ça, c’est que ce cours ne fera pas de vous des experts, ni des développeurs professionnels. Par contre, une fois fini, vous aurez des bases solides pour continuer votre apprentissage. La route du savoir est infinie.

II.1.1.2. Votre part du travail

Le cours est écrit de façon à être le plus clair possible, sans vous noyer sous un flot de détails et d’explications, mais il arrivera parfois que vous ne compreniez pas un morceau de code ou une explication. C’est tout à fait normal, ça fait partie de l’apprentissage. Reprenez le cours à tête reposée, aidez-vous de schémas ou de dessins, demandez de l’aide sur les forums , et vous ne resterez jamais bloqués longtemps.