Exercices en langage c++ ()

Complment idal des manuels dapprentissage du C++ du mme auteur, cet ouvrage vous propose 150 exercices corrigs et com-ments pour mieux assimiler le langage et ses concepts objet.Cette troisime dition dbute par une srie dexercices sur la syntaxe de base du C++ (types et oprateurs, instructions de contrle,fonctions, tableaux, pointeurs) qui ntait pas traite dans ldition prcdente. La suite de louvrage met tout particulirementlaccent sur la matrise de la programmation oriente objet.Les exercices proposs vous permettront de vous forger une vritable mthodologie de conception de vos propres classes C++. Voussaurez notamment dcider du bien-fond de la surdfinition de loprateur daffectation ou du constructeur par recopie, tirer partide lhritage (simple ou multiple) et du polymorphisme, crer vos propres bibliothques de classes, exploiter les possibilits offertespar les patrons de fonctions et de classes, etc.Chaque chapitre dbute par un rappel de cours suivi de plusieurs exercices de difficult croissante. Les corrigs sont tous prsentssuivant le mme canevas : analyse dtaille du problme, solution sous forme de programme avec exemple de rsultat dexcution,justification des choix oprs car il ny a jamais de solution unique un problme donn ! et, si besoin, commentaires sur lespoints dlicats et suggestions sur les extensions possibles du programme.

Au sommaireGnralits sur le C++, types de base, oprateurs et expressions (7 exercices) Instructions de contrle (16 exercices) Fonctions(10 exercices) Tableaux, pointeurs et chanes de type C (13 exercices) Structures (6 exercices) Du C au C++ (9 exercices) Classes, constructeurs et destructeurs (7 exercices) Proprits des fonctions membres (5 exercices) Construction, destruction et ini-tialisation des objets (7 exercices) Fonctions amies (3 exercices) Surdfinition doprateurs (11 exercices) Conversions de typedfinies par lutilisateur (7 exercices) Technique de lhritage (7 exercices) Hritage multiple (6 exercices) Fonctions virtuelleset polymorphisme (3 exercices) Flots dentre et de sortie (5 exercices) Patrons de fonctions (4 exercices) Patrons de classes(8 exercices) Gestion des exceptions (7 exercices) Exercices de synthse (6 exercices) Composants standard (11 exercices).

Sur le site www.editions-eyrolles.com Dialoguez avec lauteur Tlchargez le code source des corrigs dexercices

Code

dite

ur:G

1220

1

ISBN

:978

-2-2

12-1

2201

-5

Claude DelannoyIngnieur informaticien au CNRS, Claude Delannoy possde une grande pratique de la formation continueet de lenseignement suprieur. Rputs pour la qualit de leur dmarche pdagogique, ses ouvrages surles langages et la programmation totalisent plus de 250 000 exemplaires vendus.

97

82

21

21

22

01

5

19E

Exer

cices

enla

ngag

eC+

+C.

Del

ann

oy

250 000 ouvrages

vendus

250 000 ouvrages

vendus Claude Delannoy

Exercices en langage

C++Exercices

en langage

C++

3 e dition

3 e dition

Exercicesen langageC++

delC++ titre 4/07/07 15:19 Page 2

AUX EDITIONS EYROLLES

Du mme auteur

C. Delannoy. Apprendre le C++. N12135, 1re dition 2007, 780 pages.

C. Delannoy. C++ pour les programmeurs C. N12231, environ 580 pages, paratre.

C. Delannoy. Programmer en Java (Java 5 et 6). N12232, 5e dition, environ 780 pages + CD-Rom, paratre.

C. Delannoy. Exercices en Java (Java 5). N11989, 2e dition, 2006, 330 pages.

C. Delannoy. Langage C. N11123, 1998, 944 pages (rdition au format semi-poche).

C. Delannoy. Programmer en langage C. Avec exercices corrigs. N11072, 1996, 280 pages.

C. Delannoy. Exercices en langage C. N11105, 1997, 260 pages.

Autres ouvrages dans la mme collection

P. Roques. UML 2 par la pratique. Cours et exercices. N12014, 5e dition 2006, 360 pages.

X. Blanc, I. MounIeR. UML 2 pour les dveloppeurs. Cours et exercices corrigs. N12029, 2006, 218 pages.

H. BeRsInI, I. Wellesz. Lorient objet. Cours et exercices en UML 2 avec PHP, Java, Python, C# et C++. N12084, 3e dition, 2007, 520 pages.

J. engels. XHTML et CSS : cours et exercices. N11637, 2005, 350 pages.

J. engels. PHP 5 : cours et exercices. N11407, 2005, 518 pages.

Autres ouvrages

I. HoRton. Visual C++ 6. Avec un CD-Rom contenant le produit Microsoft Visual C++ 6 Introductory Edition. N9043, 1999, 1 250 pages.

G. leBlanc. C# et .NET 2.0. N11778, 2006, 700 pages.

E. DasPet et C. PIeRRe de geyeR. PHP 5 avanc. N12167, 4e dition, environ 800 pages, paratre en octobre 2007.

a. goncalves. Cahier du programmeur Java EE5. N12038, 2007, 330 pages.

c. PoRteneuve. Bien dvelopper pour le Web 2.0. N12028, 2006, 560 pages.

Claude Delannoy

Exercicesen langageC++

3e dition

delC++ titre 4/07/07 15:19 Page 1

DITIONS EYROLLES61, bd Saint-Germain75240 Paris Cedex 05

www.editions-eyrolles.com

Le code de la proprit intellectuelle du 1er juillet 1992 interdit en effet expressment la photocopie usage collectif sans autorisation des ayants droit. Or, cette pratique sest gnralise notamment dans les tablissements denseignement, provoquant une baisse brutale des achats de livres, au point que la possibilit mme pour les auteurs de crer des uvres nouvelles et de les faire diter correctement est aujourdhui menace.En application de la loi du 11 mars 1957, il est interdit de reproduire intgralement ou partiellement le

prsent ouvrage, sur quelque support que ce soit, sans autorisation de lditeur ou du Centre Franais dExploitation du Droit de Copie, 20, rue des Grands-Augustins, 75006 Paris. Groupe Eyrolles, 1997, 1999, 2007, ISBN : 978-2-212-12201-5

Dpt lgal : aot 2007N dditeur : 7676Imprim en France

ditions Eyrolles V

Avant-propos

La matrise dun langage de programmation passe obligatoirement par la pratique, cest--direla recherche personnelle dune solution un problme donn, et cette affirmation reste vraiepour le programmeur chevronn qui tudie un nouveau langage. Cest dans cette situation quese trouve gnralement une personne qui aborde le C++ :

soit elle connat dj un langage procdural classique autre que le C (Java, Visual Basic,Pascal, ...),

soit elle connat dj la langage C sur lequel sappuie effectivement C++ ; toutefois, cedernier langage introduit suffisamment de possibilits supplmentaires et surtout de nou-veaux concepts (en particulier ceux de la Programmation Oriente Objet) pour que sonapprentissage sapparente celui dun nouveau langage.

Cet ouvrage vous propose daccompagner votre tude du C++ et de la prolonger laide dexer-cices appropris, varis et de difficult croissante, et ceci quelles que soient vos connaissancespralables. Il comporte :

4 chapitres destins ceux dentre vous qui ne connaissent pas le C : types de base, opra-teurs et expressions ; instructions de contrle ; fonctions ; tableaux, pointeurs et chanes destyle C ;

un chapitre destin assurer la transition de C C++ destins ceux qui connaissent djle langage C ;

seize chapitres destins tous : les notions de classe, constructeur et destructeur ; les pro-prits des fonctions membre ; la construction, la destruction et linitialisation des objets ;les fonctions amies ; la surdfinition doprateurs ; les conversions de type dfinies parlutilisateur ; la technique de lhritage ; les fonctions virtuelles ; les flots dentre et de

