le langage c++ initiez-vous la programmation en c%2b%2b

8/13/2019 Le Langage C++ Initiez-Vous La Programmation en C%2B%2B

1/870

Jesse Liberty

et Bradley Jones

Initiez-vous

la programmation

en C++

C++Le langage


2/870

Jesse Liberty et Bradley Jones

Le langage C++

L E P R O G R A M M E U R


3/870

Pearson Education France a apport le plus grand soin la ralisation de ce livre afin de vous four-

nir une information complte et fiable. Cependant, Pearson Education France nassume de respon-

sabilits, ni pour son utilisation, ni pour les contrefaons de brevets ou atteintes aux droits de tierces

personnes qui pourraient rsulter de cette utilisation.

Les exemples ou les programmes prsents dans cet ouvrage sont fournis pour illustrer les descriptionsthoriques. Ils ne sont en aucun cas destins une utilisation commerciale ou professionnelle.

Pearson Education France ne pourra en aucun cas tre tenu pour responsable des prjudices

ou dommages de quelque nature que ce soit pouvant rsulter de lutilisation de ces exemples ou

programmes.

Tous les noms de produits ou marques cits dans ce livre sont des marques dposes par leurs

propritaires respectifs.

Aucune reprsentation ou reproduction, mme partielle, autre que celles prvues larticle L. 122-5 2 et 3 a) du code de la

proprit intellectuelle ne peut tre faite sans lautorisation expresse de Pearson Education France ou, le cas chant, sans le

respect des modalits prvues larticle L. 122-10 dudit code.

No part of this book shall be reproduced, stored in a retrieval system, or transmitted by any means, electronic, mechanical,

photocopying, recording, or otherwise, without written permission from the publisher.

Publi par Pearson Education France

47 bis, rue des Vinaigriers

75010 PARIS

Tl. : 01 72 74 90 00

www.pearson.fr

Mise en pages : TyPAO

Tous droits rservs

Titre original : Teach Yourself C++ in 21 Days,

fifth edition

Traduit de lamricain par Nathalie Le Guillou de Penanros

Nouvelle dition franaise revue, corrige

et complte par Eric Jacoboni

ISBN original : 0-672-32711-2

Copyright 2004 Sams Publishing

All rights reserved

ISBN : 978-2-7440-4023-8

Copyright 2009 Pearson Education France


4/870


5/870


6/870

Table des matires

Introduction............................................ 1

Public vis ........................................... 1

Conventions typographiques .............. 2

Partie I .................................................... 3

1. Bien dbuter en C++. ......................... 5

Introduction ........................................ 5

Un peu dhistoire... ............................. 5

La programmation oriente objet (POO) 9volution de C++ ............................... 11

Est-il ncessaire dapprendre dabordle langage C ? .................................... 11

C++, Java et C# .................................. 11

Norme ANSI ...................................... 12

Prparation la programmation ......... 13

Votre environnement de dveloppement 13

Cration du programme ...................... 14

Cycle de dveloppement ..................... 15

Votre premier programme C++ :BONJOUR.cpp ................................... 16

Comment tirer parti de votre compilateur 19

Erreurs de compilation ........................ 20

Questions-rponses ............................. 21

Testez vos connaissances .................... 22

Exercices ............................................ 22

2. Anatomie dun programme C++ ...... 23

Un programme simple ........................ 24

tude rapide de lobjet cout ............... 26

Utilisation de lespace de nom standard 28

Commentaires ..................................... 30

Les fonctions ..................................... 33


Testez vos connaissances .................... 37Exercices ............................................ 37

3. Variables et constantes ....... ....... ........ 39

Quest-ce quune variable ? ............... 39

Dfinition dune variable .................... 44

Cration de plusieurs variables la fois 48

Affectation de valeurs aux variables .. 48

Cration dalias avec typedef ............. 50

shortou long: que choisir ? ............... 51

Variables caractre .............................. 54

Constantes .......................................... 57

Constantes numres ........................ 59



Exercices ............................................ 64


7/870

VI Le langage C++

4. Expressions et instructions ............... 65

Instructions ......................................... 66

Expressions ........................................ 67

Oprateurs .......................................... 69

Combinaison doprateurs daffectationet doprateurs mathmatiques .......... 72

Incrmentation et dcrmentation ...... 72

Priorit des oprateurs ....................... 75

Parenthses imbriques ..................... 76

Vrai ou faux ....................................... 77

Linstruction if.................................... 78

Utilisation daccoladesdans les instructions ifimbriques ..... 86

Oprateurs logiques ........................... 89

valuation en court-circuit ................. 90

Priorit des oprateurs relationnels .... 90

Vrai ou faux ....................................... 91

Oprateur conditionnel (ternaire) ....... 92

Questions-rponses ............................ 93

Testez vos connaissances ................... 94

Exercices ............................................ 95

5. Fonctions ............................................ 97

Quest-ce quune fonction ? ............... 98

Valeurs renvoyes, paramtres formelset effectifs ........................................... 99

Dclaration et dfinition de fonctions 99

Excution des fonctions ..................... 103

Porte des variables ............................ 104

Instructions des fonctions .................. 111

Retour sur les paramtres des fonctions 111

Retour sur les valeurs renvoyes ....... 112

Paramtres par dfaut ......................... 115

Surcharge de fonctions ....................... 117

Pour en savoir plus sur les fonctions .. 121

Principe des fonctions ........................ 128



Exercices ............................................ 133

6. Programmation oriente objet ......... 135

C++ est-il orient objet ? ................... 135

Cration de nouveaux types ................ 137

Prsentation des classes et des membres 138

Accs aux membres dune classe ....... 141

Accs priv et accs public ................ 142

Implmentations des mthodesde la classe .......................................... 148

Ajout de constructeurs et de destructeurs 151

Inclure des fonctions membres const.. 156

Interface et implmentation ................ 156

O placer les dclarations de classeset les dfinitions de mthodes ? .......... 159

Implmentation en ligne ..................... 161

Classes imbriques ............................. 163

Les structures ...................................... 168



Exercices ............................................. 171

7. Droulement dun programme ......... 173

Les boucles ......................................... 173

Les boucles while ............................... 175

Les boucles do...while ........................ 183

Linstructiondo...while ....................... 184

Les bouclesfor ................................... 186

Rsum des boucles ............................ 195

Contrler le flux avec des instructionsswitch .................................................. 198

Utilisation de switchdans un menu ... 201



Exercices ............................................. 206

Partie II................................................... 207

8. Pointeurs ............................................. 209

Quest-ce quun pointeur ? ................. 210

Utilit des pointeurs ............................ 220La pile et lespace mmoire adressable(tas) ..................................................... 220

En savoir plus sur les fuites mmoire . 225

Cration dobjets sur le tas ................. 226

Suppression dobjets du tas ................ 226


8/870

Table des matires VII

Accs aux donnes membres .............. 228

Cration de donnes membres dans le tas 229

Le pointeur this ................................... 232

Pointeurs perdus, incontrlablesou pointeurs fous ................................ 233

Pointeurs const.................................... 237



Exercices ............................................. 241

9. Rfrences.......................................... 243

Quest-ce quune rfrence ? .............. 244

Utilisation de loprateur adresse de(&)sur des rfrences ................................ 245

Rfrencement des objets ................... 248

Pointeurs nuls et rfrences nulles ..... 250Passage de paramtres par rfrence .. 251

En-ttes et prototypes de fonctions ..... 256

Renvoi de plusieurs valeurs ............... 257

Efficacit du passage de paramtrespar rfrence ....................................... 260

Choisir entre rfrences et pointeurs .. 269

Mlanger les rfrences et les pointeursdans une liste de paramtres ............... 269

Renvoi de rfrences dobjet horsde porte ............................................. 271

Renvoi dune rfrence un objetdans le tas ............................................ 272

O le pointeur est-il pass ? ................ 275



Exercices ............................................. 276

10. Fonctions avances........................... 279

Fonctions membres surcharges ......... 279

Utilisation de valeurs par dfaut ......... 282

Choisir entre des valeurs par dfautet des fonctions surcharges ............... 284

Le constructeur par dfaut .................. 285

Surcharge des constructeurs ............... 285

Initialisation des objets ....................... 287

Le constructeur de copie ..................... 288

Surcharge des oprateurs .................... 293

Conversion de type (transtypage) ....... 312



Exercices ............................................ 31911. Analyse et conception oriente objet 321

Les modles ........................................ 322

Conception : le langage de modlisation 322

Conception : le processus .................. 324

tape 1 La conceptualisation :commencer par la vision .................... 327

tape 2 Lanalyse : collecter les besoins 327

tape 3 La conception .................... 341

tapes 4 6 Implmentation, tests

et dploiement .................................... 355Itrations ............................................. 355



Exercices ............................................ 356

12. Hritage ............................................ 357

Quest-ce que lhritage ? .................. 357

Priv ou protg ? ............................... 362

Lhritage avec les constructeurset les destructeurs ............................... 365

Redfinition des mthodesde la classe de base ............................. 372

Mthodes virtuelles ............................ 378



Exercices ............................................ 393

13. Tableaux et chanes.......................... 395

Quest-ce quun tableau ? ................... 395

