Discussion :

[Regis.C]

Bonjour à tous,

je suis développeur java depuis toujours (je n'ai quasiment développé que dans ce langage). Je serai sans doute amené à développer prochainement en C ++. Je souhaiterai savoir les grandes différences conceptuelle de C++ en rapport à java.

Bon je sais que C++ n'a pas de machine virtuelle, ok.
1) Mais utilise-t-on des réferences sur les objets, où il y a-t-il une notion (totalement inconnue pour moi) de "pointeur" ?

2) En quoi consiste la décomposition des fichier .h et .cpp ? Que contiennent-ils respectivement ?

3) Faut-il gerer l'allocation de mémoire, ou il y a-t-il une sorte de "ramasse miette" ?

4) toutes les autres questions que vous pourriez imaginer pour quelqu'un comme moi...

Merci à tous.

[Invité]

Salut à toi,

Bon je vais essayer de répondre au 2° point tout d'abord, rapidement... en règle générale, tu écris dans ton header (fichiers .h ou .hpp) la déclaration de ta classe, ensuite dans le fichier source (fichier .cpp), tu écris le corps des méthodes de ta classe.... Voilà à préciser par d'autres membres !

Pour le 3° point : en C++, contrairement au Java, tu ne disposes pas d'un ramasse-miettes... Par conséquent, c'est à toi de te préoccuper de bien libérer la mémoire allouée pour tes objets... Ainsi, quand tu instancies un nouvel objet avec new, tu devrais toujours en contrepartie libérer la mémoire qu'il occupe quand tu n'en as plus besoin, au moyen de delete.

Je laisse des personnes plus compétentes te renseigner sur les autres points

Cordialement,


PierreAd

[Luc Hermitte]

1- Le C++ dispose évidemment de pointeurs. Qu'ils soient bruts (ceux dont parlent tous les bouquins) ou intelligents (ceux qui te simplifiront la gestion de la mémoire). Je t'invite à regarder la FAQ C++ developpez et même le tutoriel de miles.
Le C++ dispose également de "références" qui n'ont rien à voir avec les références du Java. Une référence en Java s'apparente, pour le C++, à une sorte de smart-handle à comptage de référence qui sait se dépatouiller des cycles. La référence C++ n'est qu'un alias, c'est à dire un autre nom que l'on va donner à une donnée existante.

