Utilisation de "super" en C++

Question

Mon style de codage comprend l'idiome suivant :

class Derived : public Base
{
   public :
      typedef Base super; // note that it could be hidden in
                          // protected/private section, instead

      // Etc.
} ;

Cela me permet d'utiliser "super" comme alias de Base, par exemple, dans les constructeurs :

Derived(int i, int j)
   : super(i), J(j)
{
}

Ou même en appelant la méthode depuis la classe de base dans sa version surchargée :

void Derived::foo()
{
   super::foo() ;

   // ... And then, do something else
}

Il peut même être enchaîné (je n'en ai pas encore trouvé l'utilité, cependant) :

class DerivedDerived : public Derived
{
   public :
      typedef Derived super; // note that it could be hidden in
                             // protected/private section, instead

      // Etc.
} ;

void DerivedDerived::bar()
{
   super::bar() ; // will call Derived::bar
   super::super::bar ; // will call Base::bar

   // ... And then, do something else
}

Quoi qu'il en soit, je trouve l'utilisation de "typedef super" très utile, par exemple, lorsque Base est soit verbeux et/ou modélisé.

Le fait est que super est implémenté en Java, ainsi qu'en C# (où il est appelé "base", sauf erreur de ma part). Mais le C++ ne dispose pas de ce mot-clé.

Donc, mes questions :

• Cette utilisation de typedef est-elle super commune/rare/jamais vue dans le code avec lequel vous travaillez ?
• cette utilisation du typedef est-elle super Ok (c'est-à-dire que vous voyez des raisons fortes ou moins fortes de ne pas l'utiliser) ?
• est-ce que "super" est une bonne chose, est-ce qu'il devrait être quelque peu standardisé en C++, ou est-ce que cette utilisation à travers un typedef est déjà suffisante ?

Edita: Roddy a mentionné le fait que le typedef devrait être privé. Cela signifierait que toute classe dérivée ne pourrait pas l'utiliser sans le redéclarer. Mais je suppose que cela empêcherait aussi l'enchaînement super::super (mais qui va pleurer pour ça ?).

Edit 2 : Aujourd'hui, quelques mois après avoir utilisé massivement "super", je suis tout à fait d'accord avec le point de vue de Roddy : "super" devrait être privé. Je voudrais upvoter sa réponse deux fois, mais je suppose que je ne peux pas.

Answer 1

Mentions de Bjarne Stroustrup en Conception et évolution du C++ que super comme mot-clé a été envisagé par le comité des normes ISO C++ lors de la première normalisation du C++.

Dag Bruck a proposé cette extension, en appelant la classe de base "héritée". La proposition mentionnait la question de l'héritage multiple, et aurait signalé les utilisations ambiguës. Même Stroustrup était convaincu.

Après discussion, Dag Bruck (oui, la même personne que celle qui a fait la proposition) a écrit que la proposition était implémentable, techniquement saine et sans défauts majeurs, et qu'elle gérait l'héritage multiple. D'un autre côté, il n'y avait pas assez d'avantages et le comité devrait s'occuper d'un problème plus épineux.

Michael Tiemann est arrivé en retard, et a ensuite montré qu'un super typedef'ed fonctionnerait très bien, en utilisant la même technique que celle demandée dans ce post.

Donc, non, cela ne sera probablement jamais normalisé.

Si vous n'avez pas de copie, Conception et évolution vaut bien le prix d'entrée. On peut se procurer des exemplaires d'occasion pour environ 10 $.

Answer 2

J'ai toujours utilisé "inherited" plutôt que super. (Probablement en raison de mes antécédents avec Delphi), et je fais toujours en sorte que privé Cette méthode permet d'éviter le problème lorsque le mot "hérité" est omis par erreur dans une classe et qu'une sous-classe tente de l'utiliser.

class MyClass : public MyBase
{
private:  // Prevents erroneous use by other classes.
  typedef MyBase inherited;
...

Mon "modèle de code" standard pour la création de nouvelles classes inclut le typedef, et j'ai donc peu d'occasions de l'omettre accidentellement.

Je ne pense pas que la suggestion d'enchaîner les "super::super" soit une bonne idée. Si vous faites cela, vous êtes probablement très attaché à une hiérarchie particulière, et la modifier risque de casser gravement des choses.

Answer 3

Le problème est que si vous oubliez de (re)définir super pour les classes dérivées, alors tout appel à super::quelque chose compilera bien mais n'appellera probablement pas la fonction désirée.

Par exemple :

class Base
{
public:  virtual void foo() { ... }
};

class Derived: public Base
{
public:
    typedef Base super;
    virtual void foo()
    {
        super::foo();   // call superclass implementation

        // do other stuff
        ...
    }
};

class DerivedAgain: public Derived
{
public:
    virtual void foo()
    {
        // Call superclass function
        super::foo();    // oops, calls Base::foo() rather than Derived::foo()

        ...
    }
};

(Comme l'a souligné Martin York dans les commentaires de cette réponse, ce problème peut être éliminé en rendant le typedef privé plutôt que public ou protégé).

Answer 4

FWIW Microsoft a ajouté une extension pour __super dans leur compilateur.

Answer 5

Super (ou hérité) est une très bonne chose car si vous avez besoin de coller une autre couche d'héritage entre Base et Dérivé, vous ne devez changer que deux choses : 1. la "classe Base : foo" et 2. le typedef

Si je me souviens bien, le comité des normes C++ envisageait d'ajouter un mot-clé pour cela... jusqu'à ce que Michael Tiemann fasse remarquer que cette astuce de typedef fonctionne.

En ce qui concerne l'héritage multiple, puisque c'est sous le contrôle du programmeur, vous pouvez faire ce que vous voulez : peut-être super1 et super2, ou autre.