Type de retour d'une fonction virtuelle C++

Question

Est-il possible pour une classe héritée d'implémenter une fonction virtuelle avec un type de retour différent (sans utiliser un modèle comme retour) ?

Answer 1

Dans certains cas, oui, il est légal pour une classe dérivée de surcharger une fonction virtuelle en utilisant un type de retour différent, tant que le type de retour est covariant avec le type de retour original. Prenons l'exemple suivant :

class Base {
public:
    virtual ~Base() {}

    virtual Base* clone() const = 0;
};

class Derived: public Base {
public:
    virtual Derived* clone() const {
        return new Derived(*this);
    }
};

Ici, Base définit une fonction virtuelle pure appelée clone qui renvoie un Base * . Dans l'implémentation dérivée, cette fonction virtuelle est surchargée en utilisant un type de retour de Derived * . Bien que le type de retour ne soit pas le même que dans la base, ceci est parfaitement sûr car à chaque fois que vous écrivez

Base* ptr = /* ... */
Base* clone = ptr->clone();

L'appel à clone() renvoie toujours un pointeur sur un Base car même s'il renvoie un objet Derived* ce pointeur est implicitement convertible en un Base* et l'opération est bien définie.

Plus généralement, le type de retour d'une fonction n'est jamais considéré comme faisant partie de sa signature. Vous pouvez remplacer une fonction membre par n'importe quel type de retour, à condition que celui-ci soit covariant.

Answer 2

Oui. Les types de retour peuvent être différents tant qu'ils sont covariant . La norme C++ le décrit comme suit (§10.3/5) :

Le type de retour d'une fonction de surcharge est soit identique au type de retour de la fonction de surcharge, soit covariant avec les classes des fonctions. Si une fonction D::f remplace une fonction B::f Le type de retour des fonctions est covariant s'il satisfait aux critères suivants :

• les deux sont des pointeurs vers des classes ou des références à des classes 98)
• la classe dans le type de retour de B::f est la même classe que la classe du type de retour de D::f ou, est une classe de base directe ou indirecte non ambiguë de la classe dans le type de retour de D::f et est accessible en D
• les deux pointeurs ou références ont la même qualification cv et le type de classe dans le type de retour de D::f a la même qualification cv ou une qualification cv inférieure au type de classe dans le type de retour de B::f .

La note de bas de page 98 précise que "les pointeurs de classes à plusieurs niveaux ou les références à des pointeurs de classes à plusieurs niveaux ne sont pas autorisés".

En bref, si D est un sous-type de B alors le type de retour de la fonction dans D doit être un sous-type du type de retour de la fonction en B . L'exemple le plus courant est celui où les types de retour sont eux-mêmes basés sur des D y B mais ils ne sont pas obligés de l'être. Prenons l'exemple suivant, où nous avons deux hiérarchies de types distinctes :

struct Base { /* ... */ };
struct Derived: public Base { /* ... */ };

struct B {
  virtual Base* func() { return new Base; }
  virtual ~B() { }
};
struct D: public B {
  Derived* func() { return new Derived; }
};

int main() {
  B* b = new D;
  Base* base = b->func();
  delete base;
  delete b;
}

La raison pour laquelle cela fonctionne est que tout appelant de func attend un Base pointeur. Tous les Base fera l'affaire. Ainsi, si D::func promet de toujours renvoyer un Derived il satisfera toujours au contrat établi par la classe ancêtre, car tout pointeur Derived peut être implicitement converti en un pointeur Base pointeur. Ainsi, les appelants obtiendront toujours ce qu'ils attendent.

---

En plus de permettre la variation du type de retour, certains langages autorisent l'utilisation de la fonction types de paramètres de la fonction prioritaire. Lorsqu'ils le font, ils ont généralement besoin d'être contravariant . En d'autres termes, si B::f accepte un Derived* entonces D::f serait autorisé à accepter un Base* . Les descendants sont autorisés à plus lâche dans ce qu'ils acceptent, et plus strict dans ce qu'ils renvoient. Le C++ n'autorise pas la contravariance de type paramètre. Si vous changez les types de paramètres, le C++ considère qu'il s'agit d'une toute nouvelle fonction, ce qui entraîne des problèmes de surcharge et de dissimulation. Pour plus d'informations sur ce sujet, voir Covariance et contravariance (informatique) dans Wikipédia.

Answer 3

La mise en œuvre de la fonction virtuelle par une classe dérivée peut avoir une fonction Type de retour covariant .