Avviso del compilatore (livello 2) C4250

'class1': eredita 'class2::member' tramite dominanza

Due o più membri hanno lo stesso nome. Quello in class2 viene ereditato perché è una classe di base per le altre classi che contengono questo membro.

Per eliminare C4250, usare il pragma di avviso .

Poiché una classe base virtuale è condivisa tra più classi derivate, un nome in una classe derivata domina un nome in una classe di base. Ad esempio, data la gerarchia di classi seguente, esistono due definizioni di func ereditate all'interno del diamante: l'istanza vbc::func() tramite la classe debole e la classe dominante::func() tramite la classe dominante. Una chiamata non qualificata di func() tramite un oggetto classe rombo chiama sempre l'istanza dominate::func(). Se la classe debole dovesse introdurre un'istanza di func(), nessuna delle due definizioni domina e la chiamata verrebbe contrassegnata come ambigua.

Esempi

// 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'esempio seguente genera l'errore 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;
}

Questo esempio mostra una situazione più complessa. L'esempio seguente genera l'errore 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()
}