虚赋值运算符 C++

Question

C++ 中的赋值运算符可以变为虚拟的。 为什么需要它？ 我们可以让其他运营商也虚拟化吗？

Answer 1

赋值运算符不需要是虚拟的。

下面的讨论是关于 operator= 的，但它也适用于接受相关类型的任何运算符重载，以及接受相关类型的任何函数。

下面的讨论表明，virtual 关键字在查找匹配的函数签名时不知道参数的继承。 在最后一个示例中，它展示了在处理继承类型时如何正确处理赋值。

---

虚拟函数不知道参数的继承：

函数的签名必须与虚拟函数相同才能发挥作用。 因此，即使在下面的示例中，operator=被设为虚函数，该调用也永远不会充当D中的虚函数，因为operator=的参数和返回值是不同的。

函数 B::operator=(const B& right) 和 D::operator=(const D& right) 100% 完全不同，被视为 2 个不同的函数。

class B
{
public:
  virtual B& operator=(const B& right)
  {
    x = right.x;
    return *this;
  }

  int x;

};

class D : public B
{
public:
  virtual D& operator=(const D& right)
  {
    x = right.x;
    y = right.y;
    return *this;
  }
  int y;
};

---

默认值并具有 2 个重载运算符：

您可以定义一个虚函数，以便在将 D 分配给 B 类型的变量时为 D 设置默认值。即使您的 B 变量实际上是将 D 存储到 B 的引用中。您将不会获得 D::operator=(const D& right) 函数。

在下面的情况下，来自存储在 2 个 B 引用内的 2 D 对象的赋值...使用 D::operator=(const B& right) 覆盖。

//Use same B as above

class D : public B
{
public:
  virtual D& operator=(const D& right)
  {
    x = right.x;
    y = right.y;
    return *this;
  }


  virtual B& operator=(const B& right)
  {
    x = right.x;
    y = 13;//Default value
    return *this;
  }

  int y;
};


int main(int argc, char **argv) 
{
  D d1;
  B &b1 = d1;
  d1.x = 99;
  d1.y = 100;
  printf("d1.x d1.y %i %i\n", d1.x, d1.y);

  D d2;
  B &b2 = d2;
  b2 = b1;
  printf("d2.x d2.y %i %i\n", d2.x, d2.y);
  return 0;
}

打印：

d1.x d1.y 99 100
d2.x d2.y 99 13

这表明 D::operator=(const D& right) 从未被使用过。

如果 B::operator=(const B& right) 上没有 virtual 关键字，您将得到与上面相同的结果，但 y 的值不会被初始化。 即它将使用 B::operator=(const B& right)

---

最后一步将它们结合在一起，RTTI：

您可以使用 RTTI 来正确处理虚拟函数接受你的类型。 这是弄清楚在处理可能继承的类型时如何正确处理赋值的最后一个难题。

virtual B& operator=(const B& right)
{
  const D *pD = dynamic_cast<const D*>(&right);
  if(pD)
  {
    x = pD->x;
    y = pD->y;
  }
  else
  {
    x = right.x;
    y = 13;//default value
  }

  return *this;
}

Answer 2

这取决于运营商。

将赋值运算符设为虚拟的目的是让您能够覆盖它以复制更多字段。

因此，如果您有一个 Base& 你实际上有一个 Derived& 作为动态类型，并且 Derived 有更多字段，会复制正确的内容。

但是，存在这样的风险：您的 LHS 是 Derived，而 RHS 是 Base，因此当虚拟运算符在 Derived 中运行时，您的参数不是 Derived，并且您无法从中获取字段。

这是一个很好的讨论：
http://icu-project.org/docs/papers/cpp_report/the_assignment_operator_revisited.html

Answer 3

Brian R. Bondy 写道：

<小时>

将所有内容结合在一起的最后一步，RTTI：

您可以使用 RTTI 来正确处理采用您的类型的虚拟函数。 这是解决在处理可能继承的类型时如何正确处理赋值的最后一块难题。

