La programmation en C++ cours complet, tutoriel programmez avec le langage C en pdf.

I. Cours C++ complet
II. Le début du voyage
1. Le C++, qu’est-ce que c’est?
1.1. Petite mise au point
1.1.1. Développer, un métier à part entière
1.1.2. Votre part du travail
1.1.3. Les mathématiques, indispensables?
1.1.4. L’anglais, indispensable?
1.2. Tour d’horizon du C++
1.2.1. L’histoire du C++
1.2.2. Pourquoi apprendre le C++?
1.3. La documentation
1.3.1. En résumé
2. Le minimum pour commencer
2.1. Des outils en ligne
2.2. Des outils plus poussés
2.2.1. Visual Studio Community
2.2.2. Qt Creator
2.2.3. Pour les autres outils
2.3. Un mot concernant Windows
2.4. Un mot concernant GNU/Linux
2.4.1. Un éditeur de texte
2.4.2. Un compilateur
2.4.3. En résumé
3. Rencontre avec le C++
3.1. Compilons notre premier programme
3.2. Démystification du code
3.2.1. Inclure des fonctionnalités déjà codées
3.2.2. Le point d’entrée
3.2.3. Voici mes instructions
3.3. Les commentaires
3.3.1. La syntaxe
3.3.2. En résumé
Contenu masqué
4. Une super mémoire
4.1. Les littéraux
4.1.1. Les caractères
4.1.2. Les nombres
4.2. Les variables
4.2.1. Comment créer des variables en C++?
4.2.2. Un peu de constance, voyons!
4.2.3. Manipulation de variables
4.3. Qu’en déduisez-vous?
4.3.1. Avec const
4.3.2. Le cas de std::string
4.3.3. Les avantages
4.4. Les entrées
4.4.1. Gestion des erreurs
4.4.2. En résumé
Contenu masqué
5. Le conditionnel conjugué en C++
5.1. Les booléens
5.2. if — Si, et seulement si
5.2.1. À portée
5.3. else — Sinon
5.4. else if — La combinaison des deux précédents
5.5. Conditions imbriquées
5.6. [T.P] Gérer les erreurs d’entrée — Partie I
5.7. La logique booléenne
5.7.1. AND— Tester si deux conditions sont vraies
5.7.2. OR— Tester si au moins une condition est vraie
5.7.3. NOT— Tester la négation
5.8. Tester plusieurs expressions
5.8.1. Évaluation en court-circuit
5.9. Exercices
5.9.1. Une pseudo-horloge
5.9.2. Score
5.9.3. XOR— Le OU exclusif
5.9.4. En résumé
Contenu masqué
6. Des boucles qui se répètent, répètent, répètent…
6.1. while — Tant que…
6.2. Exercices
6.2.1. Une laverie
6.2.2. PGCD
6.2.3. Somme de nombres de 1 à n
6.3. do while — Répéter … tant que
6.4. [T.P] Gérer les erreurs d’entrée — Partie II
6.5. for — Une boucle condensée
6.6. Boucles imbriquées
6.7. Convention de nommage
6.8. Contrôler plus finement l’exécution de la boucle
6.8.1. break— Je m’arrête là
6.8.2. continue— Saute ton tour!
6.8.3. En résumé
Contenu masqué
7. Au tableau!
7.1. Un tableau c’est quoi?
7.2. std : :vector — Mais quel dynamisme!
7.2.1. Déclarer un std::vector
7.2.2. Manipuler les éléments d’un std::vector
8. Accès aux éléments
8.1. Exercices
8.1.1. Calcul de moyenne
8.1.2. Minimum et maximum
8.1.3. Séparer les pairs des impairs
8.1.4. Compter les occurrences d’une valeur
8.2. std : :array — Le tableau statique
8.2.1. Déclarer un std::array
8.2.2. Remplir un tableau
8.2.3. Accéder aux éléments
8.2.4. Connaître la taille
8.2.5. Vérifier si le tableau est vide
8.3. std : :string — Un type qui cache bien son jeu
8.3.1. Connaître la taille d’une chaîne
8.3.2. Accéder à un caractère
8.3.3. Premier et dernier caractère
8.3.4. Vérifier qu’une chaîne est vide
8.3.5. Ajouter ou supprimer un caractère à la fin
8.3.6. Supprimer tous les caractères
8.3.7. Boucler sur une chaîne
8.3.8. En résumé
Contenu masqué
9. Déployons la toute puissance des conteneurs
9.1. Le socle de base : les itérateurs
9.1.1. Déclaration d’un itérateur
9.1.2. Début et fin d’un conteneur
9.1.3. Accéder à l’élément pointé
9.1.4. Se déplacer dans une collection
10. Déplacement vers l’élément suivant
10.0.1. const et les itérateurs
10.0.2. Itérer depuis la fin
10.0.3. Utilisation conjointe avec les conteneurs
10.1. Des algorithmes à gogo!
10.1.1. std::count— Compter les occurrences d’une valeur
……..

