派生类作为分配运算符的参数-不能按预期工作. [英] Derived classes as parameters to assignment operator - doesn't work as expected.

问题描述

好，说我有以下课程:

Ok, say I have the following classes:

class MyBaseClass;
class MyDerivedClass : public MyBaseClass;

class MyBaseAssigneeClass
{
    //base class assignment operator:
    virtual MyBaseAssignableClass& operator = (const MyBaseClass& that);
};

class MyDerivedAssigneeClass : public MyBaseAssignableClass
{
    //overloaded class assignment operator:
    virtual MyDerivedAssignableClass& operator = (const MyBaseClass& that);
};

以及以下代码:

And the following code:

MyDerivedAssigneeClass MyDerivedAssigneeClassInstance;
MyDerivedClass MyDerivedClassInstance;

//should call MyDerivedAssigneeClass::operator = (const MyBaseClass&) right?
MyDerivedAssigneeClassInstance = MyDerivedClassInstance;  

出乎意料的是，调用的是BASE类(MyBaseAssigneeClass)中的运算符.操作员根本不会过载.如果我将MyDerivedAssigneeClass更改为:

Unexpectedly, it''s the operator in the BASE class (MyBaseAssigneeClass) that gets called. The operator is not overloaded at all. If I change MyDerivedAssigneeClass to:

class MyDerivedAssigneeClass : public MyBaseAssignableClass
{
    //overloaded class assignment operator:
    virtual MyDerivedAssignableClass& operator = (const MyBaseClass& that);

    //Explictly overload assignment from MyDerivedClass
    //Call the other overload with that argument cast to MyBaseClass
    MyDerivedAssigneeClass& operator = (const MyDerivedClass& that) { return operator = (static_cast<const MyBaseClass&>(that)); }
};

然后就可以了.我错过了什么吗?

Then it works. Have I missed something?

推荐答案

我对您的命名有些困惑.我应该说它按预期工作.

Im a little bit confused with your naming. What should i say it works as expected.

class MyBaseClass{};
class MyDerivedClass : public MyBaseClass{};

class MyBaseAssigneeClass
{
public:
    //base class assignment operator:
    virtual MyBaseAssigneeClass& operator = (const MyBaseClass& that)
    {
      _tprintf(__T("MyBaseAssigneeClass\r\n"));
      return *this;
    }
};

class MyDerivedAssigneeClass : public MyBaseAssigneeClass
{
public:
    //overloaded class assignment operator:
    virtual MyDerivedAssigneeClass& operator = (const MyBaseClass& that)
    {
      _tprintf(__T("MyDerivedAssigneeClass\r\n"));
      return *this;
    }
};

int _tmain(int argc, _TCHAR* argv[])
{
  MyDerivedAssigneeClass    MyDerivedAssigneeClassInstance;
  MyDerivedClass            MyDerivedClassInstance;

  //should call MyDerivedAssigneeClass::operator = (const MyBaseClass&) right?
  MyDerivedAssigneeClassInstance = MyDerivedClassInstance;  

  _gettch();
  return 0;
}

输出:

output:

MyDerivedAssigneeClass

问候.

尝试仅在基类中定义=运算符，并使用可覆盖的方法:

Try to define the = operator in the base class only and use an overridable method:

class MyBaseClass
{
public:
    MyBaseClass& operator = (const MyBaseClass& that)
    {
        return Assigns(that);
    }
protected:
    virtual MyBaseClass& Assigns(const MyBaseClass& that)
    {
        ...
        return *this;
    }
};
class MyDerivedClass : public MyBaseClass
{
protected:
    virtual MyBaseClass& Assigns(const MyBaseClass& that)
    {
        ...
        return *this;
    }
};

感谢您的回复，但是，我给的例子错了.该死的，对不起.让我再试一次.

Thanks for the replies chaps, but gah, I''ve given the example wrong. Dammit, sorry. Let me try again.

class MyBaseClass
{
    //base class assignment operator:
    virtual MyBaseClass& operator = (const MyBaseClass& that);
};
class MyDerivedClass : public MyBaseClass
{
    //overridden assignment operator:
    virtual MyDerivedClass& operator = (const MyBaseClass& that);
};

以及以下代码:

And the following code:

MyDerivedClass MyObj1;
MyDerivedClass MyObj2;

//should call MyDerivedClass::operator = (const MyBaseClass&) right?
MyObj1 = MyObj2;  

我本来希望它与上面的mbue示例相同，但是在我的代码中却没有.

我希望将MyObj2隐式转换为MyBaseClass并在派生类中重写重写的赋值运算符.但这不是;基类版本被调用.我必须添加:

I would have expected this to work the same as the example that mbue posted above - but in my code, it doesn''t.

I would expect that MyObj2 would be implicitly cast to a MyBaseClass and the overridden assignment operator in the derived class called. But it isn''t; the base class version is called. I have to add:

MyDerivedClass& operator = (const MyDerivedClass& that) { return operator = (static_cast<const MyBaseClass&>(that)); }

明确接受派生类的参数.

再说一遍，我有什么想念的吗?

to explicitly accept an argument of my derived class.

Again, is there something I''m missing?

这篇关于派生类作为分配运算符的参数-不能按预期工作.的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！