Introduction-au-C

FORMATION VISUAL STUDIO 2010
C++
Livret 1 – Introduction à la programmation
THIERRY TILLIER
http://www.coursdinfo.fr
Ce support de cours est réservé à un usage
personnel. Toute utilisation et diffusion
dans le cadre d’une activité de formation
fait l’objet d’une licence de copies. Veuillez
nous contacter si vous souhaitez utiliser ce
cours dans ce cadre.
Table des matieres
Chapitre 1 Généralités............................................................................................................................. 5
1.1 Historique ...................................................................................................................................... 5
1.2 Les différents langages .................................................................................................................. 5
Chapitre 2 Canevas d'un programme ...................................................................................................... 6
2.1 Entête ............................................................................................................................................ 6
2.2 Zone de déclaration....................................................................................................................... 7
2.3 Corps du code ................................................................................................................................ 7
2.4 Les différents fichiers d'un programme ........................................................................................ 7
Chapitre 3 Partage de l’application ......................................................................................................... 8
Chapitre 4 Le rôle des outils .................................................................................................................... 9
4.1 Le Préprocesseur ........................................................................................................................... 9
4.2 Link ................................................................................................................................................ 9
Chapitre 5 Conseils de programmation................................................................................................. 11
5.1 Les variables ................................................................................................................................ 11
5.2 Les fonctions ................................................................................................................................ 11
5.3 Du code lisible ............................................................................................................................. 12
5.4 Les fichiers inclus ......................................................................................................................... 13
Chapitre 6 La programmation orientée objet (POO)............................................................................. 15
6.1 Généralités .................................................................................................................................. 15
Chapitre 7 Interface de développement ............................................................................................... 18
Chapitre 8 Créer un premier programme ............................................................................................. 20
8.1 Création d’un projet Console ...................................................................................................... 20
8.2 Ajout d’un module de code C++ .................................................................................................. 25
8.3 Générer la solution ...................................................................................................................... 27
8.4 Exécuter en mode debug............................................................................................................. 28
8.5 Fermer un projet ......................................................................................................................... 29
Chapitre 9 Conclusion............................................................................................................................ 30
Preambule
Ce cours s'adresse à toute personne désirant apprendre le C++ sans connaître le Langage C.
Les éléments communs entre le C et le C++ seront donc examiné en détail avec une orientation vers
le C++, évidemment.
Prérequis : Maîtriser l’environnement Windows
Objectifs :
Découvrir les différentes parties d’un petit projet
Apprendre à bien coder
Créer un petit programme
Découvrir Visual Studio 2010
Retrouvez tous les cours sur http://www.coursdinfo.fr
Copyright © 2013 Thierry TILLIER Tous droits réservés

Chapitre 1 Généralités
Tout programme a but : traiter des données, pour cela il y trois phases qui s'enchaînent :
L'entrée des données (Clavier, souris, fichiers, base de données, périphérique)

Le traitement des données
La sortie des données (Écran, imprimante, fichier, réseaux, périphérique).
Étant un langage procédural, les instructions sont exécutées de façon linéaire. Ces instructions sont
regroupée en bloc contenant des (fonctions ou des procédures).
Le langage C a été développé dans les années 70-72 dans les laboratoires BELL par Kernigan et
Ritchie. Il permet de développer à bas niveau (proche du Hard -µP) ou à haut niveau
(indépendamment du matériel).
Son succès est dû à UNIX (écrit en C) même s'il a beaucoup été critiqué à ces début à cause de son
compilateur trop 'tolérant'. Aujourd'hui, notamment avec le C++, le compilateur est beaucoup plus
'sérieux'.
Plus tard en 1983 et toujours dans les laboratoires BELL (A&T BELL LABORATOIRE) arrive le C++. On le
doit à Bjarne STROUSTRUP. Le Comité ANSI X3J16 a été mis en place en 1989 afin de normaliser ce
langage.
Bien que les langages C et C++ soient ressemblant, ils sont malgré tout assez différents pour parler de
deux langages à part entière.
Les langages C – C++ sont des langages portables (à condition d'utiliser des procédures et des
fonctions normalisées ANSI).
Un programme écrit en C / C++ ANSI peut donc être utilisé sur n'importe quel OS (à condition de
recompiler le programme dans le système de destination.
D'autres langages de haut niveau ont vu le jour depuis. Le plus connu est ADA.
La nécessité s'est ensuite imposé de créer des langages de plus haut niveau. (C++, Visual Basic,
Delphi, Java ...).
Une fonction de haut niveau génère une kyrielle de fonctions de base automatiquement, ce qui 5
simplifie la tâche du programmeur.
| Copyright © 2013 Thierry TILLIER Tous droits réservés

