E N C G - Casablanca

Bienvenue sur le Forum Officiel des Etudiants de l'Ecole Nationale de Commerce et de Gestion - Casablanca
 
AccueilFAQRechercherS'enregistrerMembresGroupesConnexion
CHATBox ... discutez en ligne sur le Forum !
BIENVENUE AUX NOUVEAUX ENCG'istes

Partagez | 
 

 Introduction au langage C/C++ (1)

Voir le sujet précédent Voir le sujet suivant Aller en bas 
AuteurMessage
Quantum Theory



Messages : 106
Réputation : 5
Date d'inscription : 10/08/2010
Localisation : A chercher entre le "A" et le "Z" // :)
Profession : Etudiant

MessageSujet: Introduction au langage C/C++ (1)   Ven 3 Sep - 1:15

Chapitre 1

Introduction

Un ordinateur est une machine capable d'effectuer très rapidement des opérations arithmétiques

ou logiques sur des données afin de fournir des résultats. Cependant, cette machine ne dispose

d'aucune connaissance : pour obtenir qu'elle réalise les opérations souhaitées, il faut lui fournir des

instructions qu'elle suivra ensuite à la lettre.

En général, l'utilisateur dispose d'un «algorithme» qui décrit en détail comment on passe, au

moyen d'un nombre fini d'opérations, des données aux résultats. L'algorithme (recette) est rédigé

en langage humain, bien trop riche et complexe pour être compris par la machine. L'utilisateur

devra tout d'abord transposer son algorithme en un jargon simpliste (un «langage de programmation

») pour obtenir un «programme» (on dit aussi «code» ou «code source») équivalent. Ce

programme utilisateur sera traduit à son tour en une suite d'instructions primitives effectivement

compréhensibles et exécutables par l'ordinateur. Cette traduction est réalisée par un programme

spécialisé, le «compilateur». A chaque langage de programmation correspond un compilateur, qui

porte le même nom ; ainsi ce cours est une introduction à la programmation en C++, qui utilisera

pour les exercices pratiques un compilateur C++. Le programme source est rangé dans un fichier

situé sur le disque dur ou sur une disquette. Sauf instructions spéciales, le compilateur ne connaît

que le contenu de ce fichier source. Le programme en langage machine (repéré par le suffixe .exe

sous DOS et Windows) est lui aussi rangé dans un fichier (en général dans le même dossier que le

source). Il peut alors être exécuté autant de fois que l'utilisateur le souhaite.

Pour certains langages de programmation (Basic à ses début, Maple, Scilab par exemple), on

utilise un «interprèteur» qui traduit le «code utilisateur» en langage machine ligne par ligne à

chaque exécution.

Il est important de se persuader du fait que l'ordinateur traite, selon les instructions qu'il a

reçues, des chiffres binaires (des bits ou des octets) sans se préoccuper le moins du monde de

leur signification ; les données peuvent être des résultats d'une mesure physique, un morceau de

musique numérisé, une carte météo fournie par un satellite, un texte à traduire en anglais, c'est tout

pareil pour la machine. C'est à l'utilisateur (à travers son programme) d'assurer l'interprétation

des données et des résultats.

1

Chapitre 2

Les éléments du langage

Les langages de programmation, comme toute langue, utilisent des lettres pour former des

mots ; ces mots peuvent être groupés en petites phrases simples que l'on appelle en général des

instructions. Ces phrases doivent être construites en respectant un certain nombre de règles de

syntaxe. Je présente dans ce chapitre les constituants de base des langages C/C++.

2.1 lettres et mots

Le langage C++ utilise 52 lettres : a, b, . . ., z et A, B, . . ., Z. Le compilateur C++ distingue

parfaitement les majuscules des minuscules. On emploie également les signes usuels : =, +, -, *,

/,(,),[,],{,},

> , < , &,%, ?,|, n , la virgule, le point, deux points :, le point-virgule, l'apostrophe (') et
les guillemets anglais(", sous le 3). Certains de ces symboles peuvent être combinés entre eux.

Le langage C est formé de « mots réservés» ou «mots clés», qui doivent être utilisés comme

prévu par la définition du langage ; en voici la liste :

auto double int struct

break else long switch

case enum register typedef

char extern return union

const float short unsigned

continue for signed void

default goto sizeof volatile

do if static while

Le langage C++ ajoute les mots clés suivants

asm bool catch class const_cast

delete dynamic_cast explicit false friend

inline mutable namespace new operator

private protected public reinterpret_cast

static_cast template this throw true

try typeid typename using virtual

wchar_t

La signification de certains de ces mots sera expliquée par la suite. On emploie bien d'autres

mots (toutes les fonctions mathématiques par exemple). Ces mots (identificateurs) ne font pas

partie de la norme C/C++ et peuvent

en principe être redéfinis par l'utilisateur.
2

Intro_C

3
Dans le temps imparti pour ce cours, il ne sera pas possible d'examiner (et encore moins

d'assimiler) tous les aspects du langage C++ : il s'agira plutôt d'une version simplifiée du langage,

proche du C, du C+ en quelque sorte, ou encore du C amélioré.

2.2 Premiers exemples

Je présente maintenant quelques programmes très simples en C++, avec leurs équivalents en

C pur (et en Pascal pour ceux qui connaissent ce langage). Ce premier exemple n'utilise aucune

donnée et a pour seul résultat un affichage à l'écran.

2.2.1 le programme traditionnel

1

// bonjour_2 . cpp : a f f i c h e un message t r a d i t i o n n e l
2

#include <ios t ream>
3

#include <c s t d l i b >
4

int main ( void ){
5 s td : : cout << "Bonjour tout l e monde ! " << s td : : endl ;

6 system( " pause " ) ;

7

return 0 ;
8 }

La numérotation des lignes ne fait PAS partie du programme ou du langage, elle est là pour

faciliter les explications.

Sur la ligne 1, j'ai placé un commentaire (une ligne commençant par //) : c'est du texte

destiné aux utilisateurs, la machine n'en tient aucun compte. Un commentaire expliquant le rôle

de chaque élément d'un programme permet au lecteur de comprendre sans trop de mal ce que fait

ce programme. Le compilateur considère comme un commentaire tout ce qui se trouve entre // et

une fin de ligne.

Sur la ligne 2 (et aussi 3), on rencontre une « directive du préprocesseur » laquelle commence

toujours par # et dont le rôle est de réclamer l'utilisation d'une partie de la «librairie standard».

Le préprocesseur agit comme une avant-garde du compilateur ; il va insérer (inclure) dans mon

programme un fichier entête contenant des renseignements concernant les fonctions responsables

de la lecture des données et de l'écriture des résultats (

i nput- o utput). Celles-ci ne font pas partie
du langage C++ de base. Même chose pour la ligne 3, qui rend possible l'accès à la fonction

