DE JAVA À C++

DE JAVA À C++
Petit vademecum des différences
entre les deux langages et des pièges y afférents
Jean-Paul RIGAULT
Université de Nice Sophia Antipolis
École polytechnique universitaire
Département de sciences informatiques
[email protected]
Version 1.0
Mars 2005

De Java à C++ UNIVERSITÉ DE NICE SOPHIA ANTIPOLIS
2v1.0 © 2005–Jean-Paul Rigault

UNIVERSITÉ DE NICE SOPHIA ANTIPOLIS De Java à C++
© 2005–Jean-Paul Rigault v1.0 3
Table des matières
Table des matières . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
Motivation 7
Avertissement sur la portée de ce document 7
Polices et symboles utilisés en marge 8
Chapitre 1
Syntaxe de base . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
1.1 Éléments lexicaux 9
1.1.1 Jeux de caractères 9
1.1.2 Mots réservés 9
1.1.3 Du bon usage du point-virgule 9
1.2 Opérateurs et expressions 9
1.2.1 Expressions et opérateurs généraux 9
1.2.2 Opérateurs de portée 10
1.2.3 Opérateurs de conversion (cast) de C++ 10
1.2.4 Conversions implicites 10
1.2.5 Opérateurs d’entrée-sortie 11
1.3 Structures de contrôle 11
Chapitre 2
Structure des programmes . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
2.1 Unité de compilation 12
2.1.1 Processus de compilation 12
2.1.2 Fichier source et package en Java 12
2.1.3 Fichier source et namespace en C++ 13
2.1.4 Portée des noms (scope)14
Portée des noms 14
Classes imbriquées 14

De Java à C++ UNIVERSITÉ DE NICE SOPHIA ANTIPOLIS
4v1.0 © 2005–Jean-Paul Rigault
2.2 Fonctions et classes 15
2.2.1 Types des fonctions et main() 15
2.2.2 Prototypes des fonctions 15
2.2.3 Séparation de l’interface et de l’implémentation d’une classe 16
Cas des templates de C++ 16
2.3 Contrôle d’accès 16
2.3.1 Des philosophies différentes de contrôle d’accès 16
2.3.2 Contrôle d’accès aux membres et aux classes 16
2.3.3 Amitié et contrôle d’accès au niveau package 17
2.4 Préprocesseur 17
Chapitre 3
Objets et classes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
3.1 Nature des objets 18
3.2 Création des objets 18
3.2.1 Allocation des objets 19
Allocation en C++ 19
Allocation en Java 20
3.2.2 Initialisation (construction) 20
Ordre des initialisations 21
Initialisation au vol 21
3.2.3 Finalisation (destruction) 22
Du bon usage de new en C++ 22
3.2.4 Membres statiques de classes 23
3.3 Désignation et copie des objets 24
3.3.1 Notion de référence 24
3.3.2 Copie des objets 24
Copie des types de base 25
Copie de la valeur en C++ 25
Constructeur de copie et opérateur d’affectation en C++ 25
Copie de référence en Java 25
Copie de valeur en Java 26
3.3.3 Objets constants 27
3.3.4 Passage de paramètres 27
Passage de paramètres en Java 27
Passage de paramètres en C++ 28
3.3.5 Retour de fonction 28

UNIVERSITÉ DE NICE SOPHIA ANTIPOLIS De Java à C++
© 2005–Jean-Paul Rigault v1.0 5
3.4 Réutilisation des classes par agrégation 29
3.4.1 Agrégation faible 29
3.4.2 Agrégation forte 29
Agrégation forte en C++ 29
Agrégation forte en Java 30
Simulation de l’agrégation forte par l’agrégation faible 30
3.5 Réutilisation des classes par héritage 30
3.5.1 Dérivation de classes 30
3.5.2 Fonctions virtuelles et méthodes 31
3.5.3 Classes abstraites et interfaces 32
Chapitre 4
Généricité (
Templates ) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
4.1 Généricité en C++ 33
4.2 Généricité en Java 1.4 34
4.3 Généricité en Java 1.5 et C++ : comparaison 35
4.3.1 Généricité en Java 1.5 Tiger 35
Remarque sur C++ et la généricité contrainte 35
4.3.2 Limitations de la généricité en Java 1.5 ; comparaison avec C++ 36
Chapitre 5
Exceptions et bibliothèques de base . . . . . . . . . . . . . . . . . . . . . . 38
5.1 Exceptions 38
5.2 Bibliothèques de base 38
5.2.1 Organisation des bibliothèques 38
5.2.2 Environnement d’exécution 39
Références . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41