Cours C/C++, tutoriel & guide de travaux pratiques en pdf.

I. Le langage C++
1. Première approche du C/C++
1.1. Les commentaires en C++
1.2. Les types prédéfinis du C/C++
1.3. Notation des valeurs
1.4. La définition des variables
1.5. Instructions et opérations
1.6. Les fonctions
1.6.1. Définition des fonctions
1.6.2. Appel des fonctions
1.6.3. Déclaration des fonctions
1.6.4. Surcharge des fonctions
1.6.5. Fonctions inline
1.6.6. Fonctions statiques
1.6.7. Fonctions prenant un nombre variable de paramètres
1.7. La fonction main
1.8. Les fonctions d’entrée / sortie de base
1.8.1. Généralités sur les flux d’entrée / sortie en C
1.8.2. La fonction printf
1.8.3. La fonction scanf
1.9. Exemple de programme complet
2. Les structures de contrôle
2.1. La structure conditionnelle if
2.2. La boucle for
2.3. Le while
2.4. Le do.
2.5. Le branchement conditionnel
2.6. Le saut
2.7. Les commandes de rupture de séquence
3. Types avancés et classes de stockage
3.1. Structures de données et types complexes
3.1.1. Les structures
3.1.2. Les unions
3.1.3. Les énumérations
3.1.4. Les champs de bits
3.1.5. Initialisation des structures et des tableaux
3.1.6. Les alias de types
3.1.7. Transtypages
3.2. Les classes de stockage
4. Les pointeurs et références
4.1. Notion d’adresse
4.2. Notion de pointeur
4.3. Déréférencement, indirection
4.4. Notion de référence
4.5. Lien entre les pointeurs et les références
4.6. Passage de paramètres par variable ou par valeur
4.6.1. Passage par valeur
4.6.2. Passage par variable
4.6.3. Avantages et inconvénients des deux méthodes
4.6.4. Comment passer les paramètres par variable en C ?
4.6.5. Passage de paramètres par référence
4.7. Références et pointeurs constants et volatiles
4.8. Arithmétique des pointeurs
4.9. Utilisation des pointeurs avec les tableaux
4.9.1. Conversions des tableaux en pointeurs
4.9.2. Paramètres de fonction de type tableau
4.10. Les chaînes de caractères : pointeurs et tableaux à la fois !
4.11. Allocation dynamique de mémoire
4.11.1. Allocation dynamique de mémoire en C
4.11.2. Allocation dynamique en C++
4.12. Pointeurs et références de fonctions
4.12.1. Pointeurs de fonctions
4.12.2. Références de fonctions
4.13. Paramètres de la fonction main – ligne de commande
4.14. DANGER
5. Le préprocesseur C
5.1. Définition
5.2. Les commandes du préprocesseur
5.2.1. Inclusion de fichier
5.2.2. Constantes de compilation et remplacement de texte
5.2.3. Compilation conditionnelle
5.2.4. Autres commandes
5.3. Les macros
5.4. Manipulation de chaînes de caractères dans les macros
5.5. Les trigraphes
6. Modularité des programmes et génération des binaires
6.1. Pourquoi faire une programmation modulaire ?
6.2. Les différentes phases du processus de génération des exécutables
6.3. Compilation séparée en C/C++
6.4. Syntaxe des outils de compilation
6.4.1. Syntaxe des compilateurs
6.4.2. Syntaxe de make
6.5. Problèmes syntaxiques relatifs à la compilation séparée
6.5.1. Déclaration des types
6.5.2. Déclaration des variables
6.5.3. Déclaration des fonctions
6.5.4. Directives d’édition de liens
7. Comment faire du code illisible ?
8. C++ : la couche objet
8.1. Généralités
8.2. Extension de la notion de type du C
8.3. Déclaration de classes en C++
8.4. Encapsulation des données
8.5. Héritage
8.6. Classes virtuelles
8.7. Fonctions et classes amies
8.7.1. Fonctions amies
8.7.2. Classes amies
8.8. Constructeurs et destructeurs
8.8.1. Définition des constructeurs et des destructeurs
8.8.2. Constructeurs de copie
8.8.3. Utilisation des constructeurs dans les transtypages
8.9. Pointeur this
8.10. Données et fonctions membres statiques
8.10.1. Données membres statiques
8.10.2. Fonctions membres statiques
8.11. Surcharge des opérateurs
8.11.1. Surcharge des opérateurs internes
8.11.2. Surcharge des opérateurs externes
8.11.3. Opérateurs d’affectation
8.11.4. Opérateurs de transtypage
8.11.5. Opérateurs de comparaison
8.11.6. Opérateurs d’incrémentation et de décrémentation
8.11.7. Opérateur fonctionnel
8.11.8. Opérateurs d’indirection et de déréférencement
8.11.9. Opérateurs d’allocation dynamique de mémoire
8.12. Des entrées – sorties simplifiées
8.13. Méthodes virtuelles
8.14. Dérivation
8.15. Méthodes virtuelles pures – Classes abstraites
8.16. Pointeurs sur les membres d’une classe
9. Les exceptions en C++
9.1. Lancement et récupération d’une exception
9.2. Remontée des exceptions
9.3. Liste des exceptions autorisées pour une fonction
9.4. Hiérarchie des exceptions
9.5. Exceptions dans les constructeurs
10. Identification dynamique des types
10.1. Identification dynamique des types
10.1.1. L’opérateur typeid
10.1.2. La classe type_info
10.2. Transtypages C++
10.2.1. Transtypage dynamique
10.2.2. Transtypage statique
10.2.3. Transtypage de constance et de volatilité
10.2.4. Réinterprétation des données
11. Les espaces de nommage
11.1. Définition des espaces de nommage
11.1.1. Espaces de nommage nommées
11.1.2. Espaces de nommage anonymes
11.1.3. Alias d’espaces de nommage
11.2. Déclaration using
11.2.1. Syntaxe des déclarations using
11.2.2. Utilisation des déclarations using dans les classes
11.3. Directive using
12. Les template
12.1. Généralités
12.2. Déclaration des paramètres template
12.2.1. Déclaration des types template
12.2.2. Déclaration des constantes template
12.3. Fonctions et classes template
12.3.1. Fonctions template
12.3.2. Les classes template
12.3.3. Fonctions membres template
12.4. Instanciation des template
12.4.1. Instanciation implicite
12.4.2. Instanciation explicite
12.4.3. Problèmes soulevés par l’instanciation des template
12.5. Spécialisation des template
12.5.1. Spécialisation totale
12.5.2. Spécialisation partielle
12.5.3. Spécialisation d’une méthode d’une classe template
12.6. Mot-clé typename
12.7. Fonctions exportées
II. La bibliothèque standard C++
13. Services et notions de base de la bibliothèque standard
13.1. Encapsulation de la bibliothèque C standard
13.2. Définition des exceptions standards
13.3. Abstraction des types de données : les traits
13.4. Abstraction des pointeurs : les itérateurs
13.4.1. Notions de base et définition
13.4.2. Classification des itérateurs
13.4.3. Itérateurs adaptateurs
13.4.3.1. Adaptateurs pour les flux d’entrée / sortie standards
13.4.3.2. Adaptateurs pour l’insertion d’éléments dans les conteneurs
13.4.3.3. Itérateur inverse pour les itérateurs bidirectionnels
13.5. Abstraction des fonctions : les foncteurs
13.5.1. Foncteurs prédéfinis
13.5.2. Prédicats et foncteurs d’opérateurs logiques
13.5.3. Foncteurs réducteurs
13.6. Gestion personnalisée de la mémoire : les allocateurs
13.7. Notion de complexité algorithmique
13.7.1. Généralités
13.7.2. Notions mathématiques de base et définition
13.7.3. Interprétation pratique de la complexité
14. Les types complémentaires
14.1. Les chaînes de caractères
14.1.1. Construction et initialisation d’une chaîne
14.1.2. Accès aux propriétés d’une chaîne
14.1.3. Modification de la taille des chaînes
14.1.4. Accès aux données de la chaîne de caractères
14.1.5. Opérations sur les chaînes
14.1.5.1. Affectation et concaténation de chaînes de caractères
14.1.5.2. Extraction de données d’une chaîne de caractères
14.1.5.3. Insertion et suppression de caractères dans une chaîne
14.1.5.4. Remplacements de caractères d’une chaîne
14.1.6. Comparaison de chaînes de caractères
14.1.7. Recherche dans les chaînes
14.1.8. Fonctions d’entrée / sortie des chaînes de caractères
14.2. Les types utilitaires
14.2.1. Les pointeurs auto
14.2.2. Les paires
14.3. Les types numériques
14.3.1. Les complexes
14.3.1.1. Définition et principales propriétés des nombres complexes
14.3.1.2. La classe complex
14.3.2. Les tableaux de valeurs
14.3.2.1. Fonctionnalités de base des valarray
14.3.2.2. Sélection multiple des éléments d’un valarray
14.3.2.2.1. Sélection par un masque
14.3.2.2.2. Sélection par indexation explicite
14.3.2.2.3. Sélection par indexation implicite
14.3.2.2.4. Opérations réalisables sur les sélections multiples
14.3.3. Les champs de bits
15. Les flux d’entrée / sortie
15.1. Notions de base et présentation générale
15.2. Les tampons
15.2.1. Généralités sur les tampons
15.2.2. La classe basic_streambuf
15.2.3. Les classes de tampons basic_streambuf et basic_filebuf
15.2.3.1. La classe basic_stringbuf
15.2.3.2. La classe basic_filebuf
15.3. Les classes de base des flux : ios_base et basic_ios
15.3.1. La classe ios_base
15.3.2. La classe basic_ios
15.4. Les flux d’entrée / sortie
15.4.1. La classe de base basic_ostream
15.4.2. La classe de base basic_istream
15.4.3. La classe basic_iostream
15.5. Les flux d’entrée / sortie sur chaînes de caractères
15.6. Les flux d’entrée / sortie sur fichiers
16. Les locales
16.1. Notions de base et principe de fonctionnement des facettes
16.2. Les facettes standards
16.2.1. Généralités
16.2.2. Les facettes de manipulation des caractères
16.2.2.1. La facette ctype
16.2.2.2. La facette codecvt
16.2.3. Les facettes de comparaison de chaînes
16.2.4. Les facettes de gestion des nombres
16.2.4.1. La facette num_punct
16.2.4.2. La facette d’écriture des nombres
16.2.4.3. La facette de lecture des nombres
16.2.5. Les facettes de gestion des monnaies
16.2.5.1. La facette money_punct
16.2.5.2. Les facettes de lecture et d’écriture des montants
16.2.6. Les facettes de gestion du temps
16.2.6.1. La facette d’écriture des dates
16.2.6.2. La facette de lecture des dates
16.2.7. Les facettes de gestion des messages
16.3. Personnalisation des mécanismes de localisation
16.3.1. Création et intégration d’une nouvelle facette
16.3.2. Remplacement d’une facette existante
17. Les conteneurs
17.1. Fonctionnalités générales des conteneurs
17.1.1. Définition des itérateurs
17.1.2. Définition des types de données relatifs aux objets contenus
17.1.3. Spécification de l’allocateur mémoire à utiliser
17.1.4. Opérateurs de comparaison des conteneurs
17.1.5. Méthodes d’intérêt général
17.2. Les séquences
17.2.1. Fonctionnalités communes
17.2.1.1. Construction et initialisation
17.2.1.2. Ajout et suppression d’éléments
17.2.2. Les différents types de séquences
17.2.2.1. Les listes
17.2.2.2. Les vecteurs
17.2.2.3. Les deques
17.2.2.4. Les adaptateurs de séquences
17.2.2.4.1. Les piles
17.2.2.4.2. Les files
17.2.2.4.3. Les files de priorités
17.3. Les conteneurs associatifs
17.3.1. Généralités et propriétés de base des clefs
17.3.2. Construction et initialisation
17.3.3. Ajout et suppression d’éléments
17.3.4. Fonctions de recherche
18. Les algorithmes
18.1. Opérations générales de manipulation des données
18.1.1. Opérations d’initialisation et de remplissage
18.1.2. Opérations de copie
18.1.3. Opérations d’échange d’éléments
18.1.4. Opérations de suppression d’éléments
18.1.5. Opérations de remplacement
18.1.6. Réorganisation de séquences
18.1.6.1. Opérations de rotation et de permutation
18.1.6.2. Opérations d’inversion
18.1.6.3. Opérations de mélange
18.1.7. Algorithmes d’itération et de transformation
18.2. Opérations de recherche
18.2.1. Opération de recherche d’éléments
18.2.2. Opérations de recherche de motifs
18.3. Opérations d’ordonnancement
18.3.1. Opérations de gestion des tas
18.3.2. Opérations de tri
18.3.3. Opérations de recherche binaire
18.4. Opérations de comparaison
18.5. Opérations ensemblistes
18.5.1. Opérations d’inclusion
18.5.2. Opérations d’intersection
18.5.3. Opérations d’union et de fusion
18.5.4. Opérations de différence
18.5.5. Opérations de partitionnement
19. Conclusion
A. Priorités des opérateurs
B. Draft Papers
C. GNU Free Documentation License
D. Licence de documentation libre GNU
BIBLIOGRAPHIE