system
(communication avec le système d'exploitation).

La ligne 4 contient le nom de l'élément principal (

main ) du programme. Ce nom doit figurer
une fois et une seule

. Les parenthèses indiquent au compilateur qu'il s'agit en fait d'une fonction ;
elles contiennent le mot-clé

void parce que la fonction main ne demande ici aucun argument.
Un programme plus complexe pourrait comporter de nombreuses fonctions, dont une seule devra

s'appeler

main . D'autre part, on indique au système d'exploitation (DOS, Windows,Linux,. . .), par
le mot réservé

int , que main « fournit un résultat», sous la forme d'un entier. Cet entier permet
en principe de vérifier la bonne fin du programme.

La ligne 4 contient une accolade ouvrante, qui marque le début de la fonction proprement dite ;

cette fonction se termine par l'accolade fermante de la ligne 8. Tout ce qui se trouve entre les deux

accolades s'appelle le «corps» de la fonction. On dit aussi que les instructions situées entre une

paire d'accolades forment un «bloc».

La ligne 5 contient la seule instruction effective du programme. Elle demande l'insertion, dans

le «flot de sortie», de la «chaîne de caractères»

Bonjour tout le monde ! , suivie d'une instruction
destinée au terminal (ici l'écran),

endl (à la ligne) ce qui, en français, signifie que l'on veut afficher
à l'écran la phrase

Bonjour tout le monde ! et positionner le curseur au début de la ligne suivante.
Intro_C

4
Comme l'opérateur

cout et le caractère endl font partie de la librairie standard, on préfixe ces
deux noms par

std:: .
La ligne 6 demande au système de marquer un temps d'arrêt, pour que l'on puisse lire le

résultat. Le déroulement normal (retour à l'écran d'accueil) reprend dès que l'on appuie sur une

touche. On voit que la fonction

system admet un argument, la «chaîne de caractères» pause .
On a enfin (ligne 7) une instruction

return 0 , qui envoie au système d'exploitation le «résultat
» de la fonction main, la valeur 0, indiquant que tout s'est bien passé (un résultat non nul

indiquerait une erreur). Le compilateur vérifiera que la déclaration de la fonction (

int main() ),
de type entier, est bien cohérente avec la nature du résultat (l'entier 0).

On remarque que chaque instruction se termine (et DOIT se terminer) par un point-virgule.

Les éléments précédents sont toujours, ou presque toujours, présents dans un programme en C++.

Le programme qui vient d'être présenté respecte strictement la norme C++; les compilateurs

dont vous pourrez disposer respecte plus ou moins strictement cette norme. Il se peut que votre

compilateur admette ou préfère l'entête

#include <iostream.h> . Il est aussi possible (c'est le cas
du compilateur que j'utilise) qu'il ne soit pas regardant sur la présence des préfixes

std:: et que
main()

le satisfasse. Ce comportement voisin de l'anarchie est du à ce que la norme qui définit le
C++ est récente et continue d'évoluer.

2.2.2 le même en C

Voici maintenant le même programme en C pur ; il sera parfaitement compris par un compilateur

C++, mais l'inverse n'est pas vrai : les mots-clés du C++ ne sont pas connus du C.

1 /*bonjour.c: Affiche un message traditionnel*/

2 #include <stdio.h>

3 int main()

4 {

5 printf("Bonjour tout le monde!\n");

6 return 0;

7 }

Examinons les quelques différences qui existent, à ce niveau, entre les deux dialectes.

Sur la ligne 1, un commentaire est indiqué par une ligne commençant par /* et finissant par

*/.

Sur la ligne 2, la « directive du préprocesseur» se réfère à un fichier entête (

h eader) dont le
nom est différent des précédents mais dont le rôle identique : insérer des renseignements concernant

les fonctions responsables de la lecture des données et de l'écriture des résultats (

i nput- o utput).
Celles-ci ne font pas partie, en toute rigueur, du langage C.

La ligne 3 appelle la fonction principale, et les parenthèses vides indiquent que cette fonction

n'attend pas d'arguments.

La ligne 5 est une instruction d'écriture (appel à la fonction

printf ). Cette fonction reçoit un
argument, la chaine de caractères (entre guillemets anglais)

Bonjour tout le monde ! . Cette chaîne
est suivie d'un «caractère d'échappement»

\n , qui demande de passer à la ligne.
2.2.3 le même en Pascal

Voici maintenant un programme équivalent, rédigé en Pascal.

Intro_C

5
1 {Premier programme}

2

3 PROGRAM bonjour;

4 BEGIN

5 WRITELN('Bonjour tout le monde!');

6

7 END.

Le mot clé

program doit être présent. Le corps du programme est compris entre BEGIN et
END. Les chaines de caractères sont écrites entre apostrophes et non entre guillemets. Bien que

Pascal ne distingue pas entre majuscule et minuscule, il est commode de choisir l'une des casses

pour les mots du langage, l'autre pour les variables définies par l'utilisateur.

2.2.4 format libre

Dans les trois langages, la position des mots sur la ligne est indifférente (on parle de format

libre). Le compilateur s'y retrouve grace aux mots réservés (ou aux accolades) et aux points-virgules

