Discussion :

[David Fleury]

Bonjour,

dans http://www.objectmentor.com/resources/articles/lsp.pdf à propos du LSP, l'exemple est donné à base d'un Square héritant d'un Rectangle.

Auriez-vous une idée d'exemple qui poserait problème pour le cas d'un Rectangle héritant d'un Square ?

Cordialement.

[EDIT : Il semble que je ne sois pas dans la bonne section. Peut être faudrait-il déplacer mes post dans Algorithme ?]

[David Fleury]

Voici l'argument mis en avant dans l'article (en C++)

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
42
43
44
45
46
47
48
49
#include <iostream>

using namespace std;

class Rectangle
{
public:
  Rectangle( int w = 0, int h = 0 ) : width_(w), height_(h) {}
  
  virtual int width() const { return width_; }
  virtual int height() const { return height_; }

  virtual void width( int w ) { width_ = w; }
  virtual void height( int h ) { height_ = h; }
  
private:
  int width_;
  int height_;
};

class Square : public Rectangle
{
public:
  Square( int w = 0 )
  {
    width( w ); 
  }

  virtual void width( int w ) { Rectangle::width( w ); Rectangle::height( w );}
  virtual void height( int h ) {  Rectangle::width( h ); Rectangle::height( h ); }  
};

void g( Rectangle& r )
{
  r.width( 5 );
  r.height( 4 );
  
  assert( r.width() * r.height() == 20 );
}

int main()
{
  Rectangle r( 2, 3 );
  g( r );

  Square s( 4 );
  g( s );
}

Est-ce que celui là pour l'autre sens serait recevable ?

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
42
43
44
45
46
47
48
49
50
51
#include <iostream>

using namespace std;

class Square
{
public:
  Square( int w = 0 ) { width( w ); }
  
  int width() const { return width_; }
  void width( int w ) { width_ = w; }
  
  virtual double area() const { return width() * width(); }
  
private:
  int width_;
};

class Rectangle : public Square
{
public:
  Rectangle( int w = 0, int h = 0 )
  {
    width( w ); 
    height( h );
  }

  int height() const { return height_; }
  void height( int h ) {  height_ = h; }

  virtual double area() const { return width() * height(); }

private:
  int height_;
};

void g( Square& r )
{
  r.width( 5 );
  
  assert( r.area() == 25 );
}

int main()
{
  Square s( 4 );
  g( s );

  Rectangle r( 2, 3 );
  g( r );
}

[behess]

Il me semble plus logique qu'un carré hérite d'un rectangle, ce serait géométriquement plus juste... non ?

[David Fleury]

Malheureusement, je ne suis pas sûr que "géométriquement juste" soit un argument pour la modélisation dans mon cas.
L'article en question montre d'ailleurs que non.

J'ai cru comprendre que c'est un sujet délicat, ou tout le monde ne semble pas d'accord. En tout cas, l'essentiel est qu'une hiérarchie de classes répond à un besoin, et cette hiérarchie n'est valide que selon l'usage qu'on en fait. sa validité dépend du contexte.

[CinePhil]

Géométriquement, un carré est un rectangle particulier donc un carré hérite d'un rectangle, pas l'inverse !

À moins que vous ne vouliez remettre en question 3000 ans de géométrie ?

[gl]

Il y a déjà un long sujet à ce sujet sur le forum : Héritage classes carré/rectangle.