Kompilatorvarning (nivå 2) C4250

"class1" : ärver "class2::member" genom arvkonflikt

Anmärkningar

Två eller flera medlemmar har samma namn. Den i class2 ärvs eftersom den är en basklass för de andra klasserna som innehöll den här medlemmen.

Om du vill förhindra C4250 använder du varnings pragma.

Eftersom en virtuell basklass delas mellan flera härledda klasser dominerar ett namn i en härledd klass ett namn i en basklass. Med tanke på följande klasshierarki finns det till exempel två definitioner av func som ärvts inom diamantföremål: vbc::func() instans via weak class och dominant::func() genom dominant class. Ett okvalificerat anrop av func() via ett diamond class-objekt, anropar alltid instansen dominate::func(). Om den svaga klassen skulle introducera en instans av func() skulle ingen av definitionerna dominera, och anropet skulle flaggas som tvetydigt.

Examples

I följande exempel genereras 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
}

I följande exempel genereras 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;
}

Det här exemplet visar en mer komplex situation. I följande exempel genereras 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()
}