qui terminent chaque instruction (sauf les instructions destinées au préprocesseur, qui doivent être

chacune seule sur sa ligne, peut-être avec un commentaire). Ainsi, j'aurais pu écrire le programme

C++ précédent sous la forme

1 /*Premier programme horrible*/ #include <iostream>

2 int main(void){std::cout<<"Bonjour tout le monde!"<<std::endl;return 0;}

La lisibilité n'est pas la même. Il y a grand intérêt à mettre en évidence la logique du programme

à l'aide de la mise en page du texte. Chaque programmeur doit doit créer sa propre présentation,

combinant clarté, lisibilité et économie de place.

2.2.5 saisir des nombres au clavier

Le programme suivant (addition de deux entiers), va nous permettre de découvrir quelques

caractéristiques supplémentaires du langage.

1

//somme . cpp : l i t deux e n t i e r s e t a f f i c h e l e u r somme
2

#include <ios t ream>
3

#include <c s t d l i b >
4

using s td : : c in ; using s td : : cout ; using s td : : endl ;
5

int main ( void ){
6

int nb1 , nb2 , somme ;
7 cout << "donner l e premier e n t i e r : \n" ;

8 c in >> nb1 ;

9 cout << "donner l e deuxième e n t i e r : " << endl ;

10 c in >> nb2 ;

11 somme = nb1 + nb2 ;

12 cout << " l a somme vaut : " << somme << "\n" ;

13 system( " pause " ) ;

14

return 0 ;
15 }

Intro_C

6
J'ai fait savoir au compilateur (ligne 4) que j'allais utiliser les opérateurs standard

cin, cout
et

endl , ce qui va me dispenser de réécrire std:: à chaque utilisation.
Sur la ligne 6, j'ai déclaré les variables que je veux utiliser. Beaucoup de recettes de cuisine

sont rédigées de cette façon : on énonce les ingrédients requis avant de donner les instructions pour

confectionner le plat. Ces variables sont toutes des entiers. Un nom de variable (un «identificateur»)

ne doit pas commencer par un chiffre et peut comporter jusqu'à 31 lettres ou chiffres (le seul autre

caractère permis est le souligné _). Le nom d'une variable doit être significatif et aider à la

compréhension du programme (par exemple prix_par_kilo plutôt que pk3). En C, les déclarations

sont placées avant toute instruction exécutable. Le C++ admet que les variables soient déclarées

juste avant leur utilisation ; cela diminue les risques d'erreurs dans les grands programmes.

Les lignes 7 et 9 contiennent deux instructions (injection dans le flot de sortie) d'écriture à

l'écran, comme précédemment. J'ai mélangé diverses forme du retour à la ligne, toutes compréhensibles

par C++.

Les lignes 8 et 10 réalisent l'opération inverse : l'extraction de deux valeurs à partir du « flot

d'entrée», ou encore la lecture de deux entiers tapés au clavier.

À l'exécution des lignes 7 et 8 par exemple, l'écran affichera

donner le premier entier:

et l'ordinateur attendra (curseur à gauche de l'écran) que l'utilisateur tape la valeur de nb1, suivie

de

< return > ou < entrée > .
L'instruction de la ligne 10 est une «affectation» : la variable

somme reçoit une valeur, laquelle
est justement la somme nb1+nb2.

On se rend compte que les variables (ou les identificateurs) n'ont pas d'existence réelle ; ce sont

des noms (plutôt des pseudonymes) pour des emplacements dans la mémoire de la machine. La

déclaration d'une variable sert d'une part à réserver un emplacement, d'autre part à définir sa

taille, car toutes les variables n'ont pas le même encombrement.

2.2.6 la version C

Je présente maintenant et pour la dernière fois, la version C pure.

1 /*somme.c: lecture de deux entiers et affichage de leur somme*/

2 #include <stdio.h>

3 #include <stdlib.h>

4 int main(void)

5 {

6 int nb1, nb2, somme;

7 printf("donner le premier entier: \n");

8 scanf("%d", &nb1);

9 printf("donner le deuxième entier: \n");

10 scanf("%d", &nb2);

11 somme = nb1 + nb2;

12 printf("la somme vaut %d\n", somme);

13 system("pause");

14 return 0;

15 }

Sur la ligne 6, j'ai déclaré les variables que je veux utiliser.

Les lignes 7 et 9 contiennent deux instructions (appels de la fonction printf) d'écriture à l'écran,

comme précédemment.

Intro_C

7
À la ligne 8 (de même qu'en 10), on voit apparaître une nouvelle fonction,

scanf , chargée de
capter ce que l'utilisateur tape au clavier. Cette fonction utilise deux arguments. Le premier est

une chaine de caractères qui décrit la nature de l'information à saisir, ici un entier (le symbole

%d ).
Le deuxième est le nom de la variable qui doit recueillir l'information, l'un des identificateurs

nb1
ou

nb2 , précédé du symbole magique & (la raison de cette construction deviendra claire plus tard).
Cette complication est une source assez fréquente d'erreurs chez les débutants en C.

2.2.7 la version Pascal

Terminons ce paragraphe en citant un programme équivalent en Pascal.

1 {Deuxième programme}

2

3 PROGRAM addition;

4 VAR nb1, nb2, somme: integer;

5 BEGIN

6 WRITE('donnez le premier entier: '); READLN(nb1);

7 WRITE('donnez le deuxième entier: '); READLN(nb2);

8 somme := nb1 + nb2;

9 WRITELN('voici leur somme':, somme);

10 END;

On remarque une nouvelle différence entre les deux langages : le « = » du C (affectation) est

l'équivalent du « := » du Pascal. Je profite de l'occasion pour vous faire remarquer la différence

fondamentale qui existe entre affectation et égalité. La phrase «si x = 3 alors . . .» effectue une

comparaison entre x et 3, sans modifier la valeur de x ; par contre, «posons x = 3» modifie bien cette

