polymorphisme encore dsl

Version imprimable

Bonjour,
J'appelle dans operator+ une fonction add qui sera défini dans chacun des class héritant de Space.
Voir le code
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 class Space { public: Space & operator +=(const Space x); virtual inline void add(const Space *x) ; }; Space & Space::operator +=(const Space x) { this->add(&x); } class Space1d:public Space { public: int i; Space1d():i(0){} Space1d(int j):i(j) {} inline void add( const Space* x) { this->i = x->i; } };
Le problème à la compilation est :
Code:

1 2 «const class Space» has no member named «i»
i.e. pour le compilateur l'argument x de add est un oblet de la classe mère Space donc qui n'a pas d'instance int i. Ce que je voudrais savoir c'est comment résoudre ce problème???

Merci,
PS: Je remercie les habitués de ce site pour le sujet d'avant

Pour résoudre le problème, je surchage l'opérateur.
Merci

Code:

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
28
29
30
31
32
33
34
35
36
37
38
39
40
41
 
class Space
{
public:
  friend std::ostream& operator << (std::ostream& O, const Space& B);
   Space & operator +=(const Space x);
 
  virtual void Print(std::ostream& O) const
    {
      cout << "toto";
    }
};
 
Space & Space::operator +=(const Space x)
{
  return *this;
}
std::ostream& operator << (std::ostream& O, const Space& B)
{
    B.Print(O);
    return O;
}
 
class Space2d:public Space
{
public:
  int i[2];
  Space2d()
    {i[0]=0;i[1]=0;}
  Space2d(int i0,int i1){i[0]=i0;i[1]=i1;}
 
   void Print(std::ostream& O) const
    {
     cout << i[0]<<"  "<<i[1]<<endl;
    }
  Space2d & operator +=(const Space2d x)
    {
      i[0]+=x.i[0];
      i[1]+=x.i[1];
    }
};

Ca commence à être bien le C++ par rapport à ma religion d'antan le C pure.

14/12/2006, 14h58
bolhrak

En déclarant la variable i comme membre de ta classe Space (public ou protected mais pas private) ...

Ensuite déclarer un fonction virtual inline ne sert a rien, ta fonction ne sera pas inlinée puisque le virtual indique justement que la fonction peut être redéfinie dans les classes déribvées et qu'il faut donc vérifier ça à l'exécution, lors de l'appel de la fonction, alors que l'inline indique au compilo de remplacer l'appel de la fonction par lae corps de la fonction lors de la compilation.

Big problème,
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 int main() { Space2d s1,s2(2,3); Space *s; s1+=s2; cout << s1; s = &s1; *s+=s2; cout << *s; }
Affichage
Code:

1 2 3 2 3 toto2 3
Il a fait l'addition définie pour la class mère Space or j'aurai voulu qu'il fasse celle de Space2d.....

De plus s2=*s;
Code:

1 2 3 _rm.cpp:109: erreur: no match for «operator=» in «s2 = * s» _rm.cpp:60: note: candidats sont: Space2d& Space2d::operator=(const Space2d&)
A l'aide!!!!!!!

Citation:

Envoyé par bolhrak

Ensuite déclarer un fonction virtual inline ne sert a rien

