Avertissement du compilateur (niveau 2) C4250

'class1' : hérite de 'class2 ::member' via la domination

Deux membres ou plus ont le même nom. L’un d’eux class2 est hérité, car il s’agit d’une classe de base pour les autres classes qui contenaient ce membre.

Pour supprimer C4250, utilisez le pragma d’avertissement.

Étant donné qu’une classe de base virtuelle est partagée entre plusieurs classes dérivées, un nom dans une classe dérivée domine un nom dans une classe de base. Par exemple, étant donné la hiérarchie de classes suivante, il existe deux définitions de func héritées au sein du diamant : l’instance vbc ::func() par le biais de la classe faible, et la dominante ::func() par le biais de la classe dominante. Un appel non qualifié de func() par le biais d’un objet de classe de diamants appelle toujours l’instance dominant ::func(). Si la classe faible devait introduire une instance de func(), aucune définition ne domine, et l’appel serait marqué comme ambigu.

Exemples

// C4250.cpp
// compile with: /c /W2
#include <stdio.h>
struct vbc {
   virtual void func() { printf("vbc::func\n"); }
};

struct weak : public virtual vbc {};

struct dominant : public virtual vbc {
   void func() { printf("dominant::func\n"); }
};

struct diamond : public weak, public dominant {};

int main() {
   diamond d;
   d.func();   // C4250
}

L’exemple suivant génère l’erreur C4250.

// C4250_b.cpp
// compile with: /W2 /EHsc
#include <iostream>
using namespace std;
class A {
public:
   virtual operator int () {
      return 2;
   }
};

class B : virtual public A {
public:
   virtual operator int () {
      return 3;
   }
};

class C : virtual public A {};

class E : public B, public C {};   // C4250

int main() {
   E eObject;
   cout << eObject.operator int() << endl;
}

Cet exemple montre une situation plus complexe. L’exemple suivant génère l’erreur C4250.

// C4250_c.cpp
// compile with: /W2 /EHsc
#include <iostream>
using namespace std;

class V {
public:
   virtual int f() {
      return 1024;
   }
};

class B : virtual public V {
public:
   int b() {
      return f(); // B::b() calls V::f()
   }
};

class M : virtual public V {
public:
   int f() {
      return 7;
   }
};

// because of dominance, f() is M::f() inside D,
// changing the meaning of B::b's f() call inside a D
class D : public B, public M {};   // C4250

int main() {
   D d;
   cout << "value is: " << d.b();   // invokes M::f()
}