variable : elle lui affecte la valeur 3. Tous les langages de programmation modernes différencient

ces deux significations du signe «égal».

2.3 Arithmétique en C

Le programme précédent vous a permis de voir comment on additionnait deux entiers. En fait,

chaque opération arithmétique a son équivalent en C++ : on combine deux variables au moyen

d'un « opérateur», comme indiqué dans le tableau suivant.

Opération Opérateur Expression instruction C

arithmétique

Addition + a + x a + x

Soustraction - a - b a - b

Multiplication * bx b*x

Division / a/b a/b

reste modulo % r mod s r%s

2.3.1 priorités

Pour que le résultat d'une opération arithmétique comportant plusieurs « opérandes» soit bien

défini, il faut établir des règles de priorité ; pour le C++, comme pour la plupart des langages

de programmation, l'ordre de priorité décroissante est : parenthèses, multiplication ou division,

addition ou soustraction. Une expression faisant intervenir des opérateurs de même priorité est

Intro_C

8
évaluée de gauche à droite. Les quelques exemples qui suivent montrent que l'arithmétique en

C++ est en fait très simple.

2 + 3

¡ 4 = 1 ; 6 = 2 ? 3 = 9 ; 6 ? 2 = 3 = 4 ; 3 ¡ 2 ? 2 = ¡ 1 ; 1 + 9 = 3 ¡ 2 = 2
2

? (4 ¡ 1) = 6 = (1 + 2 + 3 + 4 + 5 + 6) = 3 ¡ 1
Évaluons un trinôme du second degré,

y = ax 2 + bx + c , avec a = 2 , b = 3 , c = 7 et
x

= 5 . Comme la fonction puissance n'est pas encore définie, l'instruction correspondante s'écrira
y = a*x*x + b*x +c

. Le diagramme montre l'ordre de opérations successives, indiquées par des
numéros entre parenthèses.

y = 2 * 5 * 5 + 3 * 5 + 7

(6) (1) (2) (4) (3) (5)

En d'autres termes, l'expression de

y prend les formes successives suivantes :
y

= 10 ? 5 + 3 ? 5 + 7 = 50 + 3 ? 5 + 7 = 50 + 15 + 7 = 65 + 7 = 72 :
L'affectation d'une valeur à

y est la dernière opération effectuée.
2.4 Prendre des décisions : les opérateurs de relation

On peut comparer deux variables à l'aide d'un «opérateur de relation», comme dans l'expression

suivante :

x < y . Cette expression ne peut prendre que deux valeurs, vrai (si y est effectivement
plus grand que

x ) ou faux (autres cas). On parle souvent «d'expression logique» pour désigner
ce type de construction. Le C++ reconnait 6 opérateurs de relation, rassemblés dans le tableau

ci-dessous.

Expression algébrique Expression en C signification

=

x == y x égal à y
6

= x ! = y x différent de y
< x < y x

plus petit que y
> x > y x

plus grand que y
·

x < = y x plus petit que ou égal à y
?

x > = y x plus grand que ou égal à y
Je le répète : tous les langages modernes représentent de manière différente l'affectation (= en

C++, := en Pascal) et la comparaison, == en C++, = en Pascal.

2.4.1 petit exemple

La façon la plus courante d'utiliser une expression logique construite autour d'un opérateur de

relation consiste à employer le mot réservé « if » (si) dans des instructions traduisant des phrases

comme « si

a est plus grand que b , alors...», comme dans l'exemple rudimentaire qui suit.
1

//compar . cpp : l e c t u r e e t comparaison de deux e n t i e r s
2

#include <ios t ream>
3

#include <c s t d l i b >
4

using namespace s td ;
5

int main ( void ){
6

int nb1 , nb2 ;
7 cout << "donner moi deux e n t i e r s e t j e vous d i r a i \n" ;

8 cout << " q u e l l e r e l a t i o n e x i s t e ent r e eux : " << endl ;

9 c in >> nb1 >> nb2 ;

Intro_C

9
10

i f ( nb1 == nb2 ) cout << nb1 << " e s t é g a l à " << nb2 << endl ;
11

i f ( nb1 != nb2 )
12 cout << nb1 << " n ' e s t pas é g a l à " << nb2 << endl ;

13

i f ( nb1 < nb2 )
14 cout << nb1 << " e s t plus p e t i t que " << nb2 << endl ;

15

i f ( nb1> nb2 ) cout << nb1 << " e s t PLUS GRAND que " << nb2 << endl ;
16

i f ( nb1 <= nb2 )
17 cout << nb1 << " e s t plus p e t i t que ou é g a l à " << nb2 << endl ;

18

i f ( nb1 >= nb2 )
19 cout << nb1 << " e s t plus grand que ou é g a l à " << nb2 << endl ;

20 system( " pause " ) ;

21

return 0 ;
22 }

Le programme comporte (ligne 4) une abbréviation plus puissante que la précédente ; plutôt

que d'écrire

std::cout à chaque instruction d'affichage, ou encore using std::cout et ses analogues
pour chaque opérateur, je préviens une fois pour toute que je veux pouvoir utiliser tous les

identificateurs qui font partie de la bibliothèque standard.

J'ai écrit (ligne 9) une instruction de lecture un peu plus compliquée, qui capte les valeurs

de deux entiers. Les deux valeurs peuvent être séparées par un espace ou un passage à la ligne.

Viennent ensuite 6 instructions, allant chacune d'un

if à un point-virgule dont la signification est
la suivante : si l'affirmation entre parenthèses est vraie, alors on exécute l'affichage correspondant ;

sinon, on passe à l'instruction suivante. J'ai joué avec les blancs et les passages à la ligne pour

rendre le programme lisible et varié ( ?). Les parenthèses qui entourent la condition qui suit chaque

if

sont obligatoires.
2.5 Programmer par vous-même

Nous venons de passer en revue quelques éléments du langage C++; ils sont suffisants pour