2- En schématisant. .h -> les déclarations d'identifiants qui seront utilisées en de multiples endroits (variables globales, constantes, fonctions, classes)
.cpp -> les définitions de ces identifiants (pour les classes il ne s'agit que de définir les fonctions membre des classes)

3- Pas de ramasse miettes en standard (tu en auras un avec celui de Boehm (qui a ses problèmes il me semble), et tu as aussi celui du C++/CLI (qui a sa VM .NET à lui) (le forum de VC++ sera plus approprié).
En revanche, le C++ propose une approche unique [1] pour gérer toutes les ressources (mémoire, comme pots de peinture) : le RAII (FAQ!) alors que le Java n'a le ramasse miette que pour la mémoire et le dispose-pattern (-> try-finally) pour tout le reste.
Le RAII prend toute son importance pour implémenter des comportements corrects même en cas d'exception ou de retour prématuré.

[1] il y en a d'autres, mais le RAII est globalement celle la plus recommandée par défaut. Au besoin on peut s'en écarter pour coder des trucs plus fins à la main.

4.a- Il y a plein de comparatifs qui présentent les différentes triviales entre le Java et le C++. En voici d'autres qui me viennent à l'esprit.

4.b- Les specifications d'exceptions en C++ ne feront pas ce que tu penses qu'elle font.

4.c- Le mot clé const joue un rôle très important. Il est trop souvent négligé.

4.d- Le C++ est multi-paradigmique. Ne te mets pas des oeillières. Une fonction libre n'est pas le mal incarné. Bien au contraire.
La généricité va te changer la vie. Elle introduit d'autres façons de définir les commonalities et les points de variations -- par rapport à ce que la liaison tardive du polymorphisme d'inclusion permet.

4.e- Les espaces de nom sont tes amis.

4.f- En C++, on peut généralement dégager deux sémantiques : la sémantique de valeur (copiable + "deux données de même valeur sont égales") et la sémantique d'entité (parfois clonable + "deux données différentes (même si leurs états internes sont égaux) ne vont pas être identique ; l'identité, c'est deux références sur un même objet ; après clonage d'un objet, on obtient un tout nouvel objet qui n'est pas identique : il a sa vie propre").
Java ne permet pas de définir de nouveaux types qui ont une sémantique de valeur.
Suivant la sémantique d'un type que tu vas écrire, les recettes de cuisine que tu vas appliquer sont différentes.

4.g- N'hésite pas à user de la bibliothèque standard du C++. D'autres bibliothèques, comme boost, sont aussi tes amies.

4.h- Il y a plein d'infos dans les FAQ et même dans les posts de comparaison des deux langages.

4.i- Accelerated C++ de Koenig et Moe, chez Addisson-Wesley est un excellent bouquin d'apprentissage du C++. Oubli les ressources en français.

[Regis.C]

Merci à ceux qui m'ont déjà répondu.

Je me permet d'ajouter des questions qui me viennent, parfois déclenchée par vos réponses...

- Un "pointeur" (je rappelle que j'en ignore tout) peut-il être remplacé par une réference ?
En gros, quelle est la différence entre un pointeur, et une réference ?

[Matthieu Brucher]

Une référence, c'est un alias pour l'objet lui-même, une fois que l'alias est défini, on ne peut plus en changer.
Un pointeur contient l'adresse de l'objet, il permet de changer l'objet, mais il peut aussi changer et pointer vers un autre objet.

[JolyLoic]

Si tu veux retrouver le concept d'une référence en Java, le plus proche que tu puisse avoir c'est :
- Soit un pointeur intelligent, comme boost::shared_ptr
- Soit n'importe quel pointeur si tu as mis en place un garbage collector.

La principale différence restera qu'en Java, la référence et l'objet se traitent de manière indiscriminée (Faire A=B, c'est en fait toucher la référence, faire add(A, B), c'est toucher l'objet), alors qu'en C++, on peut manier les deux séparément (affecter le pointeur ou affecter l'objet, faire de l'artithmétique sur les pointeurs ou sur les objets), et donc on doit spécifiquement indiquer si ce qui nous intéresse, c'est le pointeur ou l'objet.

[Médinoc]

Ben déjà en Java, il n'y a pas de type "Objet" : Il n'y a que des références d'objet. On ne manipule jamais directement un objet en java.
D'ailleurs, sur ce principe, il n'y a pas de passage par référence en java: Les entiers et les références d'objet sont passés par valeur.

En C++, on peut manipuler directement un objet.
Exemple:

Code Java :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
int unEntier = 3;
CUneClasse unObjet = new CUneClasse(unEntier);
unObjet.UneMethode();

Code C++ :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
//Equivalent au code java :
//On manipule un pointeur d'objet
CUneClasse *pUnObjet = new CUneClasse(unEntier);
pUnObjet->UneMethode();
 
//Cas impossible en java : On manipule l'objet directement.
//Celui-ci est créé sur la pile, avec les autres variables locales.
CUneClasse unObjet(unEntier);
unObjet.UneMethode();

À rappeler que le C++ de base ne possède ni comptage de références, ni garbage collector (je différencie les deux, le garbage collector étant pour moi ce qui permet de supprimer des groupes d'objets inaccessibles se référençant les uns les autres), il faudra donc penser à supprimer l'objet allouer dynamiquement avec l'instruction:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

delete pUnObjet;

L'objet créé directement sur la pile, lui, sera détruit dès la fin de l'exécution du bloc dans lequel il est déclaré.

[Pragmateek]

Ce n'est pas de "Java à C++" mais il y a des remarques intéressantes.
http://www.metz.supelec.fr/~frezza/D...C++/index.html

[NewbiZ]

Une référence peut se schématiser comme suit (& donne l'adresse de la variable) :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
 
int a = 16521654;
 
<- mémoire +>
+------------+-------------+-------------+
|            |   16521654  |             |
+------------+-------------+-------------+
0           32            64            96
             ^      ^
             &a     a
 
&a : 32;
a  : 16521654;

Un pointeur est une variable qui contient l'adresse d'une autre variable.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
int *b = &a;
 
<- mémoire +>
+------------+-------------+-------------+
|            |   16521654  |      32     |
+------------+-------------+-------------+
0           32            64            96
             ^      ^      ^      ^
             &a     a      &b     b
                    =*b
 
&b : 64;
b  : 32;
*b : 16521654;

L'intéret ? Il y en a trop pour qu'ils soient tous donnés.
Au lieu de manipuler des données tu manipules des adresses mémoire, ca t'évite de copier/libérer tes données a chaque fois que tu veux les "passer" à quelquechose.
Ca te permet aussi de faire des alias, de faire des index...
A savoir que tu peux faire des pointeurs de pointeurs etc...

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
 
int **c = b;
 
<- mémoire +>
+------------+-------------+-------------+-------------+
|            |   16521654  |      32     |      64     |
+------------+-------------+-------------+-------------+
0           32            64            96
             ^      ^      ^      ^      ^       
             &a     a      &b     b      &c      c
                 =*b=**c         =*c
 
&c  : 96;
c   : 64;
*c  : 32;
**c : 16521654;

Lorsque tu déclares un pointeur, tu ne stoques donc qu'un zone mémoire qui contient une adresse.
Tu ne sais donc pas ce qu'il y a dans la mémoire à cet endroit, et le plus souvent, c'est tout sauf une adresse valide... Tu dois donc utiliser l'opérateur new, qui va créer une zone mémoire et renvoyer son adresse, que tu pourra stoquer dans ton pointeur.
Dans l'exemple 2, lorsque tu fais

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

int* b;

Tu va déclarer une zone mémoire pour un pointeur vers un objet de type int.
Lorsque tu fais

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

b = NULL;

Tu va remplacer l'adresse de ce vers quoi pointe b par NULL (l'adresse mémoire poubelle).
Ensuite tu peux appeler

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

b = new int;

new va créer un espace mémoire pour un objet de taille int (4 octets), et renvoyer l'adresse de cette zone, qui pourra donc être stoquée dans b. Et tu pourra y accéder par *b.

Ensuite, lorsque tu utiliser des pointeurs vers objets, de la manière :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
 
CObject* p = new CObject;
CObject  v;

Tu ne peux bien sur pas accéder à leurs méthodes et attributs de la même manière :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
 
v.maMethode();
(*p).maMethode();

Tu as donc un opérateur spécifique pour éviter d'avoir à utiliser la lourde syntaxe (*ptr).x, c'est l'opérateur ->, tu pourra donc faire simplement :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
 
v.maMethode();
p->maMethode();

Voilà, c'est une approche surement moins formelle que ce qui est dit plus haut, mais on nous l'apprend comme ca à la fac, et je trouve que c'est la meilleure manière d'aborder le problème.

[Regis.C]

Je vous promets que j'essaye de suivre...mais honnettement je ne vois pas du tout d'intérêt à avoir plusieurs pointeurs qui pointent vers des adresses mémoire différentes qui finalement pointe vers...la valeur qu'on souhaite.

Pourquoi ne pas utiliser simplement une réference ?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
MonObjet a = new MonObjet();
a.methode1();
...
//destruction de l'objet car pas de Garbage Collector
delete a;

Que ne peut-on pas faire avec une réference, et que l'on peut faire avec un pointeur ?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
MonObjet *a = new MonObjet();
a->methode1();
...
//destruction de l'objet car pas de Garbage Collector
delete a;

J'avoue y perdre mon latin.
- Dans le 1er cas, on a une réference qui "pointe" mon objet en mémoire.
- Dans le deuxième, on a un pointeur qui pointe une adresse mémoire. A cette adresse mémoire, on a mon objet.
Soit ! Mais soit je ne vois pas le truc, soit quelque chose me manque pour que je comprenne...

Je sais, je dois passer pour un gros boulet à ne pas comprendre la notion et surtout l'intérêt des pointeurs, mais sur ce coup, je veux bien qu'on me ré-explique...désolé...

[Luc Hermitte]

Une référence ne peut être changée. Une référence est un alias vers une donnée qui existe et qui se doit d'être valide.
Un pointeur peut être changé. Un pointeur peut adresser une zone vers laquelle il n'y a pas de donnée valide (genre, on le met à 0 (==NULL), ou parce que l'on a détruit la donnée pointée).
Seuls les pointeurs doivent être utilisés pour des données à détruire.

Et côté syntaxe, c'est ainsi que cela marche:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
Toto t; // une donnée constuite, vivant sur la pile;
Toto & tr = t; // une référence vers t
Toto* tp = &t; // un pointeur vers t
 
Toto t2; // un second objet construit et sur la pile
tr = t2; // ne compile pas, interdit
tp = &t2; // OK, tp pointe maintenant vers t2
 
// aucun delete ne doit être réalisé ici, la donnée est sur la pile et
// sera implicitement détruite.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
Toto * t = new Toto; // un pointeur brut initialisé pour pointer 
     // sur une donnée que l'on vient de construire sur le tas.
Toto & tr = *t; // tr n'est un autre nom donné à la donnée pointée par t
 
// les appels se font par:
t->f();
tr.f();
 
Toto * t2 = new Toto;
tr = *t2; // n'est toujours pas possible
t2 = t; // c'est possible, mais on a perdu de la mémoire.
 
delete tr; // ne compile pas. delete attend un pointeur.
delete t; // OK, libère la mémoire et détruit la donnée pointée par t;
delete t2; // va planter vu que t2 pointe vers la donnée initialement 
// pointée par t, donnée que l'on vient de libérer et détruire.
 
t->f(); // va planter: t n'existe plus
tr.f(); // même chose

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
Toto * tp = 0; // pointeur qui ne pointe vers rien
{
    boost::shared_ptr<Toto> t = new Toto; // pointeur intelligent, 
        // à comptage de références
    t->f(); // même syntaxe d'appel que pour les pointeurs bruts
    Toto & tr = *t; // un autre nom donné à la donnée pointée par t;
    tr.f();
 
    tp = t.get(); // tp pointe0 vers la même donnée que t;
    tp->f();
} // ici, t a été implicitement libéré en sortie du bloc
tp->f(); // boom, la donnée pointée par tp a été détruite car la destruction 
// de t a provoqué la destruction de la donnée pointée.

Soit : la gestion de la mémoire doit être réservée aux pointeurs!!! (bruts ou intelligents).
Les références (du C++) ne sont que des alias et rien que des alias !
Parmi les intérêts on a : les passages de paramètres et les déréférençages de données accessibles après plusieurs indirections:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
struct Toto {
    Toto() : i_(0) {}
    int & getI() { return i_;} 
    // retour d'une référence, vers une donnée dont la durée de vie 
    // trascende celle de l'appel à la fonction getI().
private: 
    int i_;
};
...
Toto t;
int & j = t.getI();
j = 42; // facile à manipuler, non ?
std::cout << t.getI() << std::endl;
// affichera 42

[NewbiZ]

Le pointeur te permet de stoquer des adresse mémoire potentiellement vides, de les créer "à la volée", de les supprimer, de les remplacer par autre chose...et de manipuler les objets qu'ils représentent sans avoir à les copier en mémoire.

Imagines que ta mémoire c'est ton quartiers, les maisons sont des objets qui occupent cet espace. Eh bien un pointeur, représenté par une boite aux lettre avec adresse, te permettra de recevoir des lettre depuis plusieurs endroits pour peu que tu y ait posé une boite aux lettres. Tu peux donc poser des boites aux lettres avec l'adresse de ta maison sur plusieurs emplacements.
Sinon tu aurait besoin de copier ta maison dans chaque adresse que tu veux utiliser, et ca créerait des problèmes de mise à jour de ta maison, et de temps de construction... Bon, ben la référence la dedans c'est la boite au lettre qui est encastrée dans la porte de ta maison.
On va arrêter là l'exemple :>

[Regis.C]

Donc en gros si j'ai une methode qui prend pour paramètre un objet de Type MonObjet, il vaut mieux passer un pointeur de MonObjet plutôt qu'une réference.
On est sur que c'est MonObjet qui sera utilisé, si j'ai bien comprit...?
En java, on passe la réference de l'objet, et on récupère l'objet via une autre réference...c'est pas possible en C++?

[Luc Hermitte]

Non, l'heuristique de choix pointeur/référence est plus subtil dans le cas des types des paramètres formels.

Si la donnée que tu veux recevoir dans ta fonction peut ne pas être valide => pointeur
Si elle est toujours valide :
- et si tu dois pouvoir en modifier l'état => référence
- ou si l'état n'est pas modifiable => Référence constante, à moins qu'il s'agisse d'une toute petite donnée à sémantique de valeur (alors donnée prise par copie dans ce cas).

Si ta fonction agit comme un puit pour ta donnée (elle y sera détuite), ou si plus généralement la fonction s'occupe de s'appropier la responsabilité de la donnée (typique de fonctions membres utilisées pour donner des données à des objets), alors pointeur (car il faut pouvoir réaliser un delete), voire mieux std::auto_ptr<> (pointeur intelligent très particulier : il est orienté sémantique de déplacement : la responsabilité de la donnée pointée est transférée au pointeur réceptacle).


Les références Java ne sont que des pointeurs un peu particuliers.

[loufoque]

Donc en gros si j'ai une methode qui prend pour paramètre un objet de Type MonObjet, il vaut mieux passer un pointeur de MonObjet plutôt qu'une réference.

Si tu as une méthode qui prend pour paramètre une variable de type MonObjet, il faut lui passer une variable de type MonObjet (ou implicitement convertible vers MonObjet).
Passer un pointeur ne fonctionnera pas, ce sont des types différents.

De toutes façons pour les pointeurs t'as pas à te casser la tête : évite de les utiliser, sauf si tu travailles avec une bibliothèque qui fait une gestion de mémoire spéciale (comme Qt par exemple).