为 =overloading 使用 Copy 构造函数

Question

我有一个包含两个向量的类：int 和 Str。现在我想定义一个复制构造函数，以便颠倒元素的顺序；例如如果a=(1,Hello),(2,World) 和我写auto b=a; 我得到b=(2,world),(1,hello)。这是完美的工作。我遇到的问题是重载 = 运算符，以便使用复制构造函数。这是我的类加上复制构造函数：

class grade
{
  private:
    static int copies;
    std::vector<int> i;
    std::vector<std::string> s;

  public:
    grade() {copies++;};
    grade (int , std::string );
    void printval();
    void adder(int , std::string );
    int getcount();

    grade(grade & obj)
    {
        std::vector<std::string>::reverse_iterator strIt = obj.s.rbegin();
        for (std::vector<int>::reverse_iterator numIt=obj.i.rbegin();
             numIt!=obj.i.rend(); ++numIt)
        {
            this->adder(*numIt, *strIt);
            strIt++;
        }

    }
    grade operator =(grade );
};

当我重载= 运算符时，会调用构造函数，但问题是没有将 valur 传递给 LHS 变量。这是重载的=。

grade grade::operator=(grade cpy)
{
    grade newer = cpy; //Calls the copy constructor as expected
    return cpy;        //No error but blank value is returned to the LHS variable.
}

我的主要功能是：

int main()
{
    grade c2(1,"Hello");
    grade c1;

    c2.adder(4,"World");
    c2.printval();
    std::cout<<std::endl;
    grade c3 = c2;
    c3.printval();
    std::cout<<std::endl;
    c1 = c2;
    std::cout<<std::endl;
    c1.printval();

    return 0;
}

为什么c1 保持空白？？

Answer 1

实现赋值运算符最简单的方法是copy and swap idiom：

grade& operator=( grade other )
{
   swap( *this , other );
   return *this;
}

其中 swap 是一个函数，它接受两个 grades 并交换其值：

void swap( grade& lhs , grade& rhs )
{
    using std::swap;

    swap( lhs.first_member  , rhs.first_member  );
    swap( lhs.second_member , rhs.second_member );
    swap( lhs.third_member  , rhs.third_member  );
    ...
}

注意swap() 是std::swap() 的重载/特化。 std::swap() 默认使用赋值运算符来执行交换，因此如果使用它会导致无限递归。你需要做的是编写你自己的交换重载来执行成员之间的交换（如上例所示）。

请注意，您应该使用不合格的swap() 来不禁用ADL，并让编译器找到成员的自定义swap() 重载（如果他们提供）或标准库版本。

Answer 2

你问：Why does c1 remain blank??

答案是赋值运算符不修改对象本身。这是你的代码：

grade grade::operator=(grade cpy)
{
  grade newer=cpy; //Calls the copy constructor as expected
  return cpy; //No error but blank value is returned to the LHS variable.
}

方法返回输入参数cpy的副本，但不修改当前实例。当这个方法执行时，*this是“LHS 变量”，它根本没有被修改。在这个方法内（操作符重载，需要实际修改当前实例的成员变量！

Answer 3

你想要的是复制和交换习语：

#include <algorithm>
grade &grade::operator=( grade cpy ) {
    using std::swap;
    swap( i, cpy.i );
    swap( s, cpy.s );
    return *this;
}

Answer 4

如下更改复制构造函数和赋值运算符：

grade::grade(const grade& cpy)
{
    *this = cpy;
}

grade& grade::operator=(const grade& cpy)
{
    if (this == &cpy)
        return *this;

    std::vector<std::string>::reverse_iterator strIt = cpy.s.rbegin();
    for (std::vector<int>::reverse_iterator numIt=cpy.i.rbegin();numIt!=cpy.i.rend();++numIt)
    {
        this->adder(*numIt, *strIt);
        strIt++;
    }

    return *this;
}

作为一般方案：

object::object(const object& input)
{
    *this = input;
}

object& object::operator=(const object& input)
{
    if (this == &input)
        return *this;

    Deallocate();
    Allocate(input);
    Initialize(input);

    return *this;
}