écrire des programmes simples. Comment cela se passe-t-il en pratique ? En gros, il y a cinq étapes.

- Concevoir l'algorithme. C'est la partie la plus importante, mais elle est souvent passée sous

silence. Pour gagner du temps dans les cours de programmation, on fournit souvent l'algorithme

en même temps que l'exercice à résoudre. Il est cependant très souhaitable de réfléchir

quelques instants à la méthode que l'on va employer, aux variables que l'on devra utiliser,

avant d'écrire la moindre ligne de programme. Tout informaticien devrait s'inspirer de cette

phrase attribuée à Racine :

«Ma pièce, Phèdre, est terminée, je n'ai plus que les vers à écrire.»

- Rédiger le programme sur papier ou directement dans l'ordinateur, à l'aide d'un traitement

de texte, le sauvegarder sur disque ou disquette.

- Compiler le programme.

- Corriger les erreurs détectées par le compilateur et revenir à l'étape précédente, jusqu'à disparition

des messages d'erreur.

- Exécuter le programme.

- Corriger les erreurs, améliorer le programme.

Les étapes 2, 3, et 4 peuvent s'exécuter commodément à l'aide d'un «environnement de programmation

intégré» qui permet d'alterner sans heurt rédaction et compilation. Les disques durs

Intro_C

10
des machines mises à votre disposition comportent un ou plusieurs compilateurs C++. par ailleurs,

ces logiciels sont en général gratuits et téléchargeables par tous ceux qui ont la patience nécessaire.

Ainsi, si vous travaillez sous Windows, vous pouvez vous procurer :

DJGPP, qui fonctionne sous DOS ou dans une fenêtre DOS sous Windows. Il est accompagné de

l'interface graphique RHIDE, qui est une copie de celle de Turbo-Pascal (http : http://www.delorie.com

/djgpp/).

DevC++, qui fonctionne sous Windows et permet d'accéder à l'API Windows (http : //

www.bloodshed.net/)

On peut trouver, sur le site de Borland, des versions gratuites, plus ou moins simplifiées, de

Turbo-C++.

Les personnes qui travaillent sous Linux bénéficient des logiciels gratuits que l'on trouve naturellement

pour ce système d'exploitation, en particulier le compilateur g++ et le traitement de

texte emacs.

Il existe par ailleurs un très grand nombre de sites consacrés à l'enseignement du C ou du C++;

vous trouverez ici : http ://www.developpez.com/c/ un bon point de départ.

Enfin, la plupart des questions que l'on peut se poser sur le langage C++ trouvent leur réponse

dans la Foire Aaux Questions (FAQ) : http ://www.research.att.com/ austern/csc/faq.html

Dernière remarque : les fichiers de programme rédigés en C doivent comporter le suffixe

.c , alors
que ceux qui sont écrits en C++ doivent s'appeler

nnnn.cpp pour ne pas troubler le compilateur.
Chapitre 3

Ça se complique : les structures de

programmation

Les instructions d'un programme sont exécutées l'une après l'autre, dans l'ordre où elles sont

écrites. Cette « exécution séquentielle» n'est pas toujours souhaitable. Ainsi, le dernier programme

du chapitre précédent comportait des ordres d'impression qui n'étaient exécutés que lorsque certaines

conditions étaient remplies. Dans la pratique, on rencontre souvent des enchaînements plus

compliqués. Il arrive aussi que l'on souhaite répéter certaines instructions un grand nombre de

fois ; il serait pénible d'avoir à écrire un nombre égal de lignes de programme. Les «structures

de programmation» présentées dans ce paragraphe permettent justement de choisir avec précision

l'enchaînement et/ou la répétition des instructions d'un programme.

3.1 Choix

3.1.1 deux cas seulement

Je commence par compléter ce qui a été dit au paragraphe précédent concernant la construction

« si. . .alors. . .». Je trouve commode de mettre en évidence la logique du programme en rédigeant

d'abord une ébauche en «pseudo-code». À titre d'exemple, j'envisage d'imprimer des résultats

d'examen ; l'une des actions à réaliser se résume en

si note

> = 10, alors imprimer reçu.
L'avantage de cette formulation est qu'elle se traduit immédiatement en C++ :

if (note >= 10)

cout << "Reçu\n";

Certains préfèrent une représentation graphique (organigramme), avec des flèches représentant les

cas vrai ou faux ; ces représentations sont équivalentes, mais le pseudo-code se généralise plus

facilement à un algorithme complexe.

Prenons maintenant en compte le cas des candidats ajournés, au moyen de la structure

si note

> = 10, alors imprimer reçu, sinon imprimer ajourné.
La version C++ s'écrit

if (note >= 10)

cout << "Reçu\n";

else

cout "Ajourné\n";

11

Intro_C

12
Il n'y a qu'une différence avec Pascal : dans ce langage, chaque

if doit être associé à un then
3.1.2 l'opérateur ternaire « ? »

On dispose de plus en C/C++ d'un «opérateur conditionnel» à

trois opérandes , qui permet de
résumer le code précédent en une ligne, comme ceci :

note >= 10 ? cout << "Reçu" : cout << "Ajourné";

Si la condition est vraie, on exécute la première instruction, si elle est fausse, la deuxième. Remarquez

les deux points qui servent à séparer les deux instructions possibles. On peut parvenir au

même résultat d'une autre façon, plus obscure :

cout << ( note >= 10 ? "Reçu" : "Ajourné");

La parenthèse contient une expression logique (la condition

note >= 10 ), l'opérateur « ? » et deux
chaînes de caractères. Si la condition est vraie, l'ensemble prend une valeur égale au deuxième

argument (ici la chaîne

Reçu ) ; dans le cas contraire, l'ensemble prend la valeur du troisième
argument (la chaîne

Ajourné ). Dans l'un ou l'autre cas, le résultat du ? est injecté dans le flot
de sortie.

3.1.3 beaucoup de cas

Pour tenir compte de l'existence de mentions, je suis amené à compliquer le schéma précédent.

