Discussion :

[kiroukou]

Bonjour à tous,
Voila, j'ai une nouvelle question sur quelque chose que je viens de lire, et je dois dire que cela me surprend. D'apres ce que je viens de lire, on ne peut pas se servir d'une classe abstraite comme type de retour et comme type de parametre.
Cela est il vrai?
Si oui, comme fait-on pour avoir le même comportement polymorphique que Java avec les interfaces ?

Je vous remercie d'avance
ps : dslé mais je n'ai pas pu tester avant d'écrire. Je ne pourrai que demain

[jmv]

Il faut utiliser les pointeurs

Code :

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

1
2
3
4
5
6
7
class A
{
 public:
    virtual void f() = 0;
};
 
A* uneFonction(A* arg);

ps : dslé mais je n'ai pas pu tester avant de répondre. Je ne pourrai que demain moi aussi

[Luc Hermitte]

Une classe abstraite ne peut pas se manipuler par valeur. La sémantique de référence est généralement la seule chose à laquelle on a le droit avec des hiérarchies d'objets. Avec les classes abstaites, on n'a alors plus le choix.

Concernant le passage de paramètres, il faut les recevoir par adresse. Soit en recevant une adresse (par valeur -> un pointeur ; ou enveloppée dans un quelconque smart-pointer), soit en recevant une référence (constante ou non).

Pour le retour. Si l'objet va continuer à vivre à la sortie de la fonction (comme un attribut membre), on peut retourner une référence sur l'objet. Sinon, il faut retourner un objet fraichement alloué, sous forme de pointeur (intelligent ou non).

Bref. On peut, mais pas par valeur!

(Java ne permet pas la sémantique de valeur que le C++ permet avec les objets. En utilisant la sémantique de référence, on en revient à ce qui ce passe avec Java.)

[Aurelien.Regat-Barrel]

Pointeur ou référence. Le polymorphisme en C++ nécessite l'emploi de pointeurs / références, sinon c'est une sémantique par valeur => recopie.

[kiroukou]

Ok je comprend mieux
Merci beaucoup, demain je mettrai tout ceci en pratique afin de mieux percevoir les particularités.

Mon problème est que j'ai appri l'objet avec un language ou on ne manipule que des references. Du coup tout est transparent. Mais là il s'agira juste de faire attention à ce que je fais

Merci en tout cas, et bravo pour votre réactivité impréssionnante et agréable

En vous remerciant
Kiroukou

[Aurelien.Regat-Barrel]

Tu peux un peu comparer les références Java à des pointeurs intelligents style boost::shared_ptr en C++ (pointeurs intelligents avec comptage de référence).
Un autre point c'est que classe abstraite "simple" n'est pas vraiment l'équivalent des interfaces Java, ou plutot c'est imcomplet. Les interfaces Java sont simulées en C++ via des ABC (Abstract Base Class) qui sont des classes abstraites avec que des fonctions membres virtuelles pures. Ne pas oublier de rendre le destructeur virtuel dans les classe abstraites
http://c.developpez.com/faq/cpp/?pag...UCTEUR_virtuel

[kiroukou]

Merci aurelien pour ce conseil.

Mais cela m'amène à te poser une autre question

Je n'ai trouvé qu'un seul lien expliquant boost::shared_ptr sur un exemple avec std::auto_ptr ( dont tu es le co-auteur ).

Peux tu m'expliquer la différence entre ces 2 types de pointeurs (boost::shared_ptr et std::auto_ptr donc)? Leurs utilisation est-elle portable?

Et encore, pourquoi est il deconseillé de l'utiliser avec les tableaux ?

Je débute en C++ mais j'aimerai prendre directement les bonnes habitudes, ce qui explique ce harcellement de questions

Bien à vous
Kiroukou

[Aurelien.Regat-Barrel]

C'est pas déconseillé de l'utiliser avec des tableaux, c'est interdit. C'est à cause de la différence entre delete et delete []
http://c.developpez.com/faq/cpp/?pag...EURS_new_array
Le danger de auto_ptr est expliqué ici:
http://c.developpez.com/faq/cpp/?pag...NTEURS_autoptr
l'avantage de auto_ptr est d'être standard. Après y'a plein de classe smart ptr non standard. Le quasi standard c'est boost:
http://www.boost.org/
un gros complément "de référence" (mais non standard) au C++
On y trouve des smart ptr biensûr:
http://www.boost.org/libs/smart_ptr/smart_ptr.htm
notamment shared_ptr et shared_array (pour les tableaux).
Ces 2 là fonctionnent par comptage de référence.
Une autre lib réputée c'est Loki.
Un article de référence pour tout comprendre des smart ptr, par Andrei Alexandrescu:
http://www.informit.com/articles/article.asp?p=31529
Bon c'est un peu long mais très intéressant. Si tu est pressé, le plus important:
http://www.informit.com/articles/article.asp?p=31529&seqNum=5
shared_ptr est du type Reference Counting.

[kiroukou]

Vraiment merci Aurélien (et aux autres bien sur)
Je vais lire un maximum de ce que tu m'as donné.
Merci pour le temps que vous m'avez accordé.
A bientot (ca c'est sur )
Bien à vous
Kiroukou