Tant que l’entrée met std::cin dans un état invalide ou qu’elle n’est pas dans la plage de valeurs autorisées, on demande à l’utilisateur de saisir une nouvelle donnée. Vous reconnaitrez que ce code est tiré de notre fonction entree_securisee. Je l’ai extraite pour pouvoir ajouter des conditions supplémentaires. Nous verrons dans le prochain chapitre une façon d’améliorer ça.
Pour l’instant, retenez qu’il faut vérifier qu’une donnée est cohérente en plus de s’assurer qu’elle est du bon type.

À une condition… ou plusieurs

Écrire une fonction peut être plus ou moins simple, en fonction de ce qu’elle fait, mais beaucoup de développeurs oublient une étape essentielle consistant à réfléchir au(x) contrat(s) que définit une fonction. Un contrat est un accord entre deux parties, ici celui qui utilise la fonction et celui qui la code.
— La fonction mathématique std::sqrt, qui calcule la racine carrée d’un nombre, attend qu’on lui donne un réel nul ou positif. Si ce contrat est respecté, elle s’engage à retourner un réel supérieur ou égal à zéro et que celui-ci au carré soit égal à la valeur donnée en argument. Le contrat inhérent à la fonction std::sqrt se résume donc ainsi: « donne-moi un entier positif, et je te renverrai sa racine carrée ». Ça paraît évident, mais c’est important de le garder en tête.
— Quand on récupère un élément d’un tableau avec [], il faut fournir un index valide, compris entre 0 et la taille du tableau moins un. Si on fait ça, on a la garantie d’obtenir un élément valide.
— Si l’on a une chaîne de caractères ayant au moins un caractère, on respecte le contrat de pop_back et on peut retirer en toute sécurité le dernier caractère.
On voit, dans chacun de ces exemples, que la fonction attend qu’on respecte une ou plusieurs conditions, que l’on nomme les préconditions. Si celles-ci sont respectées, la fonction s’engage en retour à respecter sa part du marché, qu’on appelle les postconditions. Les passionnés de mathématiques feront un parallèle avec les domaines de définitions des fonctions.
Le but de réfléchir à ces conditions est de produire du code plus robuste, plus fiable et plus facilement testable, pour toujours tendre vers une plus grande qualité de notre code. En effet, en prenant quelques minutes pour penser à ce qu’on veut que la fonction fasse ou ne fasse pas, on sait plus précisément quand elle fonctionne et quand il y a un bug.

Contrats assurés par le compilateur

Le typage

Un exemple simple de contrat, que nous avons déjà vu sans même le savoir, s’exprime avec le typage. Si une fonction s’attend à recevoir un entier, on ne peut pas passer un std::vector. Le compilateur s’assure qu’on passe en arguments des types compatibles avec ce qui est attendu.

Avec const

Un autre type de contrat qu’on a déjà vu implique l’utilisation de const. Ainsi, une fonction qui attend une référence sur une chaîne de caractères constante garantie que celle-ci restera intacte, sans aucune modification, à la fin de la fonction. Cette postcondition est vérifiée par le compilateur, puisqu’il est impossible de modifier un objet déclaré comme étant const.

Vérifier nous-mêmes

Le compilateur fait une partie du travail certes, mais la plus grosse part nous revient. Pour vérifier nos contrats, nous avons dans notre besace plusieurs outils que nous allons voir.

Le développeur est un idiot

Vous souvenez vous du chapitre sur les tableaux? Quand nous avons vu l’accès aux éléments avec les crochets, je vous ai dit de vérifier que l’indice que vous utilisez est bien valide, sous peine de comportements indéterminés. Si vous ne le faites pas, alors c’est de votre faute si le programme plante, car vous n’avez pas respectés une précondition. C’est ce qu’on appelle une erreur de programmation, ou bug.
Dans le cas où ce genre de problème arrive, rien ne sert de continuer, mieux vaut arrêter le programme et corriger le code. Il existe justement un outil qui va nous y aider : les assertions.
………