Compilerwarnung (Ebene 2) C4250

'class1': erbt 'class2::member' über dominanz

Bemerkungen

Zwei oder mehr Mitglieder haben denselben Namen. Das In class2 wird geerbt, da es sich um eine Basisklasse für die anderen Klassen handelt, die dieses Element enthielten.

Verwenden Sie zum Unterdrücken von C4250 das Pragma der Warnung .

Da eine virtuelle Basisklasse von mehreren abgeleiteten Klassen gemeinsam genutzt wird, dominiert ein Name in einer abgeleiteten Klasse einen Namen in einer Basisklasse. In Anbetracht der folgenden Klassenhierarchie gibt es beispielsweise zwei Definitionen von Func geerbt innerhalb der Raute: die vbc::func()-Instanz über die schwache Klasse und die dominante::func() durch die dominante Klasse. Ein nicht qualifizierter Aufruf von Func() über ein Rautenklassenobjekt ruft immer die dominante Instanz::func() auf. Wenn die schwache Klasse eine Instanz von Func() einführen würde, würde keine Definition dominiert, und der Aufruf würde als mehrdeutig gekennzeichnet.

Beispiele

Im folgenden Beispiel wird C4250 generiert:

// 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
}

Im folgenden Beispiel wird C4250 generiert.

// 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;
}

Dieses Beispiel zeigt eine komplexere Situation. Im folgenden Beispiel wird C4250 generiert.

// 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()
}