Je pars de l'ébauche

si note

> = 16, imprimer TB
sinon

si note

> = 14 imprimer B
sinon

si note

> = 12 imprimer AB
sinon

si note

> = 10 imprimer P
sinon imprimer Ajourné

dont la traduction en C++ peut s'écrire de plusieurs façons, comme par exemple

if (note >= 16)

cout << "TB\n";

else

if (note >= 14)

cout << "B\n";

else

if (note >= 12)

cout << "AB\n";

else

if (note >= 10)

cout << "P\n";

else

cout << "Ajourné\n";

if (note >= 16)

cout << "TB\n";

else if (note >= 14)

cout << "B\n";

else if (note >= 12)

cout << "AB\n";

else if (note >= 10)

cout << "P\n";

else

cout << "Ajourné\n";

La forme de droite est sans doute préférable car tout aussi compréhensible mais moins encombrante.

Dans la vie courante comme en programmation, un « si » peut très bien commander plusieurs

actions. Pour réaliser cela en C++, je dois créer une « instruction composée » (ou un «bloc»

d'instructions), formée de plusieurs instructions simples entourées d'accolades, comme ceci :

Intro_C

13
if (note >= 10)

cout << "Reçu\n");

else {

cout << "Ajourné" << endl;

cout << "Prenez rendez-vous avec votre enseignant" << endl;

}

Toutes les instructions entre { et } sont solidaires et seront exécutées en bloc (de même qu'en

Pascal, tout ce qui se trouve entre BEGIN et END).

3.2 Répétitions

3.2.1 tant que

J'aborde maintenant un premier exemple de répétition programmée. Je vais utiliser une construction

analogue au pseudo-code suivant

tant qu'on ne l'a pas fait dix fois

répéter l'action demandée

En C++ (et en anglais), « tant que » se dit « while ». Je me propose de lire au clavier 10

entiers et d'en calculer la somme. C'est le rôle du programme

while1.cpp .
1

// whi l e1 . cpp : r é p é t i t i o n s impl e
2

#include <ios t ream>
3

#include <c s t d l i b >
4

using namespace s td ;
5

int main ( void ){
6

int compteur , nombre , somme ;
7

/ ? i n i t i a l i s a t i o n ? /
8 somme = 0 ; compteur = 1 ;

9

/ ? r é p é t i t i o n ? /
10

while ( compteur <= 10) {
11 cout << " ent r e z un nombre : " ;

12 c in >> nombre ;

13 somme = somme + nombre ;

14 compteur = compteur + 1 ;

15 }

16

/ ? c onc lus i on ? /
17 cout << " l a somme des dix nombres e s t : " << somme << endl ;

18 system( " pause " ) ;

19

return 0 ;
20 }

Il faut faire attention à la phase d'initialisation. Certains langages mettent systématiquement à

zéro toutes les variables avant d'exécuter la première instruction ; tel n'est pas le cas du C++. Sans

initialisation, le programme peut commencer avec une valeur de

compteur égale à ce qui traîne
dans la mémoire à cet emplacement : note de musique, morceau de texte. . .et ne jamais s'exécuter

ou ne jamais s'arrêter.

Il arrive souvent que je ne sache pas combien de fois il faut répéter une action ; c'est le cas pour

une liste de courses : je m'arrêterai de dépenser lorsque la liste sera épuisée, soit de façon plus

formelle

tant qu'il reste des objets sur ma liste

chercher et acheter l'objet suivant

Intro_C

14
rayer son nom sur la liste.

L'ordinateur ne sait pas (pas encore) interrompre la répétition quand il arrive au bout d'une

liste. Il revient au même de lui demander d'arrêter lorsqu'apparaît une valeur «anormale» dans

la liste ; on dit que la liste se termine par un «drapeau» ou une «sentinelle». Je me propose de

calculer la taille moyenne des élèves d'une classe ; il est commode de terminer la saisie des données

en fournissant une valeur négative ou nulle, comme dans

while2.cpp .
1

// whi l e2 . cpp : c a l c u l e l a moyenne de p l u s i e u r s nombres
2

#include <ios t ream>
3

#include <c s t d l i b >
4

using namespace s td ;
5

int main ( void ) {
6

int compteur ;
7

f loat t a i l l e , moyenne , somme ;
8

/ ? i n i t i a l i s a t i o n ? /
9 somme = 0 ; compteur = 0 ;

10

/ ? t r a i t ement ? /
11 cout << " ent r e z une t a i l l e (m, <= 0 pour f i n i r ) : " ;

12 c in >> t a i l l e ;

13

while ( t a i l l e > 0) {
14 somme = somme + t a i l l e ;

15 compteur = compteur + 1 ;

16 cout << " ent r e z une t a i l l e (m, <= 0 pour f i n i r ) : " ;

17 c in >> t a i l l e ;

18 }

19

/ ? c onc lus i on ? /
20 moyenne = somme/ compteur ;

21 cout << " l a t a i l l e moyenne e s t : " << moyenne << endl ;

22 system( " pause " ) ;

23 }

Il y a plusieurs nouveautés dans ce programme. Sur la ligne 7, j'ai déclaré trois variables qui

représentent des nombres fractionnaires (on dit parfois à virgule flottante, SINGLE en Pascal), ce

qui est assez normal pour des tailles exprimées en mètres. Vous remarquerez que l'initialisation

est différente de celle de l'exemple précédent (compteur = 0). D'autre part, pour que la condition

d'arrêt (taille

< = 0 ) ait un sens, il faut que taille soit connue, ce qui m'impose de le lire une fois
AVANT la boucle, puis une fois à chaque tour de boucle.

3.2.2 opérateurs composés

Les auteurs du C/C++ et bien des amateurs de ces langages aiment les instructions concises ;

c'est peut-être pourquoi la ligne 15 peut aussi s'écrire

compteur += 1;

Plus généralement, toute modification d'une variable de la forme

variable = variable opérateur expression