Accs aux lments de tableau ........... 396

criture dlments hors limite .......... 398

Erreurs dintervalle ............................ 401

Initialisation des tableaux ................... 402

Dclaration de tableaux ...................... 402

Tableaux dobjets ............................... 404

Tableaux multidimensionnels ............ 406


9/870

VIII Le langage C++

Initialisation de tableaux plusieursdimensions ........................................ 407

Construire des tableaux de pointeurs . 409

Larithmtique des pointeurs,un sujet complexe ............................... 411

Dclaration de tableaux sur le tas ...... 414

Pointeurs sur tableau et tableauxde pointeurs ........................................ 415

Pointeurs et noms de tableaux ........... 415

Suppression des tableaux stocks

sur le tas ............................................. 417

Redimensionner les tableaux en coursdexcution ......................................... 418

Tableaux de caractres et chanes ..... 421

Les fonctions strcpy()et strncpy() ..... 423La classe String .................................. 425

Listes chanes et autres structures .... 433

Cration de classes tableaux ............. 434



Exercices ............................................ 436

14. Polymorphisme................................ 437

Problmes lis lhritage simple ..... 437

Hritage multiple ............................... 445

Types abstraits de donnes (TAD) ..... 463



Exercices ............................................ 479

Partie III ................................................ 481

15. Classes et fonctions spciales .......... 483

Partage dinformations entre objets demme type : donnes membres statiques 484

Mthodes membres statiques ............. 489

Pointeurs sur des fonctions ................ 492

Pointeurs sur des fonctions membres . 507



Exercices ............................................ 513

16. Concepts avancs dhritage. .......... 515

Agrgation ......................................... 515

Hritage et Dlgation/Agrgation .... 531

Hritage priv ..................................... 541

Classes amies ...................................... 550Fonctions amies .................................. 560

Fonctions amies et surchargedoprateur .......................................... 560

Surcharge de operator


10/870

Table des matires IX



Exercices ............................................. 639

19. Les modles ...................................... 641

Quest-ce quun modle ...................... 641Construire une dfinition de modle ... 643

Passer des objets modles instancisaux fonctions ....................................... 651

Modles et amis .................................. 652

Utilisation des des modles ................ 660

La bibliothque des modles standard 676

Les conteneurs .................................... 676

Les conteneurs squentiels ................. 677

Les conteneurs associatifs .................. 687

Les classes dalgorithmes ................... 692



Exercices ............................................. 697

20. Gestion des erreurs et exceptions ... 699

Erreurs logiques et fautes de syntaxe .. 700

Les coulisses des exceptions ............... 702

Produire ses propres exceptions .......... 706

Crer une classe dexception .............. 708

Placement des blocs tryet catch ......... 712Donnes dans les exceptions et nomsdes objets exceptions .......................... 719

Exceptions et modles ........................ 727

Exceptions et erreurs .......................... 730

Recherche des erreurs ......................... 731



Exercices ............................................. 734

21. Et maintenant ?................................ 737

Le prprocesseur et le compilateur ..... 738

La directive de prprocesseur #define. 738

Inclusions et clauses dinclusion ........ 741

Les macros ......................................... 742

Manipulation des chanes ................... 745

Les macros prdfinies ....................... 747

La macro assert() ............................... 747

Les fonctions inline ............................ 757

Oprations sur les bits ........................ 758

Styles de programmation .................... 765Commentaires ..................................... 768

Comment poursuivrevotre dveloppement C++ .................. 770



Exercices ............................................ 774

A. Mots-cls C++ ................................... 775

B. Priorit des oprateurs ..................... 777

C. Solutions des exercices ..................... 779

Chapitre 1 ........................................... 779

Chapitre 2 ........................................... 780

Chapitre 3 ........................................... 782

Chapitre 4 ........................................... 784

Chapitre 5 ........................................... 784

Chapitre 6 ........................................... 787

Chapitre 7 ........................................... 791

Chapitre 8 ........................................... 793

Chapitre 9 ........................................... 794

Chapitre 10 ......................................... 797Chapitre 11 ........................................ 802

Chapitre 12 ......................................... 804

Chapitre 13 ........................................ 805

Chapitre 14 ........................................ 806

Chapitre 15 ........................................ 808

Chapitre 16 ......................................... 815

Chapitre 17 ......................................... 819

Chapitre 18 ........................................ 822

Chapitre 19 ......................................... 823

Chapitre 20 ......................................... 828Chapitre 21 ......................................... 834

D. tude des listes chanes .................. 837

Les composants dune liste chane ... 838

Index ....................................................... 849


11/870


12/870

Introduction

Ce livre a t conu pour vous initier la programmation en C++. Vous y apprendrez lesprincipaux concepts du langage (gestion des entres-sorties, boucles et tableaux, modles,etc.) et de la programmation oriente objet. Chaque chapitre contient des exemples deprogrammes qui mettent en uvre les concepts tudis et qui sont analyss en dtail.

Tous les chapitres se terminent par un jeu de questions-rponses, un quiz et des exercicesdont vous trouverez les rponses lAnnexe D.

Les listings de code de chacun des chapitres sont disponibles sur le site www.pearson.fr, la page consacre cet ouvrage.

Public visIl nest pas ncessaire davoir une exprience pralable de la programmation pour tirerparti de ce livre car il part de zro et vous apprend la fois le langage et les concepts deprogrammation C++. Les nombreux exemples de syntaxe et les analyses dtailles desextraits de code constituent un excellent guide touristique pour votre voyage dans cet envi-ronnement si riche. Que vous soyez un programmeur dbutant ou expriment, vous pour-rez constater que cet ouvrage vous permettra dapprendre rapidement et simplement le

langage C++.


13/870

2 Le langage C++

Conventions typographiques

Ces paragraphes soulignent des informations qui amlioreront lefficacit de

vos programmes C++.

Ces notes fournissent des prcisions sur le sujet abord.

Ces avertissements vous vitent de tomber dans les piges les plus communsqui peuvent vous gcher lexistence.

Les encadrs

Ils prcisent la syntaxe dune instruction.

Il peut aussi sagir daparts destins attirer votre attention sur un cas particulier ou unesituation exceptionnelle.

Cet ouvrage utilise galement des polices de caractres diffrentes pour distinguer le codeC++ du texte classique :

Les commandes, variables et autres lments de code apparaissent dans le texte dansune police chasse fixespciale.

Les termes nouveaux ou importants sont crits en italique.

Les parties variables dans les descriptions de syntaxe apparaissent enpolice chasse fixe italique. Ce style signale que vous devez remplacer lespace rserv

par le nom rel du fichier, du paramtre ou de tout autre lment quil reprsente.En outre, toutes les lignes de code sont numrotes. Vous constaterez parfois que certaineslignes trop longues pour le format de ce livre ont t dcoupes en plusieurs lignes : en cecas, les lignes de continuation ne seront pas numrotes et vous devrez saisir ces lignescomme une seule ligne dans votre diteur de texte.

Faire Ne pas faire

Un rappel des conseils suivre. Les erreurs ou confusions viter.

Astuce

Info

Attentio

n


14/870

Partie I

Dans les sept chapitres qui constituent cette partie, vous ferez vos premiers pas enprogrammation en gnral et en C++ en particulier. Les Chapitres 1 et 2 abordent lesnotions de base de la programmation et le droulement dune application. Au Chapi-tre 3, vous apprendrez grer des variables et des constantes dans un programme. LeChapitre 4 est consacr aux branchements conditionnels raliss laide dinstruc-tions et dexpressions. Vous vous initierez, au Chapitre 5, lutilisation des fonctions,et celle des classes et des objets au Chapitre 6. Enfin, partir du Chapitre 7, vousserez en mesure de comprendre le droulement dune application et dcrire vos

premiers programmes orients objet.


15/870


16/870

1

Bien dbuter en C++

Au sommaire de ce chapitre

Pourquoi choisir le langage C++ ?

Les tapes du cycle de dveloppement dun programme crire, compiler et lancer votre premier programme C++

IntroductionBienvenue dansLe Langage C++de la collection Le Programmeur ! Cet ouvrage a pourobjectif de vous initier efficacement la programmation en langage C++.

Un peu dhistoire...Les langages de programmation ont considrablement volu depuis les premiers calcula-teurs qui avaient t conus pour les calculs de trajectoires dartillerie durant la secondeguerre mondiale. cette poque, les programmeurs travaillaient avec le langage informa-tique le plus primitif qui soit le langage machine ce qui les obligeait grer de longues


17/870

6 Le langage C++

chanes de 1 et de 0. Puis, les premiers assembleurs apparurent, afin de rendre les instruc-tions machine plus comprhensibles et plus faciles utiliser puisquelles taient dsormaisreprsentes par des instructions mnmoniques comme MOVetADD.

Dans les annes 60 apparurent des langages plus volus comme BASIC et COBOL, qui

permettaient aux programmeurs dutiliser une syntaxe proche de la langue anglaise (lecode source), avec des instructions et des mots comme Let I = 100. Les lignes dinstructionstaient ensuite traduites en langage machine par des interprteurs ou des compilateurs.

Un interprteur traduit et excute une une les instructions du programme (ou codesource) et les transforme directement en actions.