exos_c++.book Page V Jeudi, 5. juillet 2007 11:10 11

Exercices en langage C++

VI ditions Eyrolles

sortie, les patrons de fonctions et les patrons de classes ; la gestion des exceptions. Le cha-pitre 20 propose des exercices de synthse.

Chaque chapitre dbute par un rappel dtaill des connaissances ncessaires pour aborder lesexercices correspondants (naturellement, un exercice dun chapitre donn peut faire intervenirdes points rsums dans les chapitres prcdents).Le cours complet correspondant ces rsums se trouve dans louvrage Apprendre le C++, dumme auteur.Au sein de chaque chapitre, les exercices proposs vont dune application immdiate du cours des ralisations de classes relativement compltes. Au fil de votre progression dans louvrage,vous raliserez des classes de plus en plus ralistes et oprationnelles, et ayant un intrtgnral ; citons, par exemple :

les ensembles ;

les vecteurs dynamiques ;

les tableaux dynamiques plusieurs dimensions ;

les listes chanes ;

les tableaux de bits ;

les (vraies) chanes de caractres ; les piles ;

les complexes.

Naturellement, tous les exercices sont corrigs. Pour la plupart, la solution propose ne selimite pas une simple liste dun programme (laquelle ne reprsente finalement quune rdac-tion possible parmi dautres). Vous y trouverez une analyse dtaille du problme et, si besoin,les justifications de certains choix. Des commentaires viennent, le cas chant, clairer les partiesquelque peu dlicates. Frquemment, vous trouverez des suggestions de prolongement ou degnralisation du problme abord.Outre la matrise du langage C++ proprement dit, les exercices proposs vous permettront devous forger une mthodologie de conception de vos propres classes. Notamment, voussaurez :

dcider du bien-fond de la surdfinition de loprateur daffectation ou du constructeurpar recopie ;

exos_c++.book Page VI Jeudi, 5. juillet 2007 11:10 11

ditions Eyrolles VII

Avant-propos

exploiter, lorsque vous jugerez que cela est opportun, les possibilits de conversionsimplicites que le compilateur peut mettre en place ;

tirer parti de lhritage (simple ou multiple) et dterminer quels avantages prsente la crationdune bibliothque de classes, notamment par le biais du typage dynamique des objets quidcoule de lemploi des fonctions virtuelles ;

mettre en uvre les possibilits de fonctions gnriques (patrons de fonctions) et de classesgnriques (patrons de classes).

Quelques exercices proposs dans les prcdentes ditions de louvrage trouvent maintenantune solution vidente en faisant appel aux composants standard introduits par la norme. Nousles avons cependant conservs, dans la mesure o la recherche dune solution ne faisant pasappel aux composants standard conserve un intrt didactique manifeste. De surcrot, nousavons introduit un nouveau chapitre (21), qui montre comment rsoudre les exerciceslorsquon accepte, cette fois, de recourir ces composants standard.

exos_c++.book Page VII Jeudi, 5. juillet 2007 11:10 11

exos_c++.book Page VIII Jeudi, 5. juillet 2007 11:10 11

ditions Eyrolles IX

Table des matires

1 Gnralits, types de base, oprateurs et expressions. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .1

Exercice 1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5Exercice 2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6Exercice 3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7Exercice 4 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8Exercice 5 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9Exercice 6 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10Exercice 7 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11

2 Les instructions de contrle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13

Exercice 8 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15Exercice 9 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16Exercice 10 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17Exercice 11. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18Exercice 12 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19Exercice 13 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20Exercice 14 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21Exercice 15 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22Exercice 16 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23Exercice 17. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24Exercice 18 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25Exercice 19 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27Exercice 20 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28Exercice 21 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29Exercice 22 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30Exercice 23 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32

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

Exercice 24 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37Exercice 25 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38Exercice 26 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39Exercice 27 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40

exos_c++.book Page IX Jeudi, 5. juillet 2007 11:10 11

Exercices en C++

X ditions Eyrolles

Exercice 28. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41Exercice 29. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42Exercice 30. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43Exercice 31 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44Exercice 32. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45Exercice 33. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46

4 Les tableaux, les pointeurs et les chanes de style C . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49

Exercice 34. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54Exercice 35. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55Exercice 36. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56Exercice 37 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57Exercice 38. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58Exercice 39. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59Exercice 40. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61Exercice 41 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63Exercice 42 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64Exercice 43. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65Exercice 44 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66Exercice 45. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66Exercice 46. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67

5 Les structures . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69

Exercice 47 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71Exercice 48. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73Exercice 49. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75Exercice 50. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76Exercice 51 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 78Exercice 52. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79

6 De C C++ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81

Exercice 53. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86Exercice 54. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87Exercice 55. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 88Exercice 56. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 88Exercice 57 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .90Exercice 58. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91

exos_c++.book Page X Jeudi, 5. juillet 2007 11:10 11

ditions Eyrolles XI

Table des matires

Exercice 59 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92Exercice 60 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93Exercice 61 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 94

7 Notions de classe, constructeur et destructeur. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97

Exercice 62 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 100Exercice 63 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102Exercice 64 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 104Exercice 65 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 106Exercice 66 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 108Exercice 67 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 109Exercice 68 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112

8 Proprits des fonctions membre . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 115

Exercice 69 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 117Exercice 70 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 119Exercice 71 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 121Exercice 72 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 123Exercice 73 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 125

9 Construction, destruction et initialisation des objets. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 127

Exercice 74 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 131Exercice 75 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 132Exercice 76 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 134Exercice 77 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 135Exercice 78 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 138Exercice 79 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 141Exercice 80 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 144

10 Les fonctions amies . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 147

Exercice 81 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 149Exercice 82 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 151Exercice 83 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 152

11 Surdfinition doprateurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 155

Exercice 84 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 158Exercice 85 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 160Exercice 86 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 161

exos_c++.book Page XI Jeudi, 5. juillet 2007 11:10 11

Exercices en C++

XII ditions Eyrolles

Exercice 87 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 163Exercice 88. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 165Exercice 89. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 167Exercice 90. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 169Exercice 91 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 171Exercice 92. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 174Exercice 93. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 177Exercice 94. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 181

12 Les conversions de type dfinies par lutilisateur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 183

Exercice 95. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 184Exercice 96. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 185Exercice 97 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 187Exercice 98. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 188Exercice 99. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 189Exercice 100 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 190Exercice 101 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 192

13 La technique de lhritage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 195

Exercice 102 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 198Exercice 103 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 200Exercice 104 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 202Exercice 105 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 203Exercice 106 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 205Exercice 107 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 207Exercice 108 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 208

14 Lhritage multiple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 213

Exercice 109 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 215Exercice 110 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 216Exercice 111 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 217Exercice 112 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 217Exercice 113 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 219Exercice 114 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 220

15 Les fonctions virtuelles. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 225

Exercice 115 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 227

exos_c++.book Page XII Jeudi, 5. juillet 2007 11:10 11

ditions Eyrolles XIII

Table des matires

Exercice 116. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 228Exercice 117 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 230

16 Les flots dentre et de sortie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 237

Exercice 118. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 242Exercice 119. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 244Exercice 120 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 247Exercice 121. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 248Exercice 122 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 249

17 Les patrons de fonctions. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 251

Exercice 123 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 254Exercice 124 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 255Exercice 125 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 256Exercice 126 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 257

18 Les patrons de classes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 259

Exercice 127. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 262Exercice 128 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 264Exercice 129 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 265Exercice 130 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 266Exercice 131. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 268Exercice 132 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 269Exercice 133 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 272Exercice 134 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 273

19 Gestion des exceptions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 275

Exercice 135 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 277Exercice 136 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 278Exercice 137. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 280Exercice 138 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 282Exercice 139 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 284Exercice 140 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 285Exercice 141 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 287

20 Exercices de synthse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 289