Chapitre 2 Canevas d'un programme
Les langages C et C++ sont sensibles à la casse (Majuscule et minuscule)
Les grandes parties dans un programme sont :
L'entête du programme
La zone de déclaration
Les fonctions du programme principal
Le corps des procédures fonctions
L’entête est une zone de commentaires contenant :

Le nom du projet
Le nom du fichier
L'auteur du fichier
La date
Autres informations utiles…
Et qui se place au début du module de code
Syntaxe :
A : // ... Le commentaire sur une ligne....
B : /* .......... commentaire .............
....... sur .......
...... plusieurs ..........
........... lignes ........*/
ou
C : // Le commentaire UNIQUEMENT EN C++

On déclare dans cette zone :
Les variables
Les constantes
Les équivalences
Les prototypes des nouvelles fonctions
Les fichiers à inclure (bibliothèque std du C++)
Cette zone sert à informer le compilateur que l'on va avoir besoin de certaines variables / Fonctions /
Fichiers et qu'il va rencontrer de nouveaux mots. Le compilateur doit savoir à quoi ils correspondent.
;
Le termine chaque ligne d'instruction (sauf les conditionnelles)
,
La sépare les variables
{ ouvre un bloc d'instruction (ouvre le corps d'une fonction/procédure)

} ferme un bloc d'instruction (ferme le corps d'une fonction/procédure)
Un programme est constitué de déclaration d'objet et de fonctions qui s'appellent les unes les
autres. La fonction main() (ou Winmain() ) est la fonction principale.
Les fichiers avec une extension *.hpp (parfois *.h).
Ces fichiers contiennent des variables ou des prototypes de fonctions
Les fichiers avec une extension *.cpp (ou *.c en Langage C). (Appellation : fichier source)
Ces fichiers contiennent les corps des fonctions définies dans le fichier homologue *.h.
Suivant la complexité d'un programme, on trouvera plusieurs fichiers *.hpp et *.cpp.
On peut avoir aussi besoin de fichiers spéciaux : les librairies dont l'extension est *.lib.

Chapitre 3 Partage de l’application
Les prototypes occupent une place importante et alourdissent la lecture du programme principal.
C'est pourquoi, en C, ils sont incorporés dans les fichiers inclus (*.h - *.hpp). Ceci est encore plus vrai
en C++.
Un programme se découpe donc en plusieurs modules, 1 module par catégorie de fonction.
Ex.
1 module pour la gestion de l'écran

1 module pour les calculs mathématiques
1 module pour l'accès aux fichiers
....
Plusieurs fichiers permettent :
en cas de modification, 1 seul fichier sera à recompiler

de travailler en équipe
de rendre les modules réutilisables
Voici un exemple en langage C d’un programme partagé (ou découpé en plusieurs parties).
Chaque bloc pourrait être réutilisé tel quel dans un autre programme.

Chapitre 4 Le rôle des outils
Avant de générer un fichier exécutable, le logiciel de développement effectue un certain nombre

