Discussion :

[Pyramidev]

Bonjour,

Que pensez-vous de l'idée d'un héritage constant en C++ ?

Code :

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

class Cercle : public const EllipseAbstraite { /*...*/ };

Caractéristiques :

• Cercle& est convertible en const EllipseAbstraite&, mais pas en EllipseAbstraite&.
• Si EllipseAbstraite a des fonctions virtuelles pures alors, pour que Cercle soit instanciable, il doit implémenter les fonctions virtuelles pures constantes de EllipseAbstraite.
• Si on appelle une fonction non constante de EllipseAbstraite via une instance de Cercle (à cause d'un const_cast), le comportement est indéterminé.
  

  Code :

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

  1
  2
  3
  4
  5
  Cercle cercle;
  const EllipseAbstraite& ellipse = cercle;;
  EllipseAbstraite& danger = const_cast<EllipseAbstraite&>(ellipse);
  danger.fonctionNonConstante(); // aïe
  danger.fonctionVirtuellePureNonConstante(); // crash

• Le code suivant est autorisé :
  

  Code :

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

  1
  2
  class Deriv : virtual public const Base { /*...*/ };
  class Deriv2 : public Deriv, virtual public Base { /*...*/ }; // pas de const

• Pour la cohérence, on aurait aussi l'héritage volatile et l'héritage constant volatile, qui ne serviraient à rien.

Le principal intérêt serait de réduire la quantité de classes en évitant les doublons Base/ConstBase :

Code :

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

1
2
class EllipseAbstraite : public ConstEllipseAbstraite { /*...*/ };
class Cercle           : public ConstEllipseAbstraite { /*...*/ };

[JolyLoic]

Avant de détailler le mécanisme plus en détails, tu pourrais détailler la motivation ? Parce que pour l'instant, je ne vois pas trop ce qu'on y gagne...

[Pyramidev]

Par exemple, à la place de ceci :

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
class Product { /*...*/ };
class Fruit : public Product { /*...*/ };
class Orange : public Fruit { /*...*/ };
 
class ConstProductTable {
public:
    virtual const Product& getProduct(size_t index) const = 0;
    // ...
};
 
class ProductTable : public ConstProductTable {
public:
    virtual void addProduct(const Product&) = 0;
    // ...
};
 
class ConstFruitTable : public ConstProductTable {
public:
    const Fruit& getProduct(size_t index) const override = 0;
    // ...
};
 
class FruitTable : public ConstFruitTable {
public:
    virtual void addFruit(const Fruit&) = 0;
    // ...
};
 
class ConstOrangeTable : public ConstFruitTable {
public:
    const Orange& getProduct(size_t index) const override = 0;
    // ...
};
 
class OrangeTable : public ConstOrangeTable {
public:
    virtual void addOrange(const Orange&) = 0;
    // ...
};

On aurait cela :

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
class Product { /*...*/ };
class Fruit : public Product { /*...*/ };
class Orange : public Fruit { /*...*/ };
 
class ProductTable {
public:
    virtual const Product& getProduct(size_t index) const = 0;
    virtual void addProduct(const Product&) = 0;
    // ...
};
 
class FruitTable : public const ProductTable {
public:
    const Fruit& getProduct(size_t index) const override = 0;
    virtual void addFruit(const Fruit&) = 0;
    // ...
};
 
class OrangeTable : public const FruitTable {
public:
    const Orange& getProduct(size_t index) const override = 0;
    virtual void addOrange(const Orange&) = 0;
    // ...
};

Edit 2016-12-19-19h52 (après la réponse de JolyLoic) : J'avais oublié de rendre pures mes fonctions virtuelles.

[JolyLoic]

Et comment implémentes-tu FruitTable::addFruit ?

[Pyramidev]

Oups. J'ai oublié de rendre pures les fonctions virtuelles de mon précédent message.
Code modifié et factorisé :

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 Product {
	// ...
};
 
class Fruit : public Product {
public:
	using base = Product;
	// ...
};
 
class Orange : public Fruit {
public:
	using base = Fruit;
	// ...
};
 
template<class T>
class ProductTable;
 
template<>
class ProductTable<Product> {
public:
    virtual const Product& getProduct(size_t index) const = 0;
    virtual void append(const Product&) = 0;
    // ...
};
 
template<class T>
class ProductTable : public const ProductTable<typename T::base> {
public:
    const T& getProduct(size_t index) const override = 0;
    virtual void append(const T&) = 0;
    // ...
};
 
class ConcreteOrangeTable : public ProductTable<Orange> {
public:
    const Orange& getProduct(size_t index) const override;
    void append(const Orange&) override;
    // ...
};

Dans mon exemple, ConcreteOrangeTable& serait convertible en ProductTable<Orange>, en const ProductTable<Fruit>& et en const ProductTable<Product>&.

[Pyramidev]

Aucun avis ?

Personnellement, je suis partagé.
D'un côté, cela permettrait de réduire le nombre de classes dans des cas assez rares.
De l'autre, cela complexifierait un peu plus le langage C++ qui est déjà compliqué.