Exercice 142 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 289Exercice 143 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 294

exos_c++.book Page XIII Jeudi, 5. juillet 2007 11:10 11

Exercices en C++

XIV ditions Eyrolles

Exercice 144 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 297Exercice 145 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 302Exercice 146 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 308Exercice 147 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .310

21 Les composants standard . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 313

Exercice 148 (67 revisit) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 314Exercice 149 (68 revisit) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 315Exercice 150 (77 revisit) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 317Exercice 151 (78 revisit) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 318Exercice 152 (79 revisit) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 318Exercice 153 (90 revisit) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 319Exercice 154 (91 revisit) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 322Exercice 155 (93 revisit) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 325Exercice 156 (142 revisit) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 327Exercice 157 (143 revisit) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 331Exercice 158 (94 revisit) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 334

exos_c++.book Page XIV Jeudi, 5. juillet 2007 11:10 11

ditions Eyrolles 1

Chapitre 1

Gnralits, types de base, oprateurs et expressions

Rappels

Gnralits

Le canevas minimal utiliser pour raliser un programme C++ se prsente ainsi :#include using namespace std ;main() // en-tte{ ..... // corps du programme}

Toute variable utilise dans un programme doit avoir fait lobjet dune dclaration en prcisantle type et, ventuellement, la valeur initiale. Voici des exemples de dclarations :int i ; // i est une variable de type int nomme ifloat x = 5.25 ; // x est une variable de type float nomme x // initialise avec la valeur 5.25const int NFOIS = 5 ; // NFOIS est une variable de type int dont la // valeur, fixe 5, ne peut plus tre modifie

exos_c++.book Page 1 Jeudi, 5. juillet 2007 11:10 11


2 ditions Eyrolles

Laffichage dinformations lcran est ralis en envoyant des valeurs sur le flot cout ,comme dans :

cout x >> y ; // lit deux valeurs au clavier et les affecte x et y

Types de base

Les types de base sont ceux partir desquels seront construits tous les autres, dits drivs (ilsagira des types structurs comme les tableaux, les structures, les unions et les classes, oudautres types simples comme les pointeurs ou les numrations).Il existe trois types entiers : short int (ou short), int et long int (ou long). Les limita-tions correspondantes dpendent de limplmentation. On peut galement dfinir des typesentiers non signs : unsigned short int (ou unsigned short), unsigned int et unsi-gned long int (ou unsigned long). Ces derniers sont essentiellement destins la mani-pulation de motifs binaires.Les constantes entires peuvent tre crites en notation hexadcimale (comme 0xF54B) ouoctale (comme 014). On peut ajouter le suffixe u pour un entier non sign et le suffixe lpour un entier de type long.Il existe trois types flottants : float, double et long double. La prcision et le domainereprsentable dpendent de limplmentation.Le type caractre permet de manipuler des caractres cods sur un octet. Le code utilisdpend de limplmentation. Il existe trois types caractre : signed char, unsigned char etchar (la norme ne prcise pas sil correspond signed char ou unsigned char).Les constantes de type caractre, lorsquelles correspondent des caractres imprimables ,se notent en plaant le caractre correspondant entre apostrophes.Certains caractres disposent dune reprsentation conventionnelle utilisant le caractre \ notamment \n qui dsigne un saut de ligne. De mme, \ reprsente le caractre et \"dsigne le caractre ". On peut galement utiliser la notation hexadcimale (comme dans \x41) ou octale (comme dans \07).Le type bool permet de manipuler des boolens . Il dispose de deux constantes notestrue et false.


ditions Eyrolles 3

chapitre n 1 Gnralits, types de base, oprateurs et expressions

Les oprateurs de C++

Voici un tableau prsentant lensemble des oprateurs de C++ (certains ne seront exploits quedans des chapitres ultrieurs) :

Les oprateurs arithmtiques et les oprateurs relationnels

Les oprateurs arithmtiques binaires (+, -, * et /) et les oprateurs relationnels ne sont dfinisque pour des oprandes dun mme type parmi : int, long int (et leurs variantes nonsignes), float, double et long double. Mais on peut constituer des expressions mixtes

Catgorie Oprateurs Associativit

Rsolution de porte :: (porte globale - unaire)

:: (porte de classe - binaire)

Rfrence () [] -> . -->

Unaire + - ++ -- ! ~ * & sizeof

cast dynamic_cast static_cast

reinterpret_cast const_cast

new new[] delete delete[]

* .*

Arithmtique + - --->

Dcalage > --->

Relationnels < >= --->

Relationnels == != --->

Manipulation de bits & --->

Manipulation de bits ^ --->

Manipulation de bits | --->

Logique && --->

Logique || --->

Conditionnel (ternaire) ? : --->

Affectation = += -= *= /= %=

&= ^= |= =



4 ditions Eyrolles

(oprandes de types diffrents) ou contenant des oprandes dautres types (bool, char etshort), grce lexistence de deux sortes de conversions implicites : les conversions dajustement de type, selon lune des hirarchies :int -> long -> float -> double -> long doubleunsinged int -> unsigned long -> float -> double -> long double

les promotions numriques, savoir des conversions systmatiques de char (avec ou sansattribut de signe), bool et short en int.

Les oprateurs logiques

Les oprateurs logiques && (et), || (ou) et (non) acceptent nimporte quel oprande numri-que (entier ou flottant) ou pointeur, en considrant que tout oprande de valeur non nulle cor-respond faux :

Les deux oprateurs && et || sont court-circuit : le second oprande nest valu que sila connaissance de sa valeur est indispensable.

Oprateurs daffectation

Loprande de gauche dun oprateur daffectation doit tre une lvalue, cest--dire la rf-rence quelque chose de modifiable.Les oprateurs daffectation (=, -=, += ...), appliqus des valeurs de type numrique, provo-quent la conversion de leur oprande de droite dans le type de leur oprande de gauche. Cetteconversion force peut tre dgradante .

Oprande 1 Oprateur Oprande 2 Rsultat

0 && 0 faux

0 && non nul faux

non nul && 0 faux

non nul && non nul vrai

0 || 0 faux

0 || non nul vrai

non nul || 0 vrai

non nul || non nul vrai

! 0 vrai

! non nul faux


ditions Eyrolles 5


Oprateurs dincrmentation et de dcrmentation

Les oprateurs unaires dincrmentation (++) et de dcrmentation (--) agissent sur la valeurde leur unique oprande (qui doit tre une lvalue) et fournissent la valeur aprs modificationlorsquils sont placs gauche (comme dans ++n) ou avant modification lorsquils sont placs droite (comme dans n--).

Oprateur de cast

Il est possible de forcer la conversion dune expression quelconque dans un type de son choix,grce loprateur dit de cast . Par exemple, si n et p sont des variables entires,lexpression :(double) n / p // ou : static_cast (n/p)

aura comme valeur celle de lexpression entire n/p convertie en double.

Oprateur conditionnel

Cet oprateur ternaire fournit comme rsultat la valeur de son deuxime oprande si la condi-tion mentionne en premier oprande est non nulle (vraie pour une expression boolenne), etla valeur de son troisime oprande dans le cas contraire. Par exemple, avec cette affectation :max = a>b ? a : b ;

on obtiendra dans la variable max la valeur de a si la condition a>b est vraie, la valeur de bdans le cas contraire. Avec :valeur = 2*n-1 ? a : b ;

on obtiendra dans la variable valeur la valeur de a si lexpression 2*n-1 est non nulle, lavaleur de b dans le cas contraire.

Exercice 1

a = x+5 /* expression 1 */

Loprateur + est prioritaire sur loprateur daffectation =.

noncliminer les parenthses superflues dans les expressions suivantes :

