Discussion :

[troussepoil]

Ai-je le droit de faire ça? (changer le 'Image2D' par 'Image' dans la définition de la méthode)

Image2D.hh

Code :

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

1
2
3
4
5
 
class Image2D {
   public:
      virtual Image2D* noirEtBlanc(std::string) = 0;
};

Image.hh

Code :

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

1
2
3
4
5
 
class Image : public Image2D, public Matrice<Pixel> {
   public:
      Image* noirEtBlanc(std::string);
};

[Laurent Gomila]

Seulement si ton compilo supporte les retours covariants (Visual C++ 2005 le fait -- aucune idée pour les autres).

[hiko-seijuro]

je crois que g++ aussi

[troussepoil]

J'ai utilisé l'exemple de la fac et mon compilateur supporte les retour covariants.
le message "Derived::Test" s'affiche.
merci.

[troussepoil]

une autre question: ça marche pareil quand on redefinit les operateurs?

Image2D.hh

Code :

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

1
2
3
4
5
 
class Image2D {
   public:
      virtual Image2D* operator*(Image2D&) = 0;
};

Image.hh

Code :

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

1
2
3
4
5
 
class Image : public Image2D, public Matrice<Pixel> {
   public:
      Image* operator*(Image&);
};

[Ulmo]

Seulement si ton compilo supporte les retours covariants (Visual C++ 2005 le fait -- aucune idée pour les autres).

Ce n'est pas vraiment du retour covariant puisque c'est le type de l'objet auquel on applique la méthode "noirEtBlanc(...)" qui va décider de la fonction utilisée.

[Laurent Gomila]

Ce n'est pas vraiment du retour covariant puisque c'est le type de l'objet auquel on applique la méthode "noirEtBlanc(...)" qui va décider de la fonction utilisée.

Et alors ce serait quoi un retour covariant pour toi, si ce n'est pas de pouvoir substituer le type de retour d'une fonction virtuelle par un type dérivé ?

[Ulmo]

Je pensais à une surcharge sur le type de retour.
J'aurais été surpris que le retour covariant ne soit pas possible. Je ne vois pas ce que cela pose comme problème, alors que je comprend bien celui posé par la surcharge sur le type de retour.

[Laurent Gomila]

C'est pas moi qui l'ait inventé, si tu prenais la peine de regarder n'importe quel cours ou FAQ en ligne tu verrais que c'est bien ça la définition du retour covariant.

[Ulmo]

Je le crois volontiers, mais comme je ne connaissais pas le terme, j'ai essayé de deviner ce qu'il désignait. Avec un ton assuré. Et je me suis planté

[troussepoil]

une autre question: ça marche pareil quand on redefinit les operateurs?

Image2D.hh
Code :

class Image2D { public: virtual Image2D* operator*(Image2D&) = 0; };


Image.hh
Code :

class Image : public Image2D, public Matrice<Pixel> { public: Image* operator*(Image&); };

Apparemment, ça ne fonctionne pas pareil, mais pourquoi? Y a t-il une façon de faire des operateur abstrait?

[Jean-Marc.Bourguet]

Apparemment, ça ne fonctionne pas pareil, mais pourquoi? Y a t-il une façon de faire des operateur abstrait?

Il n'y a pas de covariance sur les parametres. D'ailleurs pour ne pas casser le systeme des types, il faudrait de la contra-variances (et encore, uniquement sur les parametres const).

[loufoque]

Les retours covariants sont dans la norme et sont supportés par la plupart des compilateurs.
Il ne fonctionnent pas avec auto_ptr par contre.

[David Fleury]

Les retours covariants sont dans la norme et sont supportés par la plupart des compilateurs.
Il ne fonctionnent pas avec auto_ptr par contre.

J'ai cru voir que ça fonctionnait sous VC2005.

[edit] en fait, je crois maintenant qu'il accepte n'importe quoi...
mais plante à l'exécution.

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
20
21
22
23
24
25
26
27
 
 
#include <iostream>
#include <memory>
using namespace std;
 
struct A { virtual void print(){ cout << "A" << endl;}};
struct B : A { virtual void print(){ cout << "B" << endl;}};
struct C : A { virtual void print(){ cout << "C" << endl;}};
 
struct FA { auto_ptr<A> f(){ return auto_ptr<A>(new A); } };
struct FB { auto_ptr<B> f(){ return auto_ptr<B>(new B); } };
 
int main()
{
  FB fb;
  fb.f()->print();
 
  auto_ptr<A> a = auto_ptr<B>( new A );
  a->print();
 
  auto_ptr<A> b = auto_ptr<B>( new B );
  b->print();
 
  auto_ptr<A> c = auto_ptr<B>( new C );
  c->print();
}