关于虚拟赋值运算符

Question

VC6程序如下：
class Base
{
public:
Base(int m) : m_base(m) {}
Base& operator=(const Base&);
virtual void Show() const { cout << "Base: " << m_base << endl;} private:
int m_base;
};Base& Base::operator=(const Base &lhr)
{
cout << "Base::operator=" << endl;
if (this == &lhr)
{
return *this;
} m_base = lhr.m_base;
return *this;
}class Derive: public Base
{
public:
Derive(int base, int derive) : Base(base), m_derive(derive) {}
Derive& operator=(const Derive&);
void Show() const { cout << "Derive: " << m_derive << endl;}
private:
int m_derive;
};Derive& Derive::operator=(const Derive& lhr)
{
cout << "Derive::operator=" << endl;
if (this == &lhr)
return *this; Base::operator=(lhr);
m_derive = lhr.m_derive;
return *this;
}void main()
{
Derive a(1,2);
Derive b(3,4); a.Base::Show();          
a.Show(); a = b;
a.Base::Show();           //此时对象a的基类数据成员被赋值为3
a.Show();                 //对象的数据成员被赋值为4 Base* pb1 = new Derive(5, 6); *pb1 = b;                //？？问题在这里，此时调用的是base的operator=（）
pb1->Base::Show();       //因此，此处只修改了base的数据成员，即为3
pb1->Show();             //而此处*pb1的对象数据成员仍然为6
}修改方针：
将base的operator=()设置为virtual，由于虚函数对于返回值有个特例，即如果返回值为上层虚函数的子类，则虚函数关系仍然成立。
我的问题是：在VC6下，我将base的operator=()设置为virtual，“*pb1 = b; ”仍然调用的是base的operator=()，即没有调用子类的，这是为什么？难道是VC6的问题？？？

Answer 1

重载函数需要通过参数是否一致来判断
你父类和子类的operator=参数不一致所以不是重载

Answer 2

tryclass Base
{
public:
Base(int m) : m_base(m) {}
Base& operator=(const Base&)=0;
virtual void Show() const { cout << "Base: " << m_base << endl;}private:
int m_base;
};
class Derive: public Base
{
public:
Derive(int base, int derive) : Base(base), m_derive(derive) {}
Derive& operator=(const Derive&);
void Show() const { cout << "Derive: " << m_derive << endl;}
private:
int m_derive;
}; 结果 编译失败 

Answer 3

class Base
{
public:
Base(int m) : m_base(m) {}
Base& operator=(const Base&)=0; //注意这里
virtual void Show() const { cout << "Base: " << m_base << endl;}private:
int m_base;
};
class Derive: public Base
{
public:
Derive(int base, int derive) : Base(base), m_derive(derive) {}
Derive& operator=(const Base&); 
void Show() const { cout << "Derive: " << m_derive << endl;}
private:
int m_derive;
};明白了没???

Answer 4

老大，真的没明白，‘=0’应该是纯虚函数，但是你又没写virtual。
而且纯虚函数是不会有对象的
所以真的没明白你的意思，请指教

Answer 5

写上virtual也一样编译失败。这么跟你说吧：
class Base
{
public:
   virtual void Func(double d);
};
class Derive : public Base
{
public:
   virtual void Func(int n);
};void main()
{
   Derive D;
   Base *p = &D;
   int n;
   p->Func(n);  // 请问调用了哪个函数？
}
很显然，这里调用的是Base::Func，因为Base::Func跟Derive::Func根本不是重载（override），只不过是重名的两个函数而已（overload），因为它们的参数是不同的。能构成重载的函数，参数必须严格地完全相同，而不仅仅是“能够缺省地相互转换”。实际上，假若我写：
class Base
{
public:
   virtual void Func(double d);
   virtual void Func(int n);
};
你绝对不会有任何疑惑，那么我把第二个函数挪到Derive里面，你应该也能明白这两个函数的关系。
OK！把上面的“Func”替换成“operator=”，把“double d”替换成“const Base& lhr”，把“int n”替换成“const Derive& lhr”，这时候你就应该明白这两个赋值操作符的关系了吧？