d'opération en vue de s'assurer de la bonne syntaxe dans le programme. L’explication indiquée ici,
n’est plus tout à fait d’actualité avec le Framework de Windows. Cela permet néanmoins de bien
comprendre l’idée générale de ce qui se passe lors de la création du fichier exécutable.
Le préprocesseur (ou compilateur) va s'assurer que chaque fichier.cpp a une syntaxe correct et que
chaque mot et fonction nouveau est bien défini dans votre fichier.h personnel.
Le préprocesseur va ensuite générer un fichier *.obj contenant le code machine spécifique à un µP.
Il y aura un fichier.obj pour chaque fichier.cpp écrit.
Il existe différents compilateurs C++
g++ pour Linux

Compilateur Borland 5.5
Compilateur Intel
Compilateur Microsoft (Visual Studio)
...
Ensuite c'est autour de l'éditeur de liens (ou le builder).
Il va prendre les fichiers.lib dont il aura besoin pour les fonctions de base du C/C++ (printf(),
scanf()...), ainsi que tous les fichiers.obj et il va créer le fichier.exe (l'exécutable).
L'erreur typique : « Unresolve external reference » Ce qui signifie qu'il manque une bibliothèque
pour construire une fonction/procédure. Autrement dit, vous avez oublié d'inclure un fichier.

Voici un petit schéma qui explique comment sont associés les différents fichiers d’un programme
simple.
Aujourd’hui, les fichiers

*.obj ne sont plus créés,
ni le fichier *.exe. Les
choses se passent un peu
différemment, mais le
principe est similaire.
Ce schéma est valable pour la plupart des compilateurs, mais nous verrons les nouveautés apportées
10 par le Framework de Windows.

Chapitre 5 Conseils de programmation
Les variables doivent être déclarées avant d’être utilisée. Déclarer signifie faire connaitre au
programme le nom et le type des variables.
Déclaration de variables : <type> <Le nom de la variable>
Exemple :
int LeVolume ; // déclaration de la variable entière LeVolume (int pour integer)
int Somme;
float Résultat; // déclaration d'une variable décimal
Le type définit la place mémoire nécessaire à la variable, par exemple int = 4 Octets sur PC Windows.
Nous parlerons davantage des variables et des types dans le prochains cours.
Cette déclaration permet également de définir toutes les instructions possibles avec la variable.
Il en va de même pour les fonctions.
Déclaration de fonction : <type de paramètre de retour> <nom de la fonction ( <paramètres>)>
Avant d'utiliser une fonction, le compilateur doit connaître son nom et ses arguments. Pour cela, on
déclare un prototype de la fonction dans un fichier d'entête ou au début du programme principal.
Exemple : on veut écrire une fonction qui additionne 2 entiers :
int Ajouter(int PremierNombre, int DeuxiemeNombre); // Déclaration du prototype
Les fonctions seront déclarées (de préférence) dans un fichier h ou hpp , puis incluse au module de
code.
11

Définir une fonction revient à écrire le code informatique en C++ de ce que doit faire la fonction.
La fonction sera définie dans un fichier *.cpp
int Ajouter(int PremierNombre, int DeuxiemeNombre) //Reprise du prototype
{ // Corps de la fonction :
int Resultat;
Resultat = PremierNombre + DeuxiemeNombre ;
return Resultat
Pour que notre code soit compréhensible, il est bien de respecter ces quelques règles :
Afin d'éviter un maximum de commentaires explicatifs, il faut employer des noms de fonctions et des
noms de variables les plus explicites possible.
Ex:
LeVolume,
LaMoyenne,
LeDernierNombreDuTableau
SommeDe(..,..)
LireLeNom(..)
Nous parlerons de variables spéciales appelées 'les pointeurs'. On mettra un p devant son nom
identificateur .
ex : int * pMonPointeur.
Dans la mesure du possible, faites des fonctions courtes.

12

La directive pour inclure des fichiers est
#include <stdio.h> // fichiers de la bibliothèque standard – le compilateur cherche le *.h dans les
directories sytème
#include ''MonFichier.h'' // fichiers personnels. - le compilateur cherche le *.h dans le répertoire

courant.
Les fichiers.h sont du texte (alors que les fichiers *.lib ou *.dll contiennent du code compilé).
Un fichier inclus contient
*les prototypes des fonctions prédéfinies du C/C++ (stdio.h ou iostream.h)
*les prototypes des fonctions spécifiques à un projet
*les nouveaux types définis par l'utilisateur
Il n'y a jamais de corps de fonction dans un fichier.h (sauf cas particulier avec les classes en C++).
Sur la page suivante vous trouverez un exemple de code que nous aurons l’occasion de taper
13

/*****************************************************************/
/*Projet : Hello world */
/*Auteur : Thierry */
/*Date de Création : 05/01/2012 */
/*Nom du Fichier : HelloWorld.cpp */
/*****************************************************************/
/********************** FICHIERS INCLUS ***************************/
#include <iostream.h> // Contient 'entre autre, la déclaration de 'cout'
/********************** Procédures ***********************************/

// Procédure principal avec arguments en paramètres
int main(int argc, char* argv[])
{
printf("Hello World!\n");
return 0;
}
/////////////////////// Autre exemple de programme simple /////////////////////////////////////
int I, J ; // Déclaration de variable
void FonctionNumero1(void); // Déclaration d'une fonction, elle pourrait être dans un fichier.h
void main(void) // Autre genre de procédure principale

{ // début du programme – équivalent du 'begin' en Pascal
FonctionNumero1();
... // Instructions
} // Fin du programme principal – équivalent du 'end' en Pascal
void FonctionNumero1(void) // Nouvelle fonction

{
.. // instructions // corps de la fonction

}
14

Chapitre 6 La programmation orientée objet (POO)
Le langage C est un langage procédural. Il est structuré mais représente un ensemble de procédures
ou fonction qui s'appellent les unes les autres. Chaque procédure ou fonction ayant un rapport entre
elles sont regroupées dans un même module (même fichier *.cpp). Par exemple, toutes les fonctions
arithmétiques seront dans un même module.
Le C++ est un langage orienté objet. On ne manipule plus seulement des procédures mais des
nouveaux types appelés objets ou classes. Ces objets peuvent suivre une hiérarchisation.
Imaginons que vous souhaitiez faire un programme de calculs mathématiques, il faudrait définir des
groupes (qui seront vos objets) selon le schéma ci-dessous, par exemple:
Math
Arithmétique Analyse
Calcul Ensembles
Addition Multiplication Union Réels
On dira que :
Addition est un type (ou objet ) dérivé de Calcul

Calcul est un type dérivé de Arithmétique
Arithmétique est un type dérivé de Math
Il s'agit ici d'héritages multiples. Nous développerons cette notion plus en détail dans le cours.
15

L'objectif de la programmation orientée objet est de protéger les données utilisées, surtout lorsque
plusieurs programmeurs, sur une même application, ont besoin des mêmes données. Un objet est un
ensemble de données auxquelles s'appliquent des procédures / fonctions. Ces dernières s'appellent
des méthodes.
Nous en parlerons plus en détail lorsque nous aborderons les classes.
16

Presentation de Visual Studio 2010
Cette partie présente rapidement l’IDE Visual Studio qui permet de développer des applications en C++ ou
VB.Net et bien d’autres choses encore.
17

Chapitre 7 Interface de développement
Visual Studio est un IDE (environnement de développement) il regroupe et automatise les fonctions
de compilation et d'éditeur de liens et de debug.
Vous pouvez créer des projets console (SHELL – anciennement DOS), des interfaces graphiques, des
dll ....
1 : Veuillez lancer Visual

Studio 2010
18

2 : Visual Studio se lance
3 : Visual Studio affiche à

l’écran sa page de démarrage.
19

Chapitre 8 Créer un premier programme
Objectif : Apprendre à créer un nouveau projet.

1 : Cliquez sur Fichier 2 : Cliquez sur Nouveau
3 : Cliquez sur Projet
4 : La fenêtre suivante 5 : Vous avez ensuite le choix du type

vous propose différents de projet. Cliquez sur le premier :
langages. Cliquez sur Application Console Win32 pour
Visual C++ commencer simplement
Remarquez ici une

description du type de
projet choisi.
20

6 : Tapez le nom
du projet
7 : Cliquez sur
Parcourir
8 : Sélectionnez le dossier
Exercices du Livret1, puis
cliquez sur Sélectionner un
dossier
21

9 : Cliquez sur OK
10 : Les étapes suivantes

permettent de paramétrer
des fichiers par défaut.
Cliquez sur Suivant
22

Cette étape permet de modifier
quelques paramètres.
11 : Décochez l’option En-

tête précompilé
12 : Cochez Projet vide
13 : Cliquez sur le
bouton Terminer
23

14 : L’interface de
programmation de notre
projet est prête
Cette zone affichera

notre code en langage
C++
Cette zone affichera

l’arborescence de nos
différents fichiers
contenant le code en
C++ et les fichiers
inclus
Cette zone affiche les

propriétés de
l’élément sélectionné.
On s’en servira lors de
la création d’interfaces
graphiques
La barre d’état indique que

le projet a été créé
correctement
24

Objectif : Créer un fichier qui contiendra notre code C++
2 : Cliquez sur Ajouter

1 : Cliquez sur Projet
un nouvel un élément
3 : Cliquez sur Fichier C++

(.cpp)
25

4 : Tapez le nom du fichier 5 : Vérifiez
l’emplacement où sera
enregistré le fichier
6 : Cliquez sur
Ajouter
7 : Le module vierge apparait.
8 : Veuillez taper le code ci-

dessous.
26

Objectif : Créer la solution exécutable du programme.
Générer la solution c’est compiler en langage machine (enfin presque) le petit programme qu’on
vient de faire. Cette étape permet de vérifier qu’il n’y a pas d’erreur de syntaxe ou d’oubli.
1 : Cliquez sur le menu Générer
2 : Cliquez sur Générer la

solution
3 : La fenêtre du bas affiche

le résultat de la solution. Si
des erreurs sont détectées,
elles apparaitront ici.
27

1 :Cliquez sur le bouton
Démarrer.
Le programme s’exécute, il ouvre une fenêtre Shell (MS DOS) écrit le

mot BIENVENUE, puis la fenêtre se referme aussitôt. On n’a pas le
temps de voir vraiment ce qui se passe.
Nous verrons dans le prochain livret comment empêcher l’arrêt du

programme.
Ce qui nous intéresse pour le moment c’est la

fenêtre de Sortie qui indique ce qui a été fait et
si le programme s’est déroulé sans problème.
Le code 0 (0x0) indique

que le programme s’est
arrêté normalement.
28

Cliquez sur Fichier, puis sur Fermer la
solution, votre projet doit se fermer.
29

Chapitre 9 Conclusion
Ce premier livret nous a permis de faire un rapide tour sur les éléments de bases communs à tous les
langages de programmation.
Le prochain livret traite du langage C++ dans le détail et vous permettra de faire de nombreux petits
programmes pour bien comprendre. Une large part traitera de la manière de déboguer un
programme.
30

31

THIERRY TILLIER FORMATIONS
http://www.coursdinfo.fr
06 81 51 11 24
thierry.tillier@coursdinfo.fr
Copyright © 2013 Thierry TILLIER Tous droits réservés

Introduction-au-C

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Introduction-au-C

Transféré par

Droits d'auteur :

Formats disponibles

FORMATION VISUAL STUDIO 2010

Prérequis : Maîtriser l’environnement Windows

Retrouvez tous les cours sur http://www.coursdinfo.fr

Copyright © 2013 Thierry TILLIER Tous droits réservés

L'entrée des données (Clavier, souris, fichiers, base de données, périphérique)

| Copyright © 2013 Thierry TILLIER Tous droits réservés

Les grandes parties dans un programme sont :

L’entête est une zone de commentaires contenant :

Et qui se place au début du module de code

A : // ... Le commentaire sur une ligne....

B : /* .......... commentaire .............

....... sur .......

...... plusieurs ..........

........... lignes ........*/

C : // Le commentaire UNIQUEMENT EN C++

| Copyright © 2013 Thierry TILLIER Tous droits réservés

{ ouvre un bloc d'instruction (ouvre le corps d'une fonction/procédure)

Les fichiers avec une extension *.hpp (parfois *.h).

Ces fichiers contiennent des variables ou des prototypes de fonctions

Suivant la complexité d'un programme, on trouvera plusieurs fichiers *.hpp et *.cpp.

| Copyright © 2013 Thierry TILLIER Tous droits réservés

Un programme se découpe donc en plusieurs modules, 1 module par catégorie de fonction.

1 module pour la gestion de l'écran

en cas de modification, 1 seul fichier sera à recompiler

| Copyright © 2013 Thierry TILLIER Tous droits réservés

Avant de générer un fichier exécutable, le logiciel de développement effectue un certain nombre

Il y aura un fichier.obj pour chaque fichier.cpp écrit.

Il existe différents compilateurs C++

g++ pour Linux

Ensuite c'est autour de l'éditeur de liens (ou le builder).

| Copyright © 2013 Thierry TILLIER Tous droits réservés

Aujourd’hui, les fichiers

| Copyright © 2013 Thierry TILLIER Tous droits réservés

Déclaration de variables : <type> <Le nom de la variable>

int LeVolume ; // déclaration de la variable entière LeVolume (int pour integer)

float Résultat; // déclaration d'une variable décimal

Il en va de même pour les fonctions.

Déclaration de fonction : <type de paramètre de retour> <nom de la fonction ( <paramètres>)>

Exemple : on veut écrire une fonction qui additionne 2 entiers :

int Ajouter(int PremierNombre, int DeuxiemeNombre); // Déclaration du prototype

| Copyright © 2013 Thierry TILLIER Tous droits réservés

La fonction sera définie dans un fichier *.cpp

int Ajouter(int PremierNombre, int DeuxiemeNombre) //Reprise du prototype

Resultat = PremierNombre + DeuxiemeNombre ;

Dans la mesure du possible, faites des fonctions courtes.

| Copyright © 2013 Thierry TILLIER Tous droits réservés

#include ''MonFichier.h'' // fichiers personnels. - le compilateur cherche le *.h dans le répertoire

Un fichier inclus contient

*les prototypes des fonctions prédéfinies du C/C++ (stdio.h ou iostream.h)

*les prototypes des fonctions spécifiques à un projet

*les nouveaux types définis par l'utilisateur

| Copyright © 2013 Thierry TILLIER Tous droits réservés

/********************** FICHIERS INCLUS ***************************/

#include <iostream.h> // Contient 'entre autre, la déclaration de 'cout'

/********************** Procédures ***********************************/

/////////////////////// Autre exemple de programme simple /////////////////////////////////////

int I, J ; // Déclaration de variable

void main(void) // Autre genre de procédure principale

void FonctionNumero1(void) // Nouvelle fonction

.. // instructions // corps de la fonction

| Copyright © 2013 Thierry TILLIER Tous droits réservés

Addition Multiplication Union Réels

Addition est un type (ou objet ) dérivé de Calcul

Les fichiers avec une extension .hpp (parfois .h).

Suivant la complexité d'un programme, on trouvera plusieurs fichiers .hpp et .cpp.

/ FICHIERS INCLUS *****/

/ Procédures *************/