DE JAVA À C++

Transcription

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++
2
UNIVERSITÉ DE NICE SOPHIA ANTIPOLIS
v1.0
© 2005–Jean-Paul Rigault
De Java à C++
UNIVERSITÉ DE NICE SOPHIA ANTIPOLIS
Table des matières
Table des matières . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
Motivation
Avertissement sur la portée de ce document
Polices et symboles utilisés en marge
7
7
8
Chapitre 1
Syntaxe de base . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
1.1
Éléments lexicaux
1.1.1
1.1.2
1.1.3
1.2
Jeux de caractères
Mots réservés
Du bon usage du point-virgule
Opérateurs et expressions
1.2.1
1.2.2
1.2.3
1.2.4
1.2.5
1.3
9
9
9
9
9
Expressions et opérateurs généraux
Opérateurs de portée
Opérateurs de conversion (cast) de C++
Conversions implicites
Opérateurs d’entrée-sortie
Structures de contrôle
9
10
10
10
11
11
Chapitre 2
Structure des programmes . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
2.1
Unité de compilation
2.1.1
2.1.2
2.1.3
2.1.4
12
Processus de compilation
Fichier source et package en Java
Fichier source et namespace en C++
Portée des noms (scope)
Portée des noms
Classes imbriquées
© 2005–Jean-Paul Rigault
v1.0
12
12
13
14
14
14
3
De Java à C++
2.2
Fonctions et classes
2.2.1
2.2.2
2.2.3
2.3
15
Types des fonctions et main()
Prototypes des fonctions
Séparation de l’interface et de l’implémentation d’une classe
Cas des templates de C++
Contrôle d’accès
2.3.1
2.3.2
2.3.3
2.4
UNIVERSITÉ DE NICE SOPHIA ANTIPOLIS
15
15
16
16
16
Des philosophies différentes de contrôle d’accès
Contrôle d’accès aux membres et aux classes
Amitié et contrôle d’accès au niveau package
Préprocesseur
16
16
17
17
Chapitre 3
Objets et classes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
3.1
Nature des objets
18
3.2
Création des objets
18
3.2.1
3.2.2
3.2.3
3.2.4
3.3
19
19
20
20
21
21
22
22
23
Désignation et copie des objets
3.3.1
3.3.2
3.3.3
3.3.4
3.3.5
4
Allocation des objets
Allocation en C++
Allocation en Java
Initialisation (construction)
Ordre des initialisations
Initialisation au vol
Finalisation (destruction)
Du bon usage de new en C++
Membres statiques de classes
24
Notion de référence
Copie des objets
Copie des types de base
Copie de la valeur en C++
Constructeur de copie et opérateur d’affectation en C++
Copie de référence en Java
Copie de valeur en Java
Objets constants
Passage de paramètres
Passage de paramètres en Java
Passage de paramètres en C++
Retour de fonction
v1.0
24
24
25
25
25
25
26
27
27
27
28
28
© 2005–Jean-Paul Rigault
De Java à C++
UNIVERSITÉ DE NICE SOPHIA ANTIPOLIS
3.4
Réutilisation des classes par agrégation
3.4.1
3.4.2
3.5
Agrégation faible
Agrégation forte
Agrégation forte en C++
Agrégation forte en Java
Simulation de l’agrégation forte par l’agrégation faible
Réutilisation des classes par héritage
3.5.1
3.5.2
3.5.3
Dérivation de classes
Fonctions virtuelles et méthodes
Classes abstraites et interfaces
29
29
29
29
30
30
30
30
31
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
4.3.2
Généricité en Java 1.5 Tiger
Remarque sur C++ et la généricité contrainte
Limitations de la généricité en Java 1.5 ; comparaison avec C++
35
35
36
Chapitre 5
Exceptions et bibliothèques de base . . . . . . . . . . . . . . . . . . . . . . 38
5.1
Exceptions
38
5.2
Bibliothèques de base
38
5.2.1
5.2.2
Organisation des bibliothèques
Environnement d’exécution
38
39
Références . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
© 2005–Jean-Paul Rigault
v1.0
5
De Java à C++
6
UNIVERSITÉ DE NICE SOPHIA ANTIPOLIS
v1.0
© 2005–Jean-Paul Rigault
De Java à C++
UNIVERSITÉ DE NICE SOPHIA ANTIPOLIS
Introduction
Motivation
C++ et Java sont actuellement les deux langages à objets majeurs utilisés dans
l’industrie1. Ces deux langages font donc actuellement partie de la palette de tout
développeur digne de ce nom.
Au delà de leurs ressemblances superficielles, les deux langages sont fondamentalement différents. Leur philosophie de conception n’est pas la même, les styles de programmation qu’ils mettent en avant sont loin d’être identiques, et les programmes
obtenus ont des comportements et une sémantique tout à fait dissemblables.
Pour des raisons de simplicité (apparente ?), de goûts et de couleurs, et aussi de
mode, Java est devenu le premier langage enseigné dans les écoles et les universités. Le
présent document s’adresse donc (a priori) à des apprentis en C++ supposés connaître
les bases de Java. Il tente de mettre en évidence les différences les plus marquantes et
les pièges à éviter.
Avertissement sur la portée de ce document
Ce document n’est en aucun cas un manuel d’apprentissage de l’un ou l’autre langages. On trouve pour cela d’excellents ouvrages: [5][6][10][11][16][19] pour C++,
[4][8][9] pour Java. Certains de ces textes sur Java comportent des notations nombreuses sur les différences entre Java et C++ (par exemple [8][9]), mais ces remarques
s’adressent plutôt à des programmeurs en C++ passant à Java, alors que nous visons ici
la population duale. On consultera avec profit les livres de conseils de programmation, par exemple [13][14][15] pour C++ ou [2] pour Java.
Le C++ décrit ici est ISO C++, tel que défini par la norme internationale parue en
1998. Le compilateur gcc-3.4.3 est utilisé comme implémentation de référence (il
n’est pas totalement compatible avec la norme mais en est bien plus proche que beaucoup d’autres compilateurs). En ce qui concerne Java, on s’appuie essentiellement sur
Java 2 avec l’implémentation de référence Jdk 1.4 de Sun Microsystems. Quelques
mentions à la nouvelle version de Java (version 5, dite aussi Tiger, correspondant au
Jdk 1.5) sont faites, en particulier dans le chapitre 4. Les références [12][17] décrivent
de manière plus complète les différences entre les deux versions de Java
Les mécanismes décrits ici correspondent essentiellement à ceux qui peuvent faire
partie d’un cours de base en Java ou C++. En particulier, certaines propriétés avancées
ne sont pas ou peu abordées : citons à titre d’exemples, pour C++, l’héritage multiple,
1. même si un troisième compétiteur, C#, est récemment apparu, s’appuyant sur toute la
puissance de Microsoft.Voir [7][18].
© 2005–Jean-Paul Rigault
v1.0
7
De Java à C++
UNIVERSITÉ DE NICE SOPHIA ANTIPOLIS
le mécanisme d’identification dynamique de type (Run Tme Type Information ou
RTTI), certains mécanismes avancés de templates... ; et pour Java, la ref lexivité (reflection), le support de la programmation concurrente (multithreading), etc.
Polices et symboles utilisés en marge
Les symboles suivants sont utilisés en marge, parfois accompagnés de texte en
regard dans une couleur différente.
Différence conceptuelle
Les deux langages diffèrent de manière fondamentale sur un
point relativement important. En particulier, ceci concerne des
mécanismes qui sont a priori présents dans les deux langages mais
réalisés de manière très différente.
Stop
Arrêtez-vous et prenez le temps de réf léchir à la remarque !
Piège
Au moins de l’avis de l’auteur... Certains de ces pièges sont
redoutables lorsque l’on passe d’un langage à l’autre.
Conseil
Un conseil en passant...
C++
Spécificité de C++
On décrit un trait propre à C++, pour lequel il n’existe pas
d’équivalent direct en Java.
Spécificité de Java (1.4)
On décrit un trait propre à Java, pour lequel il n’existe pas
d’équivalent direct en C++.
Spécificité de Java 1.5 (Tiger)
On décrit un trait propre à cette nouvelle version de Java... que
personne ne sait désigner par un numéro unique !
Nous utilisons les variations de police suivantes :
- la police Courier correspond à du code C++ ou Java, tel quel,
- le gras italique attire l’attention sur une notion ou une définition importante,
- l’italique simple s’applique aux termes donnés directement en anglais.
8
v1.0
© 2005–Jean-Paul Rigault
De Java à C++
UNIVERSITÉ DE NICE SOPHIA ANTIPOLIS
Chapitre 1
Syntaxe de base
1.1
Éléments lexicaux
1.1.1 Jeux de caractères
Java supporte totalement le jeu de caractères Unicode, y compris pour les identificateurs. C++ ne supporte pas (encore) Unicode directement ; il permet cependant
d’utiliser des caractères étendus (wide character, wchar_t) et, ainsi, d’utiliser Unicode
dans les chaînes de caractères.
1.1.2 Mots réservés
Les deux langages étendent l’ensemble de mots réservés (mots-clés) d’ANSI C. C++
a un nombre de mots réservés que l’on peut trouver déraisonnable (plus de 701).
1.1.3 Du bon usage du point-virgule
C++ et Java utilisent le point-virgule de la même manière, pour terminer une instruction simple. Dans aucun des deux langages, l’accolade fermante d’un bloc ne
nécessite d’être suivie par un point-virgule.
En revanche, C++ exige que l’accolade fermante d’une définition de classe, de
structure, d’union ou d’énumération soit suivie d’un point-virgule :
class A {
// ... (détails omis)
}; // le ’;’ est indispensable ici en C++
1.2
Opérateurs et expressions
1.2.1 Expressions et opérateurs généraux
C++ et Java empruntent la syntaxe des expressions et la plupart les opérateurs du
langage C (au moins ceux qui ont un sens2).
1. Ce qui reste très inférieur à ce que propose C# !
© 2005–Jean-Paul Rigault
v1.0
9
De Java à C++
UNIVERSITÉ DE NICE SOPHIA ANTIPOLIS
Chacun ajoute des opérateurs spécifiques : par exemple >>> ou instanceof en
Java, ou typeid, ::, ou encore les opérations de pointeurs sur membres (.*, ->*)
en C++.
C++ et Java permettent tous deux la surcharge des fonctions (voir 2.2.2) ; en revanche, C++ est actuellement le seul à permettre la surcharge des opérateurs, c’est-à-dire
leur définition pour de nouveaux types.
1.2.2 Opérateurs de portée
C++
C++ utilise l’opérateur de portée (double deux-points, ::) pour qualifier un nom
par la classe ou le namespace dont il est membre. Java utilise l’opérateur de sélection
(point, .) pour qualifier un nom par sa classe (dans le cas d’un membre statique) ou
par son package.
1.2.3 Opérateurs de conversion (cast) de C++
C++
L’opérateur de conversion explicite (cast) de Java a une syntaxe identique à celle de
C. Bien que C++ supporte également cette syntaxe, il introduit quatre opérateurs de
cast présentant une nouvelle syntaxe : dynamic_cast, static_cast,
reinterpret_cast et const_cast.
Ces nouveaux opérateurs de cast ont au moins deux avantages sur la forme utilisée
par le langage C :
- ils permettent d’exprimer les différentes intentions pour lesquelles on peut
être conduit à utiliser un cast,
- ils ont une syntaxe qui rend les casts faciles à repérer dans le source d’un programme (ils sont greppables1).
Sémantiquement, le cast (unique) de Java correspond au dynamic_cast de C++.
1.2.4 Conversions implicites
C++
Les deux langages permettent des conversions implicites dans les expressions, c’està-dire des conversions que le compilateur peut utiliser automatiquement pour donner
un sens à une expression. Mais alors que celles de Java sont limitées aux conversions
usuelles (par exemple int → double) et aux conversions d’héritage (de la classe
dérivée vers la classe de base ou vers une interface implémentée), C++ permet à l’utilisateur de définir ses propres conversions implicites, et ceci de deux manières :
- un constructeur qui peut être invoqué avec un seul paramètre définit une
conversion implicite du type du paramètre vers le type de la classe ;
- le programmeur peut définir une conversion implicite dans l’autre sens (de la
classe vers un autre type) en munissant la classe d’un opérateur de cast.
2. Pas exemple Java ne reprend pas les opérateurs de C concernant les pointeurs (*, &, ->)
puisqu’il n’y a pas de pointeurs (explicites) dans ce langage.
1. Ce qui signifie qu’il est possible de les rechercher dans le texte du programme grâce à des
expressions régulières (par exemple avec une commande comme grep, ou encore sed, ed,
lex, f lex, etc.).
10
v1.0
© 2005–Jean-Paul Rigault
De Java à C++
UNIVERSITÉ DE NICE SOPHIA ANTIPOLIS
Dans l’exemple qui suit, le constructeur, qui peut prendre un seul argument, définit
une conversion int → Rational alors que l’opérateur de cast permet la conversion
implicite Rational → double.
class Rational {
public:
Rational(int = 0, int = 1); // constructeur de conversion
operator double() const;
// opérateur de cast
// ...
};
Java Tiger a introduit des conversions implicites, mais uniquement dans le cas particulier de la conversion d’un type de base (e.g., int) vers son wrapper (e.g.,
Integer) et vice versa (autoboxing et unboxing).
1.2.5 Opérateurs d’entrée-sortie
C++
Java n’a pas d’opérateur d’E/S spécial. Il utilise des fonctions de bibliothèque et la
méthode toString() pour convertir (implicitement si nécessaire) un objet en une
chaîne imprimable ou encore il a recours à des méthodes de sérialisation et désérialisation des objets.
En C++, la surcharge des opérateurs a rendu possible la construction de la bibliothèque iostream et la définition des opérateurs << et >> pour l’écriture et la lecture
des objets. Il s’agit d’un mécanisme d’E/S dirigé par les types et extensible. Ce mécanisme est même doublement extensible. D’une part, il est possible de définir ces opérateurs pour tout nouveau type et il est fort conseillé de le faire (dès le début de
l’implémentation d’une nouvelle classe). D’autre part, on peut définir ses propres
classes en dérivant de celles d’iostream, pour gérer des E/S sur des supports particuliers (e.g., sockets) ou avec des effets spéciaux (e.g., compression/décompression).
1.3
Structures de contrôle
Là encore, C++ et Java empruntent leurs structures de contrôle (if, switch,
while, for, etc.) à C. Sur ce point, il n’y a pas de différence fondamentale entre les
deux langages.
Noter que Java n’a pas d’instruction goto mais que le mot-clé correspondant y est
quand même réservé !
© 2005–Jean-Paul Rigault
v1.0
11
De Java à C++
UNIVERSITÉ DE NICE SOPHIA ANTIPOLIS
Chapitre 2
Structure des programmes
2.1
Unité de compilation
2.1.1 Processus de compilation
Dans les deux langages, le source d’un programme est constitué de plusieurs
fichiers, appelés unités de compilation. Comme le nom l’indique, chaque unité est
compilée séparément, afin de produire des fichiers binaires (fichiers-objets d’extension .o ou .obj en C++, fichier de byte-code .class en Java).
Une fois les fichiers binaires obtenus, il faut les regrouper pour obtenir un exécutable. Alors que ce mécanisme est effectué statiquement1 en C++ par un utilitaire
nommé éditeur de liens, les fichiers .class sont chagés dynamiquement et automatiquement par la machine virtuelle Java.
Afin de permettre cette compilation séparée, chaque unité doit comporter l’information nécessaire au compilateur pour effectuer sa traduction. En particulier, elle doit
référencer explicitement les autres unités de compilation qu’elle utilise.
2.1.2 Fichier source et package en Java
En Java, l’unité de compilation est un fichier source contenant au plus une classe
publique, et portant le nom de cette classe (suivi de l’extension .java). Ces fichiers
sont regroupés en packages organisés hiérarchiquement et dotés d’une convention de
nommage (par exemple fr.essi.jpr.util). Ces noms de packages sont mis en
correspondance avec les répertoires du système d’exploitation qui contiennent les
fichiers du package (.class et .java) ; ainsi le nom précédent pourrait-il correspondre, par exemple, au répertoire
/users/jpr/Java/fr/essi/jpr/util
Chaque fichier source spécifie le package auquel il appartient par une directive
package. La directive import permet de rendre accessibles les entités d’un autre
package dans le fichier source courant :
package fr.essi.jpr.robot;
import java.util.StringTokenizer;
1. c’est-à-dire à la fin de la compilation, avant l’exécution. En fait, la plupart des environnements sur lesquels les programmes C++ sont susceptibles de s’exécuter supportent la notion
de bibliothèques dynamiques, mais ce mécanisme ne fait pas partie de la définition du langage lui-même, contrairement au chargement dynamique de classes de Java.
12
v1.0
© 2005–Jean-Paul Rigault
De Java à C++
UNIVERSITÉ DE NICE SOPHIA ANTIPOLIS
import fr.essi.jpr.util.*;
La directive import recherche les packages dans une liste de répertoires constituant
le Class Path, qui est fourni soit par la variable d’environnement CLASSPATH, soit par
une option de la ligne de commande. Ainsi, dans l’exemple précédent, le Class Path
devrait contenir le répertoire /users/jpr/Java.
C++
2.1.3 Fichier source et namespace en C++
En C++, l’unité de compilation est un fichier source, portant l’extension .cpp1,
ainsi que tout les fichiers d’en-tête (extension .h) qu’il inclut (#include), et ceci
récursivement. Une telle unité de compilation peut contenir des définitions de types,
de classes, de fonctions ordinaires, de fonctions-membres, d’objets globaux...
Il n’y a pas de notion de package à proprement parler, ni donc de correspondance
fixe avec les répertoires du système d’exploitation. La directive #include va chercher les fichiers d’inclusion dans le répertoire courant et/ou dans un ensemble de
répertoires par défaut. On peut étendre cette ensemble de répertoires par une option
(-I par exemple) de la commande de compilation (e.g., g++).
Néanmoins, afin d’éviter d’avoir un seul espace de nommage global, C++ définit la
notions d’espace de noms (namespace). Pour utiliser une entité quelconque (un type,
une classe, une fonction, un objet global, etc.), il faut donc inclure le fichier d’en-tête
qui contient sa définition ou déclaration, et aussi spécifier lors de l’utilisation de
l’entité le namespace qui contient son nom grâce à l’opérateur de portée (::). En particulier, toutes les entités de la bibliothèque C++ font partie du namespace standard,
nommé std :
#include <iostream>
#include <vector>
main() {
std::cout << "hello" << std::endl;
std::vector<int> v;
}
On peut faire l’économie de la qualification par :: et importer un nom particulier
d’un namespace en utilisant la déclaration using
#include <iostream>
#include <vector>
using std::cout;
using std::vector;
main() {
cout << "hello" << std::endl;
vector<int> v;
}
1. Tout au moins, c’est l’extension que j’adopte à l’ESSI. C’est l’extension par défaut des
outils Microsoft et elle a l’avantage d’être partout reconnue. D’autres extensions sont parfois utilisées pour un fichier de source C++ : .cc, .C, .c++, .cxx, etc. De même, au lieu
de .h, certains utilisent d’autres extensions pour les fichiers d’en-tête : .hh, .H, .hpp,
.h++, .hxx, etc.
© 2005–Jean-Paul Rigault
v1.0
13
De Java à C++
UNIVERSITÉ DE NICE SOPHIA ANTIPOLIS
ou même tous les noms connus jusqu’au point courant grâce à la directive using
#include <iostream>
#include <vector>
using namespace std;
// importe tous les noms du namespace
// connus à ce point
main() {
cout << "hello" << endl;
vector<int> v;
}
Après avoir inclus les fichiers de la bibliothèque C++ dont vous avez besoin
(<string>, <vector>, <iostream>, etc.), n’oubliez pas de faire ce using
namespace std; à moins que vous ne soyez prêt à utiliser partout l’opérateur :: !
Notez que les namespaces de C++ comme les packages de Java sont ouverts : on peut
leur ajouter librement des éléments. Cependant, en Java, il faut avoir le droit d’écriture dans le répertoire correspondant au package ; et, en C++, il est en principe interdit
d’ajouter au namespace std.
2.1.4 Portée des noms (scope)
Portée des noms Java connaît trois notions de portée des noms qui sont, du plus global au plus restreint : package, classe, bloc.
C++ dispose lui de notions analogues, mais un peu différentes, de portée :
- portée de namespace, avec deux sous-possibilités :
- potentiellement visible dans tout le programme (extern),
- visible uniquement dans l’unité de compilation (static),
- portée de classe (pour les membres statiques comme ceux d’instance),
- portée de bloc (variable locale).
Les noms qui n’appartiennent à aucun namespace sont en fait supposés faire partie du
namespace global (et anonyme) accessible par l’opérateur :: unaire. Les variables à
portée de namespace sont souvent appelées variables globales ; elles peuvent être externes ou statiques.
Classes imbriquées Les deux langages supportent la notion de classe imbriquée (nested class). En C++, une classe imbriquée fait simplement partie de la portée de nommage d’une autre classe. C’est une pure question de portée. En Java, il y a deux types
de classes imbriquées :
- les classes imbriquées (ou internes) statiques, identiques aux classes imbriquées de C++,
- les classes imbriquées (ou internes) normales, dont chaque instance possède
un lien sur une instance de la classe englobante.
Enfin, notons que C++ ne possède rien d’équivalent aux classes internes anonymes
de Java.
14
v1.0
© 2005–Jean-Paul Rigault
De Java à C++
UNIVERSITÉ DE NICE SOPHIA ANTIPOLIS
2.2 Fonctions et classes
2.2.1 Types des fonctions et main()
C++
C++
En Java, les seules fonctions possibles doivent être membres d’une classe (méthodes) et on en distingue deux types : les méthodes d’instance (qui on un argument
implicite this), et les méthodes statiques, qui n’on pas d’argument this mais dont
le nom est dans la portée de la classe. L’exécution d’un programme Java lance une
méthode statique main() dont la classe est désignée par la commande de lancement
(java). Il peut donc y avoir plusieurs méthodes main() dans un même programme
(au plus une par classe).
C++ dispose aussi de fonctions-membres d’instance et statiques, comme Java. Mais il
dispose également de fonctions ordinaires (non membres d’une classe, à portée globale
ou de namespace) ; la fonction main() par laquelle débute l’exécution d’un programme C++ doit être une de ces fonctions ordinaires et elle doit être unique dans
tout le programme.
Les deux langages permettent la surcharge des fonctions (méthodes). En outre C++
permet la surcharge des opérateurs sous forme de fonctions-membres ou de fonctions
ordinaires : le nom de la fonction doit commencer par le mot-clé operator suivi de
la notation correspondant à l’opérateur (operator+, operator[], operator
new, etc.).
2.2.2 Prototypes des fonctions
C++
La déclaration de fonction en C++ possède deux mécanismes inconnus en Java :
- la possibilité d’arguments ayant des valeurs par défaut ;
- la possibilité de déclarer une fonction en ligne (inline), suggestion au compilateur de remplacer l’appel de la fonction par une expansion en ligne de son
corps, plutôt que de générer une séquence d’appel/retour.
On peut toujours simuler le premier point en Java grâce à la surcharge des fonctions.
Quant au second, il s’agit d’une tentative d’optimisation manuelle dont on pourrait
penser qu’elle devrait être prise en charge par le compilateur1.
C++ a aussi des modes de passage de paramètres plus nombreux que Java (voir
3.3.4).
En Java, les fonctions possèdent une liste d’exceptions (throw list), introduite par le
mot-clé throws, qui spécifie les exceptions que la fonction ne capture pas et donc
qu"elle laisse filer. Le compilateur Java effectue des vérifications basées sur la throw list.
C++ a le même concept (introduit par le mot-clé throw, sans s) mais, d’une part, la
throw list y est optionnelle et, d’autre part, ce langage ne requiert que des vérifications
dynamiques.
1. C’est en fait assez délicat sans changer profondément le mécanisme compilation/édition de
liens utilisé par C++. Jusqu’à présent la philosophie de conception de C++ repose sur la disponibilité d’un environnement de traduction et d’exécution léger, identique à (et même
confondu avec) celui de C.
© 2005–Jean-Paul Rigault
v1.0
15
De Java à C++
UNIVERSITÉ DE NICE SOPHIA ANTIPOLIS
2.2.3 Séparation de l’interface et de l’implémentation d’une classe
C++
C++
En Java le corps des méthodes est donné directement dans la définition de la classe.
En C++, il est possible de faire de même (les fonctions-membres sont alors implicitement inline) mais il est plus courant de placer la définition de la classe (liste des
déclarations de ses membres) ainsi que les prototypes de fonctions ordinaires dans un
fichier d’en-tête .h, et la définition du corps des fonctions (membres ou ordinaires)
dans un fichier .cpp. Cela permet aux clients de la classe de n’inclure, et donc de ne
dépendre, que du fichier d’en-tête .h. Le fichier .cpp, quant à lui, peut être compilé
une fois pour toutes et placé dans une bibliothèque.
Cette séparation de la spécification d’un objet d’une part et de son implémentation
d’autre part, est considérée depuis longtemps comme une bonne pratique de génie
logiciel. Si l’on veut la retrouver en Java, on doit passer par l’intermédiaire d’interfaces, ce qui est parfois assez contraignant et peu naturel.
Cas des templates de C++ Noter cependant qu’en C++, lors de la définition de
fonctions ou de classes génériques (templates), la distinction entre .h et .cpp n’existe
plus vraiment, le compilateur ayant besoin à la fois de la spécification de la classe et du
corps de ses fonctions pour effectuer l’instanciation. On peut alors, soit tout mettre
dans le fichier d’en-tête .h, soit, par habitude, garder la séparation mais inclure le
.cpp à la fin du .h. Dans ce dernier cas, le .cpp en question ne constitue pas une
unité de compilation et ne devra donc pas être compilé séparément.
2.3
Contrôle d’accès
2.3.1 Des philosophies différentes de contrôle d’accès
Même si, à première vue, les mécanismes peuvent paraître assez semblables, C++ et
Java ont des philosophies sensiblement différentes en ce qui concerne le contrôle
d’accès. Celui de C++ a une nature qui relève plus du génie logiciel : rendre accessible
ce qui est utile à l’architecture générale, interdire l’accès au reste. Comme le dit
STROUSTRUP lui-même, le contrôle d’accès de C++ « n’empêche pas de tricher » (par
exemple, une manière de tricher est de se livrer à des conversions « sauvages » utilisant
reinterpret_cast).
En revanche, l’une des utilisations importantes de Java est d’écrire du code migrant
qui va s’exécuter dans un environnement hôte non seulement différent de celui où le
code a été développé, mais encore inconnu et peut-être sensible. Le contrôle d’accès
doit alors obligatoirement interdire de mettre la pagaïe dans l’environnement de
l’hôte.
2.3.2 Contrôle d’accès aux membres et aux classes
C++ et Java proposent tous les deux les mêmes trois niveaux d’accès pour les membres d’une classe (public, protected et private), avec la même sémantique.
16
v1.0
© 2005–Jean-Paul Rigault
De Java à C++
UNIVERSITÉ DE NICE SOPHIA ANTIPOLIS
C++
Java ajoute les niveaux d’accès public et private pour les classes d’un package,
ce qui est une notion inconnue de C++.
En revanche, seul C++ permet de spécifier un niveau d’accès lors de la dérivation
de classe. Ainsi
class B : private A { };
signifie que les membres publics et protégés hérités de A prennent le niveau d’accès
private dans B.
2.3.3 Amitié et contrôle d’accès au niveau package
Aux trois niveaux d’accès précédents, Java ajoute le niveau d’accès package-private,
auquel ne correspond d’ailleurs aucun mot-clé, puisque c’est le niveau par défaut.
C++ n’a rien de tel, puisqu’il ne connaît pas la notion de package. En revanche il dispose du concept d’amitié (friend), qui permet à une fonction (ou une classe) non
membre d’une autre classe d’avoir accès aux membres privés et protégés de cette dernière.
En C++, une classe doit choisir ses amis, cela fait partie de la définition de la classe.
En Java il suffit qu’une classe soit dans le même package qu’une autre pour avoir accès
aux membres package-private de cette dernière (rappelons que les packages sont ouverts
— voir 2.1.3).
2.4 Préprocesseur
C++
Le préprocesseur est un outil spécifique à C et C++. En C++, on n’en abusera pas,
cependant ! Seules sont absolument indispensables #include et les directives de
compilation conditionnelles (#if, #ifdef, #ifndef). La plupart des utilisations de
#define, qui sont inévitables en C, peuvent être avantageusement remplacées par
des constructions C++ plus sûres : définition de constante, fonction en ligne, fonction
générique.
© 2005–Jean-Paul Rigault
v1.0
17
De Java à C++
UNIVERSITÉ DE NICE SOPHIA ANTIPOLIS
Chapitre 3
Objets et classes
3.1
Nature des objets
Les deux langages distinguent les types de base (caractères, entiers, réels, pointeurs
pour C++) des types définis par des classes. Les instances de ces derniers types sont les
objets au sens de la programmation par objets, et c’est ainsi que Java les nomme.
Comme le mot « objet » est fortement surchargé, nous évitons de l’utiliser dans ce
sens et nous lui préférons alors instance de classe. Le mot « objet » utilisé sans qualification particulière désigne donc dans ce texte une variable ou une constante ou
même une fonction de n’importe quel type.
Les deux langages manipulent les instances de types de base et celles de classes de
manière très différente. C++, tout en gardant la distinction forte (les types de base ne
sont pas des classes), s’efforce d’en rendre le manipulations identiques (allocation
mémoire, comportement lors de la copie), autant que faire se peut. Java, quant à lui,
assume complètement la distinction en proposant des mécanismes différents de manipulation.
En outre, afin de permettre de manipuler des types de base comme des instances de
classe, Java fournit un ensemble de classes d’enrobage (wrapper) comme Integer,
Double, etc. Ces wrappers ne sont pas fournis en C++, mais il est facile de les définir
(et même de le faire économiquement grâce à des classes génériques).
Il est clair que ce chapitre est l’un de ceux où la différence entre les mécanismes des
deux langages est la plus criante.
3.2
C++
Création des objets
Créer un objet (de base ou non) c’est
- allouer de la mémoire,
- puis initialiser cette mémoire.
En Java comme en C++ ces deux étapes sont indissociables. Dans les deux langages,
pour les instances de classes, la seconde étape est de la responsabilité d’un constructeur. C++ fournit même des pseudo-constructeurs (par défaut1 et de copie) pour les
types de base.
1. qui d’ailleurs n’est pas invoqué par défaut !
18
v1.0
© 2005–Jean-Paul Rigault
De Java à C++
UNIVERSITÉ DE NICE SOPHIA ANTIPOLIS
La manière d’allouer la mémoire conditionne la durée de vie des objets. Elle n’est
également pas sans rapport avec la portée (scope) des noms des objets.
3.2.1 Allocation des objets
Allocation en C++ Qu’ils soient d’un type de base ou une instance de classe, tous les
objets en C++ peuvent être alloués d’une des quatre manières suivantes :
1. allocation statique : l’objet est alloué au lancement de l’exécution du programme et désalloué automatiquement à la fin (par exit()) ; ceci concerne
les variables à portée de namespace, les membres statiques de classe, et les
variables locales de bloc déclarées static ;
2. allocation automatique : l’objet est alloué automatiquement dans un bloc et
libéré tout aussi automatiquement à la sortie de ce bloc ; si le contrôle entre à
nouveau dans le bloc, une version fraîche de l’objet est réallouée. Ceci concerne les variables locales ordinaires (dites automatiques, auto) ;
3. allocation dynamique : l’objet est alloué par l’opérateur new, qui retourne un
pointeur dessus ; il doit être désalloué explicitement par le programme grâce
à l’opérateur delete ;
4. allocation d’exception : les objets correspondant aux exceptions (qui en C++
peuvent être de n’importe quel type copiable, voir 5.1) sont alloués par l’opérateur throw et désalloués automatiquement lorsqu’ils n’ont plus d’utilité
(c’est-à-dire après leur dernière capture par catch).
On voit donc que deux des allocations (1 et 2) et trois des désallocations (1, 2 et 4)
sont automatiques. L’extrait de programme suivant montre les différentes
possibilités :
class A {
static int _ast;
public:
A() {}
// détails omis
};
int A::_ast(5);
// membre statique : allocation statique (1)
A aext;
// variable globale : allocation statique (1)
main()
{
A a;
// variable locale à allocation automatique (2)
static A lst(2);// variable locale statique : allocation statique (1)
A *pa = new A();// allocation dynamique (3)
try {
throw A(); // allocation d’exception (4)
} catch (A&) {
// fin de la vie de l’objet créé par throw
}
delete pa;
// fin de la vie de l’objet créé par new
© 2005–Jean-Paul Rigault
v1.0
19
De Java à C++
UNIVERSITÉ DE NICE SOPHIA ANTIPOLIS
return 0;
// fin de la vie de la variable locale automatique a
}
// exit() implicite : fin de la vie des objets statiques lst, aext et A::_ast
La table 1 résume les différentes possibilités d’allocation en C++, avec la durée de
vie et les portées associées.
Table 1: Allocation des objets en C++
mode
d’allocation
création
durée de vie
portée
statique
définition hors d’un
bloc
destruction automatique à la fin de l’exécution du programme
namespace (variable
globale) ou bloc
(variable locale
static)
automatique
définition dans un
bloc (sans modifieur
ou avec modifieur
auto ou
register)
destruction automatique à la fin du bloc,
que l’on quitte ce bloc
normalement ou par
l’effet d’une exception
bloc
utilisation de new
de new à delete
celle du (des) pointeur(s) ou références
permettant d’accéder
à l’objet
utilisation de throw
destruction automatique au dernier
dynamique
exception
catch
le(s) bloc(s) du
catch qui permet(tent) de capturer
l’exception
Allocation en Java En Java, la situation est plus simple. Il n’y a que trois modes
d’allocation, deux pour les types de base et un pour les instances de classe. Les instances de types de base peuvent être allouées automatiquement (portée de bloc) ou statiquement (membres statiques de classe) et les instances de classes (et de tableaux) ne
peuvent être allouées que par new. En particulier, les exceptions aussi sont allouées
par new.
3.2.2 Initialisation (construction)
Dans les deux langages, juste après que la mémoire d’une instance de classe ait été
allouée, un constructeur est invoqué afin d’initialiser l’objet. Le mécanisme de construction par défaut et la synthèse automatique par le compilateur d’un constructeur
par défaut sont également similaires.
20
v1.0
© 2005–Jean-Paul Rigault
De Java à C++
UNIVERSITÉ DE NICE SOPHIA ANTIPOLIS
Noter cependant que Java n’a pas de synthèse automatique du constructeur de
copie (voir 3.3.2).
C++
Ordre des initialisations C++ est très précis sur l’ordre de construction des parties
d’un objet complexe :
1. la (ou les) classe(s) de base, dans l’ordre de la liste de dérivation,
2. les membres propres (c’est-à-dire les membres de données que la classe dérivée ajoute), dans l’ordre de leur apparition dans la définition de la classe,
3. le corps du constructeur.
Il fournit une syntaxe particulière, la liste d’initialisation de membres, pour invoquer
directement les constructeurs de ces différentes parties :
class A1 {
public:
A1(int);
// ...
};
class A2 {
public:
A2(int);
// ...
};
class B : public A1, public A2 {
string _s;
int _i;
public:
// constructeur avec liste d’initialisation de membres
B() : A1(3), A2(2.75), _s("hello"), _i(3) {}
// ...
};
Noter que l’ordre des initialisations dans la liste n’a pas d’importance, l’ordre indiqué
plus haut étant toujours utilisé par le compilateur. C’est cependant une bonne pratique de toujours trier la liste d’initialisation de membres dans l’ordre qui sera utilisé
par C++ (et cela évite les warnings de certains compilateurs).
Java n’a pas un ordre aussi précisément défini, ni de liste d’initialisation de membres. Il réclame seulement que la classe de base soit initialisée (appel éventuel du constructeur de super) avant toute autre chose dans le constructeur d’une classe dérivée.
Initialisation au vol Java permet librement de donner des valeurs par défaut aux
membres lors de la définition de la classe :
public class A {
private int _i = 10;
private B _b = new B();
private static int _st = 5;
}
© 2005–Jean-Paul Rigault
v1.0
21
De Java à C++
UNIVERSITÉ DE NICE SOPHIA ANTIPOLIS
En C++, ceci ne peut être fait que dans un constructeur1 pour les membres d’instance
et lors d’une définition de statique (voir 3.2.4) pour les membres statiques.
3.2.3 Finalisation (destruction)
C++
En C++, juste avant qu’une instance de classe ne disparaisse, on appelle son destructeur. Les deux actions sont indissociables, si bien que le point d’invocation du destructeur est toujours parfaitement connu en C++ (voir table 1).
On pourrait penser que les destructeurs ne sont pas indispensables en Java, puisque
ce langage libère automatiquement la mémoire grâce à son garbage collector. Cependant,
en C++, le destructeur n’a pas pour but exclusif de libérer de la mémoire : il doit exécuter les dernières volontés de l’objet, ce qui peut inclure de nombreuses autres actions
(dont on aime souvent pouvoir préciser le point exact où elles sont effectuées).
En Java la méthode finalize() joue d’une certaine manière le rôle du destructeur. Cependant, on ne peut savoir précisément quand elle va être invoquée, ni même
si elle va l’être ; cela dépend du bon vouloir du ramasse-miettes (garbage collector).
En C++, l’ordre de destruction est tout aussi précis que celui de la construction, et
c’est l’ordre inverse de cette dernière.
Du bon usage de new en C++ La richesse des modes d’allocation des objets rend
l’utilisation de new beaucoup moins fréquente en C++ qu’en Java. En particulier on
évitera d’utiliser l’allocation dynamique là ou une variable locale automatique est
mieux adaptée. Ainsi le code suivant
void f() {
A *pa = new A();
// travail sur *pa qui reste purement local à ce bloc
delete pa;
}
est-il maladroit si l’objet pointé par pa a une visibilité et une durée de vie restreintes
au bloc de f(), comme cela semble être le cas2 sur l’exemple. De plus ce code n’est
pas sûr en cas d’exception levée lors de l’exécution de f() (qui fera delete pa ?).
En revanche le code suivant
void f() {
A a(5);
// travail sur a qui reste purement local à ce bloc
// et qui est détruit automatiquement au retour de la fonction
}
est ici équivalent et sûr car il garantit la destruction de a, quelle que soit la raison pour
laquelle f() se termine (retour normal ou exception — voir table 1).
1. À l’exception des membres static const int (ou, plus généralement, de nature
entière) qui sont les seuls à pouvoir être initialisés au vol en C++.
2. Noter que, en C, l’utilisation de malloc() serait tout aussi maladroite dans le même contexte.
22
v1.0
© 2005–Jean-Paul Rigault
De Java à C++
UNIVERSITÉ DE NICE SOPHIA ANTIPOLIS
3.2.4 Membres statiques de classes
Les deux langages supportent les membres de données statiques. En Java, il est possible d’initialiser un membre statique au vol (voir 3.2.2) si l’intialisation n’a pas une
forme trop complexe ; sinon on peut utiliser un bloc d’initialisation statique :
public class A {
static double[] digits = new double[10];
// ...
static {
for (int i = 0; i < 10; ++i)
digits[i] = i;
}
}
C++ ne dispose pas (malheureusement) d’une telle possibilité et il faut initialiser les
membres statiques explicitement, grâce à une définition de statique :
// Définition de la classe A dans le fichier A.h
class A [
private:
static int _ist;
static A _ast;
public:
A(double);
// ...
};
// Implémentation de la classe A dans le fichier A.cpp
// (en tête du fichier en général, hors de tout bloc)
int A::_ist = 10;
// définition de statique (même si membre privé !)
A A::_ast(3.5);
// idem
Et si l’initialisation est plus compliquée (à l’image du tableau digits ci-dessus, dans
l’exemple Java), il faut se débrouiller, par exemple, avec les constructeurs normaux de
la classe, ce qui n’est pas très satisfaisant...
En outre, l’initialisation des membres statiques en C++ souffre d’un grave défaut.
Le langage ne garantit pas dans quel ordre elle est effectuée entre les différentes unités
de compilation. Losqu’il existe des dépendances d’intialisation entre ces membres statiques, le programmeur doit être trés vigilant et doit souvent recourir à des idiomes
spécifiques.
© 2005–Jean-Paul Rigault
v1.0
23
De Java à C++
3.3
UNIVERSITÉ DE NICE SOPHIA ANTIPOLIS
Désignation et copie des objets
3.3.1 Notion de référence
Les deux langages supportent la notion de référence, mais de manière très différente. En C++ une référence doit être explicitement dénotée, mais peut s’appliquer
indifféremment à une variable de type de base ou à une instance de classe :
class A {
public:
A(int);
// ...
};
int i = 3;
// une variable entière
A a(3);
// une instance
int& ri = i;
// une référence sur une variable entière
A& ra = a;
// une référence sur une instance de la classe A
Ici une référence est juste un autre nom pour un objet, un synonyme. Ainsi dans les
exemples précédents, i et ri désignent le même objet (un entier), de même que a et
ra désignent la même instance de la classe A. En C++, une référence ne peut être
nulle et doit toujours être initialisée.
Dans le cas de Java, le nom d’une instance de classe est implicitement une
référence :
public class A {
public A(int i);
// ...
}
C++
A a = new A(3); // référence sur une (nouvelle) instance de A
En Java une référence peut être nulle (c’est même sa valeur par défaut) :
A a1 = null;
// référence nulle
A a2;
// référence nulle aussi
C++ possède aussi la notion de pointeur, héritée de C et que n’a pas Java (enfin...
voir 3.3.2). Un pointeur est un variable (ou constante) qui contient l’adresse d’un
autre objet :
int *pi = &i;
En C et C++, *pi désigne l’objet pointé ; dans notre exemple, *pi et i désignent
donc la même variable entière (donc *pi est une référence sur i, n’est-ce pas ?).
3.3.2 Copie des objets
Il y a deux contextes de copie, l’initialisation et l’affectation (montrés ici en C++) :
class A {
public:
A(int);
// ...
24
v1.0
© 2005–Jean-Paul Rigault
De Java à C++
UNIVERSITÉ DE NICE SOPHIA ANTIPOLIS
};
A a0(2), a1(5);
A a2 = a1;
// initialisation
a0 = a2;
// affectation
Les différences entre les deux langages concernant les opérations de copie des instances de classe constituent l’un des pièges les plus redoutables pour les débutants
dans l’un ou l’autre langage.
Copie des types de base La sémantique des opérations de copie est identique, dans
les deux langages, pour les types de base : elle consiste en une copie de la valeur, les
objets restant différents :
int i = 5;
int j = i;
En Java comme en C++, les objets i et j restent différents (ils n’ont pas la même
adresse) mais ils ont maintenant la même valeur.
En revanche, quand il s’agit de copie d’instances de classe les deux langages diffèrent fondamentalement.
C++
C++
Copie de la valeur en C++ Conformément à la philosophie indiquée en 3.1, C++
étend aux classes la sémantique de copie des types de base, c’est-à-dire la notion de
copie de la valeur. Ainsi dans l’exemple précédent, après
A a2 = a1;
// initialisation
a1 et a2 sont toujours deux objets différents, mais ils ont maintenant la même valeur,
ils sont égaux. Il en est de même pour a0 et a2 après
a0 = a2;
// affectation
La même sémantique de copie de la valeur est utilisée en C++, même lorsqu’on
accède aux objets à travers des références :
A& ra1 = a1;
// ra1 et a1 désignent le même objet
A& ra2 = a2;
// ra2 et a2 désignent le même objet
ra1 = a0;
// a1 (et ra1) est maintenant égal à a0, pas identique
ra1 = ra2;
// ra1 et ra2 désignent les objets maintenant égaux
// mais non identiques a1 et a2
Constructeur de copie et opérateur d’affectation en C++ Mais qu’est ce que la
valeur d’une instance de classe en C++ ? Autrement dit, qu’est-ce qui est copié, au
juste ? Ceci est de la responsabilité de deux opérations fondamentales : le constructeur
de copie et l’opérateur d’affectation de copie.
Rappelons que C++ est capable, sous certaines conditions, de synthétiser automatiquement ces deux opérations pour les classes qui ne les possèdent pas.
Copie de référence en Java Si nous transposons en Java l’exemple précédent :
public class A {
public A(int i) {
// ...
}
// ...
© 2005–Jean-Paul Rigault
v1.0
25
De Java à C++
UNIVERSITÉ DE NICE SOPHIA ANTIPOLIS
}
A a0 = new A(2);
A a1 = new A(5);
après
A a2 = a1;
// initialisation
a1 et a2 désignent le même objet, ce sont deux noms synonymes pour le même objet.
De même pour a0 et a2 après
a0 = a2;
// affectation
On voit donc que la copie d’objets en Java consiste à établir l’identité des objets ce
qui implique évidemment l’égalité de leur valeur. Ceci se retrouve également dans la
signification des opérateurs de comparaison (== et !=) qui, en Java, vérifient l’identité
des objets alors qu’en C++ ils vérifient l’égalité (des valeurs) des objets. Pour vérifier
l’égalité des objets en Java, il faut utiliser la méthode equals().
Les références de Java sont en fait analogues aux pointeurs de C++1, à quelques
détails près, dont celui de la syntaxe. Ainsi pour avoir le même effet que dans l’exemple Java précédent, on pourrait écrire en C++ :
class A {
public:
A(int) {
// ...
}
// ...
};
A a0(2);
A a1(5);
A *pa1 = &a1;
A *pa2 = pa1;
// *pa1 et *pa2 désignent maintenant le même objet
A *pa0;
pa0 = pa2;
// *pa0 et *pa2 désignent maintenant le même objet
Copie de valeur en Java Comme Java copie des références, si l’on veut copier les
valeurs, il faut utiliser un détour comme la méthode clone() (ce qui n’est pas toujours adéquat) ou un constructeur de copie « à la C++ » :
public class A {
public A(int i) {
// ...
}
public A(A a) { // constructeur de copie
// ...
1. On lit et on entend parfois que Java n’a pas de pointeurs. C’est un raccourci de langage
abusif, car en fait, en ce qui concerne les accès aux objets, Java n’a que des pointeurs ! En
revanche, Java n’a ni la syntaxe des opérations sur pointeurs (opérateurs *, ->, &), ni
l’arithmétique des pointeurs, ni la possibilité de « pointer n’importe où ». Ceci lui évite la
confusion qui s’en suit en C et C++ entre tableaux et pointeurs, et aussi le rend plus sûr en
rendant impossibles les pointeurs erratiques.
26
v1.0
© 2005–Jean-Paul Rigault
De Java à C++
UNIVERSITÉ DE NICE SOPHIA ANTIPOLIS
}
// ...
}
A a1 = new A(3);
A a2 = new A(a1);
// copie de la valeur de a1 dans a2
Bien entendu, il convient d’écrire complètement le constructeur de copie, Java
n’étant pas capable de le synthétiser automatiquement, comme peut le faire C++.
3.3.3 Objets constants
C++
Java permet de déclarer un membre de données comme final, ce qui rend
impossible sa modification. Mais ceci est réservé au membres de classes. En revanche,
C++ permet de déclarer constant n’importe quel objet grâce au mot-clé const.
Lorsqu’il s’applique à un objet référencé ou pointé, le mot-clé const signifie que
l’objet n’est pas modifiable à travers le pointeur ou la référence (mais il peut rester
modifiable par une autre désignation) :
int i;
const int& rci = i; // rci et i désigne le même entier
rci = 3;
// interdit ! Cet objet est constant à travers le nom rci
i = 10;
// reste toujours possible
C++ permet aussi d’indiquer que c’est la valeur du poiunteur lui-même qui est
constante (c’est-à-dire que ce pointeur ne peut pas pointer sur un autre objet). Il convient alors de changer la position du mot clé const :
const int *pi = &i; // pointeur sur une constante
*pi = 12;
// interdit
pi = &j;
// OK si j est un int
int *const pci = &i;// pointeur constant
*pci = 12;
// OK
pci = &j;
// interdit
const int *const p = &i;
// pointeur constant sur une constante
3.3.4 Passage de paramètres
Passage de paramètres en Java En Java, il existe deux modes de passage des arguments de fonction : le passage par valeur et... le passage par valeur !
En fait les types de base sont passés par valeur, comme dans la plupart des langages
(et en particulier comme en C++).
Pour les instances de classes, les références sont passées par valeur ! En fait, pour les
instances de classe, Java ne manipule que des pointeurs et c’est le pointeur sous-jacent
qui est passé par valeur (voir la copie de référence en 3.3.2). Si ce pointeur est modifié
dans la fonction, c’est une copie qui en est modifiée, pas celui fourni par l’appelant. Il
s’ensuit qu’une méthode de Java ne peut en aucun cas changer directement les paramètres effectifs qu’on lui passe. Ainsi la fonction suivante qui a pour but d’échanger
ses deux arguments ne fonctionne pas en Java
© 2005–Jean-Paul Rigault
v1.0
27
De Java à C++
UNIVERSITÉ DE NICE SOPHIA ANTIPOLIS
public class Swap {
static void swap(Object o1, Object o2) {
Object o = o1;
o1 = o2;
o2 = o;
}
}
car les deux paramètres ne sont effectivement échangés que dans le corps de la fonction, pas dans l’appelant. En revanche, une méthode Java peut bien sûr modifier l’état
d’un objet passé en paramètre, en appelant l’une des méthodes de cet objet.
C++
Passage de paramètres en C++ C++ a trois modes de passage de paramètres :
- par copie de la valeur,
- par pointeur (c’est en fait un passage par valeur, celle du pointeur),
- par référence (dans ce cas le paramètre formel désigne, durant l’exécution de
la fonction, le même objet que le paramètre effectif).
Dans les deux derniers cas, on peut décider si l’objet pointé ou référencé par le paramètre effectif doit rester constant pendant l’exécution de la fonction en préfixant la
déclaration du paramètre formel par const :
void f(const A& a1, A& a2) {
a1 = a2;
// interdit ! l’objet est constant à travers le nom a1
a2 = a1;
// OK : l’objet a2 de l’appelant est modifié et égal à a1
}
Le passage par référence (et par pointeur) de C++ permet de modifier effectivement la valeur des paramètres effectifs. Voici la définition de la fonction swap() sous
forme d’une fonction générique1 C++ (voir chapitre 4) :
template <typename T>
void swap(T& t1, T& t2) {
T t = t1;
t1 = t2;
t2 = t;
}
3.3.5 Retour de fonction
En ce qui concerne le retour de fonction, les deux langages sont conformes à leur
philosophie de copie. Java retourne une valeur pour les types de base, une référence
pour les instances de classe. Le programmeur C++ peut retourner au choix une valeur,
un pointeur ou une référence, quelle que soit la nature de l’objet.
Dans le cas du retour par pointeur ou par référence, le programmeur C++ doit
s’assurer que l’objet pointé ou référencé a une durée de vie plus longue que l’exécution de la fonction elle même (c’est-à-dire que cet objet ne doit pas être un objet local
automatique). Java n’a évidemment pas ces problèmes.
1. Cette fonction est d’ailleurs définie dans la bibliothèque standard (std::swap()).
28
v1.0
© 2005–Jean-Paul Rigault
De Java à C++
UNIVERSITÉ DE NICE SOPHIA ANTIPOLIS
3.4 Réutilisation des classes par agrégation
L’agrégation est la possibilité pour un objet (le composite) de « contenir » une instance d’une autre classe (le composant).
Selon le sens que l’on donne à « contenir », on peut distinguer plusieurs sortes
d’agrégations, dont les deux plus importantes sont
- l’agrégation faible (appelée aussi agrégation par référence), dans laquelle l’objet
composite dispose d’un simple lien (un pointeur ou une référence) sur l’objet
composant ; par ailleurs, les deux objets vivent une vie indépendante et ce
type d’agrégation autorise le partage du composant par plusieurs composites ;
- l’agrégation forte (appelée aussi composition en UML, ou agrégation par
valeur), dans laquelle le composite possède une copie propre du composant,
sur laquelle, en quelque sorte, il a « le droit de vie ou de mort » (le composant
a la même durée de vie que son composite) et qui n’est pas partageable (par
agrégation forte) avec un autre composite.
Les deux langages supportent l’agrégation faible pour les instances de classes et
l’agrégation forte pour les types de base. Seul C++ supporte directement l’agrégation
forte pour les instances de classes et l’agrégation faible pour les types de base.
3.4.1 Agrégation faible
C++
C’est le mode d’agrégation de Java pour une instance de classe. Le composite contient juste une référence sur le composant.
En C++, l’agrégation faible est obtenue en représentant le lien sur le composant par
un pointeur ou une référence Le pointeur ou la référence peuvent alors indifféremment désigner une instance d’un type de base ou d’une classe.
L’agrégation faible permet de profiter du polymorphisme éventuel du composant.
3.4.2 Agrégation forte
C++
Agrégation forte en C++ C’est le mode d’agrégation de C++ lorsque l’on compose
par une instance (d’un type de base ou de classe) :
class B {
// ...
};
class A {
B _b;
int _i;
B& _br;
B *_pb;
int& _ri;
// ...
};
© 2005–Jean-Paul Rigault
// Composition par valeur (agrégation forte)
// Composition par valeur (agrégation forte)
// Composition par référence (agrégation faible)
// Composition par pointeur (agrégation faible)
// Composition par référence (agrégation faible)
v1.0
29
De Java à C++
UNIVERSITÉ DE NICE SOPHIA ANTIPOLIS
Le constructeur du composite est responsable de la construction (initialisation) des
membres en agrégation forte et le destructeur est responsable de leur finalisation.
L’agrégation forte de C++ est un mécanisme statique. Aucun polymorphisme sur le
composant n’est possible. Si l’on a des composants polymorphes, il faut simuler
l’agrégation forte par la faible (voir ci-dessous).
Agrégation forte en Java C’est le mode d’agrégation de Java pour une instance d’un
type de base. En revanche, cette agrégation n’est pas directement supportée pour les
instances de classe. Il faut alors la simuler par l’agrégation faible.
Simulation de l’agrégation forte par l’agrégation faible Dans les deux langages, on
peut être amené à simuler l’agrégation forte par sa version faible, soit parce que cette
dernière n’est pas supportée (Java), soit parce que l’on veut profiter de composants
polymorphes (C++).
Il convient alors de mettre en place les mécanismes suivants :
- la construction (initialisation) du composite doit prendre en charge celle du
composant ;
- le destructeur (en C++) du composite doit se charger de la finalisation du
composant ;
- le contrôle d’accès doit être judicieusement utilisé afin d’éviter le partage du
composant par d’autres composites (il faut éviter les références qui « fuient »
du composite) ;
- en C++, les opérations de copie (constructeur et affectation) doivent être correctement définies afin d’assurer la sémantique de l’agrégation forte (et en
particulier l’absence de possibilité de partage au moins logique1).
La dernière règle est particulièrement importante en C++ puisque ne pas la respecter pourrait conduire à des références sur des objets qui n’existent plus. En Java, le garbage collector assure en général que, tant que des références existent, l’objet référencé
n’est pas détruit.
3.5
Réutilisation des classes par héritage
3.5.1 Dérivation de classes
Les deux langages, reposant sur le paradigme des objets, proposent l’héritage (ou
dérivation ou extension) de classes, à peu près dans les même conditions. Dans la
classe dérivée, on peut ajouter des propriétés (données ou fonctions-membres) ainsi
que rédéfinir des fonctions-membres hérités (mais voir 3.5.2 pour une différence
importante liée à cette redéfinition).
1. On peut avoir une sémantique de valeur, comme on dit, tout en ayant du partage d’information. Ce qui est important pour l’utilisateur d’une classe ayant une telle sémantique, est
que tout se passe comme si la valeur était transférée lors des opérations de copie. Les techniques de copie à la demande (Copy On Write ou COW) exploitent cette remarque.
30
v1.0
© 2005–Jean-Paul Rigault
De Java à C++
UNIVERSITÉ DE NICE SOPHIA ANTIPOLIS
C++
C++
La version d’une fonction-membre redéfinie dans la classe dérivée doit avoir les
mêmes arguments (en nombre et type) que dans la classe de base. En revanche le type
de retour peut être covariant en C++, c’est-à-dire d’un sous-type de ce qu’il était au
niveau de la classe de base. Java 1.4 ne supporte pas cette covariance (il réclame l’invariance), mais Java 1.5 le fait.
Il y a cependant deux grandes différences dans le mécanisme de dérivation des
deux langages ;
- C++ permet de spécifier un niveau de contrôle d’accès lors de la dérivation
(voir 2.3.2) ;
- C++ supporte l’héritage multiple de classes, et introduit le mécanisme d’héritage virtuel pour éviter la duplication liée à l’héritage (indirect) plusieurs fois
de la même classe1 ; Java ne supporte l’héritage multiple que pour les interfaces, pas pour les classes (voir 3.5.3).
3.5.2 Fonctions virtuelles et méthodes
Le typage dynamique (dit aussi late binding, liaison différée) est supporté par les deux
langages pour les fonctions-membres d’instance. Mais, alors que c’est le mécanisme
unique d’appel de fonction-membre en Java, en C++ le typage dynamique n’est effectif que si la fonction-membre est déclarée virtuelle (virtual) au niveau de la classe
de base.
Dans la terminologie usuelle du monde des objets, une fonction-membre soumise
au typage dynamique est appelée une méthode2. Donc, en Java, toutes les fonctionsmembres d’instance sont des méthodes, alors qu’en C++ seules celles déclarées virtuelles le sont.
Dans les deux langages une méthode peut être déclarée abstraite, c’est-à-dire sans
définition (sans corps) dans la classe considérée3. La syntaxe est différente : en Java on
utilise le mot-clé abstract,
public abstract class A {
public abstract int f();
// ...
}
en C++ on déclare simplement que le corps n’est pas défini à la fin de la déclaration
(on parle de fonction virtuelle pure)
class A {
virtual int f() = 0;
}
1. Il s’agit là d’un mécanisme avancé de C++, qui dépasse le cadre de ce document.
2. En fait, pour augmenter la confusion terminologique, Java désigne aussi les fonctionsmembres statiques (qui ne sont virtuelles ni en C++, ni en Java) sous le nom de méthodes
statiques !
3. Ce n’est pas tout à fait exact en C++ : une méthode peut-être déclarée abstraite et peut
avoir une définition dans la même classe. Il n’empêche que cette méthode devra être redéfinie dans les classes dérivées concrètes. Les destructeurs virtuels sont dans ce cas, puisqu’une
classe C++ doit toujours avoir un constructeur défini (possiblement par défaut).
© 2005–Jean-Paul Rigault
v1.0
31
De Java à C++
UNIVERSITÉ DE NICE SOPHIA ANTIPOLIS
Dans les deux cas, le résultat est le même : la classe devient tout entière abstraite (voir
3.5.3) et la méthode devra être (re)définie dans les classes dérivées concrètes.
Dans les deux langages, ni les fonctions-membres de classe (c’est-à-dire statiques),
ni les constructeurs ne sont des fonctions virtuelles (méthodes).
3.5.3 Classes abstraites et interfaces
Dès qu’une classe possède (au moins) une méthode abstraite, elle est elle-même
abstraite, c’est à dire qu’elle n’a pas d’instance. Cette règle est implicite en C++ alors
qu’il faut le déclarer (mot-clé abstract) en Java, comme indiqué dans l’exemple cidessus.
En Java, il existe un cas particulier et important de classe abstraite, l’interface. Une
interface Java ne contient que des méthodes abstraites et aucun membre de données
d’instance (les membres de données d’une interface sont implicitement static
final).
Alors qu’en Java une classe dérivée étend (extends) sa classe de base, on dit qu’elle
implémente (implements) une interface. Une classe implémentant une interface
doit satisfaire le contrat représenté par l’interface : soit elle est abstraite, soit elle doit
fournir une (re)définition de toutes les méthodes de l’interface.
Une interface Java peut étendre une autre interface, mais pas l’implémenter. Une
classe peut implémenter plusieurs interfaces (mais pas étendre plusieurs classes,
comme nous l’avons déjà mentionné en 3.5.1).
C++ ne dispose pas directement de cette notion d’interface, bien qu’on puisse la
simuler par des sortes de classes abstraites « pures », ne contenant que des fonctions
virtuelles pures et des membres de donnée statiques constants.
32
v1.0
© 2005–Jean-Paul Rigault
De Java à C++
UNIVERSITÉ DE NICE SOPHIA ANTIPOLIS
Chapitre 4
Généricité (Templates )
Pendant longtemps l’existence des fonctions et classes génériques (function templates
et class templates) en C++ et leur absence totale en Java a été la différence majeure entre
les deux langages. Même après l’introduction des « génériques » (generics) en Java 1.5
Tiger, les deux langages restent, de ce point de vue encore, fondamentalement éloignés
C++
4.1
Généricité en C++
En C++, la généricité permet de paramétrer la définition d’une fonction ou d’une
classe. On définit donc non pas une fonction ou une classe à proprement parler, mais
plutôt le modèle (template) d’une infinité de fonctions ou de classes, une pour chaque
jeu de paramètres effectifs. Ces dernières sont appelées instances1 de la fonction ou de
la classe générique.
Le mécanisme d’instanciation générique de C++ est une sorte de macro-expansion
dirigée par les types. À ce titre il doit être effectué par le compilateur, et les paramètres
génériques doivent donc être des entités connues à la compilation. Tout se passe
comme si le compilateur produisait le code source de la fonction ou de la classe après
substitution des paramètres génériques. Une fois instanciée, (presque2) rien ne distingue la fonction ou la classe obtenue d’une fonction ou d’une classe ordinaire (c’est-àdire non issue de générique).
Les classes génériques doivent être instanciées explicitement, alors que les fonctions
génériques peuvent l’être implicitement si le compilateur est capable de déterminer la
valeur des paramètres génériques effectifs à la simple analyse de l’appel. Dans ce dernier cas, une fonction générique est une simple fonction à surcharge paramétrée, et
c’est d’ailleurs le mécanisme de résolution de surcharge qui a la responsabilité de l’instanciation.
Rappelons que, pour les classes comme pour les fonctions, les paramètres génériques peuvent être de trois natures différentes :
1. Dans la terminologie des objets, de manière générale, une instance est ce qui se conforme à
un modèle. Ainsi une instance de classe (un objet) est-elle conforme au modèle fournit par
la classe.Et une « vraie » classe issue d’une classe générique se conforme-t-elle au modèle
proposé par cette dernière.
2. En fait, il y a quelques restrictions d’usage, concernant en particulier les conversions implicites des arguments. Ceci dépasse le cadre de ce document.
© 2005–Jean-Paul Rigault
v1.0
33
De Java à C++
UNIVERSITÉ DE NICE SOPHIA ANTIPOLIS
- un nom de type (typename),
- une constante (de nature entière) et statique, c’est-à-dire dont la valeur est
connue à la compilation ; ceci inclut les pointeurs (sur les objets externes) ;
- toute une classe générique.
Voici une esquisse de définition de classe montrant les trois possibilités :
template <typename T, int N, template <typename> Cont>
class MyClass {
// ...
};
La classe génrique MyClass dépend d’un paramètre génrique qui est un nom de type
(T), d’une constante entière N, et d’un troisième paramètre sui est lui-même une
classe générique (Cont) dépendant d’un paramètre de type (anonyme ici). Voici une
instantiation possible de cette classe (et d’un objet du type correspondant) :
MyClass<int, 10, std::vector> mc;
L’utilisation des classes génériques est précieuse dans la manipulation de collections
homogènes comme celles de la STL, puisque l’on peut assurer d’emblée, à la compilation, la sécurité du typage sans avoir besoin de la vérifier à l’exécution.
La possibilité de paramètres entiers combinés avec le mécanisme (avancé) de spécialisation générique (template specialization) donne une très grande puissance théorique
à la généricité de C++ : elle constitue un système complet au sens de Turing, c’est-àdire que l’on peut y calculer n’importe quelle fonction calculable. Comme il s’agit en
outre d’un outil de génération de code, ceci rend possible ce que l’on appelle la métaprogrammation (statique), dite encore programmation générique ou template programming (voir, par exemple, 1).
4.2 Généricité en Java 1.4
Jusqu’à Java 1.4 inclus, ce langage ne disposait pas de mécanisme de généricité statique. Le compilateur ne pouvait vérifier totalement la sécurité du typage comme il le
fait en C++ et il fallait donc recourir à une vérification de type dynamique, c’est-àdire à l’exécution. Si la vérification échouait, une exception était lancée.
Ceci explique par exemple que les collections de Java soient des collections
d’Objects et qu’il est nécessaire de convertir, à l’exécution, ces objets dans le type
désiré. Cette conversion doit se faire avec un cast, toujours vérifié dynamiquement1
même si le programmeur a pris soin de maintenir l’homogénéité de la collection.
Globalement, si l’on considère l’ensemble de la compilation et de l’exécution, le
résultat peut sembler être le même et les deux langages sont tous deux sûrs en ce qui
concerne le typage. Cependant, en Java, les erreurs de typage sont détectées tard, au
mieux lors des tests d’exécution et, d’autre part, la vérification dynamique a un coût
qui peut être élevé.
1. l’équivalent d’un dynamic_cast en C++ (voir 1.2.3)
34
v1.0
© 2005–Jean-Paul Rigault
De Java à C++
UNIVERSITÉ DE NICE SOPHIA ANTIPOLIS
4.3 Généricité en Java 1.5 et C++ : comparaison
4.3.1 Généricité en Java 1.5 Tiger
Conscients de l’inconvénient manifeste lié à l’incapacité de vérifier la sûreté de
types à la compilation, les concepteurs de Java ont introduit, après une longue gestation et moult hésitations, la notion de classe générique dans la nouvelle version dite
Tiger. Il n’y a évidement pas de fonctions (ordinaires) génériques en Java puisqu’il n’y
a pas de fonctions ordinaires du tout ! Cependant les méthodes peuvent aussi être
génériques.
Au niveau de l’utilisation (écriture du programme), il y a deux différences fondamentales entre les generics de Java et les templates de C++ :
- en Java, seuls les noms de type sont autorisés comme paramètres,
- en Java, les types utilisés comme paramètres génériques peuvent être bornés
par des relations d’extension et/ou d’implémentation alors qu’ils sont toujours libres en C++.
À tire d’exemple, voici une esquisse de la définition d’une classe générique en Java :
class MyClass<T, U extends Comparable> {
// ...
}
Cette classe générique dépend de deux paramètres qui sont des noms de types, T et U.
Il n’y a pas besoin de mot-clé comme typename (ni même template). En outre il
est spécifié que le type (la classe) U doit dériver ou implémenter Comparable (ici
c’est « implémenter » puisque Comparable est une interface prédéfinie) ; on parle
dans ce cas de généricité contrainte.
L’instanciation se fait bien sûr explicitement :
MyClass<String, Integer> mc =
new MyClass<String, Integer>();
C++
Remarque sur C++ et la généricité contrainte On peut se demander pourquoi C++
n’a pas adopté la généricité contrainte, car cela semble une bonne propriété permettant de renforcer les vérifications statiques de type. En fait, contrairement à Java et à
cause de son mécanisme de génération, C++ n’a pas réellement besoin de cette
expression explicite des contraintes : si le code C++ instancié compile correctement,
c’est qu’il satisfait les contraintes ! C’est une forme d’abstraction pure souvent utilisée
en C++, en particulier dans la STL, où les contraintes restent implicites.
Dans l’exemple précédent, le principe d’abstraction pure nous dirait que si le type U
dispose de l’opérateur <, c’est qu’il satisfait l’interface de « comparabilité », et qu’il n’y
a donc pas besoin d’expliciter cette dernière comme on le ferait en Java. C’est vraiment une différence de philosophie de conception !
Par ailleurs, le mécanisme de généricité de C++ est suffisamment puissant pour
permettre d’exprimer la généricité contrainte et de la vérifier à la compilation, si on le
souhaite, et ceci sans qu’il n’y ait besoin d’étendre le langage. Ceci met en jeu la
méta-programmation statique déjà mentionnée et dépasse le cadre de ce document.
© 2005–Jean-Paul Rigault
v1.0
35
De Java à C++
UNIVERSITÉ DE NICE SOPHIA ANTIPOLIS
4.3.2 Limitations de la généricité en Java 1.5 ; comparaison avec C++
La différence la plus importante entre les deux mécanismes de généricité relève de
la manière dont ils sont réalisés dans les deux langages.
Nous avons déjà remarqué que la généricité de C++ était réalisée comme une sorte
de macro-expansion et qu’une fois instanciée, (presque) rien ne distingue la classe
obtenue d’une classe ordinaire. Ceci signifie en particulier qu’en C++ des instances
de la même classe générique, mais pour des paramètres différents, correspondent non
seulement à des types différents mais aussi à des implémentations différentes. Par
exemple, non seulement list<int> et list<string> sont des types différents
en C++ mais leur code l’est aussi.
Il n’en est pas de même en Java Tiger ; la généricité y est un pur mécanisme de
compilation et il n’en reste pratiquement rien à l’exécution1. Ainsi List<Integer>
et List<String> partagent-ils le même code qui est celui de la « vieille » liste de
Java 1.4, c’est-à-dire une liste d’Objects. Le type d’instanciation (ici Integer ou
String) est perdu à l’exécution. L’avantage est double :
- il n’y a pas de duplication de code comme il y en a en C++,
- la machine virtuelle Java n’a pas eu besoin d’être modifiée pour s’accommoder des génériques (c’était une contrainte forte de conception).
Ne pas dupliquer le code est un avantage indéniable sur C++ car les templates ont
une tendance à générer des fichiers binaires assez volumineux. Cependant les inconvénients de l’approche Java sont assez redoutables et, pour certains critiques, outrepassent cet avantage. Citons quelques unes des limitations des génériques de Java :
1. incompatibilité avec les types de base ;
2. impossibilité d’instancier un objet ou un tableau dont le type est un paramètre générique ;
3. un paramètre générique ne peut être la cible de instanceof ;
4. les membres statiques d’une classe générique (données ou méthodes) ne peuvent pas dépendre des paramètres génériques ;
5. les classes d’exception ne peuvent être génériques.
La première limitation provient de l’implémentation sous forme d’un classe unique
dans laquelle les paramètres génériques sont remplacés par Object. Il faut donc des
objets ! La conséquence est une importante perte de performance pour les types de
base, puisqu’il faut les « empaqueter »2.
Les quatre limitations suivantes sont causées par l’oubli des paramètres de type à
l’exécution et constituent une importante perte d’orthogonalité du langage. Pour le
point 4, noter qu’il existe un seul exemplaire d’un membre statique de classe générique quel que soit le nombre d’instances génériques pour des types différents (en C++
il en existe autant que d’instances génériques différentes). Pour le point 5, catch
serait incapable de distinguer (à l’exécution) des classes d’exception instanciées pour
des paramètres génériques différents.
1. Cette perte de mémoire porte le nom d’effacement (erasure) en Java 1.5.
2. L’autoboxing et l’unboxing de Tiger (1.2.4) facilitent l’écriture mais n’améliorent en rien les
performances.
36
v1.0
© 2005–Jean-Paul Rigault
De Java à C++
UNIVERSITÉ DE NICE SOPHIA ANTIPOLIS
Bien entendu C++ ne souffre d’aucune de ces limitations.
On peut caricaturer la situation à l’exécution de la façon suivante. En C++ on dispose des instances génériques mais on a oublié qu’elles provenaient du même modèle,
alors qu’en Java on dispose du modèle (appauvri) mais on n’a plus aucun souvenir des
différentes instances ! Bien que plus lourde, l’approche de C++ a au moins le mérite
de l’orthogonalité.
© 2005–Jean-Paul Rigault
v1.0
37
De Java à C++
UNIVERSITÉ DE NICE SOPHIA ANTIPOLIS
Chapitre 5
Exceptions et bibliothèques de base
Il n’est évidemment pas envisageable de décrire ici les bibliothèques de base des
deux langages et leurs nombreuses différences. On se contentera donc de quelque
remarques sur leurs philosophies de conception, loin d’être semblables.
5.1
C++
Exceptions
Les exceptions relèvent à la fois de la définition du langages et de classes de bibliothèques prédéfinies. Il fallait bien les mettre quelque part...
En Java une classe d’exception doit être dans la hiérarchie dérivant de la classe
Exception. En C++, on peut placer une classe d’exception dans la hiérarchie des
exceptions standards (dont la classe de base est std::exception) mais cela n’est
pas obligatoire. Une exception en C++ peut être de type quelconque, du moment
qu’elle dispose des opérations de copie.
Java distingue deux sortes d’exceptions,
- les exceptions contrôlées qu’il est impératif soit de capturer (catch), soit de
spécifier dans la throw list de la fonction courante,
- les exceptions non contrôlées, descendantes de Error ou de
RunTimeException, et pour lesquelles ces actions sont inutiles.
Rien de tel en C++ où il n’est jamais nécessaire de capturer une exception et où les
throw lists ne sont vérifiées que dynamiquement (voir 2.2.2).
5.2 Bibliothèques de base
5.2.1 Organisation des bibliothèques
Il y a une différence fondamentale dans l’organisation des classes dans les deux langages. En Java, toutes les classes descendent de la classe Object, alors qu’en C++ le
concept de racine unique n’existe pas.
Cette différence se retrouve dans l’organisation des bibliothèques. En Java, ces dernières sont structurées par une hiérarchie unique et profonde et constituent pour ainsi
dire un gros arbre, disons un banian1. En C++ nous avons plutôt à faire à une forêt
38
v1.0
© 2005–Jean-Paul Rigault
De Java à C++
UNIVERSITÉ DE NICE SOPHIA ANTIPOLIS
méditerranéenne, un maquis, formé de beaucoup de petits arbres rabougris. Incontestablement, C++ a d’autres moyens d’exprimer l’organisation des bibliothèques que
l’héritage, et parmi ces moyens les templates et le principe d’abstraction pure qui les
soutient (voir 4.3.1) ne sont pas les moins puissants.
5.2.2 Environnement d’exécution
Il existe une seconde différence, tout aussi fondamentale. Java est en soi à la fois un
langage et un environnement d’exécution (trans)portable alors que C++ s’est jusqu’à
présent refusé à être plus qu’un langage. Dans ces conditions, Java est plus à même de
faire abstraction des propriétés spécifiques des différentes plates-formes et peut proposer, de manière standard, des bibliothèques beaucoup plus riches et universelles :
interfaces graphiques, programmation concurrente (multithreading), primitives de
communication et de distribution, etc. C++ étant, quant à lui, tributaire des différents
environnements d’exécution, ne peut atteindre cette sorte d’abstraction et d’universalité. La seule chose qui ait pu être proposée de manière standard et consensuelle (et
encore, non sans mal au début !) est un ensemble de classes représentant les collections de base de la programmation ainsi que les algorithmes opérant dessus. Ceci
constitue la Standard Template Library, ou STL, où la généricité de C++ est totalement
mise à profit.
Cependant, l’« universalité » de Java est battue en brèche : dans plusieurs domaines
ont déjà été proposées des bibliothèques concurrentes (pensez par exemple à Swing
promu par Sun et/contre swt qui provient du projet Eclipse). Et, à l’opposé, certains
envisagent d’étendre la bibliothèque standard de C++ afin d’éviter un foisonnement
préjudiciable. En effet, il commence à exister de nombreuses bibliothèques en C++, à
peu près équivalentes en fonctionnalité mais absolument incompatibles à l’usage, pour
certaines classes d’application comme par exemple, et à nouveau, les interfaces graphiques (Qt, wxWidgets ou gtk+ pour n’en citer que quelques unes) ou la programmation concurrente.
Il est à peu près évident que la bibliothèque standard de C++ est appelée à se développer. En particulier de nombreuses propositions issue de la bibliothèque Boost
(voir 3) devraient, à terme, être intégrées dans ISO C++.
1. dont les interfaces seraient les racines adventives !
© 2005–Jean-Paul Rigault
v1.0
39
De Java à C++
40
UNIVERSITÉ DE NICE SOPHIA ANTIPOLIS
v1.0
© 2005–Jean-Paul Rigault
De Java à C++
UNIVERSITÉ DE NICE SOPHIA ANTIPOLIS
Références
[1]
Andrei Alexandrescu
Modern C++ Design: Generic Programming and Design Patterns Applied
Addison Wesley, 2001.
Un livre passionnant sur la programmation générique (template programming)
en C++. Attention, il ne s’agit pas d’un ouvrage facile et sa lecture exige la
maîtrise des mécanismes de C++.
[2]
Joshua Bloch
Effective Java: Progamming Language Guide
Addison Wesley, 2001.
Une suite de remarques et de conseils sur la programmation en Java. Indispensable à tout programmeur sérieux.
[3]
Boost
Boost Library
http://www.boost.org
L’une des plus riches, et sans doute la plus innovante par bien des aspects, des
bibliothèques en C++. Certains des éléments de cette bibliothèque seront sans
doute à terme incorporés dans les futures versions de la norme ISO C++.
[4]
Bruce Eckel
Thinking in Java
3rd Edition, Prentice Hall, 2002.
[5]
Bruce Eckel
Thinking in C++,Volume 1: Introduction to Standard C++
2nd Edition, Prentice Hall, 2002.
[6]
Bruce Eckel et Chuck Allison
Thinking in C++, Volume 2: Practical Programming
2nd Edition, Prentice Hall, 2003.
Trois excellents livres pour l’apprentissage de Java et C++, par le même auteur.
Comme quoi on peut pratiquer les deux langages (et même aimer le faire) ! À
noter que les livres de Bruce Eckel peuvent être téléchargées gratuitement
(sous forme HTML) depuis http://mindview.net/Books.
[7]
Anders Hejlsberg, Scott Wiltamuth et Peter Golde
The C# Programming Language
Addison Wesley, 2003
La description du langage C# (versions 1 et 2) par, en particulier, son principal
architecte (Anders Hejlsberg).
© 2005–Jean-Paul Rigault
v1.0
41
De Java à C++
UNIVERSITÉ DE NICE SOPHIA ANTIPOLIS
[8]
Cay S. Horstmann et Gary Cornell
Core Java 2, Volume 1: Fundamentals
Prentice Hall, 1999.
[9]
Cay S. Horstmann et Gary Cornell
Core Java 2, Volume 2: Advanced Features
Prentice Hall, 1999.
Les deux volumes ont été traduits en français sous le titre Au Cœur de Java
(Campus Press, 2000). Un autre excellent livre pour l’apprentissage de Java. Il
contient aussi de nombreuses comparaisons entre C++ et Java.
[10] Nicolai M. Josuttis
The C++ Standard Library: A Tutorial and Reference
Addison Wesley, 1999.
Un bon livre, très complet, sur la STL.
[11] Stanley B. Lippman et Josée Lajoie
C++ Primer
3rd Edition, Addison Wesley, 1998.
Un des bons livres pour l’apprentissage de C++.
[12] Brett McLaughlin et David Flanagan
Java 1.5 Tiger
O’Reilly, 2004.
Un petit livre d’introduction aux extensions apportées par la nouvelle version
de Java : Java 2 version 5.0 (ou 1.5 ?) dite Tiger.
[13] Scott Meyers
Effective C++: 50 Specific Ways to Improve your Programs and Design
Addison Wesley, 1992.
[14] Scott Meyers
More Effective C++: 35 New Ways to Improve your Programs and Design
Addison Wesley, 1995.
[15] Scott Meyers
Effective STL: 50 Specific Ways to Improve your Use of the Standard Template Library
Addison Wesley, 2001.
Les trois livres de Scott Meyers sont aussi indispensables au programmeur en
C++ que le livre de Joshua Bloch l’est au programmeur en Java. Les deux premiers ouvrages ont été publiés par Addison Wesley sous forme d’un CD unique (Effective C++ CD), qui est une forme bien adaptée pour butiner dans cette
série de remarques et conseils.
[16] Stephen Prata
C++ Primer Plus
4th Edition, Sams, 2001.
Un autre livre recommandable pour l’apprentissage de C++.
42
v1.0
© 2005–Jean-Paul Rigault
De Java à C++
UNIVERSITÉ DE NICE SOPHIA ANTIPOLIS
[17] Herbert Schildt
Java 2 v5.0 tiger
Osborne McGraw Hill, 2004.
Un autre livre sur la nouvelle version de Java.
[18] Patrick Smacchia
Pratique de .Net et C#
O’Reilly, 2003.
Un livre d’introduction à la plate-forme multi-langages .Net et au nouveau
langage de Microsoft, concurrent de Java, C#.
[19] Bjarne Stroustrup
The C++ Programming Language
3rd Edition, Addison Wesley, 1997.
Description de C++ et de la STL par l’inventeur du langage. Riche en exemples et en notations sur la philosophie du programmeur selon Bjarne. Il existe
une 3e édition « spéciale », assez peu différente (mais plus chère !).
© 2005–Jean-Paul Rigault
v1.0
43
De Java à C++
44
UNIVERSITÉ DE NICE SOPHIA ANTIPOLIS
v1.0
© 2005–Jean-Paul Rigault