Discussion :

[vincho]

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

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
 
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 :

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

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

[vincho]

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

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
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.

[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.

[vincho]

Big problème,

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 main()
{
Space2d s1,s2(2,3);
  Space *s;
 
 
  s1+=s2;
  cout << s1;
 
  s = &s1;
 
  *s+=s2;
  cout << *s;
}

Affichage

Code :

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

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 :

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

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!!!!!!!

[Jan Rendek]

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 :

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

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
}

[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

[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.

[vincho]

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

snif snif

[vincho]

vraiement personne...