a = (x+5) /* expression 1 */a = (x=y) + 2 /* expression 2 */a = (x==y) /* expression 3 */(a


6 ditions Eyrolles

a = (x=y) + 2 /* expression 2 */Ici, loprateur + tant prioritaire sur =, les parenthses sont indispensables.

a = x==y /* expression 3 */Loprateur == est prioritaire sur =.

a int, tandis que c est sou-mis la conversion systmatique char -> int ; les rsultats sont alors additionnspour aboutir la valeur 11 de type int.

4. p et c sont dabord soumis aux mmes conversions systmatiques que ci-dessus ; le rsultat35 est de type int.

noncSoient les dclarations :

char c = '\x01' ;short int p = 10 ;

Quels sont le type et la valeur de chacune des expressions suivantes :p + 3 /* 1 */c + 1 /* 2 */p + c /* 3 */3 * p + 5 * c /* 4 */


ditions Eyrolles 7


Exercice 3

1. c est tout dabord converti en int, avant dtre ajout n. Le rsultat (10), de type int,est alors converti en long, avant dtre ajout p. On obtient finalement la valeur 1010,de type long.

2. On value dabord la valeur de 2*x, en convertissant 2 (int) en float, ce qui fournit lavaleur 2.5 (de type float). Par ailleurs, c est converti en int (conversion systmati-que). On value ensuite la valeur de 2*x, en convertissant 2 (int) en float, ce quifournit la valeur 2.5 (de type float). Pour effectuer laddition, on convertit alors lavaleur entire 5 (c) en float, avant de lajouter au rsultat prcdent. On obtient finale-ment la valeur 7.75, de type float.

3. n est tout dabord converti en char ( cause de loprateur de cast ), tandis que c estconverti (conversion systmatique) en int. Puis, pour procder laddition, il est nces-saire de reconvertir la valeur de (char) n en int. Finalement, on obtient la valeur 10,de type int.

4. z est dabord converti en float, ce qui fournit la valeur 5.5 (approximative, car, en fait,on obtient une valeur un peu moins prcise que ne le serait 5.5 exprim en double). Parailleurs, on procde la division entire de n par 2, ce qui fournit la valeur entire 2. Cettedernire est ensuite convertie en float, avant dtre ajoute 5.5, ce qui fournit le rsul-tat 7.5, de type float.

noncSoient les dclarations :

char c = '\x05' ;int n = 5 ;long p = 1000 ;float x = 1.25 ;double z = 5.5 ;

Quels sont le type et la valeur de chacune des expressions suivantes :n + c + p /* 1 */2 * x + c /* 2 */(char) n + c /* 3 */(float) z + n / 2 /* 4 */



8 ditions Eyrolles

Exercice 4

1. 1 2. 03. 5 (p%n vaut 4, tandis que p>n vaut 1).4. 1 (p/n est dabord valu en int, ce qui fournit 1 ; puis le rsultat est converti enfloat, avant dtre affect x).

5. 1.8 (p est converti en float, avant dtre divis par le rsultat de la conversion de n enfloat).

6. 1.9 (p est converti en float, avant dtre ajout 0.5 ; le rsultat est divis par lersultat de la conversion de n en float).

7. 1 (p est converti en float, avant dtre ajout 0.5 ; le rsultat (5.5) est alors convertien int avant dtre divis par n).

8. 259. 45

noncSoient les dclarations suivantes :

int n = 5, p = 9 ;int q ;float x ;

Quelle est la valeur affecte aux diffrentes variables concernes par chacune des instructionssuivantes ?

q = n < p ; /* 1 */q = n == p ; /* 2 */q = p % n + p > n ; /* 3 */x = p / n ; /* 4 */x = (float) p / n ; /* 5 */x = (p + 0.5) / n ; /* 6 */x = (int) (p + 0.5) / n ; /* 7 */q = n * (p > n ? n : p) ; /* 8 */q = n * (p < n ? n : p) ; /* 9 */


ditions Eyrolles 9


Exercice 5

A : i = 1 n = 0B : i = 11 n = 11C : i = 21 j = 6 n = 120D : i = 18 n = 18E : i = 12 j = 4 n = 12

noncQuels rsultats fournit le programme suivant :

#include using namespace std ;main (){ int i, j, n ; i = 0 ; n = i++ ; cout


10 ditions Eyrolles

Exercice 6

A : n = 10 p = 10 q = 10 r = 1B : n = 15 p = 10 q = 5C : n = 15 p = 11 q = 10D : n = 16 p = 11 q = 15

noncQuels rsultats fournira ce programme :#include using namespace std ;main(){ int n=10, p=5, q=10, r ;

r = n == (p = q) ; cout

ditions Eyrolles 11


Exercice 7

Il ne faut pas oublier que les oprateurs && et || nvaluent leur second oprande que lorsquecela est ncessaire. Ainsi, ici, il nest pas valu dans les cas 1 et 3. Voici les rsultats fournispar ce programme :

A : n = 6 p = 2 q = 1B : n = 6 p = 3 q = 1C : n = 6 p = 2 q = 0D : n = 6 p = 3 q = 1

noncQuels rsultats fournira ce programme :

#include using namespace std ;main(){ int n, p, q ;

n = 5 ; p = 2 ; /* cas 1 */ q = n++ >p || p++ != 3 ; cout

ditions Eyrolles 13

Chapitre 2

Les instructions de contrle

Rappels

Le terme instruction dsignera indiffremment : une instruction simple (termine par unpoint-virgule), une instruction structure (choix, boucle) ou un bloc (instructions entre { et }).

Instruction if

Elle possde deux formes :if (expression) instruction_1 else instruction_2if (expression) instruction_1

Lorsque des instructions if sont imbriques, un else se rapporte toujours au dernier ifauquel un else na pas encore t attribu.

Instruction switch

switch (expression) { bloc_d_instructions ]



14 ditions Eyrolles

Cette instruction value la valeur de lexpression entire mentionne, puis recherche dans le blocqui suit sil existe une tiquette de la forme case x (x tant une expression constante, cest--dire calculable par le compilateur) correspondant cette valeur. Si cest le cas, il y a branche-ment linstruction figurant la suite de cette tiquette. Dans le cas contraire, on passe lins-truction suivant le bloc. Lexpression peut tre de type char, auquel cas elle sera convertie enentier.Une instruction switch peut contenir une ou plusieurs instructions break qui provoquent lasortie du bloc. Il est possible dutiliser le mot default comme tiquette laquelle le pro-gramme se branche lorsque aucune valeur satisfaisante na t rencontre auparavant.

Instructions do... while et while

do instruction while (expression) ;

while (expression) instruction

Lexpression gouvernant la boucle peut tre dun type quelconque ; elle sera convertie en boolselon la rgle : non nul devient vrai, nul devient faux.

Instruction for

for ([expression_dclaration_1] ; [expression_2] ; [expression_3] ) instruction

Les crochets signifient que leur contenu est facultatif.

expression_dclaration_1 est soit une expression, soit une dclaration dune ou plu-sieurs variables dun mme type, initialises ou non ;

expression_2 est une expression quelconque (qui sera ventuellement convertie enbool) ;

expression_3 est une expression quelconque.

Cette instruction est quivalente :{ expression_dclaration_1 ; while (expression_2) { instruction ; expression_3 ; }}


ditions Eyrolles 15

chapitre n 2 Les instructions de contrle

Instructions break , continue et goto

Une boucle (do... while, while ou for) peut contenir une ou plusieurs instructions breakdont le rle est dinterrompre le droulement de la boucle, en passant linstruction qui suitcette boucle. En cas de boucles imbriques, break fait sortir de la boucle la plus interne. Sibreak apparat dans un switch imbriqu dans une boucle, elle ne fait sortir que du switch.Linstruction continue semploie uniquement dans une boucle. Elle permet de passer prma-turment au tour de boucle suivant.Linstruction goto permet le branchement en un emplacement quelconque du programme,repr par une tiquette, comme dans cet exemple o, lorsquune certaine condition est vraie,on se branche ltiquette erreur :for (...) { ..... if (...) goto erreur ; .....

} erreur : .....



16 ditions Eyrolles

Exercice 8

1. Il manque un point-virgule la fin de la premire ligne :if (a

ditions Eyrolles 17


Exercice 9

a.NulPetit

b.Petit

c.

MoyenGrand

d.Grand

e.

Grand

noncSoit le programme suivant :

#include main(){ int n ; cin >> n ; switch (n) { case 0 : cout


18 ditions Eyrolles

Exercice 10

a. Il manque un point-virgule :do cin >> c ; while (c != '\n') ;

b. Il manque une instruction (ventuellement vide ) aprs le mot do. On pourrait crire, parexemple :do {} while ( (cin >> c, c != '\n') ;

ou :do ; while ( cin >> c, c != '\n') ;

c. Il ny aura pas derreur de compilation (la valeur entire 1 est convertie en boolen, ce quifournit la valeur vrai) ; toutefois, il sagit dune boucle infinie .

Exercice 11

Plusieurs possibilits existent, puisquil suffit de reporter, dans le corps de la boucle, desinstructions figurant artificiellement sous forme dexpressions dans la condition depoursuite :

do cout 0 " ;while (cin >> n, n> c while (c != '\n') ;b.

do while ( cin >> c, c != '\n') ;c.

do {} while (1) ;

nonccrire plus lisiblement :

do {} while (cout > n, n

ditions Eyrolles 19


ou, mieux :

do { cout > n ; }while (n


20 ditions Eyrolles

}

b.#include using namespace std ;main(){ int i, n, som ; som = 0 ; i = 0 ; /* ne pas oublier cette "initialisation" */ do { cout > n ; som += n ; i++ ; /* ni cette "incrmentation" */ } while (i

ditions Eyrolles 21


9 est multiple de 315 est multiple de 320 est multiple de 5

Exercice 14

A : n = 6B : n = 10C : n = 10D : n = 15E : n = 21


#include using namespace std ;main(){ int n, p ;

n=0 ; while (n


22 ditions Eyrolles

Exercice 15

A : n = 6, p = 1 B : n = 6, p = 3


#include using namespace std ;main(){ int n, p ;

n=p=0 ; while (n

ditions Eyrolles 23


Exercice 16

A : i = 5, n = 5B : i = 5, n = 5C : i = 9, n = 5D : i = 1, n = 1D : i = 2, n = 3D : i = 3, n = 6E : i = 3, n = 6


#include using namespace std ;main(){ int i, n ;

for (i=0, n=0 ; i


24 ditions Eyrolles

Exercice 17

Il existe beaucoup de rdactions possibles ; en voici 3 :

1.#include #include // pour la dclaration de sqrtusing namespace std ;main(){ double x ; do { cout > x ; if (x < 0) cout

ditions Eyrolles 25


if (x


26 ditions Eyrolles

float som ; /* pour la somme de la srie */ int i ;

do { cout > nt ; } while (nt

ditions Eyrolles 27


Exercice 19

#include using namespace std ;

main(){ const char car = '*' ; /* caractre de remplissage */ int nlignes ; /* nombre total de lignes */ int nl ; /* compteur de ligne */ int nesp ; /* nombre d'espaces prcdant une toile */ int j ;

cout > nlignes ; for (nl=0 ; nl


28 ditions Eyrolles

Exercice 20

#include #include // pour setwusing namespace std ;main(){ int nbf ; // compteur du nombre de faons de faire 1 euro int n10 ; // nombre de pices de 10 centimes int n5 ; // nombre de pices de 5 centimes int n2 ; // nombre de pices de 2 centimes

noncAfficher toutes les manires possibles dobtenir un euro avec des pices de 2 cents, 5 cents et 10 cents.Dire combien de possibilits ont t ainsi trouves. Les rsultats seront affichs comme suit :

1 euro = 50 X 2c 1 euro = 45 X 2c 2 X 5c 1 euro = 40 X 2c 4 X 5c 1 euro = 35 X 2c 6 X 5c 1 euro = 30 X 2c 8 X 5c 1 euro = 25 X 2c 10 X 5c 1 euro = 20 X 2c 12 X 5c 1 euro = 15 X 2c 14 X 5c 1 euro = 10 X 2c 16 X 5c 1 euro = 5 X 2c 18 X 5c 1 euro = 20 X 5c 1 euro = 45 X 2c 1 X 10c1 euro = 40 X 2c 2 X 5c 1 X 10c1 euro = 35 X 2c 4 X 5c 1 X 10c1 euro = 10 X 2c 2 X 5c 7 X 10c1 euro = 5 X 2c 4 X 5c 7 X 10c1 euro = 6 X 5c 7 X 10c1 euro = 10 X 2c 8 X 10c1 euro = 5 X 2c 2 X 5c 8 X 10c1 euro = 4 X 5c 8 X 10c1 euro = 5 X 2c 9 X 10c1 euro = 2 X 5c 9 X 10c1 euro = 10 X 10c

En tout, il y a 66 faons de faire 1 euro

Rappelons que linsertion dans le flot cout dune expression de la forme setw(n, o n est uneexpression entire, demande de raliser laffichage suivant (et uniquement ce dernier) sur n caractresau minimum. Lemploi de setw ncessite linclusion du fichier iomanip.


ditions Eyrolles 29


nbf = 0 ; for (n10=0 ; n10


30 ditions Eyrolles

while (i++

ditions Eyrolles 31


max = -1 ; // initialisation max (possible car toutes notes >=0 min = 21 ; // initialisation min (possible car toutes notes < 21 while (cout > note, note >=0) { if (note == max) nmax++ ; if (note > max) { max = note ; nmax = 1 ; } if (note == min) nmin++ ; if (note < min) { min = note ; nmin = 1 ; } }

if (max >= 0) { cout


32 ditions Eyrolles

Exercice 23

#include #include // pour setwusing namespace std ;main(){ const int NMAX = 10 ; // nombre de valeurs int i, j ;

/* affichage ligne en-tte */ cout

ditions Eyrolles 33

Chapitre 3

Les fonctions

Rappels

Gnralits

Une fonction est un bloc dinstructions ventuellement paramtr par un ou plusieurs argu-ments et pouvant fournir un rsultat nomm souvent valeur de retour . On distingue la dfi-nition dune fonction de son utilisation, cette dernire ncessitant une dclaration.La dfinition dune fonction se prsente comme dans cet exemple :float fexple (float x, int b, int c) // en-tte de la fonction{ // corps de la fonction}

Len-tte prcise le nom de la fonction (fexple) ainsi que le type et le nom (muet) de ses dif-frents arguments (x, b et c). Le corps est un bloc dinstructions qui dfinit le rle de la fonc-tion.Au sein dune autre fonction (y compris main), on utilise cette fonction de cette faon :float fepxle (float, int, int) ; // dclaration de fexple ("prototype") .....

fexple (z, n, p) ; //appel fexple avec les arguments effectifs z, n et p



34 ditions Eyrolles

La dclaration dune fonction peut tre omise lorsquelle est connue du compilateur, cest--dire que sa dfinition a dj t rencontre dans le mme fichier source.

Mode de transmission des arguments

Par dfaut, les arguments sont transmis par valeur. Dans ce cas, les arguments effectifs peu-vent se prsenter sous la forme dune expression quelconque.En faisant suivre du symbole & le type dun argument dans len-tte dune fonction (et dans sadclaration), on ralise une transmission par rfrence. Cela signifie que les ventuelles modi-fications effectues au sein de la fonction porteront sur largument effectif de lappel et nonplus sur une copie. On notera qualors largument effectif doit obligatoirement tre une lva-lue du mme type que largument muet correspondant. Toutefois, si largument muet est, desurcrot, dclar avec lattribut const, la fonction reoit quand mme une copie de largumenteffectif correspondant, lequel peut alors tre une constante ou une expression dun type sus-ceptible dtre converti dans le type attendu.Ces possibilits de transmission par rfrence sappliquent galement une valeur de retour(dans ce cas, la notion de constance na plus de signification).

La notion de rfrence est thoriquement indpendante de celle de transmission dargument ;en pratique, elle est rarement utilise en dehors de ce contexte.

Linstruction return

Linstruction return sert la fois fournir une valeur de retour et mettre fin lexcution dela fonction. Elle peut mentionner une expression ; elle peut apparatre plusieurs reprises dansune mme fonction ; si aucune instruction return nest mentionne, le retour est mis en place la fin de la fonction.Lorsquune fonction ne fournit aucun rsultat, son en-tte et sa dclaration comportent le motvoid la place du type de la valeur de retour, comme dans :void fSansValRetour (...)

Lorsquune fonction ne reoit aucun argument, len-tte et la dclaration comportent une listevide, comme dans :int fSansArguments ()

Les arguments par dfaut

Dans la dclaration dune fonction, il est possible de prvoir pour un ou plusieurs arguments(obligatoirement les derniers de la liste) des valeurs par dfaut ; elles sont indiques par lesigne =, la suite du type de largument, comme dans cet exemple :


ditions Eyrolles 35

chapitre n 3 Les fonctions

float fct (char, int = 10, float = 0.0) ;

Ces valeurs par dfaut seront alors utilises lorsquon appellera ladite fonction avec un nom-bre darguments infrieur celui prvu. Par exemple, avec la prcdente dclaration, lappelfct ('a') sera quivalent fct ('a', 10, 0.0) ; de mme, lappel fct ('x', 12) seraquivalent fct ('x', 12, 0.0). En revanche, lappel fct () sera illgal.

Conversion des arguments

Lorsquun argument est transmis par valeur, il est ventuellement converti dans le type men-tionn dans la dclaration (la conversion peut tre dgradante). Ces possibilits de conversiondisparaissent en cas de transmission par rfrence : largument effectif doit alors tre une lva-lue du type prvu ; ctte dernire ne peut possder lattribut const si celui-ci nest pas prvudans largument muet ; en revanche, si lagument muet mentionne lattribut const, largu-ment effectif pourra tre non seulement une constante, mais galement une expression duntype quelconque dont la valeur sera alors convertie dans une variable temporaire dontladresse sera fournie la fonction.

Variables globales et locales

Une variable dclare en dehors de toute fonction (y compris du main) est dite globale. La por-te dune variable globale est limite la partie du programme source suivant sa dclaration.Les variable globales ont une classe dallocation statique, ce qui signifie que leurs emplace-ments en mmoire restent fixes pendant lexcution du programme.Une variable dclare dans une fonction est dite locale. La porte dune variable locale estlimite la fonction dans laquelle elle est dfinie. Les variables locales ont une classe dallo-cation automatique, ce qui signifie que leurs emplacements sont allous lentre dans lafonction, et librs la sortie. Il est possible de dclarer des variables locales un bloc.On peut demander quune variable locale soit de classe dallocation statique, en la dclarant laide du mot-cl static, comme dans :static int i ;

Les variables de classe statique sont, par dfaut, initialises zro. On peut les initialiserexplicitement laide dexpressions constantes dun type compatible par affectation aveccelui de la variable. Celles de classe automatique ne sont pas initialises par dfaut. Elles doi-vent tre initialises laide dune expression quelconque, dun type compatible par affecta-tion avec celui de la variable.



36 ditions Eyrolles

Surdfinition de fonctions

En C++, il est possible, au sein dun mme programme, que plusieurs fonctions possdent lemme nom. Dans ce cas, lorsque le compilateur rencontre lappel dune telle fonction, il effec-tue le choix de la bonne fonction en tenant compte de la nature des arguments effectifs. Dune manire gnrale, si les rgles utilises par le compilateur pour sa recherche sont assezintuitives, leur nonc prcis est assez complexe, et nous ne le rappellerons pas ici. On trou-vera de nombreux exemples de surdfinition et un rcapitulatif complet des rgles dans nosouvrages consacrs au C++ (publis galement aux ditions Eyrolles). Signalons simplementque la recherche dune fonction surdfinie peut faire intervenir toutes les conversions usuelles(promotions numriques et conversions standards, ces dernires pouvant tre dgradantes),ainsi que les conversions dfinies par lutilisateur en cas dargument de type classe, conditionquaucune ambigut napparaisse.

Les fonctions en ligne

Une fonction en ligne (on dit aussi dveloppe ) est une fonction dont les instructions sontincorpores par le compilateur (dans le module objet correspondant) chaque appel. Celavite la perte de temps ncessaire un appel usuel (changement de contexte, copie des valeursdes arguments sur la pile ...) ; en revanche, les instructions en question sont gnresplusieurs fois.Une fonction en ligne est ncessairement dfinie en mme temps quelle est dclare (elle nepeut plus tre compile sparment) et son en-tte est prcde du mot-cl inline, commedans :

inline fct ( ...) { ..... }


ditions Eyrolles 37


Exercice 24

La fonction fct est utilise dans la fonction main, sans tre encore connue du compilateur,ce qui provoque une erreur de compilation. Pour y rmdier, on dispose de deux possibilits :

dclarer la fonction avant son utilisation dans main, de prfrence au dbut :

#include using namespace std ;main(){ int fct (int) ; // dclaration de fct ; on pourrait crire int fct (int x) int n, p=5 ; n = fct (p) ; cout


38 ditions Eyrolles

Il est conseill dutiliser la premire dmarche qui a le mrite de permettre de modifier lesemplacements des dfinitions de fonctions dans un fichier source ou, mme, de le scinder enplusieurs parties (compilation spare).

Exercice 25

Lnonc ne prcisant rien, nous utiliserons une transmission darguments par valeur. Commeon nimpose pas dordre aux dfinitions des diffrentes fonctions dans le fichier source, ondclarera systmatiquement toutes les fonctions utilises.#include using namespace std ;

void f1 (void){ cout

ditions Eyrolles 39


main(){ void f1 (void) ; void f2 (int) ; int f3 (int) ; f1 () ; f2 (3) ; f3 (3) ;}

Exercice 26

B : dans fct, n = 10, p = 5, q = 20A : dans main, n = 20, p = 5, q = 2C : dans f, n = 10, p = 20, q = 2

noncQuels rsultats fournira ce programme :


int n=10, q=2 ;main(){ int fct (int) ; void f (void) ; int n=0, p=5 ; n = fct(p) ; cout


40 ditions Eyrolles

Exercice 27


float oper (float v1, float v2, char op){ float res ; switch (op) { case '+' : res = v1 + v2 ; break ; case '-' : res = v1 - v2 ; break ; case '*' : res = v1 * v2 ; break ; case '/' : res = v1 / v2 ; break ; default : res = v1 + v2 ; } return res ;}

main(){ float oper (float, float, char) ; // dclaration de oper float x, y ;

cout > x >> y ;

cout

ditions Eyrolles 41


Exercice 28

#include using namespace std ;char op ; // variable globale pour la nature de l'opration // attention : doit tre dclare avant d'tre utilise

float oper (float v1, float v2){ float res ; switch (op) { case '+' : res = v1 + v2 ; break ; case '-' : res = v1 - v2 ; break ; case '*' : res = v1 * v2 ; break ; case '/' : res = v1 / v2 ; break ; default : res = v1 + v2 ; } return res ;}

main(){ float oper (float, float) ; /* prototype de oper */ float x, y ;

cout > x >> y ;

op = '+' ; cout


42 ditions Eyrolles

Il sagissait ici dun exercice d cole destin forcer lutilisation dune variable globale.Dans la pratique, on vitera autant que possible ce genre de programmation qui favorise troples risques d effets de bord .

Exercice 29

La meilleure solution consiste prvoir, au sein de la fonction en question, une variable declasse statique. Elle sera initialise une seule fois zro (ou toute autre valeur ventuelle-ment explicite) au dbut de lexcution du programme. Ici, nous avons, de plus, prvu unpetit programme dessai.


void fcompte (void){ static int i ; // il est inutile, mais pas interdit, d'crire i=0 i++ ; cout

ditions Eyrolles 43


Exercice 30


int mul2 (int n){ if (n%2) return 0 ; else return 1 ;}

int mul3 (int n){ if (n%3) return 0 ; else return 1 ;}

main(){ int mul2 (int) ; int mul3 (int) ; int n ; cout > n ; if (mul2(n)) cout


44 ditions Eyrolles

Exercice 31

tant donn que la fonction doit tre en mesure de modifier la valeur de son second argument,il est ncessaire que ce dernier soit transmis par rfrence.


void ajoute (int exp, int & var){ var += exp ; return ;}main(){ void ajoute (int, int &) ; int n = 12 ; int p = 3 ; cout

ditions Eyrolles 45


Exercice 32

Les cas a, b, c et d ne posent aucun problme. Il y a respectivement appel des fonctions I, II,III et IV, sans quaucune conversion dargument ne soit ncessaire.e. Appel de la fonction I, aprs conversion de la valeur de c en int.f. Appel incorrect, compte tenu de son ambigut ; deux possibilits existent en effet :

conserver n, convertir p en float et appeler la fonction III ou, au contraire, convertir n enfloat, conserver p et appeler la fonction IV.

g. Appel de la fonction III, aprs conversion de c en float.h. Appel de la fonction III, aprs conversion (dgradante) de z en float.i. Appel incorrect, compte tenu de son ambigut ; deux possibilits existent en effet :

convertir le premier argument en float et le second en int et appeler la fonction III ou, aucontraire, convertir le premier argument en int et le second en float et appeler lafonction IV.

noncSoient les dclarations suivantes :

int fct (int) ; // fonction Iint fct (float) ; // fonction IIvoid fct (int, float) ; // fonction IIIvoid fct (float, int) ; // fonction IVint n, p ;float x, y ;char c ;double z ;

Les appels suivants sont-ils corrects et, si oui, quelles seront les fonctions effectivementappeles et les conversions ventuellement mises en place ?

a. fct (n) ;b. fct (x) ;c. fct (n, x) ;d. fct (x, n) ;e. fct (c) ;f. fct (n, p) ;g. fct (n, c) ;h. fct (n, z) ;i. fct (z, z) ;



46 ditions Eyrolles

Exercice 33

a. Nous devons donc dabord dclarer (et dfinir en mme temps) la fonction fct comme unefonction en ligne. Le programme main scrit de la mme manire, si ce nest que la dcla-ration de fct ny est plus ncessaire puisquelle apparat auparavant (il reste permis de ladclarer, condition de ne pas utiliser le qualificatif inline).

#include using namespace std ;inline int fct (char c, int n) { int res ; if (c == 'a') res = n + c ; else if (c == 's') res = n - c ; else res = n * c ; return res ;}main (){ int n = 150, p ; char c = 's' ; p = fct (c, n) ; cout

ditions Eyrolles 47


b. Il sagit en fait dune question pige. En effet, la fonction fct tant en ligne, elle ne peutplus tre compile sparment. Il est cependant possible de la conserver dans un fichierdextension h et dincorporer simplement ce fichier par #include pour compiler le main.Cette dmarche se rencontrera dailleurs frquemment dans le cas de classes comportantdes fonctions en ligne. Alors, dans un fichier dextension h, on trouvera la dclaration de laclasse en question, lintrieur de laquelle apparatront les dclarations-dfinitions desfonctions en ligne.


ditions Eyrolles 49

Chapitre 4

Les tableaux, les pointeurs et les chanes de style C

Rappels

Tableau un indice

Un tableau un indice est un ensemble dlments de mme type dsigns par un identifica-teur unique. Chaque lment est repr par un indice prcisant sa position dans lensemble (lepremier lment est repr par lindice 0).Linstruction suivante :float t [10] ;

rserve lemplacement pour un tableau de 10 lments de type float, nomm t.Un lment de tableau est une lvalue. Un indice peut prendre la forme de nimporte quelleexpression arithmtique dun type entier quelconque. Le nombre dlments dun tableau(dimension) doit tre indiqu sous forme dune expression constante.



50 ditions Eyrolles

Tableaux plusieurs indices

La dclaration :int t[5][3] ;

rserve un tableau de 15 (5 3) lments. Un lment quelconque de ce tableau se trouvealors repr par deux indices comme dans ces notations :t[3][2] t[i][j]

Dune manire gnrale, on peut dfinir des tableaux comportant un nombre quelconquedindices.Les lments dun tableau sont rangs en mmoire selon lordre obtenu en faisant varier ledernier indice en premier.

Initialisation des tableaux

Les tableaux de classe statique sont, par dfaut, initialiss zro. Les tableaux de classe auto-matique ne sont pas initialiss par dfaut.On peut initialiser (partiellement ou totalement) un tableau lors de sa dclaration, comme dansces exemples :int t1[5] = { 10, 20, 5, 0, 3 } ; // place les valeurs 10, 20, 5, 0 et 3 dans les cinq lments de t1

int t2 [5] = { 10, 20 } ; // place les valeurs 10 et 20 dans les deux premiers lments de t2

Les deux dclarations suivantes sont quivalentes :int tab [3] [4] = { { 1, 2, 3, 4 }, { 5, 6, 7, 8 }, { 9,10,11,12 } }int tab [3] [4] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12 } ;

Les initialiseurs fournis pour linitialisation des lments dun tableau doivent tre des expres-sions constantes pour les tableaux de classe statique, et des expressions quelconques (duntype compatible par affectation) pour les tableaux de classe automatique.

Les pointeurs, les oprateurs & et *

Une variable pointeur est destine manipuler des adresses dinformations dun type donn.On la dclare comme dans ces exemples :int * adi ; // adi contiendra des adresses dentiers de type intfloat * adf ; // adf contiendra des adresses de flottants de type float


ditions Eyrolles 51

chapitre n 4 Les tableaux, les pointeurs et les chanes de style C

Loprateur & permet dobtenir ladresse dune variable :int n ; .....

adi = &n ; // adi contient ladresse de nLoprateur * permet dobtenir linformation dadresse donne. Ainsi *adi dsigne la lvaluedadresse adi, cest--dire ici n :int p = *adi ; // place dans p la valeur de n*adi = 40 ; // place la valeur 40 ladresse contenue dans adi, // donc ici dans n

Il existe un type pointeur gnrique , cest--dire pour lequel on ne prcise pas la nature desinformations pointes, savoir le type void *.

Oprations sur les pointeurs

On peut incrmenter ou dcrmenter des pointeurs dune valeur donne. Par exemple :adi++ ; // modifie adi de manire quelle pointe // sur lentier suivant nadi -= 10 ; // modifie adi de manire quelle pointe // 10 entiers avant

Lunit dincrmentation ou de dcrmentation des pointeurs gnriques est loctet.On peut comparer ou soustraire des pointeurs de mme type (pointant sur des lments demme type).

Affectations de pointeurs et conversions

Il nexiste aucune conversion implicite dun type pointeur en un autre, lexception de la con-version en pointeur gnrique.Il nexiste aucune conversion implicite dun entier en un pointeur, lexception de la valeur 0qui est alors convertie en un pointeur ne pointant sur rien .

Tableaux et pointeurs

Un nom de tableau est une constante pointeur. Avec :int t[10] ;

t+1 est quivalent &t[1] ;t+i est quivalent &t[i] ;ti] est quivalent *(t+i).



52 ditions Eyrolles

Avec :int t[3] [4] ;

t est quivalent &t[0][0] ou t[0] ;t+2 est quivalent &t[2][0] ou t[2]Lorsquun nom de tableau est utilis en argument effectif, cest (la valeur de) ladresse qui esttransmise la fonction. La notion de transmission par rfrence na pas de sens dans ce cas.Dans la dclaration dune fonction disposant dun argument de type tableau, on peut utiliserindiffremment le formalisme tableau (avec ou sans la dimension effective du tableau) oule formalisme pointeur ; ces trois dclarations sont quivalentes :void fct (int t[10])void fct (int t[])void fct (int * t)

Gestion dynamique de la mmoire

Si type reprsente la description dun type absolument quelconque et si n reprsente uneexpression dun type entier (gnralement long ou unsigned long), lexpression :new type [n]

alloue lemplacement ncessaire pour n lments du type indiqu et fournit en rsultat unpointeur (de type type *) sur le premier lment. En cas dchec dallocation, il y a dclen-chement dune exception bad_alloc (les exceptions font lobjet du chapitre 19). Lindica-tion n est facultative : avec new type, on obtient un emplacement pour un lment du typeindiqu, comme si lon avait crit new type[1].Lexpression :delete adresse // il existe une autre syntaxe pour les // tableaux dobjets - voir chap. 9

libre un emplacement pralablement allou par new ladresse indique. Il nest pas nces-saire de rpter le nombre dlments, du moins lorsquil ne sagit pas dobjets, mme si celui-ci est diffrent de 1. Le cas des tableaux dobjets est examin au chapitre 9.

Pointeurs sur des fonctions

Un pointeur sur une fonction est dfini par le type des arguments et de la valeur de retour de lafonction, comme dans :int (* adf) (double, int) ; // adf est un pointeur sur une fonction // recevant un double et un int // et renvoyant un int

Un nom de fonction, employ seul, est traduit par le compilateur en ladresse de cette fonction.


ditions Eyrolles 53


Chanes de style C

Une chane de caractre de style C est une suite doctets (reprsentant chacun un caractre),termine par un octet de code nul. Les chanes constantes sont reprsentes selon cette con-vention. Les lectures opres sur le flot cin, ainsi que les critures sur le flot cout, utilisentcette convention lorsquelles portent sur des lvalue de type tableau de caractres ou pointeursur des caractres (type char *).Un tableau de caractres peut tre initialis par une chane constante. Ces deux instructionssont quivalentes :char ch[20] = "bonjour" ; char ch[20] = { b, o, n, j, o, u, r, \0) ;

Arguments de la ligne de commande

Lors du lancement dun programme, la plupart des environnements permettent de lui fournirdes paramtres . Ceux-ci sont alors simplement transmis la fonction main, sous forme dechane de style C, comme des arguments effectifs dappel dune fonction. Ils sont, en outre,prcds du nombre total darguments (int) et du nom du programme (chane de style C).Pour pouvoir les exploiter, il est alors ncessaire dutiliser une dclaration de main telle que :main (int nbarg, char * argv[])



54 ditions Eyrolles

Exercice 34

/* 1 */ remplit le tableau avec les valeurs 0 (0+0), 2 (1+1) et 4 (2+2) ; on obtien-drait plus simplement le mme rsultat avec lexpression 2*i.

/* 2 */ affiche classiquement les valeurs du tableau t, dans lordre naturel.

/* 3 */ fait la mme chose, en utilisant le formalisme pointeur au lieu du formalismetableau. Ainsi, *(t+i) est parfaitement quivalent t[i].

/* 4 */ fait la mme chose, en utilisant la lvalue adt ( laquelle on a affect initialementladresse t du tableau) et en lincrmentant pour parcourir les diffrentes adresses des 4 l-ments du tableau.

/* 5 */ affiche les valeurs de t, lenvers, en utilisant le mme formalisme pointeur quedans 4. On aurait pu crire, de faon quivalente :

for (i=2 ; i>=0 ; i--) cout

ditions Eyrolles 55


Voici les rsultats fournis par ce programme :

0 2 4 0 2 4 0 2 4 4 2 0

Exercice 35

a. La programmation est, ici, classique. Nous avons simplement dfini une constante NVALdestine contenir le nombre de valeurs du tableau. Notez bien que la dclaration intt[NVAL] est accepte puisque NVAL est une expression constante .


main(){ const int NVAL = 10 ; /* nombre de valeurs du tableau */ int i, min, max ; int t[NVAL] ;

cout


56 ditions Eyrolles

b. On peut remplacer systmatiquement t[i] par *(t+i). Voici finalement le programmeobtenu :#include using namespace std ;

main(){ const int NVAL = 10 ; /* nombre de valeurs du tableau */ int i, min, max ; int t[NVAL] ;

cout

ditions Eyrolles 57


Mais on peut recopier dabord dans t1 les lments positifs de t2, avant de complter ven-tuellement par des zros. Cette seconde formulation, moins simple que la prcdente, se rv-lerait toutefois plus efficace sur de grands tableaux :

int i, j ; for (i=0, j=0 ; j 0) t1[i++] = t2[j] ; for (j=i ; j


58 ditions Eyrolles

Exercice 38

a. La premire solution ne pose aucun problme particulier : int i, j ; som = 0 ; for (i=0 ; i

ditions Eyrolles 59


Cela nest vrai que parce que lon passe de pointeurs sur des groupes dlments un pointeursur ces lments. Autrement dit, aucune contrainte dalignement ne risque de nuire ici. Il nenirait pas de mme, par exemple, pour des conversions de char * en int *.

Gnralement, on y gagnera en lisibilit en explicitant la conversion mise en uvre laidede loprateur de cast. Notez que, par ailleurs, cela peut viter certains messages daver-tissement (warnings) de la part du compilateur.Voici finalement ce que pourraient tre les instructions demandes : int i ; int * adt ; som = 0 ; adt = (float *) t ; for (i=0 ; i


60 ditions Eyrolles

pas allouer un emplacement puisque le tableau en question aura t allou dans la fonc-tion appelant somme).Voici ce que pourrait tre la fonction demande :

float somme (float t[], int n)// on peut crire somme (float * t,... // ou encore somme (float t[4], ... // mais pas somme (float t[n], ... { int i ; float s = 0 ; for (i=0 ; i

ditions Eyrolles 61


Exercice 40

En C++, par dfaut, les arguments sont transmis par valeur. Mais, dans le cas dun tableau,cette valeur, de type pointeur, nest rien dautre que ladresse du tableau. Quant la transmis-sion par rfrence, elle na pas de signification dans ce cas. Nous navons donc aucun choixconcernant le mode de transmission de notre tableau.En ce qui concerne le nombre dlments du tableau, on peut indiffremment en transmettreladresse (sous forme dun pointeur de type int *), ou la valeur ; ici, la seconde solution estla plus approprie, puisque la fonction na pas besoin den modifier la valeur.En revanche, en ce qui concerne le maximum et le minimum, ils ne peuvent pas tre transmispar valeur, puisquils doivent prcisment tre dtermins par la fonction. Il faut donc obliga-toirement prvoir de passer :

soit des rfrences. Len-tte de notre fonction se prsentera ainsi :void maxmin (int t[], int n, int & admax, int & admin)

soit des pointeurs sur des float. Len-tte de notre fonction se prsentera ainsi :void maxmin (int t[], int n, int * admax, int * admin)

Lalgorithme de recherche de maximum et de minimum peut tre calqu sur celui de lexercice39, en remplaant max par *admax et min par *admin. Voici ce que pourrait tre notrefonction :

avec transmission par rfrence :void maxmin (int t[], int n, int & admax, int & admin){ int i ; admax = t[1] ; admin = t[1] ; for (i=1 ; i admax) admax = t[i] ; if (t[i] < admin) admin = t[i] ; }}

nonccrire une

Engineering

Exercices en langage c++ ()