Un compilateurpasse par une tape intermdiaire (la compilation) qui produit dabord unfichier objet. Le compilateur fait ensuite appel un diteur de liens (ou linker) qui trans-forme ce fichier objet en programme excutable.

Les interprteurs lisent les instructions ligne ligne et excutent le code immdiatement,

ce qui en simplifie lutilisation. Aujourdhui, les programmes interprts sont gnralementappels scripts.

Certains langages, comme Visual Basic 6, dsignent linterprteur sous le nom de biblio-thque dexcution. Dautres langages, comme Visual Basic .NET et Java, disposent dun autrecomposant, appel "machine virtuelle" (VM, Virtual Machine) ou excuteur. Bien que la VMsoit aussi un interprteur, il ne sagit plus dun interprteur de code source qui se contentede traduire un langage lisible en code objet : la VM interprte et excute un "langagemachine indpendant de lordinateur" compil, parfois appel "langage intermdiaire".

Les compilateurs ajoutent les tapes supplmentaires de compilation du code source

(comprhensible par lhomme) en code objet (lisible par la machine). Ceci pourrait appa-ratre comme un inconvnient mais, en ralit, cette tape permet de crer un programmedont la vitesse dexcution est optimise puisque la traduction du fichier source en langagemachine a dj t ralis une fois pour toutes, au moment de la compilation. Il nest doncplus ncessaire de retraduire le programme chaque fois quon lexcute.

Lautre avantage des langages compils comme C++ tient la diffusion des programmespuisque lon peut distribuer un fichier excutable des personnes qui ne disposent pas ducompilateur. Avec un langage interprt, par contre, lutilisateur doit ncessairementpossder linterprteur pour pouvoir excuter le programme.

C++ est gnralement un langage compil, mme sil existe quelques interprteurs C++. linstar de nombreux langages compils, il a la rputation de produire des programmesrapides et performants.

En fait, pendant longtemps, la principale proccupation des programmeurs tait de conce-voir des applications trs courtes pouvant sexcuter rapidement, car la mmoire et letemps de calcul cotaient cher. Avec la miniaturisation des ordinateurs, laugmentation de


18/870

Chapitre 1 Bien dbuter en C++ 7

leurs performances et la chute des prix, les priorits ont chang. Dsormais, le cot dedveloppement dpasse largement celui dun ordinateur de type PC ou mini. Limportantest dcrire des programmes performants, bien construits et faciles mettre jour (cest--dire sans surcot excessif).

Le mot programme a deux sens. Il dsigne les instructions (ou code source)crites par un dveloppeur, mais galement lensemble dun logiciel excuta-ble. Cette homonymie peut tre une source de confusion et il est important defaire la distinction entre le fichier source et le programme excutable.

Comment rsoudre les problmesLes problmes auxquels sont confronts les programmeurs sont totalement diffrents deceux quils devaient rsoudre il y a une vingtaine dannes. Dans les annes 80, les

programmes traitaient des volumes importants de donnes brutes. Le programmeur etlutilisateur final taient tous deux des spcialistes de linformatique. De nos jours, lesutilisateurs sont bien plus nombreux et peu connaissent tous les dtails des ordinateurs et dufonctionnement des programmes. Lutilisateur final actuel recherche des solutions prtes lemploi et capables deffectuer des oprations de gestion courantes ou ponctuelles.

Linformatique est devenue plus conviviale, mais ce processus a galement conduit lamise en uvre de programmes de plus en plus complexes. Dans les annes 70, les utilisa-teurs taient contraints de saisir des commandes nigmatiques pour voir dfiler lcrandes volumes impressionnants de donnes brutes. Cette poque est rvolue ! Une applica-tion se compose dsormais de fentres, de menus et de botes de dialogue intgrs une

interface conviviale.Avec le dveloppement du Web, les ordinateurs ont abord une re nouvelle de pntrationdu march ; les utilisateurs dordinateurs sont plus nombreux que jamais, et ils sont trsexigeants.

Au cours des dernires annes, les applications se sont galement tendues dautres pri-phriques : lordinateur de bureau nest plus la seule cible des applications. Les tlphonesportables, les assistants personnels (PDA), les PC de poche et autres priphriques consti-tuent des cibles toutes trouves pour les applications modernes.

Depuis la premire dition de ce livre, les programmeurs ont rpondu aux demandes des

utilisateurs et les programmes sont devenus plus volumineux et plus complexes. La nces-sit de dvelopper des techniques de programmation permettant de grer cette complexitest devenue vidente.

Les besoins changeant, les techniques et les langages voluent galement pour aider lesprogrammeurs grer la complexit des demandes. Dans cet ouvrage, nous nous

Info


19/870

8 Le langage C++

concentrerons uniquement sur une partie essentielle de cette volution : le passage de laprogrammation procdurale la programmation oriente objet.

La programmation procdurale, structure et oriente objet

Il y a quelques annes encore, les programmes taient conus comme des suites de proc-dures destines traiter les donnes. Une procdure galement appelefonction oumthodeest un ensemble dinstructions sexcutant lune aprs lautre. Les donnes etles procdures taient totalement dissocies et le travail du programmeur consistait connatre les fonctions appeles par dautres fonctions et les donnes qui taient modi-fies. Pour faire face ce niveau de complexit, on a donc invent la programmationstructure.

Le principe gnral de la programmation structure consiste diviser pour mieux rgner.Un programme peut alors tre considr comme un ensemble de tches. Toute opration

trop complexe pour tre dcrite simplement est dcompose en un ensemble doprationsplus simples, jusqu nobtenir que des tches suffisamment triviales pour tre aismentcomprhensibles.

Le calcul du salaire moyen de chaque employ dune entreprise est, par exemple, unetche assez complexe. Toutefois, il est possible de diviser le traitement en plusieurs tchessecondaires :

1. Compter le nombre demploys.

2. Dterminer le revenu de chaque employ.

3. Faire le total de tous les salaires.

4. Diviser cette valeur par le nombre demploys.

La troisime tape (total des salaires) peut galement se diviser en tches plus simples :

1. Lire lenregistrement de chaque salari.

2. Extraire le salaire de chaque employ.

3. Ajouter cette valeur au total gnral.

4. Accder lenregistrement suivant.

La lecture de chaque enregistrement peut, de la mme faon, tre dcompose en oprationsplus lmentaires :

1. Ouvrir le fichier des employs.

2. Rechercher le bon enregistrement.

3. Lire les donnes.


20/870


21/870

10 Le langage C++

sans comprendre le principe des compresseurs. Il reste possible de modifier ce fonction-nement interne sans affecter celui du programme, condition toutefois que les spcifica-tions soient respectes (le compresseur du rfrigrateur peut tre remplac par un autre deconception similaire).

Lorsque notre technicien veut utiliser un composant lectronique, il na pas besoin denconnatre les rouages internes. Toutes les proprits de ce composant sont encapsulesdans lobjet composant, elles ne sont pas communiques au circuit mont. Il nest pasncessaire de connatre le fonctionnement du composant pour lutiliser efficacement.Ce fonctionnement est masqu par son botier.

Le langage C++ gre lencapsulation laide de types dfinis par lutilisateur : les classes.Pour en savoir plus sur la conception dune classe, reportez-vous au Chapitre 6. Si elle estcorrectement dfinie, une classe agit comme une entit encapsule elle fonctionnecomme un composant autonome. Comme pour un objet du monde rel, son fonctionne-

ment interne peut tre masqu. Les utilisateurs dune classe bien conue nont pas besoinde savoir comment elle fonctionne, mais uniquement comment lutiliser.

Hritage et rutilisabilit

Lorsquils souhaitent concevoir une nouvelle voiture, les ingnieurs de Superauto ont lechoix entre monter un projet partir de zro et modifier un modle existant. Le modlePipo est peut-tre parfait pour la ville, mais cette voiture manque de nervosit sur auto-route. Les ingnieurs ont donc dcid de lui adjoindre un turbo-compresseur et une bote six vitesses. Le responsable du projet prfre donc partir dun modle existant, le perfec-tionner, le tester, et lappeler Star. La Star sera donc une sorte de Pipo, mais il sagiradune version spciale, disposant de nouvelles fonctionnalits.

Le langage C++ implmente la notion dhritage. Grce lhritage, vous pouvez dclarerun nouveau type partir dun type existant. On dit que la sous-classe obtenue drive dutype existant ; on la nomme quelquefois "type driv". Si la Star est drive de la Pipo ethrite donc de toutes ses qualits, certaines proprits peuvent lui tre ajoutes, dautresmodifies. Pour en savoir plus sur lhritage et son application en C++, reportez-vous auxChapitres 12 et 16.

Polymorphisme

La Star ne rpondra pas ncessairement de la mme faon que la Pipo un appui surlacclrateur. En effet, la premire peut utiliser son injection et son turbo alors que laseconde devra se contenter de sa carburation classique. Quoi quil en soit, il suffit auconducteur de dmarrer son vhicule et de se dplacer o bon lui semble. Il nest pasoblig de connatre les dtails du moteur.


22/870