Première approche du C/C++

Le C/C++ est un langage procédural, du même type que le Pascal par exemple. Cela signifie que les instructions sont exécutées linéairement et regroupées en blocs : les fonctions et les procédures (les procédures n’existent pas en C/C++, ce sont des fonctions qui ne retournent pas de valeur).
Tout programme a pour but d’effectuer des opérations sur des données. La structure fondamentale est donc la suivante :

ENTRÉE DES DONNÉES
(clavier, souris, fichier, autres périphériques)
|
TRAITEMENT DES DONNÉES
|
SORTIE DES DONNÉES
(écran, imprimante, fichier, autres périphériques)

Ces diverses étapes peuvent être dispersées dans le programme. Par exemple, les entrées peuvent se trouver dans le programme même (l’utilisateur n’a dans ce cas pas besoin de les saisir). Pour la plupart des programmes, les données en entrée proviennent du flux d’entrée standard, et les données émises en sortie sont dirigées vers le flux de sortie standard. Toutefois, le processus d’entrée des données peut être répété autant de fois que nécessaire pendant l’exécution d’un programme, et les données traitées au fur et à mesure qu’elles apparaissent. Par exemple, pour les programmes graphiques, les données sont reçues de la part du système sous forme de messages caractérisant les événements générés par l’utilisateur ou par le système lui-même (déplacement de souris, fermeture d’une fenêtre, appui sur une touche, etc.). Le traitement des programmes graphiques est donc une boucle infinie (que l’on appelle la boucle des messages), qui permet de récupérer les messages et de prendre les actions en conséquence. Dans ce cas, la sortie des données correspond au comportement que le programme adopte en réponse à ces messages. Cela peut être tout simplement d’afficher les données saisies, ou, plus généralement, d’appliquer une commande aux données en cours de manipulation.
Les données manipulées sont stockées dans des variables, c’est-à-dire des zones de la mémoire. Comme leur nom l’indique, les variables peuvent être modifiées (par le traitement des données). Des opérations peuvent donc être effectuées sur les variables, mais pas n’importe lesquelles. Par exemple, on ne peut pas ajouter des pommes à des bananes, sauf à définir cette opération bien précisément. Les opérations dépendent donc de la nature des variables. Afin de réduire les risques d’erreurs de programmation, les langages comme le C/C++ donnent un type à chaque variable (par exemple : pomme et banane). Lors de la compilation (phase de traduction du texte source du programme en exécutable), ces types sont utilisés pour vérifier si les opérations effectuées sont autorisées. Le programmeur peut évidemment définir ses propres types.

……

Si le lien ne fonctionne pas correctement, veuillez nous contacter (mentionner le lien dans votre message)
Télécharger cours du langage C (2,57 MO) (Cours PDF)