Comment lever l'ambiguïté des membres d'une classe dans un héritage multiple avec des ensembles de types qui ne se chevauchent pas ?

Dissiper l'ambiguïté des membres d'une classe dans un héritage multiple avec des ensembles de types qui ne se chevauchent pas

Le défi se pose lors de l'héritage de plusieurs bases avec des ensembles qui ne se chevauchent pas de types. Lors de l'appel d'une fonction membre, le compilateur s'attend à identifier la classe de base spécifique à utiliser, mais dans de tels cas, il rencontre une ambiguïté.

Alors que le modèle Contains détermine si un type existe dans un pack variadique, les règles de fusion pour la recherche de membres de classe dans les cas où l'ensemble de déclarations de la classe dérivée est vide, cela peut entraîner une ambiguïté. Comme aucune des classes de base n'a de membres dans l'ensemble de déclarations de la classe dérivée, le processus de fusion fusionne les ensembles de recherche de chaque base, conduisant à un appel ambigu.

Solutions possibles

• Déclarations d'utilisation explicites : en ajoutant des déclarations d'utilisation explicites pour la fonction membre de chaque classe de base, la classe dérivée définit efficacement ces membres, rendant son ensemble de déclarations non vide et contournant les règles de fusion ambiguës.

  <code class="cpp">struct Derived : public Base<int, char>, public Base<double, void>
  {
    using Base<int, char>::foo;
    using Base<double, void>::foo;
  };</code>

• Base Collector : à l'aide d'une technique de métaprogrammation de modèle, implémentez une classe BaseCollector qui collecte les membres de toutes les classes de base et les déclare en utilisant dans la classe dérivée . Cette approche fournit une solution générique sans nécessiter de déclarations d'utilisation explicites.

  <code class="cpp">struct Derived : BaseCollector<Base2<int>, Base2<std::string>>
  { };</code>

• Extension de pack variadique à l'aide de la déclaration (C 17) : L'utilisation de l'expansion de pack variadique peut simplifier l'implémentation de BaseCollector, la rendant à la fois plus courte et plus efficace.

  <code class="cpp">template <typename... Bases>
  struct BaseCollector : Bases...
  {
    using Bases::foo...;
  };</code>

  En employant ces techniques, nous pouvons lever l'ambiguïté des appels de membres de classe dans plusieurs scénarios d'héritage avec des ensembles de types qui ne se chevauchent pas, permettant ainsi une implémentation claire et sans ambiguïté exécution de code.

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!