En C++, des objets diffrents peuvent avoir des comportements adquats diffrents enrponse la mme action grce au polymorphisme de fonction et de classe. Polysignifieplusieurs et morphesignifie forme. Le polymorphisme se traduit donc par un nom uniquepouvant prendre plusieurs formes, et il est trait aux Chapitres 10 et 14.

volution de C++Lorsque les qualits de la programmation, de la conception et de lanalyse orientes objetcommencrent tre reconnues, Bjarne Stroustrup cra C++ partir du langage le plusutilis pour le dveloppement des logiciels professionnels, le langage C. Il lui ajouta tousles lments ncessaires la programmation oriente objet.

On a coutume de dire que C++ est un surensemble de langage C et que, par consquent,tout programme C est virtuellement un programme C++. Pourtant, ces deux langages sont

trs diffrents. Pendant longtemps, C++ a attir les programmeurs C car ces derniers trou-vaient sa syntaxe familire. Toutefois, pour tirer le meilleur profit des fonctionnalits deC++, de nombreux dveloppeurs ont compris quils devaient laisser de ct une partiede leurs acquis en C et aborder les problmes diffremment.

Est-il ncessaire dapprendre dabord le langage C ?Nombreux parmi vous sont ceux qui vont se poser cette question, puisque C++ est unsurensemble du langage C. La rponse de son crateur et de la plupart des program-meurs C++ est la suivante : il est inutile dapprendre le langage C, voire prfrable de

commencer directement par le langage C++.La programmation C est fonde sur les concepts de programmation structure, alors que laprogrammation C++ repose sur ceux de la programmation oriente objet. Si vous apprenezdabord le langage C, vous devrez alors vous dfaire des habitudes nfastes lies celangage.

Ce livre ne sadresse pas obligatoirement un public ayant une exprience pralable de laprogrammation. Si vous tes programmeur C, vous pouvez vous contenter de survoler lespremiers chapitres du livre. Le dveloppement orient objet nest rellement abord qupartir du Chapitre 6.

C++, Java et C#C++ est lun des principaux langages pour le dveloppement de logiciels professionnels.Ces dernires annes, Java a eu un temps la faveur des programmeurs. Toutefois, nombre


23/870

12 Le langage C++

dentre eux, qui avaient abandonn C++ au profit de Java, ont depuis fait marche arrire.En tout tat de cause, les deux langages sont si semblables quapprendre lun revient connatre 90 % de lautre.

C# (prononcezC sharp) est un langage plus rcent dvelopp par Microsoft pour la plate-

forme .NET. Il utilise la mme syntaxe que C++ et, bien que ces deux langages diffrenten quelques points importants, lapprentissage de C++ apporte la majorit des connaissan-ces ncessaires lutilisation de C#. Si vous dcidiez par la suite dapprendre C#, linves-tissement ralis dans lapprentissage de C++ vous sera trs bnfique.

Extensions gres de Microsoft pour C++

Avec larrive de .NET, Microsoft a introduit les extensions gres pour C++ (ManagedC++).Il sagit dune extension du langage C++ lui permettant dutiliser la nouvelle plate-forme Microsoft et ses bibliothques. Managed C++ permet surtout un programmeur

C++ de profiter des fonctionnalits avances de lenvironnement .NET. Au cas o vousdcideriez de crer des applications spcifiquement conues pour la plate-forme .NET,vous devrez tendre votre connaissance du C++ standard pour y inclure ces extensions.

Norme ANSILe comit daccrditation des standard, qui dpend de lANSI (American National StandardsInstitute), a labor un standard international pour C++.

Le standard C++ est galement appel norme ISO (International Organization for Stan-

dardization), norme NCITS (National Committee for Information Technology Standards),norme X3 (ancienne appellation de NCITS), ou norme ANSI/ISO. Dans ce livre, nouscontinuerons faire rfrence la norme ANSI car cest le terme le plus utilis.

Lobjectif du standard ANSI est de garantir la portabilit du C++ afin que le code que vousallez crire pour le compilateur de Microsoft, par exemple, ne gnre pas derreur avec unautre compilateur. Le code prsent dans ce livre tant compatible ANSI, il pourra trecompil sans erreur sur des plates-formes Macintosh, Windows ou Unix.

Pour la plupart des utilisateurs C++, le standard ANSI est transparent. La version la plusrcente de cette norme est lISO/IEC 14882-2003. La version prcdente, lISO 14882-1998,

a bnfici dune stabilit durable et tous les fournisseurs de renom la prennent en charge.Nous nous sommes efforcs dassurer une totale compatibilit ANSI du code dans cettedition.

Toutefois, noubliez pas que les compilateurs ne sont pas tous totalement compatibles avecla norme. En outre, certaines parties de la norme ont t laisses au choix du concepteur


24/870


du compilateur : il nest donc pas garanti que ces parties se compilent ou fonctionnent dela mme manire avec des compilateurs diffrents.

Les extensions gres pour C++ ne sappliquant qu la plate-forme .NET et,

ne faisant pas partie de la norme ANSI, elles ne sont pas traites dans cetouvrage.

Prparation la programmationPlus que tout autre langage, C++ oblige le dveloppeur concevoir soigneusement uneapplication avant de lcrire. Les programmes figurant dans les premiers chapitres de cetouvrage ne ncessitent pas danalyse car ils sont triviaux. En revanche, les problmescomplexes rencontrs en programmation professionnelle ne peuvent tre rsolus quaveccette approche. La conception et lanalyse permettent de mieux cerner les diffrentsaspects du problme. Un programme bien construit ne contient pas derreurs et peut ais-ment tre mis jour. Daprs des tudes rcentes, on estime que le cot dun programmerepose 90 % sur la mise au point et la maintenance. La phase de conception permet derduire les cots et, par l mme, le prix de revient du logiciel.

Avant de passer la conception dun programme, vous devez connatre parfaitement leproblme rsoudre. Les programmes les plus simples comme les plus complexes sarti-culent autour dun droulement clair et logique.

Il convient galement de dterminer si le problme peut tre rsolu laide dun programmeexistant qui sera modifi, ou laide dun logiciel du commerce. Quil choisisse lune ou

lautre solution, le programmeur ne manquera de toutes faons pas de travail : trouver dessolutions moins coteuses des problmes actuels produira toujours de nouvelles oppor-tunits un peu plus tard.

En supposant que le problme rsoudre ait t bien compris et quil faille crire unnouveau programme, vous tes prt commencer votre conception.

Le processus dapprhension totale du problme (analyse) et dlaboration dun plan pourune solution (conception) est indispensable lobtention dune application professionnellede carrure internationale.

Votre environnement de dveloppementPour utiliser ce livre, nous supposons que vous disposez dun compilateur permettant desaisir des donnes directement sur une "console" (par exemple une fentre de commandeMS-DOS ou une fentre shell), cest--dire sans vous proccuper dun environnement

Info


25/870

14 Le langage C++

graphique comme Windows ou Macintosh. Recherchez une option comme console oueasy windowou consultez la documentation de votre compilateur.

Votre compilateur peut faire partie dun environnement de dveloppement intgr (IDE)ou possder son propre diteur de texte pour saisir le code source des programmes. Vous

pouvez galement utiliser un diteur de texte spar ou un logiciel de traitement de textedu moment que vous produisez des fichiers texte sans formatage ni style particuliers. LeBloc-notes de Windows, lditeur Edit de DOS, les diteurs Brief, Epsilon, Emacs et visont particulirement bien adapts la saisie des codes sources. Si vous disposez dun trai-tement de texte tel que WordPerfect ou Word (ou autre), utilisez la commande denregis-trement au format texte simple.

Les documents crs partir dun diteur de texte sappellent des fichiers sources. En C++,ils portent traditionnellement lextension .cpp, .cpou .c. Dans cet ouvrage, nous avonschoisi lextension .cpp. Vrifiez que votre compilateur la prend en charge.

La plupart des compilateurs C++ acceptent toutes les extensions et affectentpar dfaut lextension .cppaux fichiers sources. Toutefois, soyez prudents, carcertains compilateurs traitent les fichiers .ccomme du code C et les fichiers.cppcomme du code C++. Vrifiez la documentation du compilateur. Danstous les cas, une utilisation cohrente des .cpppour les fichiers du code sourceC++ facilitera la tche des programmeurs qui devront comprendre votre code.

Cration du programmeLa premire tape de la cration dun programme consiste crire les commandes adap-tes (instructions) dans un fichier source. Mme si les instructions du fichier sourcesemblent quelque peu mystrieuses pour ceux qui ne connaissent pas C++, il sagit quandmme dun format lisible. Le fichier source nest pas un programme : il vous sera impossiblede le lancer ou de lexcuter comme vous le feriez avec un programme excutable.

Faire Ne pas faire

crire le fichier source laide de lditeur de

texte fourni avec le compilateur ou dunditeur externe.

Enregistrer votre fichier source avec lexten-sion .c, .cpou .cpp.

Consulter la documentation du compilateur etde lditeur de liens pour connatre les diff-rentes tapes de la cration du programme.

Utiliser les fonctions de mise en forme dun

traitement de texte. Si vous utilisez un traite-ment de texte, sauvegardez le fichier sourceau format texte ASCII.