虚拟 B&   运算符=(const B&右) 
  { 
    const D *pD =dynamic_cast(&right); 
    如果（pD） 
    { 
      x＝pD-＞x； 
      y＝pD-＞y； 
    } 
    别的 
    { 
      x = 右.x; 
      y = 13;//默认值 
    } 

    返回*这个； 
  } 
  

我想对此解决方案添加一些评论。 将赋值运算符声明为与上面相同会带来三个问题。

编译器生成一个赋值运算符，它接受一个 const D& 参数，该参数不是虚拟的，并且不会执行您可能认为它会执行的操作。

第二个问题是返回类型，您将返回对派生实例的基引用。 可能问题不大，因为代码无论如何都能工作。 不过，最好还是相应地返回参考文献。

第三个问题，派生类型赋值运算符不会调用基类赋值运算符（如果您想要复制私有字段怎么办？），将赋值运算符声明为 virtual 不会使编译器为您生成赋值运算符。 这实际上是没有至少两次重载赋值运算符来获得所需结果的副作用。

考虑基类（与我引用的帖子中的相同）：

class B
{
public:
    virtual B& operator=(const B& right)
    {
        x = right.x;
        return *this;
    }

    int x;
};

以下代码完成了我引用的 RTTI 解决方案：

class D : public B{
public:
    // The virtual keyword is optional here because this
    // method has already been declared virtual in B class
    /* virtual */ const D& operator =(const B& b){
        // Copy fields for base class
        B::operator =(b);
        try{
            const D& d = dynamic_cast<const D&>(b);
            // Copy D fields
            y = d.y;
        }
        catch (std::bad_cast){
            // Set default values or do nothing
        }
        return *this;
    }

    // Overload the assignment operator
    // It is required to have the virtual keyword because
    // you are defining a new method. Even if other methods
    // with the same name are declared virtual it doesn't
    // make this one virtual.
    virtual const D& operator =(const D& d){
        // Copy fields from B
        B::operator =(d);
        // Copy D fields
        y = d.y;
        return *this;
    }

    int y;
};

这可能看起来是一个完整的解决方案，但事实并非如此。 这不是一个完整的解决方案，因为当您从 D 派生时，您将需要 1 个采用 const B& 的运算符 =、1 个采用 const D& 的运算符 = 和一个采用 const D& 的运算符采用const D2&。 结论很明显，operator =()重载的数量相当于超类的数量+1。

考虑到D2继承了D，我们来看看继承的两个operator =()方法是什么样的。

class D2 : public D{
    /* virtual */ const D2& operator =(const B& b){
        D::operator =(b); // Maybe it's a D instance referenced by a B reference.
        try{
            const D2& d2 = dynamic_cast<const D2&>(b);
            // Copy D2 stuff
        }
        catch (std::bad_cast){
            // Set defaults or do nothing
        }
        return *this;
    }

    /* virtual */ const D2& operator =(const D& d){
        D::operator =(d);
        try{
            const D2& d2 = dynamic_cast<const D2&>(d);
            // Copy D2 stuff
        }
        catch (std::bad_cast){
            // Set defaults or do nothing
        }
        return *this;
    }
};

很明显，operator =(const D2&) 只是复制字段，想象一下它就在那里。 我们可以注意到继承的运算符 =() 重载中的模式。 遗憾的是，我们无法定义虚拟模板方法来处理这种模式，我们需要多次复制和粘贴相同的代码才能获得完整的多态赋值运算符，这是我看到的唯一解决方案。 也适用于其他二元运算符。

---

编辑

正如评论中提到的，为了让生活更轻松，至少可以做的是定义最顶层的超类赋值运算符 =()，并从所有其他超类运算符 =() 方法调用它。 此外，在复制字段时，可以定义 _copy 方法。

class B{
public:
    // _copy() not required for base class
    virtual const B& operator =(const B& b){
        x = b.x;
        return *this;
    }

    int x;
};