peut aussi s'écrire

variable opérateur= expression

où opérateur est l'un des «opérateurs arithmétiques» définis au §2. Attention à ne pas introduire

de blanc entre opérateur et =. On peut compacter la ligne 14 de la même façon.

Intro_C

15
3.2.3 Opérateurs d'incrémentation/décrémentation

Lorsque l'on manipule un compteur (ou un indice), on est souvent amené à augmenter cette

variable d'une unité ; le langage C++ propose une instruction compacte et assez commode pour

ce faire. En fait, les trois instructions ci-dessous sont équivalentes :

i = i+1 ; i += 1 ; i++ ;

Les choses se compliquent un peu lorsque la structure

i++ est incluse dans une expression. La
variable

i i est utilisée puis incrémentée. On emploie souvent le terme de post-incrémentation pour
désigner ce comportement. Il est aussi possible d'augmenter

i de un avant de l'utiliser, au moyen
d'un opérateur de pré-incrémentation,

++i; Vous ne serez pas surpris d'apprendre qu'il existe
aussi des opérateurs de pré- ou post-décrémentation, qui diminuent de un la variable à laquelle ils

s'appliquent, comme dans l'instruction

indice--;
Ces opérateurs sont rarement utilisés seuls, mais ils apparaissent très souvent dans l'écriture des

répétitions, comme expliqué plus loin. En attendant, je vous propose d'observer le fonctionnement

du programme

incr.cpp , qui met en oeuvre plusieurs opérateurs d'incrémentation.
1

/ ? inc r . cpp : pre ¡ e t pos t ¡ inc r ementat ion ? /
2

#include <ios t ream>
3

#include <c s t d l i b >
4

using namespace s td ;
5

int main ( void ){
6

int i ;
7 i = 5 ;

8 cout << i << endl ;

9 cout << i++ << endl ;

10 cout << i << endl << endl ;

11 i = 5 ;

12 cout << i << endl ;

13 cout << ++i << endl ;

14 cout << i << endl ;

15 system( " pause " ) ;

16

return 0 ;
17 }

3.2.4 Encore une répétition : la boucle «for»

Examinons d'abord une répétition utilisant un «while». Je me propose d'imprimer, au moyen

d'un programme en C++, les 12 premiers nombres entiers, leur carré et leur cube. Le programme

ci-dessous convient.

1

// whi l e3 . cpp b ouc l e " wh i l e "
2

#include <ios t ream>
3

#include <c s t d l i b >
4

using namespace s td ;
5

int main ( void ) {
6

int compteur = 1 ;
7

while ( compteur <= 12) {
8 cout << compteur << ' \ t ' << compteur

? compteur << ' \ t '
9 << compteur

? compteur ? compteur << ' \n ' ;
10 compteur += 1 ;

11 }

12 system( " pause " ) ;

13

return 0 ;
Intro_C

16
14 }

J'ai utilisé (ligne 6) un nouveau raccourci ; la variable

compteur y est simultanément définie et
initialisée. De plus, j'ai introduit plusieurs caractères de tabulation,

\t ; il s'agit bien d'un seul
caractère, que l'on peut mettre entre apostrophes.

Une instruction «for » peut être considérée à peu près comme un condensé des lignes 6 à 11 du

programme précédent.

1

// f o r 1 . cpp : b ouc l e " f o r " e l ement a i r e
2

#include <ios t ream>
3

#include <c s t d l i b >
4

using namespace s td ;
5

int main ( void ){
6

int compteur ;
7

for ( compteur = 1 ; compteur <= 1 2 ; compteur++)
8 cout << compteur << ' \ t ' << compteur

? compteur << ' \ t '
9 << compteur

? compteur ? compteur << ' \n ' ;
10 system( " pause " ) ;

11

return 0 ;
12 }

La variable

compteur est déclarée ligne 6 et initialisée ligne 7. Malgré les apparences de la mise en
page, l'opérateur

for ne gouverne qu'une seule instruction, qui commence par cout et se répend
sur deux lignes. Pour répéter un bloc d'instructions, il faut les placer entre accolades.

3.2.5 équivalence «while»-«for»

La structure générale d'une instruction comme celle de la ligne 7 est

for (initialisation ; condition pour continuer ; in- ou dé-crémentation)

instruction ou bloc d'instructions

Plus généralement, on peut écrire

for(Expression_1,Expression_2,Expression_3)

instruction

ce qui est pratiquement équivalent à la construction

Expression_1 ; (initialisation)