Utiliser une extension .c si votre compila-teur considre ces fichiers comme du code Cet non du code C++.

Info


26/870


Cration dun fichier objet laide du compilateur

Pour transformer le code source en programme, vous allez utiliser un compilateur. Linvo-cation et la configuration de cet outil variant dun compilateur un autre, il est vivementrecommand de consulter la documentation.

La compilation produit un fichier objet. Le plus souvent, il porte lune des extensions .objou .o. Toutefois, il ne sagit pas encore dun programme excutable. Pour crer le fichier.exe, vous devez utiliser lditeur de liens (linker).

Cration dun fichier excutable laide de lditeur de liens

Les programmes C++ sont produits en liant un ou plusieurs fichiers objet (.obj ou .o)avec une ou plusieurs bibliothques. Une bibliothque regroupe des fichiers fournis avec lecompilateur, achets sparment ou que vous crez et compilez vous-mme. Tous les

compilateurs C++ sont livrs avec une bibliothque de fonctions et de classes trs utiles,que vous pouvez inclure dans vos programmes. Nous traiterons les classes et les fonctionsplus en dtail ultrieurement.

La cration dun fichier excutable se dcompose en trois tapes :

1. Cration dun fichier source portant lextension .cpp.

2. Compilation du code source en un fichier objet portant lune des extensions .objou .o.

3. Liaison du fichier objet avec les diffrentes bibliothques, afin dobtenir le programme

excutable.

Cycle de dveloppementSi chaque programme fonctionnait parfaitement ds le premier coup, le cycle de dvelop-pement complet serait : criture du programme, compilation du code source, dition desliens et lancement de lapplication. Malheureusement, rares sont les programmes qui necontiennent aucune erreur. Certaines feront chouer la compilation du programme,dautres ldition des liens, dautres encore ne se dclareront quau moment de lexcution

(celles-ci sont souvent appeles "bogues").

Toute erreur, quelle quelle soit doit tre corrige. Ceci implique de modifier le codesource, de le compiler nouveau, de recrer les liens et de relancer le programme.La Figure 1.1 illustre les diffrentes tapes de ce cycle de dveloppement.


27/870

16 Le langage C++

Votre premier programme C++ : BONJOUR.cppLes ouvrages traitant de programmation proposent traditionnellement un programme quipermet dafficher "Bonjour" lcran. Nous ne drogerons donc pas cette rgle !

Ouvrez lditeur de texte, puis tapez le code source du Listing 1.1 en respectant scrupuleu-sement la syntaxe (ne tenez pas compte de la numrotation des lignes qui ne sert ici quclarifier les choses). Aprs vrification, enregistrez le fichier, compilez-le, ditez les liens,puis lancez-le. Si tout se passe correctement, "Bonjour !" apparat lcran. Ne vous souciezpas des instructions utilises ici ; pour le moment, nous nous contentons de vous prsenter

Figure 1.1Les tapes du cyclede dveloppementdun programme C++.

Dbut

Ecriture/modification

du codesource

Compilation

Erreurs decompilation ?

Editionde liens

Erreursd'ditionde liens ?

Lancementdu programme

Erreursd'excution ?

Oui

Oui

Oui

Non

Non

Non

Fin


28/870


le cycle de dveloppement. En fait, les diffrents aspects de ce programme seront traitsdans les deux prochains chapitres.

Le listing suivant est numrot gauche afin de vous permettre de suivre pas pas

son droulement. Vous ne devez pas taper ces numros. Dans le premier exemple,vous devez uniquement taper pour la premire ligne :

#include

Listing 1.1 : Programmebonjour.cpp

1: #include 2:3: int main()4: {5: std::cout


29/870


30/870


Comment tirer parti de votre compilateurCe livre nestpasspcifique un compilateur donn ; les programmes inclus fonctionne-ront donc avec nimporte quelcompilateur C++ compatible ANSI, sur nimporte quelle

plate-forme (Windows, Macintosh, Unix, Linux, etc.).Ceci dit, une grande majorit de programmeurs travaillent sous lenvironnement Windowset la plupart des dveloppeurs professionnels ont recours aux compilateurs Microsoft. Ilnest pas possible dindiquer ici les dtails de la compilation et de ldition de liens avectous les compilateurs possibles, mais nous pouvons vous montrer comment dbuter avecMicrosoft Visual C++ ; cela ne devrait pas tre trs diffrent avec votre compilateur, bienquil soit conseill de vous reporter sa documentation spcifique.

Construction du projet Bonjour

Les tapes ncessaires la cration et au test du programme Bonjour sont les suivantes :

1. Lancez le compilateur.

2. Choisissez Nouveau/Projet dans le menu Fichier.

3. Choisissez Application Console Win32 et entrez un nom pour le projet, Bonjour, parexemple, puis cliquez sur Terminer.

4. Slectionnez Projet vide dans les choix proposs et cliquez sur OK. Une bote dedialogue contenant des informations sur le nouveau projet saffiche.

5. Cliquez sur OK. Vous revenez la fentre principale de lditeur.6. Choisissez Nouveau dans le menu Fichier.

7. Choisissez Fichier C++ et donnez-lui un nom : bonjour, par exemple, que vous saisirezdans la zone de texte Nom du fichier.

8. Cliquez sur OK. Vous revenez la fentre principale de lditeur.

9. Saisissez le code du Listing prcdent.

10. Choisissez Gnrer bonjour dans le menu Gnrer.

11. Vrifiez que vous navez pas derreurs de compilation. Vous trouverez ces informationsau bas de lditeur.

12. Excutez le programme en appuyant sur Ctrl+F5.

13. Appuyez sur la barre despacement pour terminer le programme.


31/870

20 Le langage C++

Le programme sexcute, mais laffichage est si rapide que je nai pas le temps de lire.Quest-ce qui ne va pas ?

Consultez la documentation de votre compilateur ; vous devez pouvoir contraindre le

programme respecter une pause aprs son excution. Avec les compilateurs Microsoft ilsuffit dutiliser la combinaison de touches Ctrl+F5.

Avec nimporte quel compilateur, vous pouvez insrer les lignes suivantes immdiatementavant linstruction return(cest--dire entre les lignes 5 et 6 du Listing 1.1) :

char reponse;std::cin >> reponse;

Le programme fera une pause pour attendre que vous entriez une valeur. Pour terminerle programme, entrez un nombre (par exemple 1) puis appuyez sur Entre (si ncessaire).

La signification des termes std::cin et std::cout sera prsente dans les prochains

chapitres ; pour linstant, utilisez-les sans vous poser de questions.

Erreurs de compilationLes erreurs de compilation peuvent survenir dans un certain nombre de cas. Le plussouvent, il sagit dune faute de frappe ou dun oubli. Les bons compilateurs mettront laligne incrimine en vidence et vous indiqueront lerreur que vous avez commise. Les plusperformants proposeront mme une solution au problme rencontr !

Pour tester les fonctionnalits de votre compilateur, il suffit dinsrer dlibrment uneerreur dans le programme bonjour.cpp, en tant la ligne 7 o doit se trouver laccoladefermante.

Listing 1.2 : Erreur de compilation

1: #include 2:3: int main()