// Copy method usage
class D1 : public B{
private:
    void _copy(const D1& d1){
        y = d1.y;
    }

public:
    /* virtual */ const D1& operator =(const B& b){
        B::operator =(b);
        try{
            _copy(dynamic_cast<const D1&>(b));
        }
        catch (std::bad_cast){
            // Set defaults or do nothing.
        }
        return *this;
    }

    virtual const D1& operator =(const D1& d1){
        B::operator =(d1);
        _copy(d1);
        return *this;
    }

    int y;
};

class D2 : public D1{
private:
    void _copy(const D2& d2){
        z = d2.z;
    }

public:
    // Top-most superclass operator = definition
    /* virtual */ const D2& operator =(const B& b){
        D1::operator =(b);
        try{
            _copy(dynamic_cast<const D2&>(b));
        }
        catch (std::bad_cast){
            // Set defaults or do nothing
        }
        return *this;
    }

    // Same body for other superclass arguments
    /* virtual */ const D2& operator =(const D1& d1){
        // Conversion to superclass reference
        // should not throw exception.
        // Call base operator() overload.
        return D2::operator =(dynamic_cast<const B&>(d1));
    }

    // The current class operator =()
    virtual const D2& operator =(const D2& d2){
        D1::operator =(d2);
        _copy(d2);
        return *this;
    }

    int z;
};

不需要设置默认值方法，因为它只会接收一次调用（在基本运算符 =() 重载中）。 复制字段时的更改在一处完成，并且所有运算符 =() 重载都会受到影响并实现其预期目的。

感谢 sehe 的建议。

Answer 4

虚拟分配用于以下场景：

//code snippet
Class Base;
Class Child :public Base;

Child obj1 , obj2;
Base *ptr1 , *ptr2;

ptr1= &obj1;
ptr2= &obj2 ;

//Virtual Function prototypes:
Base& operator=(const Base& obj);
Child& operator=(const Child& obj);

情况1：obj1 = obj2;

在这个虚拟概念中，我们在 Child 类上调用 operator= 时不起作用。

情况 2&3: *ptr1 = obj2;

          
   *ptr1 = *ptr2;

这里的分配不会如预期的那样。 原因是 operator= 是在 Base 类上调用的。

可以使用以下任一方法进行纠正：
1) 铸造

dynamic_cast<Child&>(*ptr1) = obj2;   // *(dynamic_cast<Child*>(ptr1))=obj2;`
dynamic_cast<Child&>(*ptr1) = dynamic_cast<Child&>(*ptr2)`

2) 虚拟概念

现在只需使用virtual Base&即可。 operator=(const Base& obj) 不会有帮助，因为 Child 和 Base 中 operator= 的签名不同。

我们需要添加Base& Child 类中的operator=(const Base& obj) 及其通常的Child& operator=(const Child& obj) 定义。 包含后面的定义很重要，因为在没有默认赋值运算符的情况下将被调用。（obj1=obj2 可能不会给出所需的结果）

Base& operator=(const Base& obj)
{
    return operator=(dynamic_cast<Child&>(const_cast<Base&>(obj)));
}

情况 4：obj1 = *ptr2;

在这种情况下，编译器在 Child 中查找 operator=(Base& obj) 定义作为 operator = 在 Child 上调用。 但由于它不存在，并且 Base 类型无法隐式提升为 child，因此会出现错误。（需要进行强制转换，如 obj1=dynamic_cast(*ptr1);)

如果我们按照case2&3实现，这种情况就会得到处理。

可以看出，在使用基类指针/引用进行赋值的情况下，虚拟赋值使调用更加优雅。

我们可以让其他运营商也虚拟化吗？ 是

Answer 5

仅当您想要保证从您的类派生的类正确复制其所有成员时才需要它。 如果您没有使用多态性做任何事情，那么您实际上不需要担心这一点。

我不知道有什么会阻止您虚拟化您想要的任何运算符——它们只不过是特殊情况的方法调用。

此页面提供了关于这一切如何进行的出色而详细的描述作品。