Comment résoudre l'ambiguïté des fonctions surchargées avec héritage multiple en C ?

Ambiguïté dans les fonctions surchargées avec héritage multiple

Dans la programmation orientée objet, l'héritage multiple permet à une classe dérivée d'hériter de plusieurs classes de base. Cependant, cela peut conduire à des situations dans lesquelles plusieurs fonctions héritées portant le même nom mais des signatures différentes créent une ambiguïté lors de la compilation.

Considérez l'extrait de code suivant :

struct Base1{
    void foo(int){
    }
};

struct Base2{
    void foo(float){
    }
};

struct Derived : public Base1, public Base2{
};

int main(){
    Derived d;
    d.foo(5);
}

Ici, la classe Derived hérite de la fonction foo() de Base1 et Base2 avec différents types de paramètres. Lorsque l'appel à d.foo(5) est effectué dans la fonction principale, le compilateur ne peut pas déterminer quelle fonction appeler, ce qui entraîne l'erreur « appel ambigu à foo ».

Comment les règles de recherche de membres Déterminer l'ambiguïté

Pour comprendre la raison de cette ambiguïté, nous devons examiner les règles de recherche de membres définies dans la norme C. Lorsque le compilateur recherche la définition d'une fonction, il considère d'abord toutes les déclarations de la fonction dans la classe et ses classes de base. Cependant, s'il existe plusieurs déclarations portant le même nom, mais provenant de classes différentes, cela élimine toutes les déclarations cachées ou provenant de sous-objets différents.

Dans le cas de plusieurs fonctions héritées, si les déclarations restantes ne sont pas du même type ou incluent un membre non statique provenant de sous-objets différents, la recherche entraîne une ambiguïté. C'est la situation à laquelle nous sommes confrontés dans l'extrait de code donné.

Résoudre l'ambiguïté

Il existe plusieurs façons de résoudre l'ambiguïté dans cette situation :

• Utiliser des appels entièrement qualifiés : Qualifier entièrement l'appel à la fonction foo() avec le nom de la classe, tel que d.Base1::foo(5) ou d.Base2::foo(5), spécifiera explicitement la fonction à invoquer.
• Utiliser les déclarations using : La déclaration using peut être utilisé pour déclarer explicitement quelle fonction utiliser. Par exemple, dans la classe Derived, nous pourrions avoir : using Base1::foo; Cette instruction importerait la fonction foo() de Base1 dans la classe Derived, ce qui en ferait la fonction par défaut pour les appels avec un paramètre entier.
• Redéfinissez la fonction : S'il existe une préférence claire pour l'une des fonctions héritées, elle peut être redéfinie dans la classe dérivée avec la signature souhaitée. Cela doit être évité si possible, car cela peut entraîner une confusion et des incohérences potentielles.

Dans l'extrait de code donné, le deuxième exemple fonctionne puisqu'il n'y a qu'une seule fonction foo() dans la portée de la classe Derived. . L'appel d.foo(5) invoque en fait la fonction void foo(float).

Conclusion

Plusieurs fonctions héritées avec des signatures différentes peuvent créer une ambiguïté lors de la compilation. Comprendre les règles de recherche de membres et utiliser des techniques telles que les appels pleinement qualifiés ou l'utilisation de déclarations peuvent aider à résoudre ces ambiguïtés et à garantir un appel de fonction correct.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!