Advertencia del compilador (nivel 2) C4250

"class1": hereda "class2::member" mediante dominación

Observaciones

Dos o más miembros tienen el mismo nombre. El de class2 se hereda, porque es una clase base para las demás clases que contenían este miembro.

Para suprimir la advertencia C4250, use la pragma warning.

Dado que una clase base virtual se comparte entre varias clases derivadas, un nombre de una clase derivada domina a un nombre en una clase base. Por ejemplo, dada la jerarquía de clases siguiente, hay dos definiciones de func heredadas dentro del rombo: la instancia vbc::func() a través de la clase débil y dominant::func() a través de la clase dominante. Una llamada no calificada de func() a través de un objeto de clase de rombo siempre llama a la instancia dominate::func(). Si la clase débil fuera a introducir una instancia de func(), ninguna definición dominaría y la llamada se marcaría como ambigua.

Ejemplos

En el ejemplo siguiente se genera la advertencia C4250:

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

En el ejemplo siguiente se genera la advertencia 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;
}

En este ejemplo se muestra una situación más compleja. En el ejemplo siguiente se genera la advertencia 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()
}