Apprendre Java-et-C++-en-parallele

4 689 vues

Publié le

Cours Java et C++ en paralléle

Publié dans : Formation
1 commentaire
7 j’aime
Statistiques
Remarques
Aucun téléchargement
Vues
Nombre de vues
4 689
Sur SlideShare
0
Issues des intégrations
0
Intégrations
616
Actions
Partages
0
Téléchargements
646
Commentaires
1
J’aime
7
Intégrations 0
Aucune incorporation

Aucune remarque pour cette diapositive

Apprendre Java-et-C++-en-parallele

  1. 1. boichat 7/10/08 15:42 Page 1 4e Jean-Bernard Boichat édi tio Jean-Bernard Boichat n 4ee édition Ingénieur de développement, Jean-Bernard Boichat est spécialiste en C++, Java, systèmes embarqués, méthodologie et technologies Internet. Il travaille actuellement Apprendre Java dans le domaine des systèmes dinformation pour les passagers des transports publics. Apprendre Java Faire dune pierre deux coups Java et C++ sont deux langages à la syntaxe très proche. Grâce à lapprentissage de leurs différences, défauts et C++ en parallèle qualités intrinsèques, vous serez mieux préparé pour concevoir un code plus propre, fondé sur une vision élargie de ces deux langages, de leurs possibilités et de leurs limites. Comment est structuré ce livre ? C++ Louvrage présente et compare les concepts communs aux langages Java et C++ (déclarations de variables, tableaux...), mais expose également les particularités de chacun. Les chapitres sont organisés selon un niveau de et C++ difficulté croissant, avec exercices corrigés à la clé. À qui s’adresse ce livre ? Java • Aux débutants en programmation qui souhaitent apprendre les deux langages les plus demandés dans le monde professionnel en • Aux développeurs maîtrisant lun des langages et souhaitant sinitier à lautre • Aux étudiants en informatique (IUT, 2e cycle, écoles dingénieurs) Au sommaire Premier exemple de programme en Java et en C++ • Fichiers d’en-têtes • Fonction d’entrée main ( ) • Compilation et exécution d’un programme • Déclaration et affectation des variables • Opérateurs de condition • Boucles for, while et do • Classes en Java et en C++ • Tableaux et chaînes de caractères • Fonctions, méthodes et arguments • Méthodes parallèle parallèle Apprendre des classes String en Java et String en C++ • Bibliothèques et packages • Gestion des exceptions en Java et en C++ • Entrées-sorties : lecture et écriture d’un fichier • Constructeurs d’objets en Java et en C++ • Variables et méthodes sta- tiques de classe • Clonage d’objet en Java • Encapsulation des données • Héritage et polymorphisme • Transtypage et d’objet en Java et en C++ • Les vector en C++ • Passage par valeur et par référence • Analyse des performances • Code éditeur : G12403 • ISBN : 978-2-212-12403-3 Programmation d’interfaces graphiques • Applets et JavaBeans • Les templates en C++ et les types génériques en Java • Utilisation de SQL • Java Native Interface (JNI) • Le langage C# de Microsoft • Développer en Java et C++ sous Linux. 782212 124033 Sur le CD-Rom offert avec ce livre • JDK 6 • MinGW et MSYS (GNU g++ 3.4.5) • NetBeans 6.1 • .NET Framework 3.5 J.-B. Boichat • Crimson 3.70 • Code source des exemples et exercices du livre Plate-forme requise : PC avec processeur Pentium 233 MHz ou plus • Windows Vista, XP, 2000 ou 2003 • 9 512 Mo de RAM • 1 Go despace disque. Sur le site www.editions-eyrolles.com 35 E • Consultez les mises à jour et compléments • Dialoguez avec lauteur
  2. 2. ApprendreJava en C++ et parallèle
  3. 3. CHEZ LE MÊME ÉDITEUROuvrages sur JavaA. Tasso. – Le livre de Java premier langage (5e édition).N°12376, 2008, 520 pages + CD-Rom.C. Delannoy. – Programmer en Java. Java 5 et 6.N°12326, 2008, 788 pages (format semi-poche).J. Bougeault. – Java - La maîtrise. Java 5 et 6.N°12250, 2008, 550 pages.A. Patricio. – Java Persistence et Hibernate.N°12259, 2008, 364 pages.C. Delannoy. – Exercices en Java. Java 5.0.N°11989, 2006, 314 pages.E. Puybaret. – Les Cahiers du programmeur Java (3e édition).Java 1.4 et 5.0.N°11916, 2006, 370 pages + CD-Rom.R. Fleury. – Les Cahiers du programmeur Java/XML.N°11316, 2004, 218 pages.P. Haggar. – Mieux programmer en Java. 68 astuces pour optimiser son code.N°9171, 2000, 256 pages.J.-P. Retaillé. – Refactoring des applications Java/J2EE.N°11577, 2005, 390 pages.Ouvrages sur C++C. Delannoy. –C++ pour les programmeurs C.N°12231, 2007, 602 pages.C. Delannoy. – Exercices en langage C++ (3e édition).N°12201, 2007, 336 pages.C. Delannoy. – Apprendre le C++.N°12135, 2007, 760 pages.H. Sutter. – Mieux programmer en C++.N°9224, 2000, 215 pages.
  4. 4. Jean-Bernard Boichat ApprendreJava enC++ et parallèle 4e édition
  5. 5. ÉDITIONS EYROLLES 61, bd Saint-Germain 75240 Paris Cedex 05 www.editions-eyrolles.com Le code de la propriété intellectuelle du 1er juillet 1992 interdit en effet expressément la photocopie à usage collectif sans autorisation des ayants droit. Or, cette pratique s’est généralisée notamment dans les établissements d’enseignement, provoquant une baisse brutale des achats de livres, au point que la possibilité même pour les auteurs de créer des œuvres nouvelles et de les faire éditer correctement est aujourd’hui menacée. En application de la loi du 11 mars 1957, il est interdit de reproduire intégralement ou partiellement leprésent ouvrage, sur quelque support que ce soit, sans autorisation de l’éditeur ou du Centre Français d’Exploitation duDroit de Copie, 20, rue des Grands-Augustins, 75006 Paris.© Groupe Eyrolles, 2008, ISBN : 978-2-212-12403-3
  6. 6. =Boichat FM.book Page V Vendredi, 26. septembre 2008 12:52 12 Pour Ornella, qui m’a soutenu et cajolé durant cet été 2008 pas comme les autres ! À mes chers enfants, Nathalie, Stéphanie et Nicolas.
  7. 7. =Boichat FM.book Page VI Vendredi, 26. septembre 2008 12:52 12
  8. 8. =Boichat FM.book Page VII Vendredi, 26. septembre 2008 12:52 12 Table des matières Avant-propos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . XXV Pourquoi un tel ouvrage ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . XXV À qui s’adresse ce livre ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . XXV Quel est l’intérêt d’apprendre plusieurs langages ? . . . . . . . . . . . . . . . XXV Quelles versions de Java et de C++ ? . . . . . . . . . . . . . . . . . . . . . . . . . . . XXVI Pourquoi le Standard C++ ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . XXVII Comment est présenté cet ouvrage ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . XXVII De quel matériel a-t-on besoin ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . XXVII Pourquoi autant d’exemples et d’exercices ? . . . . . . . . . . . . . . . . . . . . . XXVIII Commentaires et suivi de l’ouvrage . . . . . . . . . . . . . . . . . . . . . . . . . . . . XXVIII CHAPITRE 1 L’incontournable Hello world . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1 Hello world en C++ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2 Hello world en Java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4 La machine virtuelle Java – JRE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5 Erreurs de compilation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6 Notre premier fichier Makefile . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6 Enfin un premier make effectif. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8 Le point d’entrée main() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9 Les paramètres de main() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9 main() et C++ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10 main() et Java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
  9. 9. =Boichat FM.book Page VIII Vendredi, 26. septembre 2008 12:52 12 Apprendre Java et C++ en parallèle VIII Analyse comparative. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11 Jouer avec Crimson. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13 Résumé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13 Exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13 CHAPITRE 2 La déclaration et l’affectation des variables numériques . . . 15 Déclaration des variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15 Choix des noms de variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16 Affectation des variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17 Transtypage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21 Positionnement des variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21 Variables du type pointeur en C++ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23 Utilisation des pointeurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24 Utilisation de malloc() en C++ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24 Variables constantes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25 Variables globales en C++ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26 Fichiers d’en-tête en C++ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27 Opérations et opérateurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27 La classe Java Math . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28 Les opérateurs traditionnels . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29 Char et byte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30 Intervalles des types entiers en Java . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31 Règles de priorité des opérateurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32 Une diversion sur le cin (entrée) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32 Les opérateurs d’affectation composés . . . . . . . . . . . . . . . . . . . . . . . . . . 34 Les opérations binaires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35 Typedef et énumération en C++ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38 Résumé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40 Exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
  10. 10. =Boichat FM.book Page IX Vendredi, 26. septembre 2008 12:52 12 Table des matières IX CHAPITRE 3 Et si on contrôlait l’exécution ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41 Recommandations pour la forme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41 Opérateurs de condition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42 Et si c’était faux (False) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44 L’opérateur logique NOT . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45 Préconisation du bool en C++ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45 Les boucles for, while et do . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46 Les boucles for en Java à partir du JDK 1.5. . . . . . . . . . . . . . . . . . . . . . . . 49 Tester plusieurs conditions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49 Ceci ET cela . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49 Optimisation dans le cas de conditions multiples . . . . . . . . . . . . . . . . . . . 50 Ceci OU cela . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51 Éviter les tests de conditions multiples compliqués. . . . . . . . . . . . . . . . . . 51 Plusieurs sélections avec switch . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52 L’infâme goto . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54 Résumé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55 Exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55 CHAPITRE 4 On fait ses classes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57 Notre première classe en C++ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57 Définition de la classe Personne. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57 Définition des objets d’une classe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59 Un seul constructeur. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59 Une seule méthode . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59 Nom et définition des classes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60 Code de la classe Personne. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60 Directive include . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62 Commentaires et documentation des classes . . . . . . . . . . . . . . . . . . . . . . . 63 Un Makefile évolué . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65 Notre première classe en Java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66 Tester les classes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 68 Commentaires et documentation des classes . . . . . . . . . . . . . . . . . . . . . . . 68 Création des objets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71
  11. 11. =Boichat FM.book Page X Vendredi, 26. septembre 2008 12:52 12 Apprendre Java et C++ en parallèle X Make, javac et redondance . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72 Nos classes Java dans un paquet .jar . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73 Comment étendre notre classe Personne ? . . . . . . . . . . . . . . . . . . . . . . . 74 Diversion sur les structures C . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75 Résumé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77 Exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77 CHAPITRE 5 On enchaîne avec les tableaux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79 Tableaux d’entiers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80 Copie de tableau d’entiers en Java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82 Tableau dynamique en C++ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83 Tableaux multidimensionnels . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85 Le jeu d’Othello en Java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85 Le jeu d’Othello en C++. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86 Le cavalier du jeu d’échecs. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 88 Chaînes de caractères en C . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 88 Les String de Java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 90 Les string du C++, un nouvel atout . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92 Les méthodes des classes String (Java) et string (C++) . . . . . . . . . . . . 94 Résumé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97 Exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97 CHAPITRE 6 De la méthode dans nos fonctions . . . . . . . . . . . . . . . . . . . . . . . . . . 99 Fonctions et méthodes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99 splice() de Perl . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 100 splice() comme fonction C . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 101 Retour par arguments . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 101 Accès à des données répétitives . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102 Retour de fonction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102 Recommandation pour des programmeurs C potentiels. . . . . . . . . . . . . . . 103 Comment utiliser nos fonctions C ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 103 Nos fonctions C dans un module séparé. . . . . . . . . . . . . . . . . . . . . . . . . . . 106
  12. 12. =Boichat FM.book Page XI Vendredi, 26. septembre 2008 12:52 12 Table des matières XI Les arguments de méthodes en C++ . . . . . . . . . . . . . . . . . . . . . . . . . . . . 107 Passage par référence (classe C++ Perl1). . . . . . . . . . . . . . . . . . . . . . . . . . 107 Paramètres déclarés comme const . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 109 Passage par valeur (classe C++ Perl2) . . . . . . . . . . . . . . . . . . . . . . . . . . . . 109 const et passage par valeur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 111 Passage par pointeur (classe C++ Perl3) . . . . . . . . . . . . . . . . . . . . . . . . . . 112 Le suffixe const pour une méthode C++ . . . . . . . . . . . . . . . . . . . . . . . . . . 113 Fonctions et méthodes inline en C++ . . . . . . . . . . . . . . . . . . . . . . . . . . . 114 Utilisation des énumérations avec des méthodes C++ . . . . . . . . . . . . . . . . 116 Utilisation des énumérations en Java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 117 Les arguments de méthodes en Java . . . . . . . . . . . . . . . . . . . . . . . . . . . . 118 splice() avec retour par l’argument (classe Java Perl1) . . . . . . . . . . . . . . . 118 splice() avec retour de méthode (classe Java Perl2) . . . . . . . . . . . . . . . . . . 120 Java : argument par référence ou par valeur ? . . . . . . . . . . . . . . . . . . . 121 Les espaces de noms en C++ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 122 Utilisation classique du namespace . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 123 Conflit de nom . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 123 Comment définir un espace de noms . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 124 Fichiers d’en-tête et namespace . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 125 Fichiers d’en-tête multiples en C++ . . . . . . . . . . . . . . . . . . . . . . . . . . . . 126 Résumé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 127 Exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 127 CHAPITRE 7 Notre code dans des bibliothèques . . . . . . . . . . . . . . . . . . . . . . . . . 129 Les extensions .jar, .a et .dll . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 130 Les packages en Java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 131 Compiler les classes de notre package . . . . . . . . . . . . . . . . . . . . . . . . . . . . 133 La variable d’environnement CLASSPATH. . . . . . . . . . . . . . . . . . . . . . . . 135 Nos classes dans un fichier d’archive .jar. . . . . . . . . . . . . . . . . . . . . . . . . . 136 Signer et vérifier un fichier .jar. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 136 Test avec le fichier monpaquet.jar . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 136 Résumé des différentes étapes avec les fichiers .bat . . . . . . . . . . . . . . . . . 137
  13. 13. =Boichat FM.book Page XII Vendredi, 26. septembre 2008 12:52 12 Apprendre Java et C++ en parallèle XII Les constructions de bibliothèques C et C++ . . . . . . . . . . . . . . . . . . . . . 141 Création d’une bibliothèque statique en C++ . . . . . . . . . . . . . . . . . . . . . . . 141 Utilisation de notre bibliothèque C++ . . . . . . . . . . . . . . . . . . . . . . . . . . . . 142 Résumé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 144 Exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 144 CHAPITRE 8 À quelques exceptions près . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 145 Au contraire du C++, Java est né avec les exceptions . . . . . . . . . . . . . . 145 Utilisation des exceptions en Java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 146 Capture des exceptions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 147 Ignorer les exceptions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 148 Plusieurs exceptions en une seule fois . . . . . . . . . . . . . . . . . . . . . . . . . . . . 150 Lancement d’une exception . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 151 Recommandation pour l’écriture de méthodes réutilisables. . . . . . . . . . . . 153 Retour avec -1 comme en C ou C++ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 153 Création de nouvelles exceptions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 153 Nettoyage à l’aide de finally . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 155 Utilisation des exceptions en C++ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 156 Un exemple sans exceptions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 157 Un exemple avec exceptions. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 158 Propager les exceptions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 161 Exception dans la bibliothèque Standard C++ . . . . . . . . . . . . . . . . . . . . . . 163 Généraliser les exceptions en C++ comme en Java ? . . . . . . . . . . . . . . 164 Résumé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 164 Exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 165 CHAPITRE 9 Entrées et sorties . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 167 Du texte délimité à partir de Microsoft Access . . . . . . . . . . . . . . . . . . . 168 Lecture de fichiers texte en C++ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 169 La méthode getline(). . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 170 Lecture de fichiers texte en Java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 172 Utilisation de la variable separatorChar . . . . . . . . . . . . . . . . . . . . . . . . . . . 173 Lecture de fichiers sur Internet en Java . . . . . . . . . . . . . . . . . . . . . . . . . 174
  14. 14. =Boichat FM.book Page XIII Vendredi, 26. septembre 2008 12:52 12 Table des matières XIII Lecture de fichier binaire en C++ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 176 Écriture d’un fichier binaire en C++ . . . . . . . . . . . . . . . . . . . . . . . . . . . 178 Compilation conditionnelle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 179 Écriture d’un fichier binaire en Java . . . . . . . . . . . . . . . . . . . . . . . . . . . 181 Lecture d’un fichier binaire en Java . . . . . . . . . . . . . . . . . . . . . . . . . . . . 183 Écriture d’un fichier texte en Java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 185 Écriture d’un fichier texte en C++ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 186 Le XML pour l’information structurée . . . . . . . . . . . . . . . . . . . . . . . . . . . 186 Écriture du fichier XML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 187 Accès des répertoires sur le disque . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 189 Lecture d’un répertoire en C++ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 189 Lecture d’un répertoire en Java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 191 Les flux en mémoire (C++) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 193 sprintf() de la bibliothèque C . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 193 istringstream et ostringstream . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 195 Un exemple complet avec divers formatages . . . . . . . . . . . . . . . . . . . . . . . 197 Le printf Java du JDK 1.5. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 199 istrstream et ostrstream. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 200 Formatage en Java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 200 Filtrer du texte en Java avec StringTokenizer et StreamTokenizer . . 201 Résumé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 203 Exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 203 CHAPITRE 10 Variations sur un thème de classe . . . . . . . . . . . . . . . . . . . . . . . . . . 205 Le constructeur par défaut en C++ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 205 Le constructeur de copie en C++ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 209 Le constructeur de copie par défaut . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 209 La forme du constructeur de copie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 210 Ne pas confondre constructeur et affectation . . . . . . . . . . . . . . . . . . . . . . . 212 Le constructeur par défaut en Java . . . . . . . . . . . . . . . . . . . . . . . . . . . . 213 Le constructeur de copie en Java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 215 Les variables et méthodes statiques d’une classe . . . . . . . . . . . . . . . . . 216 Nous tirons un numéro . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 216
  15. 15. =Boichat FM.book Page XIV Vendredi, 26. septembre 2008 12:52 12 Apprendre Java et C++ en parallèle XIV En C++ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 216 En Java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 219 finalize() en Java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 222 Un dernier exemple en Java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 222 Résumé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 223 Exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 223 CHAPITRE 11 Manipuler des objets en Java et C++ . . . . . . . . . . . . . . . . . . . . . . . . 225 L’opérateur = ou un exercice d’affectation . . . . . . . . . . . . . . . . . . . . . . 225 Commençons en Java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 225 Poursuivons en C++ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 227 Créer un opérateur = . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 230 L’incontournable classe string en C++ . . . . . . . . . . . . . . . . . . . . . . . . . . 232 Recommandation d’ordre des méthodes. . . . . . . . . . . . . . . . . . . . . . . . . . . 235 Retour à la source . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 236 Le clonage d’objet en Java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 236 Surcharge d’opérateurs en C++, et nos amis friend . . . . . . . . . . . . . . . 238 Surcharge d’opérateur. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 238 Pas de surcharge d’opérateur en Java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 240 Les friend, ces amis qui nous donnent l’accès . . . . . . . . . . . . . . . . . . . . . . 241 Amis : un exemple plus complet. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 243 Faut-il éviter les amis (friend) ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 245 Résumé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 247 Exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 248 CHAPITRE 12 Un héritage attendu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 249 L’exemple de java.lang.Integer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 249 La réutilisation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 251 Héritage et composition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 251 L’encapsulation des données . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 254 La syntaxe de l’héritage en Java et C++ . . . . . . . . . . . . . . . . . . . . . . . . . 255 L’initialisation des constructeurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 256
  16. 16. =Boichat FM.book Page XV Vendredi, 26. septembre 2008 12:52 12 Table des matières XV Combiner héritage et composition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 260 Accès public, privé ou protégé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 260 Le polymorphisme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 260 Les Schtroumpfs en Java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 261 Les Schtroumpfs en C++ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 262 Le virtual en C++ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 265 Les classes abstraites en C++ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 267 Fonction purement virtuelle en C++ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 267 Destructeur virtuel en C++. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 269 Les classes abstraites en Java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 270 Le transtypage (casting) d’objet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 273 Le transtypage en Java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 273 Comment éviter le transtypage. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 274 Le transtypage en C++ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 275 L’héritage en Java et en C++ : les différences . . . . . . . . . . . . . . . . . . . . 276 Résumé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 277 Exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 277 CHAPITRE 13 Des héritages multiples . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 279 Héritage multiple en C++ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 279 Héritage multiple en Java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 282 Définition d’une interface en Java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 283 J’ai déjà hérité, que faire avec mon Thread ? . . . . . . . . . . . . . . . . . . . . . . . 284 Une interface au lieu d’un héritage classique. . . . . . . . . . . . . . . . . . . . . . . 285 Des constantes dans une interface Java . . . . . . . . . . . . . . . . . . . . . . . . . . . 286 Grouper des constantes dans une interface. . . . . . . . . . . . . . . . . . . . . . . . . 287 Sérialisation et clonage d’objets en Java . . . . . . . . . . . . . . . . . . . . . . . . 287 Sérialiser des objets Java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 287 Le clonage d’objet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 290 Résumé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 291 Exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 292
  17. 17. =Boichat FM.book Page XVI Vendredi, 26. septembre 2008 12:52 12 Apprendre Java et C++ en parallèle XVI CHAPITRE 14 Devenir collectionneur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 293 Le vector en C++ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 294 Utiliser un itérateur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 295 Les algorithmes du langage C++ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 296 La classe vector en C++ et l’algorithme sort() . . . . . . . . . . . . . . . . . . . . . . 298 La classe list en C++ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 300 L’interface List en Java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 301 L’interface Set en Java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 304 Une liste de téléphone en Java avec HashMap . . . . . . . . . . . . . . . . . . . . 306 La même liste de téléphone avec map en C++ . . . . . . . . . . . . . . . . . . . . 308 Les types génériques en Java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 310 Un premier exemple simple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 310 Autoboxing et Fibonacci . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 312 Résumé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 314 Exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 314 CHAPITRE 15 Concours de performance . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 315 Comment analyser les performances ? . . . . . . . . . . . . . . . . . . . . . . . . . . 315 Les outils en Java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 316 Les outils en C++ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 317 Gagner en performance : une rude analyse . . . . . . . . . . . . . . . . . . . . . . 320 Que peut apporter une meilleure analyse ?. . . . . . . . . . . . . . . . . . . . . . . . . 322 Passage par valeur ou par référence en C++ . . . . . . . . . . . . . . . . . . . . . 322 Performance et capacité mémoire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 324 Les entrées-sorties . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 324 Lecture de fichiers en C++ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 325 Influence de l’appel de fonctions successives. . . . . . . . . . . . . . . . . . . . . . . 327 Lecture de fichiers en Java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 328 Tests globaux de performance . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 330 Avec system() en C++ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 330 Avec exec() en Java. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 331
  18. 18. =Boichat FM.book Page XVII Vendredi, 26. septembre 2008 12:52 12 Table des matières XVII Autres calculs de performance ou de contraintes . . . . . . . . . . . . . . . . . 332 Résumé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 333 Exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 333 CHAPITRE 16 Comment tester correctement ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . 335 Le Y2K bug . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 335 Une stratégie de test dès la conception . . . . . . . . . . . . . . . . . . . . . . . . . . 335 Avec ou sans débogueur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 336 Les tests de base . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 336 La fonction extraction() en C++. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 337 Le programme de test de la fonction extraction () . . . . . . . . . . . . . . . . . . . 338 Le programme de test extraction () en Java . . . . . . . . . . . . . . . . . . . . . . . . 340 Suivre à la trace . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 341 Définition du problème. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 341 La classe Traceur en C++ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 341 Tester la classe Traceur en C++ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 343 La classe Traceur en Java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 344 Encore des améliorations pour notre traceur ? . . . . . . . . . . . . . . . . . . . . . . 347 Résumé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 348 Exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 348 CHAPITRE 17 Ces fameux patterns . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 349 Qui sont donc ces fameux patterns ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . 349 Les patterns Singleton et Observer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 349 Le Singleton ou le constructeur protégé . . . . . . . . . . . . . . . . . . . . . . . . . 350 Le Singleton en Java. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 350 Le Singleton en C++ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 351 Le pattern Observer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 353 Java MVC : l’interface Observer et la classe Observable . . . . . . . . . . . . . 353 Le pattern Observer en Java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 354 Résumé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 355 Exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 356
  19. 19. =Boichat FM.book Page XVIII Vendredi, 26. septembre 2008 12:52 12 Apprendre Java et C++ en parallèle XVIII CHAPITRE 18 Un livre sur Java sans l’AWT ! . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 357 Apprendre à programmer avec des applications graphiques . . . . . . . 358 Le code de notre première application AWT . . . . . . . . . . . . . . . . . . . . . 358 Classes anonymes et classes internes . . . . . . . . . . . . . . . . . . . . . . . . . . . . 360 S’adapter aux événements traditionnels de l’API . . . . . . . . . . . . . . . . . . . 362 Et si on s’adaptait à d’autres types d’événements ? . . . . . . . . . . . . . . . . . 363 Applets ou applications . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 365 init() et start() pour une applet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 369 Un mot sur les servlets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 370 get(), set() et les JavaBeans . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 370 Qu’est-ce qu’un Bean ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 371 Beans et C++ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 371 Résumé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 371 Exercice . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 372 CHAPITRE 19 Un livre sur C++ sans templates ! . . . . . . . . . . . . . . . . . . . . . . . . . . . 373 Les modèles ou patrons en C++ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 373 Un modèle de fonction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 374 Un modèle de classe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 376 Résumé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 377 Exercice . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 377 CHAPITRE 20 Impossible sans SQL ! . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 379 Création d’un fichier délimité en C++ . . . . . . . . . . . . . . . . . . . . . . . . . . 379 Création d’une base de données sous Microsoft Access . . . . . . . . . . . . 381 Activation d’ODBC - XP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 382 Activation d’ODBC - Vista. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 384 Accès ODBC à partir de Java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 386 Requête SQL. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 388 Création d’une nouvelle table depuis Java . . . . . . . . . . . . . . . . . . . . . . . 389
  20. 20. =Boichat FM.book Page XIX Vendredi, 26. septembre 2008 12:52 12 Table des matières XIX MySQL et Linux : recommandations . . . . . . . . . . . . . . . . . . . . . . . . . . . 391 Autres choix d’interfaces . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 392 Résumé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 392 Exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 392 CHAPITRE 21 Java et C++ main dans la main : le JNI . . . . . . . . . . . . . . . . . . . . . . 393 Pourquoi et comment utiliser JNI ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . 393 Des salutations d’une bibliothèque C++ . . . . . . . . . . . . . . . . . . . . . . . . . 394 javah pour le code C++ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 395 Création de notre salut.dll . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 396 JNI, passage de paramètres et Swing . . . . . . . . . . . . . . . . . . . . . . . . . . . 397 Notre interface Swing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 401 Résumé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 405 CHAPITRE 22 Quelques applications usuelles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 407 Coupons et collons . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 407 Nous coupons en Java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 408 Nous coupons en C++ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 411 Un exemple de fichier .acr . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 416 Recollons les morceaux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 416 Nous collons en Java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 416 Nous collons en C++ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 419 Un message sur notre téléphone mobile . . . . . . . . . . . . . . . . . . . . . . . . . 423 Programmons le jeu d’Othello . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 428 Les règles du jeu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 428 La conception . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 428 Le jeu d’Othello en C++. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 429 Le jeu d’Othello en Java. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 431 Suggestions d’autres applications . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 436 Archiver des fichiers. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 436 Télécharger un site Web entier . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 436 Résumé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 436
  21. 21. =Boichat FM.book Page XX Vendredi, 26. septembre 2008 12:52 12 Apprendre Java et C++ en parallèle XX CHAPITRE 23 L’étape suivante : le langage C# de Microsoft . . . . . . . . . . . . . . 437 Que vient donc faire le C# dans cet ouvrage ? . . . . . . . . . . . . . . . . . . . . 437 Un peu d’histoire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 438 C++, Java et C# : les différences majeures . . . . . . . . . . . . . . . . . . . . . . . . . 439 Hello world en C# . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 439 Les Makefile avec C# . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 444 Espace de noms . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 444 Les structures en C# . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 446 La classe Personne du chapitre 4 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 449 Couper et coller en C# . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 451 Résumé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 457 ANNEXES ANNEXE A Contenu du CD-Rom . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 461 ANNEXE B Installation des outils de développement pour Java et C++ 463 Installation de 7-Zip . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 464 Installation des exemples et des exercices . . . . . . . . . . . . . . . . . . . . . . . . 466 Installation du JDK de Sun Microsystems . . . . . . . . . . . . . . . . . . . . . . . 467 Qu’est-ce que le JDK ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 467 Désinstallation des anciennes versions. . . . . . . . . . . . . . . . . . . . . . . . . . . . 467 Téléchargement à partir du site Web de Sun Microsystems . . . . . . . . . . . . 467 Installation à partir du CD-Rom . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 468 Installation de MinGW (g++) et MSYS . . . . . . . . . . . . . . . . . . . . . . . . . 471 Installation simplifiée de MinGW et MSYS. . . . . . . . . . . . . . . . . . . . . . . . 472 Vérifications finales et dernières mises au point . . . . . . . . . . . . . . . . . . 474 Vérification de l’installation des outils . . . . . . . . . . . . . . . . . . . . . . . . . . . . 474 Le fameux chapitre 21 avec JNI . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 476 Le fichier source src.jar. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 478
  22. 22. =Boichat FM.book Page XXI Vendredi, 26. septembre 2008 12:52 12 Table des matières XXI Installation de la documentation. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 482 Raccourci ou favori . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 483 MinGW et MSYS sur Internet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 487 Problèmes potentiels avec le make et MSYS . . . . . . . . . . . . . . . . . . . . . . . 488 Les outils Linux de MSYS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 489 La commande msys.bat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 489 La commande cd . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 492 Les commandes ls et pwd. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 492 Copie dans un fichier . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 493 Emploi du pipe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 494 Awk, l’un des outils essentiels de Linux . . . . . . . . . . . . . . . . . . . . . . . . . . 494 Un script de sauvegarde . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 495 ANNEXE C Installation et utilisation de Crimson . . . . . . . . . . . . . . . . . . . . . . . 499 Site Web de Crimson . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 500 Installation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 500 Réinstallation de Crimson . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 500 Configuration préparée . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 501 Installation à partir du CD-Rom. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 501 Association des fichiers à Crimson dans l’explorateur . . . . . . . . . . . . 503 Installation d’un raccourci . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 505 Premier démarrage de Crimson . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 505 Demande d’autorisation sous Windows Vista . . . . . . . . . . . . . . . . . . . . . . 506 Glisser les fichiers depuis l’explorateur . . . . . . . . . . . . . . . . . . . . . . . . . 507 Configuration de Crimson . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 508 Configuration des menus . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 510 Fermer toutes les fenêtres. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 519 Remarques générales . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 520 Exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 521 ANNEXE D Installation du SDK du Framework de .NET . . . . . . . . . . . . . . . . 523 Installation du SDK 3.5 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 523
  23. 23. =Boichat FM.book Page XXII Vendredi, 26. septembre 2008 12:52 12 Apprendre Java et C++ en parallèle XXII Téléchargement de .NET depuis Internet . . . . . . . . . . . . . . . . . . . . . . . 526 Pas de nouveau PATH. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 527 Vérification de l’installation du .NET Framework SDK . . . . . . . . . . . . . . 528 Documentation du SDK de .NET . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 528 Le compilateur du langage C# . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 532 Visual C# - L’édition Express. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 533 ANNEXE E Apprendre Java et C++ avec NetBeans . . . . . . . . . . . . . . . . . . . . . 535 Généralités . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 535 Linux. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 536 Téléchargement de nouvelles versions . . . . . . . . . . . . . . . . . . . . . . . . . . 536 Documentations et didacticiels . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 536 Installation à partir du CD-Rom . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 536 Configuration pour le C++ et le make . . . . . . . . . . . . . . . . . . . . . . . . . . . . 546 Présentation de NetBeans . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 547 NetBeans et Java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 547 Java et la classe Personne . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 547 Nouveau projet avec source existante. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 549 Distribuer nos applications . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 556 Naviguer et déboguer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 556 Javadoc . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 559 UML – Diagramme de classe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 563 NetBeans et C++ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 565 Le jeu d’Othello dans NetBeans . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 565 Création du projet C++ dans NetBeans . . . . . . . . . . . . . . . . . . . . . . . . . . . 567 Déboguer un projet C++ avec NetBeans . . . . . . . . . . . . . . . . . . . . . . . . . . 575 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 577 ANNEXE F Apprendre Java et C++ avec Linux . . . . . . . . . . . . . . . . . . . . . . . . . . 579 Démarrage de Linux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 580 Installation des outils . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 581 Vérification de l’installation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 582 Les exemples du chapitre 1. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 583
  24. 24. =Boichat FM.book Page XXIII Vendredi, 26. septembre 2008 12:52 12 Table des matières XXIII gedit comme éditeur Linux. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 585 NetBeans sous Linux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 587 ANNEXE G Dans la littérature et sur le Web . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 589 Dans la littérature . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 589 Sur le Web . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 591 Le projet GNU . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 592 Les compilateurs GNU pour C et C++. . . . . . . . . . . . . . . . . . . . . . . . . . . . 592 Les newsgroups . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 592 GNU EMACS. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 592 C++. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 592 Java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 593 C# . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 593 Perl et Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 593 Le Web lui-même . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 593 Autres recherches d’informations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 594 Rechercher des sujets de travaux pratiques . . . . . . . . . . . . . . . . . . . . . 594 Index . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 597
  25. 25. =Boichat FM.book Page XXIV Vendredi, 26. septembre 2008 12:52 12
  26. 26. =Boichat FM.book Page XXV Vendredi, 26. septembre 2008 12:52 12 Avant-propos Pourquoi un tel ouvrage ? Les réponses à cette question sont multiples. Au cours de cette préface, nous essayerons d’y répondre sans trop de philosophie et de débats contradictoires. Nous commencerons par deux raisons évidentes : • Ces deux langages de programmation, Java et C++, sont très semblables, tout au moins dans leurs syntaxes. Il est ainsi tout à fait possible de reprendre un morceau de code du premier langage et de l’appliquer sans adaptation dans le second. • Ils sont tous les deux très populaires dans le monde de l’informatique, le premier avec la venue d’Internet, le second comme langage système essentiel. Pour assurer une progression constante et logique, au travers d’une comparaison directe de ces deux langages, il nous a fallu structurer la présentation du livre en fonction des particularités de chacun. Cela n’a pas été facile et nous avons accepté le défi de tenter une telle expérience. Il a été évidemment impossible de couvrir tous les détails de Java et de C++ car nous avons voulu que cet ouvrage conserve une épaisseur raisonnable. À qui s’adresse ce livre ? Nous aimerions dire aux débutants, mais ce ne serait sans doute pas honnête vis-à-vis des experts et des gourous C++, car ce dernier langage est considéré comme l’un des plus difficiles à assimiler et à maîtriser. Nous pensons aussi aux programmeurs Basic ou, mieux encore, à ceux favorisés par leurs connaissances dans des langages plus orientés objet, comme Delphi, le langage Pascal de Borland ou le C#. Comme autres cas de figure, nous citerons également les programmeurs Java, Smalltalk, C ou C++ traditionnels qui aimeraient s’initier à l’un de ces deux langages essentiels et les ajouter à leur curriculum vitae. Quel est l’intérêt d’apprendre plusieurs langages ? Dans le cas précis, comme ces deux langages sont très proches, autant les apprendre en parallèle. Un autre aspect, encore plus essentiel, est l’apprentissage de leurs différences,
  27. 27. =Boichat FM.book Page XXVI Vendredi, 26. septembre 2008 12:52 12 Apprendre Java et C++ en parallèle XXVI de leurs qualités et de leurs défauts, ce qui nous amènera ainsi à programmer en utilisant des techniques variées et réfléchies. Le résultat sera un code beaucoup plus propre, conçu selon une vision plus large des systèmes, de leurs possibilités et de leurs limites. Pour un programmeur, aussi bien débutant que professionnel, l’apprentissage d’un nouveau langage est avant tout enrichissant. Une fonctionnalité manquante dans un langage l’amènera à une remise en question de ses méthodes. Par exemple, quand un program- meur C++ découvre qu’il n’existe pas de destructeur en Java, il va se poser toute une série de questions. En fin de compte, cette réflexion pourra sans aucun doute le conduire à réviser ses concepts et à écrire ses programmes C++ différemment. De la même manière, un programmeur C qui cherche à apprendre C++ et Smalltalk en parallèle, ce qui est loin d’être une mauvaise idée, va sans doute découvrir de nouveaux termes comme celui de variable de classe et se mettra à douter de ses vieilles habitudes en programmation C. Enfin, un programmeur qui, en guise de premier exercice en Java, décide de transférer une page Web sur son site, va certainement remettre en question ses choix lorsqu’il devra employer tel ou tel langage pour ses applications. En fin d’ouvrage, dans le dernier chapitre, nous donnerons un aperçu du langage de Microsoft né en 2001, le C#. Nous serons alors surpris de retrouver la plupart des thèmes déjà abordés avec Java et C++ et combien il sera aisé alors d’écrire un premier programme dans ce langage. Le lecteur se rendra compte alors que son bagage informa- tique est déjà solide. Dans cet ouvrage, nous parlerons aussi de performances, ainsi que de la manière de vérifier et de tester les programmes. Ces deux aspects font partie de la formation des informati- ciens ; ils sont importants dans l’acquisition des méthodes de travail et des connaissances techniques pour concevoir et développer des applications professionnelles. Quelles versions de Java et de C++ ? Il faut tout d’abord indiquer que cet ouvrage ne couvre que le bien nommé « pure Java ». Il en va de même pour le C++ que nous appelons plus précisément le « Standard C++ ». Un grand nombre de fonctions intégrées dans le JDK 1.6 (officiellement nommé JDK 6) peuvent être directement comparées à celles disponibles dans le Standard C++. Le code C++ présenté dans cet ouvrage, tout comme le code en Java, devrait de plus pouvoir se compiler et s’exécuter dans plusieurs environnements comme Windows ou Linux. Les exemples contenus dans ce livre couvrent des domaines variés et parfois complexes. Cependant, le code présenté restera compilable, nous aimerions dire pour l’éternité, et l’ache- teur de ce livre n’aura pas besoin d’acquérir une nouvelle édition dans les prochains mois. Le langage Java a beaucoup évolué ces dernières années, au contraire du C++ qui a atteint une stabilité naturelle. Aujourd’hui, nous parlons de Java 2 (Swing, Beans), Java 5 ou Java 6, qui représentent les versions de 1.2 à 1.4, 1.5 et 1.6 respectivement, des JDK de Sun Microsystems. Certains concepts et constructions de la version 1.1 ont été remplacés par des techniques plus évoluées. Dans cet ouvrage, nous laisserons volontairement de
  28. 28. =Boichat FM.book Page XXVII Vendredi, 26. septembre 2008 12:52 12 Avant-propos XXVII côté la plupart des méthodes et des classes dépréciées des versions antérieures à la 1.6. Nous mentionnerons aussi quelques nouveautés apparues depuis la version 1.5. Pourquoi le Standard C++ ? Pourquoi avons-nous choisi le Standard C++ et non pas le langage C ou le C++ tradi- tionnel ? Il y a en fait plusieurs raisons à cela. La principale concerne les nouvelles bibliothèques qui ont été rajoutées à partir de 1995 et qui font partie du langage au même titre que celles, nombreuses, qui font partie de Java. Comme exemple, nous pourrions citer la classe string qui n’existe pas dans le C++ classique. Certaines classes des premières versions du Standard C++ ont été dépréciées et corrigées dans cette édition. Le Standard C++ est maintenant aussi agréé par les standards ANSI et ISO et représente une base encore plus solide pour un langage qui ne devrait plus beaucoup évoluer selon les dires de son créateur, Bjarne Stroustrup. Comment est présenté cet ouvrage ? Lors de la présentation des langages, nous commençons en général par le C++ et poursui- vons ensuite avec la partie Java. En effet, pourquoi ne serions-nous pas respectueux avec le plus vieux d’abord ? En cas de difficultés, suivant les connaissances du programmeur, il est tout à fait possible de passer plus rapidement sur un sujet et d’y revenir par la suite. Pour un programmeur Visual Basic, s’initier en Java et C++ va représenter un travail important, car la syntaxe sera toute nouvelle pour lui. Dans ce cas-là, il devra sans doute se concentrer d’abord sur la partie Java et revenir ensuite sur le C++ avec ses particularités et ses variantes plus complexes. Si nous avions traité l’un ou l’autre de ces langages séparément, la structure de cet ouvrage aurait été totalement autre. Java et C++ possèdent en effet quelques particularités fonciè- rement différentes qui auraient pu être exposées d’une autre manière. Ici, la difficulté principale réside dans les premiers chapitres où, pour présenter des exemples qui tiennent debout, nous avons souvent besoin de connaître certains aspects du langage qui seront examinés dans les chapitres suivants, et ce tout en traitant en parallèle les deux langages. Tous les exemples de code présentés dans les différents chapitres ont été compilés séparé- ment et souvent sous différents systèmes d’exploitation. Ils sont bien évidemment présents sur le CD-Rom accompagnant cet ouvrage. De quel matériel a-t-on besoin ? Cet ouvrage est conçu pour travailler dans un environnement Windows (XP ou Vista). Dans l’annexe F, nous montrerons qu’il est aussi possible d’utiliser Linux. Un système équipé d’un processeur cadencé à 450 MHz et de 256 Mo de mémoire vive est suffisant pour assurer une compilation des programmes et garantir un environnement

×