利用复制构造函数进行=过载

Utilizing Copy constructor for =overloading

本文关键字：过载 构造函数 复制      更新时间：2023-10-16

我有一个带有两个向量的类： 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保持空白??

实现评估操作员的最简单方法是副本和交换成语：

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

其中交换是一个函数，该函数需要两个grade s并交换其值：

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()使用Assigment操作员默认执行交换，因此，如果使用它，则导致无限递归。您要做的是编写自己的掉期超载，该超载通过成员交换来执行成员（如上所述）。

请注意，您应该使用不合格的swap()来不禁用ADL，然后让编译器查找成员的自定义swap() Overload（如果提供一个）或标准库版本。

您问：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变量"，并且根本没有被修改。在此方法中（操作员超载，您需要实际修改当前实例的成员变量！

您想要的是复制和swap成语：

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

更改复制构造函数和分配操作员如下： 

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;
}
相关文章：