4: { 5: std::cout


32/870


33/870

22 Le langage C++

tendance utiliser ce terme comme un raccourci dsignant la vritable tape de compi-lation suivie de ldition de liens.

Testez vos connaissances1. Quelle est la diffrence entre un interprteur et un compilateur ?2. Comment compiler un fichier source ?

3. quoi sert lditeur de liens ?

4. Quelles sont les diffrentes tapes du cycle de dveloppement ?

Exercices

1. Examinez le listing qui suit et, sans lexcuter, devinez ce quil permet de faire.1: #include 2: int main()3: {4: int x = 5;5: int y = 7;6: std::cout


34/870

2

Anatomie dunprogramme C++

Au sommaire de ce chapitre La structure dun programme C++

Les interactions entre ses composants

La nature et le rle dune fonction

Un programme C++ se compose dobjets, de fonctions, de variables et dun certainnombre dautres composants. Lessentiel de cet ouvrage est consacr lexplicationdtaille de ces diffrents lments mais, pour comprendre comment ils sarticulentensemble, il convient dtudier un programme complet.


35/870

24 Le langage C++

Un programme simpleLe programme bonjour.cppdu Chapitre 1 est intressant bien des gards. Pour information,le Listing 2.1 reproduit la version originale du fichier source.

Listing 2.1 : Le programmebonjour.cppprsente une structure type dapplication C++

1: #include 2:3: int main()

4: { 5: std::cout


36/870

Chapitre 2 Anatomie dun programme C++ 25

Le programme commence vraiment en ligne 3, avec la fonction main(). Cette fonction estobligatoire dans tous les programmes C++. Une fonction est un bloc dinstructions quieffectue une ou plusieurs actions et qui peut tre appele par une autre fonction, maismain()est spciale car elle est appele automatiquement au lancement du programme.

Comme toutes les fonctions, main() doit indiquer le type de la valeur quelle renvoie.Dans le programme bonjour.cpp, il sagit de int, ce qui signifie que la fonction renverraune valeur entire au systme dexploitation lorsquelle se terminera. Ici, elle renvoie lavaleur 0, comme le montre la ligne 6. Cette valeur renvoye a relativement peu dimpor-tanceet est assez rarement utilise, mais le standard C++ exige que la fonction main()soitdclare ainsi.

Certains compilateurs permettent de dclarermain()comme renvoyant void,ce qui signifie quaucune valeur nest renvoye. Ceci nest plus autoris enC++ et il est prfrable de ne pas prendre cette mauvaise habitude. Dclarez

main()comme renvoyant intet renvoyez simplement la valeur 0 la dernireligne de la fonctionmain().

Tous les systmes dexploitation permettent de tester la valeur renvoye par unprogramme. La convention consiste renvoyer 0 pour indiquer que le programmesest termin correctement, et une valeur diffrente de zro dans le cascontraire.

Toutes les fonctions commencent par une accolade ouvrante ({) et se terminent par uneaccolade fermante (}). Dans notre programme, les accolades de la fonction main()figu-

rent aux lignes 4 et 7. Toute instruction comprise entre ces deux accolades fait partie de lafonction.

Le plat de rsistance du programme se trouve la ligne 5.

Lobjet cout permet dafficher un message lcran. Les objets et leurs particularitsseront prsents au Chapitre 6 et lobjet coutet son alter ego cinseront dcrits au Chapi-tre 17. En C++, ces deux objets permettent de grer respectivement les sorties (notamment lcran) et les entres (au clavier, par exemple).

coutest un objet fourni par la bibliothque standard. Une bibliothque est une collectionde classes. La bibliothque standard est fournie avec tout compilateur compatible ANSI.

On indique au compilateur que lobjet cout que lon souhaite utiliser fait partie de labibliothque standard laide du spcificateur despace de nom std. Vous pouvez en effetavoir des objets portant le mme nom, mais provenant de fournisseurs diffrents et cest laraison pour laquelle C++ prvoit lutilisation des "espaces de noms". Un espace de nomest une faon de dire : "Lorsque je dis std::cout, je fais rfrence lobjet coutfaisant

Attentio

n

Info


37/870

26 Le langage C++

partie de lespace de nom standard, et daucun autre". Vous le faites savoir au compilateuren indiquant le terme stdsuivi de deux caractres deux-points avant lobjet cout. Nousreparlerons des espaces de noms ultrieurement.

La syntaxe de coutest relativement simple. Ce terme est suivi de loprateur de redirec-

tion de sortie (


38/870


9: std::cout


39/870

28 Le langage C++

Le chiffre suit immdiatement la chane de caractres, car vous navez pas insr de sautde ligne. Sans le savoir, vous avez concatndeux valeurs.

La ligne 7 affiche un message puis utilise le manipulateur std::endl qui a pour butdcrire une nouvelle ligne lcran (Pour en savoir plus sur endl, reportez-vous au

Chapitre 16). endl faisant aussi partie de la bibliothque standard, on utilise le prfixestd::, comme pour cout.

endlsignifie end line (ligne finale). La dernire lettre est bien la lettre "l" et non lechiffre 1.

Lutilisation de endl est prfrable celle de \n, car il est adapt au systmedexploitation utilis. En revanche, \nrisque de ne pas reprsenter le caractre denouvelle ligne complet exig sur un systme dexploitation ou une plate-formeparticuliers.

la ligne suivante, vous dcouvrez un nouveau caractre de formatage : \t. Il permetdinsrer une tabulation pour aligner les chanes de caractres (lignes 10 16). La ligne 10montre que lon peut afficher tous les nombres entiers, quel que soit leur type. laligne 14, on passe une addition (8 + 5) cout, qui affiche 13.

la ligne 15, la fraction 5/8 est transmise cout. Le terme (float) indique quune valeurdcimale ( virgule flottante) doit safficher. Lexpression 7000*7000est ensuite trans-mise cout (ligne 17) et le terme double indique cout quil sagit dune valeur virgule flottante. Pour obtenir des informations dtailles sur les types de donnes, reportez-vous au Chapitre 3.

Aux lignes 18 et 20, vous avez remplac le nom du programmeur par le vtre. Si cest lecas, la sortie confirmera que vous tes un programmeur C++, ce qui doit tre vrai puisquecest lordinateur qui le dit !

Utilisation de lespace de nom standardLutilisation systmatique de std::devant coutet endlpouvant devenir plutt fastidieuse la longue, la norme ANSI propose deux solutions ce petit problme.

La premire consiste indiquer au compilateur, au dbut du code, que vous allez utiliser

les objets coutet endlde la bibliothque standard, comme au Listing 2.3 (lignes 5 et 6).

Listing 2.3 : Utilisation du mot-cl using

1: // Listing 2.3 - Utilisation du mot-cl using 2: #include

Info


40/870


3: int main() 4: { 5: using std::cout; 6: using std::endl; 7:

8: cout


41/870


42/870


43/870


44/870


En rsum, les commentaires ne doivent pas dire ce qui se passe, mais expliquerpourquoicela arrive.

Les fonctionsBien que main() soit une fonction, ses caractristiques la distinguent des autres. En effet,lutilit des fonctions standard est quelles peuvent tre appelesou invoques tout momentdans un programme ; or la fonction main()est appele par le systme dexploitation.

Le droulement dun programme est squentiel (cest--dire quil suit lordre des lignes decode). Quand il rencontre une instruction dappel dune fonction, il se droute pour excutercette dernire. Lorsque la fonction se termine, le programme continue son excution avecla ligne place immdiatement aprs lappel de la fonction.

Comparons lappel dune fonction une action de la vie courante : alors que vous dessinez

un paysage, la mine de votre crayon se casse. Vous cessez immdiatement de dessiner afinde tailler votre crayon. Puis vous reprenez votre activit artistique l o vous laviez inter-rompue. Il en est de mme dans un programme. Lorsque celui-ci a besoin dun service, ilfait appel une fonction, puis reprend son droulement une fois que celle-ci est termine.Le Listing 2.6 illustre ce concept.

Pour plus dinformations sur les fonctions, reportez-vous au Chapitre 5. Lestypes de donnes prises en charge seront prsentes au Chapitre 3. Ce chapi-tre-ci donne uniquement un aperu des fonctions, car on les retrouvera dans laplupart des programmes C++.

Listing 2.6 : Appel de fonction dans un programme

1: #include 2:

3: // Fonction DemoFonction 4: // affiche un message dinformation 5: void DemoFonction() 6: { 7: std::cout


45/870


46/870


47/870

36 Le langage C++

Somme() a recu 3 et 5

Retour dans main().c vaut maintenant 8Fin du traitement...

Dfinie la ligne 2, la fonction Somme()reoit deux paramtres entiers et renvoie unevaleur entire. Le programme commence la ligne 8 ; il affiche un message invitantlutilisateur entrer deux nombres (ligne 16), spars par un espace. Ces nombres sontplacs dans les variables aet baux lignes 17 et 18. Pour valider, tapez sur Entre. Lafonction main() passe ces deux nombres en paramtres la fonction Somme()(ligne 20).

Le programme se droute dans la fonction Somme() qui commence la ligne 2. Lesvaleurs de aet bsont reues, respectivement, par les paramtres xet y. La fonction afficheces valeurs puis les additionne ; le rsultat obtenu est renvoy la ligne 5, puis la fonctionrend la main la fonction qui la appele la fonction main(), ici.

Dans les lignes 17 et 18, lobjet cinpermet dobtenir des valeurs pour les variables aet b,qui sont ensuite affiches laide de lobjet cout. Nous traiterons en dtail les variables etles diffrents aspects dun programme dans les chapitres suivants.

Mthodes ou fonctionsIl faut noter ici que les diffrents langages de programmation et les diffrentes mtho-dologies peuvent dsigner les fonctions par un autre nom. Lun des termes les plushabituels est celui de mthode. Une mthode est simplement une fonction qui fait partiedune classe.

Questions-rponsesQ Quelle est la signification du terme #include?

R Il sagit dune directive du prprocesseur qui sexcute lorsque vous appelez le compi-lateur. Cette directive insre le fichier dont le nom est indiqu entre chevrons, commesi vous laviez saisi en totalit, dans le code source du programme.

Q Quelle est la diffrence entre les commentaires //et les commentaires de type /*?R Les commentaires double slash (//) (commentaires sur une ligne) prennent fin avec le

retour la ligne, alors que les commentaires slash-toile (/*) (commentaires sur plu-sieurs lignes) se terminent avec un symbole de fermeture (*/). Noubliez pas de fermertous les commentaires multilignes afin dviter toute erreur de compilation.


48/870


49/870


50/870

3

Variables et constantes

Au sommaire de ce chapitre

Dclarer et dfinir des variables et des constantes

Affecter des valeurs aux variables, puis grer ces valeurs Afficher le contenu dune variable lcran

Les programmes doivent mmoriser les donnes quils utilisent ou les crer pour les ruti-liser lors de lexcution du programme. Pour cela, les variables et les constantes proposentplusieurs mthodes pour reprsenter, stocker et manipuler des informations.

Quest-ce quune variable ?

En C++, une variableest un emplacement destin recevoir des donnes. Cette zone sesitue dans la mmoire vive de votre ordinateur et reoit une valeur qui peut ensuite trerelue.

Les variables sont utilises pour un stockage temporaire. Si vous quittez un programme etarrtez votre ordinateur, linformation stocke dans ces variables est perdue. Un stockage


51/870


52/870


53/870


54/870

Chapitre 3 Variables et constantes 43

Les lignes 7 20 font appel loprateur sizeof, qui est utilis comme une fonction.Il renvoie la taille de lobjet qui lui a t pass en paramtre. Par exemple, la ligne 8, le motcl intest pass sizeof. Vous verrez plus loin dans ce chapitre que intpermet de dcrireune variable entire standard. Si lon utilise sizeofsur un Pentium 4 sous Windows XP, la

taille dune valeur intquivaut celle dun entier long, soit quatre octets.Les autres lignes du Listing 3.1 affichent les tailles des autres types de donnes. Vous ensaurez plus sur les valeurs que ces types de donnes peuvent stocker et ce qui les diffrencieun peu plus loin.

signedet unsignedToutes les variables entires ont deux variantes : signe (signed) ou non signe (unsi-gned). En effet, on a parfois besoin de nombre ngatifs, parfois non. Les entiers dclarssans le mot-cl unsignedsont considrs comme signs. Les entiers signs sont soit ngatifs,

soit positifs, alors que les entiers non signs sont toujours positifs.Les entiers, quils soient signs ou non, occupent le mme espace mmoire. De ce fait, unepartie de la place de stockage dun entier sign sera donc utilise pour indiquer sil est positifou ngatif. La valeur la plus leve que vous pouvez stocker dans un entier non sign corres-pond donc au double du nombre positif le plus lev contenu dans une variable entire signe.

Par exemple, si un entier shortest stock sur deux octets, un entier shortnon sign peutcontenir une valeur comprise entre 0 et 65 535. Pour un entier shortsign, la moiti desvaleurs admises correspond des nombres ngatifs. Lintervalle autoris se situe doncentre 32 768 et +32 767.

Types fondamentauxC++ dispose de plusieurs types prdfinis, qui peuvent tre diviss en types entiers (voirplus haut), en types flottants et en type caractre.

Les variables virgule flottante peuvent tre exprimes sous la forme de fractions, ce sontdes nombres rels. Les variables de type caractre noccupent gnralement quun seuloctet et servent souvent stocker les 256 caractres et symboles du jeu ASCII standard etdes jeux ASCII tendus (en vigueur dans certaines langues).

Le jeu de caractres ASCII est un ensemble normalis de lettres, de nombres etde symboles reconnu par tous les ordinateurs. ASCII est lacronyme de Ameri-can Standard Code for Information Interchange. Cette norme de codage estprise en charge par la plupart des systmes dexploitation, bien que nombredentre eux prennent galement en charge dautres jeux de caractres interna-tionaux.

Info


55/870

44 Le langage C++

Les types de variables utilises en C++ sont dcrits dans le Tableau 3.1. En face du libelldu type C++ figurent la traduction franaise ainsi que sa taille et les valeurs qui peuventtre stockes. Ces valeurs sont dtermines par la taille des types de variables, conform-ment la sortie produite par le programme du Listing 3.1 ; consultez son rsultat pour voir

si vos types de variables sont de la mme taille. Il est trs probable que ce sera le cas, moins que vous nutilisiez un ordinateur ayant un processeur 64 bits.

La taille des variables peut varier en fonction du compilateur et du processeurde votre ordinateur. En fait, le Tableau 3.1 et le listing qui prcde secompltent, car les valeurs ont t extraites de la mme configuration. Si leprogramme affiche un rsultat diffrent, reportez-vous au manuel de votrecompilateur.

Dfinition dune variablePour linstant, vous avez vu la cration et lutilisation de plusieurs variables. Il est tempsmaintenant dapprendre crer les vtres.

Tableau 3.1 : Types de variables

Type C++ Traduction franaise Taille Valeurs

bool boolen 1 octet true(vrai) ou false(faux)

unsigned short int entier court non sign 2 octets de 0 65 535

short int entier court 2 octets de 32 768 32 767

unsigned long int entier long non sign 4 octets de 0 4 294 967 295

long int entier long 4 octets de 2 147 483 648 2 147 483 647

int entier (16 bits) 2 octets de 32 768 32 767

int entier (32 bits) 4 octets de 2 147 483 648 2 147 483 647

unsigned int entier non sign (16 bits) 2 octets de 0 65 535

unsigned int entier non sign (32 bits) 2 octets de 0 4 294 967 295

char texte 1 octet 256 caractres

float nombre dcimal 4 octets de 1,2e38 3,4e38

double nombre double 8 octets de 2,2e308 1,8e308

Info


56/870


57/870

46 Le langage C++

Il est vident que le second programme est plus facile comprendre. En outre, les nomslongs donnent un sens au code et facilitent dventuelles modifications.

Respect de la casse des caractres

Le langage C++ fait la diffrence entre les majuscules et les minuscules, ce qui signifiequune variable appele ageest diffrente dune variable appeleAge, qui est elle-mmediffrente de la variableAGE.

Certains compilateurs permettent de dsactiver cette fonctionnalit. Cettepratique est dconseille car vous risquez de ne pas pouvoir compiler vosprogrammes avec dautres compilateurs et den rendre la lecture plus difficilepour les autres programmeurs.

Conventions de nommageIl existe plusieurs conventions pour les noms de variables. Peu importe celle que vouschoisirez, mais il convient de rester homogne dans lattribution des noms tout au long duprogramme de manire faciliter la lecture du code par dautres programmeurs.

Certains programmeurs dtestent les majuscules et tapent tout le code en minuscules. Si lenom de la variable requiert deux lments (par exemple, sous total), il est possible deles sparer laide dun caractre de soulignement, ou de les accoler. Exemple :sous_totalou sousTotal. La prsence dune lettre majuscule au milieu du nom de lavariable facilite la lecture ; elle fait penser une bosse et cest la raison pour laquelle onlappelle camel case.

Lutilisation des caractres de soulignement ne fait pas lunanimit. Certains estimentque le code source est plus facile lire, alors que dautres pensent que la touche nestpas bien situe sur le clavier. Dans cet ouvrage, nous avons adopt la notation "droma-daire". Pour une meilleure lisibilit du texte, tous les lments du nom (sauf le premier)commencent par une majuscule. Exemple : monAge, totGeneral, etc. Notez que nousnutilisons pas les caractres accentus, la plupart des versions ne les prenant pas encharge.

En programmation avance, on rencontre souvent la notation dite hongroise. Cette prati-que consiste utiliser un prfixe correspondant au type de la variable. Par exemple, lesvariables entires peuvent commencer par un iminuscule. Les variables de type longpeuvent commencer par un l. Bien entendu, il existe dautres prfixes signalant diffren-tes constructions en C++ pour les pointeurs, les constantes, etc., que nous verrons par lasuite.

Attentio

n


58/870


59/870

48 Le langage C++

Les mots suivants sont rservs :

Cration de plusieurs variables la foisVous pouvez crer plusieurs variables de type identique dans la mme instruction en sparantles noms par des virgules :

unsigned int monAge, monPoids; // 2 vars entires non signeslong int surface, largeur, longueur; // 3 variables entires longues

Comme vous pouvez le constater, monAge et monPoids sont des variables entires nonsignes car il est inconcevable quun ge ou un poids soient ngatifs. Sur la deuximeligne, les variables surface, largeuret longueursont de type long. Une mme instructionde dfinition ne peut comprendre des types de variables diffrents.

Affectation de valeurs aux variablesPour affecter une valeur une variable, on utilise loprateur daffectation (=). Danslexpression suivante, on affecte la valeur 5 la variable largeur :

unsigned short largeur;

largeur = 5;

And bitor not_eq xor

and_eq compl or xor_eq

bitand not or_eq

Faire Ne pas faire

Dfinir une variable en indiquant son type etson nom.

Utiliser des noms de variables significatifs.

Ne pas oublier que C++ respecte la casse descaractres.

Tenir compte de lespace occup par la varia-ble en mmoire en fonction de son type, pouraffecter des valeurs adquates.

Utiliser des mots-cls de C++ comme nomsde variables.

Prsumer du nombre doctets utiliss pour lestockage dune variable.

Utiliser des variables non signes pourstocker des nombres ngatifs.


60/870


longest un raccourci pour long int, comme shortpour short int.

Il est possible de combiner les instructions de cration dune variable celles daffectationdune valeur. Vous pouvez par exemple combiner ces deux tapes pour la variable largeuren crivant :

unsigned short largeur = 5;

Linitialisation ressemble beaucoup laffectation prcdente. Les diffrences entre lesdeux oprations sont mineures en ce qui concerne les entiers. Dans ce chapitre, vous allezapprendre que certaines variables doivent tre initialises, car il nest plus possible de leurattribuer de valeur par la suite.

On peut galement initialiser plusieurs variables simultanment. Linstruction suivante,

par exemple, cre deux variables du type longet les initialise :long largeur = 5, hauteur = 7;

Vous pouvez mlanger des dfinitions et des initialisations :

int monAge = 39, tonAge, sonAge = 40;

Dans cet exemple, trois variables entires sont cres, mais seules la premire et ladernire sont initialises.

Vous pouvez compiler le fichier source du Listing 3.2. Ce programme calcule la surface

dun rectangle, puis affiche le rsultat lcran.

Listing 3.2 : Utilisation de variables

1: // Dmonstration de variables 2: #include 3:

4: int main() 5: { 6: using std::cout; 7: using std::endl;

8:9: unsigned short int Largeur = 5, Longueur;

10: Longueur = 10;11:12: // Cre un entier court non sign13: // et linitialise avec le rsultat de la

Info


61/870


62/870


63/870


64/870


la ligne 7, Nombreest une variable de type entier court non sign qui, sur un Pentium 4sous Windows XP, est dune longueur de deux octets et peut donc contenir une valeurcomprise entre 0 et 65 535. la ligne suivante, cette variable reoit la valeur maximale etle rsultat saffiche correctement (ligne 9).

la ligne 10, la variable est incrmente de un, comme le montre le symbole ++. Aupassage, vous pouvez constater que le nom de C++ semble indiquer quil sagit dunincrment du langage C. La valeur de Nombreest donc gale 65 536, valeur refusepour un entier court non sign. La variable est remise zro et son contenu apparat lcran.

la ligne 12, Nombreest incrment de nouveau. Sa nouvelle valeur (1) saffiche.

Rebouclage des entiers signsUn entier sign se distingue dun entier non sign puisque la moiti des valeurs admises

sont ngatives. Au lieu de vous reprsenter un compteur de voiture, vous pourriez imagi-ner une horloge comme celle de la Figure 3.2, o les chiffres augmentent dans les sensdes aiguilles, et diminuent dans le sens inverse. Ils se croisent en bas du cadran (6 heures).

Lorsque vous ne disposez plus de nombres positifs, vous atteignez le plus grand nombrengatif puis dcomptez jusqu la valeur 0.

Dans le programme du Listing 3.5, le nombre positif maximal est incrment de un.

Figure 3.2Si les pendules utilisaientdes nombres signs.


65/870


66/870


67/870


68/870


ConstantesComme les variables, les constantessont des emplacements de stockage dinformation.Mais, la diffrence des variables, elles ne sont pas modifiables : vous devez donc initiali-

ser une constante lorsque vous la dclarez et vous ne pourrez plus ensuite lui affecter denouvelle valeur.

C++ distingue deux types de constantes : les constantes littrales et les constantes symbo-liques.

Constantes littralesUne constante littraleest une valeur apparaissant directement dans le code du programmeau moment o lon en a besoin. Exemple :

int monAge = 32;

monAge est une variable de type int, alors que 32 est une constante littrale. Vous nepouvez pas affecter de valeur 32et sa valeur ne peut pas tre modifie.

\f saut de page

\n nouvelle ligne

\r retour chariot

\t tabulation horizontale

\v tabulation verticale

\ guillemet simple

\" guillemet double

\? point dinterrogation

\\ barre oblique inverse

\000 notation octale

\xhhh notation hexadcimale

Tableau 3.3 : Caractres dchappement(suite)

Caractre Signification


69/870

58 Le langage C++

Constantes symboliques

Comme une variable, une constante symboliqueest reprsente par un nom. Toutefois, soncontenu ne peut tre modifi aprs son initialisation.

Supposons que vous ayez dclar deux variables de type entier Eleveset Classeset quesouhaitiez connatre le nombre dlves dune cole. Si vous savez que chaque classe estforme de 15 lves, le calcul se prsentera ainsi :

Eleves = Classes * 15;

Dans cet exemple, 15est une constante littrale. Votre programme serait plus facile lireet mettre jour si cette valeur tait reprsente par une constante symbolique :

Eleves = Classes * elevesParClasse

Si vous dcidez plus tard de modifier le nombre dlves par classe, il vous suffira dechanger la valeur dinitialisation de la constante elevesParClasse : vous naurez pasbesoin de modifier toutes les instructions qui utilisent cette valeur.

Il existe deux faons de dclarer une constante symbolique en C++. La plus ancienne,dsormais obsolte, consiste utiliser la directive #define du prprocesseur. La seconde,plus approprie, consiste utiliser le mot-cl const.

Dfinition de constantes avec #define

De nombreux programmes faisant appel la directive #define, vous devez bien en

comprendre le fonctionnement. Pour dfinir une constante de cette manire (obsolte),vous pouvez taper :

#define elevesParClasse 15

La constante elevesParClassena pas de type particulier (int, char, etc.). En fait, leprprocesseur effectuera une simple substitution de texte : chaque fois quil rencontrerale mot elevesParClassedans le texte du programme, il le remplacera 15.

Le prprocesseur sexcutant avant le compilateur, ce dernier ne verra donc jamais votreconstante, mais uniquement le nombre 15.

Mme si #definesemble trs simple utiliser, il est prfrable de lviter carla norme C++ la dclar obsolte.Atten

tion


70/870


71/870


72/870


73/870

62 Le langage C++

Les constantes numres prsentent lavantage dtre parfaitement claires, lutilit dutype numr Joursest vidente.

Questions-rponsesQ Si un entier court peut tre remis zro en cas de dpassement de capacit, pourquoi

ne pas toujours utiliser des entiers longs ?

R Tous les types dentiers pourront renvoyer des valeurs errones en cas de dpassementde capacit. Toutefois, les valeurs maximales acceptes seront de 65 535 pour ununsigned short intde deux octets, et de 4 294 967 295 pour ununsigned longintde quatre octets. Cependant, sur la plupart des machines, un entier longoccuperadavantage de mmoire (4 octets contre 2) et, dans ce cas, un programme contenant100 variables de ce type occupera donc 200 octets de mmoire vive supplmentaires.

Dsormais ce problme nest plus crucial, car les PC disposent maintenant de quantits demmoire considrables.

Utiliser des types suprieurs vos besoins peut galement demander plus de traitementde la part du processeur.

Q Que se passe-t-il si jaffecte un nombre virgule un entier alors que jaurai dutiliser un float?

Par exemple :

int unNombre = 5.4;

R Dans ce cas, un compilateur efficace enverra un avertissement, mais cette affectationest autorise. Le nombre affect sera tronqu : la valeur 5,4 deviendra la valeur entire5, ce qui entranera une perte dinformation.

Q Pourquoi doit-on utiliser des constantes symboliques et ne pas se contenter desconstantes littrale ?

R Si vous utilisez la mme valeur en de nombreux endroits de votre programme, vouspourrez la modifier en une seule fois si elle est dsigne par une constante symbolique.Par ailleurs une constante symbolique, de par son nom, est plus explicite. Il peut tredifficile de comprendre pourquoi un nombre est multipli par la constante 60, alors que

cela deviendra vident sil sagit de la constante secParMinute.

Q Que se passe-t-il si jaffecte un nombre ngatif une variable non signe ?

Par exemple :

unsigned int unNombrePositif = -1;


74/870


75/870


76/870

4

Expressionset instructions

Au sommaire de ce chapitre Les instructions

Les blocs dinstructions

Les expressions

Les branchements conditionnels

Les conditions logiques

Un programme est, la base, un ensemble de commandes qui sexcutent squentiel-

lement. Il est possible de modifier cette squence et dexcuter un jeu de commandes ouun autre selon quune condition particulire est ou nest pas satisfaite.


77/870


78/870


79/870


80/870


81/870


82/870


83/870


84/870


85/870


86/870

Chapitre 4 Expressions et instructions 75

la variable monAgeest incrmente. la ligne 20, tonAgeest incrment par prfixe, doncavantlaffichage qui produit 41.

Aux lignes 22 et 23, le rsultat est raffich. Les deux valeurs sont gales puisquelinstruction dincrmentation a t excute.

Priorit des oprateursDans linstruction compose suivante :

x = 5 + 3 * 8;

quelle sera lopration effectue en premier, laddition ou la multiplication ? Si cest laddi-tion, le rsultat sera 8 * 8, soit 64. Si cest la multiplication, le rsultat sera 5 + 24, soit 29.

La norme C++ ne laisse pas de place au hasard dans lapplication des oprations. Tout

oprateur a un niveau de priorit par rapport aux autres (voir lAnnexe C). La multiplica-tion ayant une priorit suprieure laddition, cest elle qui sera excute en premier et lavaleur de lexpression sera donc gale 29.

Lorsque deux oprateurs sont de priorit identique, les oprations seffectuent de gauche droite. Dans lexpression suivante :

x = 5 + 3 + 8 * 9 + 6 * 4;

La multiplication est prioritaire, de gauche droite. Do : 8 * 9 = 72, et 6 * 4 = 24. Ce quirevient :

x = 5 + 3 + 72 + 24;

Laddition seffectue ensuite de gauche droite : 5 + 3 = 8 ; 8 + 72 = 80 ; 80 + 24 = 104.

Attention : certains oprateurs (laffectation par exemple) sont valus de droite gauche !

Que faire si lordre des priorits ne vous convient pas ? Prenons un exemple :

totalSecondes = nbMinutesA + nbMinutesB * 60;

Dans cette expression, nbMinutesBs

le langage c++ initiez-vous la programmation en c%2b%2b

Documents