La plupart des compilos supportent ce type de déclaration. Ils garantissent le polymorphisme mais sont capable 'd'inliner' quand le type ne fait pas de doute.
Ex:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 class Foo { public: virtual int bar() { return val_; } private: val_; }; int main() { Foo foo; // Création sur la pile, pas de polymorphisme possible int x = foo.bar(); // Pas de liaison dynamique --> inline }

14/12/2006, 16h23
bolhrak

Effectivement je n'avais pas pensé à ce cas là ! Généralement quand j'ai une hiérarchie de classe c'est justement pour exploiter le polymorphisme et je déclare donc mes variables sur le tas
14/12/2006, 16h29
Laurent Gomila

Ce que tu cherches à faire c'est du double-dispatch, càd que la liaison dynamique ne dépend non plus du type d'une instance, mais de deux. Et là les mécanismes de fonctions virtuelles ne sont plus suffisant.

Fais quelques recherches sur le sujet.
14/12/2006, 17h11
vincho

j'essaye mais je n'y arrive pas...

snif snif
14/12/2006, 18h09
vincho

vraiement personne...
14/12/2006, 18h19
Invité

ca suffit le spam... cherche donc, et laisse le temps à ceux qui savent de répondre :zzz:
14/12/2006, 18h23
bolhrak

:google2:
http://www.google.fr/search?q=C%2B%2...en-US:official
14/12/2006, 18h26
Invité

Citation:

Envoyé par bolhrak

:google2:

cf. ma signature :scarymov:
14/12/2006, 18h32
bolhrak

Le proxy de ma boîte me bloque l'accès à ton lien :s :evilred:

Je regarderai ce soir :p
15/12/2006, 00h24
Luc Hermitte

Suis-je le seul à être perturber par le mélange entre un héritage et des opérateurs qui ont une gueule furieusement mathématique?
Tu cherches à modélier quoi ?
15/12/2006, 12h52
Patriarch24

Citation:

Envoyé par Luc Hermitte

Suis-je le seul à être perturber par le mélange entre un héritage et des opérateurs qui ont une gueule furieusement mathématique?

Non tu n'es pas le seul :koi:. Et je comprends pas vraiment le fait d'"ajouter" des espaces --Space--, possiblement de dimensions différentes, entre eux.

Voilà la solution que je propose à mon problème

Code:

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
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
 
#include <iostream>
#include <vector>
#include <list>
 
using namespace std;
 
 
class Point
{
public:
  friend std::ostream& operator << (std::ostream& O, const Point& x);
  virtual Point & operator +=( Point& x)=0;
  virtual Point & operator -=( Point& x)=0;
  virtual void Print( Point& B)=0 ;
};
 
std::ostream& operator << (std::ostream& O,  Point& B)
{
  B.Print(B);
  return O;
}
Point & operator+(Point& x1, Point& x2)
{
  Point & x= x1;
  return x+=x2;
}
Point & operator-(Point& x1, Point& x2)
{
  Point & x= x1;
  return x-=x2;
}
 
 
template< class T > class Target
{
public :
  virtual T & add( T& x) = 0 ;
  virtual T & sub( T& x) = 0 ;
  virtual void f_Print(T& x)=0;
} ;
 
 
template< class T > class F : virtual public Point
{
public :
  virtual Point & operator +=( Point& x)
    {
      typedef Target< T > TargetT ;
      return dynamic_cast< TargetT& >(x).add( static_cast< T& >(*this) ) ;
    }
  virtual Point & operator -=( Point& x)
    {
      typedef Target< T > TargetT ;
      return dynamic_cast< TargetT& >(x).sub( static_cast< T& >(*this) ) ;
    }
  virtual void Print( Point& x)
    {
      typedef Target< T > TargetT ;
      return dynamic_cast< TargetT& >(x).f_Print(  static_cast< T& >(*this) ) ;
    }
};
 
 
class Point1d : public F< Point1d >,
          public Target< Point1d >
{
public :
  int i;
  Point1d()
    {i=0;}
  Point1d(int j){i=j;}
 
   Point1d & add( Point1d& x){this->i+=x.i;}
   Point1d & sub( Point1d& x){this->i-=x.i;}
  virtual void f_Print(Point1d& x)
    {
      cout << i<< endl;
    }
} ;
 
 
 
class Point2d : public F< Point2d >,
          public Target< Point2d >
 
{
public :
  int i[2];
  Point2d()
    {i[0]=0;i[1]=0;}
  Point2d(int i0,int i1){i[0]=i0;i[1]=i1;}
  Point2d & add( Point2d& x){this->i[0]+=x.i[0];this->i[1]+=x.i[1];}
  Point2d & sub( Point2d& x){this->i[0]-=x.i[0];this->i[1]-=x.i[1];}
  virtual void f_Print( Point2d& x)
    {
      cout << i[0]<< " " << i[1]<< endl;
    }
};
 
 
 
int main()
{
 
  Point1d a(1), c(2) ;
  Point2d b(1,2) ;
 
 
  Point*ptr;
  ptr = &a;
  *ptr = c - *ptr;
  cout << *ptr;
 
ptr =&b;
 
 
  *ptr+=*ptr;
  cout << *ptr;
 
}

Mon affichage console:

Code:

youpi ca marche

15/12/2006, 15h22
vincho

Maintenant si ça intéresse des gens, je peux comparer l'efficacité de ce code face au c classique où chaqu'une des fonction est écrites n fois ( n le nombre de type différents).

Ah oui, je voudrais savoir si le double-dispatch est résolu à la compilation où à l'éxecution. Car si c'est à l'éxécution alors c'est sure que mon code C++ va tourner moins vite
15/12/2006, 15h28
vincho

Citation:

Suis-je le seul à être perturber par le mélange entre un héritage et des opérateurs qui ont une gueule furieusement mathématique?

Qu-est ce que vous voulez dire par là??
15/12/2006, 15h39
Jean-Marc.Bourguet

Je crois que tu n'as toujours pas repondu a la question de fond soulevee par Luc. Generalement des operations comme l'assignation ou d'addition ont du sens sur des classes ayant une semantique de valeur et les operations virtuelles ont du sens sur des classes ayant une semantique d'entite. Les rares cas ou j'ai vu les deux ensembles, c'etait souvent dans le cadre de l'idiome lettre-enveloppe (qui m'a toujours semble bizarre et auquel je prefere la composition; mais c'est un autre debat).

Tu cherches donc a faire quelque chose de rarement pertinent, et tu n'es visiblement pas dans l'exception principale ou c'est pertinent.

Quelques remarques en passant:
- pourquoi operator<< est-il friend. Si c'est necessaire, c'est generalement un signe que quelque chose ne va pas dans l'interface publique.
- pourquoi += et -= prennent-il une reference non constante?
- pourquoi + prend-il des references non constantes?
- + et - retournent des references (non constantes en plus) vers des variables locales

La suite est quelque chose de tres bizarre. Quel est le probleme que tu cherches a resoudre?
15/12/2006, 16h01
nikko34

Citation:

Envoyé par Jean-Marc.Bourguet

- pourquoi operator<< est-il friend. Si c'est necessaire, c'est generalement un signe que quelque chose ne va pas dans l'interface publique.

ça peut se justifier si on doit appeller certaines méthodes non publiques de l'objet dans operator<< mais qu'on ne veut pas du tout qu'elles soient publiques, pour garder l'encapsulation.

(dans C++ coding standards je crois, "friend ne brise pas l'encapsulation mais la renforce", quelque chose comme ça)
15/12/2006, 16h22
Jean-Marc.Bourguet

Citation:

Envoyé par nikko34

ça peut se justifier si on doit appeller certaines méthodes non publiques de l'objet dans operator<< mais qu'on ne veut pas du tout qu'elles soient publiques, pour garder l'encapsulation.

La question est pourquoi vouloir afficher quelque chose qui n'est pas publiquement accessible?

Citation:

dans C++ coding standards je crois, "friend ne brise pas l'encapsulation mais la renforce", quelque chose comme ça)

Mais friend augmente le couplage. Etre tres couple avec des fonctions d'IO me pose un probleme.

(Je rapelle que dans le cas present, friend n'est absolument pas necessaire. operator<< faire appel a un membre public).
15/12/2006, 21h20
JolyLoic

Citation:

Envoyé par Jean-Marc.Bourguet

La question est pourquoi vouloir afficher quelque chose qui n'est pas publiquement accessible?

La principale raison que j'ai vue pour ça, c'est quand l'affichage ne servait pas à faire le véritable affichage du programme, mais uniquement de l'affichage de log/debug.