0

我有一个有两个向量的类： anint和 an 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一直空白？？

4

4 回答 4

3

实现赋值运算符的最简单方法是复制和交换习语：

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()默认情况下使用赋值运算符来执行交换，所以如果你使用它，你会导致无限递归。你需要做的是编写你自己的交换重载来执行成员间的交换（如上面的例子）。

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

于 2014-02-06T21:38:26.803 回答
1

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

#include <algorithm>
grade &grade::operator=( grade cpy ) {
    using std::swap;
    swap( i, cpy.i );
    swap( s, cpy.s );
    return *this;
}
于 2014-02-06T21:38:20.363 回答
1

您问：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 变量”，根本没有被修改。在这个方法内（操作符重载，需要实际修改当前实例的成员变量！

于 2014-02-06T21:52:06.730 回答
0

更改您的复制构造函数和赋值运算符，如下所示：

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;
}
于 2014-02-06T21:43:56.410 回答