while{Expression_2}{ (condition d'arrêt)

instruction

Expression_3 ; (incrémentation)

}

3.2.6 jusqu'à

Tous les exemples de répétition que je viens de présenter ont une caractéristique commune :

on vérifie si une condition est vraie avant d'exécuter la (ou les) instructions de la boucle. Si la

condition est fausse dès le début, la boucle n'est jamais parcourue. Il est parfois utile d'effectuer

cette vérification après avoir décrit au moins une fois le corps de boucle. Au lieu de : tant que

Intro_C

17
(condition), répéter, on voudrait : répéter, jusqu'à ce que (condition). Cette distinction existe en

Pascal (while et repeat. . .until) ; elle existe aussi, sous une forme un peu différente, en C++, comme

le montre le code suivant, une transposition du programme

while3.cpp .
1

// jus qua . cpp : b ouc l e r e p e t e r . . . jus qu ' a ce que
2

#include <ios t ream>
3

#include <c s t d l i b >
4

using namespace s td ;
5

int main ( void ) {
6

int compteur = 1 ;
7

do {
8 cout << compteur << ' \ t ' << compteur

? compteur << ' \ t '
9 << compteur

? compteur ? compteur << endl ;
10 compteur += 1 ;

11 }

12

while ( compteur <= 1 2 ) ;
13 system( " pause " ) ;

14

return 0 ;
15 }

3.3 Choix entre plusieurs possibilités : switch

Il peut m'arriver d'avoir à choisir entre plusieurs possibilités d'égale importance. Dans ce cas,

plutôt que d'avoir recours à une enfilade de

if . . . else ,je peux utiliser la structure switch , comme
le montre l'exemple un peu artificiel

switch.cpp . Il s'agit cependant d'un programme nettement
plus compliqué que les précédents et il n'est pas nécessaire d'assimiler dès maintenant tous les détails.

L'utilisateur va taper au clavier un certain nombre de voyelles et le programme lui répondra

combien il y avait de a, de e,. . .

1

// swi t ch1 . cpp : s t r u c t u r e swi t c h pour compter des v o y e l l e s
2

#include <ios t r eam . h>
3

#include <c s t d l i b >
4

using namespace s td ;
5

int main ( void ){
6

int nba = 0 , nbe = 0 , nbi = 0 , nbo = 0 ,
7 nbu = 0 , nby = 0 ;

8

int voyl ;
9 cout << " tape z des v o y e l l e s , en minuscule \n" ;

10 cout << " c a r a c t è r e f i n de f i c h i e r pour a r r ê t e r \n" ;

11

while ( ( voyl = c in . ge t ( ) ) != EOF){
12

switch ( voyl ) {
13

case ' a ' : ++nba ;
14

break ;
15

case ' e ' : ++nbe ;
16

break ;
17

case ' i ' : ++nbi ;
18

break ;
19

case ' o ' : ++nbo ;
20

break ;
21

case 'u ' : ++nbu ;
22

break ;
23

case ' y ' : ++nby ;
24

break ;
Intro_C

18
25

default :
26 cout << " ce n ' e s t pas une v o y e l l e \n" ;

27 cout << " tapez une v o y e l l e s . v . p . \ n" ;

28

break ;
29 }

30 }

31 cout << "nombre de a : " << nba << " nombre de e : " << nbe << endl ;

32 cout << "nombre de i : " << nbi << " nombre de o : " << nbo << endl ;

33 cout << "nombre de u : " << nbu << " nombre de y : " << nby << endl ;

34 system( " pause " ) ;

35

return 0 ;
36 }

Les variables entières

nba , nbe ,. . .sont des compteurs de voyelles. Surprise, le programme lit
des voyelles entreposées dans

voyl , qui est un entier. Ceci est correct et souvent plus commode
que la déclaration rigoureuse

char voyl; . En effet, les caractères sont codés dans la machine sous
forme d'un entier et peuvent être considérées comme des entiers sans signe.

Je trouve ensuite une boucle

while qui lit une série de lettres et s'arrète quand je frappe
une «marque de fin de fichier ».

EOF est la désignation conventionnelle de cette marque, qui est
différente pour chaque système d'exploitation (Apple, Microsoft, Linux) mais la bonne définition

se trouve dans les entêtes

<stdio.h> ou <iostream> . Chez Microsoft, c'est <control>-z .
La logique qui commande la boucle est concentrée dans l'instruction bizarre de la ligne 10

(bizarre mais caractéristique du C++). La fonction

cin.get() lit un caractère au clavier. L'affectation
attribue à

voyl cette même valeur. Enfin, en C++, une affectation a elle-même une valeur,
justement celle que vient de recevoir l'identificateur de gauche (

voyl ici). On peut donc comparer
cette valeur à

EOF et continuer si elle est différente. Ouf. En français, on aurait dit « si le prochain
caractère lu n'est pas

EOF , alors. . .». Enfin, l'écriture bizarre cin.get de la fonction sera expliquée
vers la fin du cours.

On entre ensuite dans la structure

switch . La variable qui régit le fonctionnement de switch
est citée entre parenthèses. On énumère ensuite chaque cas à l'aide du mot clé

case , puis on
énonce les instructions correspondantes. Il est ici inutile de mettre des accolades pour constituer

un groupe solidaire : tout ce qui se trouve entre deux

case est exécuté.
L'instruction

break provoque un saut à la première ligne qui suit la structure switch. Si
break

ne figure pas, toutes les instructions de la structure sont exécutées.
Le dernier cas (

default ) est un fourre-tout qui récupère tout ce qui n'est pas une voyelle. On
voit que cette structure est semblable au CASE OF de Pascal, à part

break et default .
3.4 Opérateurs logiques

Jusqu'ici, je n'ai présenté que des prises de décision reposant sur des conditions simples. Mais

il est tout à fait possible de construire des expressions logiques composées ou complexes, à l'aide

d'opérateurs logiques, comme dans « si le coefficient de

x 2 est non nul ET si le déterminant est
positif, alors. . .» La traduction en C++ fait appel à l'un des opérateurs rassemblés dans le tableau

suivant.

Expression logique Expression en C++

négation !

et &&

ou

jj
Le premier opérateur n'attend qu'un seul argument (opérateur « unaire»), qui doit être vrai ou

faux ; il produit la valeur opposée. Les deux autres doivent recevoir deux arguments logiques (opérateurs

«binaires»), comme par exemple

Intro_C

19
if (note_moyenne >= 10 || note_examen >= 10)

cout << reçu\n";

Remarquez que la condition globale sera vraie si l'une ou l'autre ou les deux conditions partielles

sont vraies (ou non-exclusif).
Revenir en haut Aller en bas
Voir le profil de l'utilisateur http://allah-ahad.blogspot.com/
 
Introduction au langage C/C++ (1)
Voir le sujet précédent Voir le sujet suivant Revenir en haut 
Page 1 sur 1
 Sujets similaires
-
» NOUVELLE INTRODUCTION : FIPAR OU LES PREMICES D'UN AUTRE ECHEC ?
» La stratégie du choc, interview de Naomi KLEIN
» Numéro de TVA intracommunautaire
» refus de vente et condition pourl appliquer.. a lire
» quel système de fidélité?

Permission de ce forum:Vous ne pouvez pas répondre aux sujets dans ce forum
E N C G - Casablanca :: Espace Scientifique :: Technologie, Informatique & Internet-
Sauter vers: