c++ 重载运算符、赋值、深复制和加法

Question

我目前正在对运算符重载进行一些探索，同时重新阅读一些旧的大学教科书，我认为我误解了一些东西，所以希望这对于一些回答者来说是一些很好的简单声誉。 如果这是重复的，请指出我正确的方向。

我创建了一个简单的计数器类，它（在这个阶段）有一个成员 val （一个 int）。

我已经初始化了其中的三个计数器，varOne 到 varThree，并希望第三个计数器是前两个计数器的总和（例如，在下面的代码中 varThree.val 设置为 5）

counter::counter(int initialVal)
{
    val = initialVal;
    //pVal = new int;
    //*pVal = 10; // an arbitrary number for now
}

int main (int argc, char const* argv[])
{
    counter varOne(3), varTwo(2), varThree;
    varThree = varOne + varTwo;

    return 0;
}

重载了operator+，如下所示：

counter operator+(counter& lhs, counter& rhs)
{
    counter temp(lhs.val + rhs.val);
    return temp;
}

我已经 使其成为非成员函数和计数器类的友元，以便它可以访问私有值。

当添加另一个私有成员 pVal （指向 int 的指针）时，我的问题就开始了。 添加这意味着我不能再执行简单的 varThree = varOne 复制，因为当 varOne 被销毁时，varThree.pVal 仍将指向同一位内存。

我已重载 operator= 如下。

int counter::getN()
{
    return *newVal;
}

counter& counter::operator=(counter &rhs)
{
    if (this == &rhs) return *this;
    val = rhs.val;
    delete pVal;
    pVal = new int;
    *pVal = rhs.getN();
    return *this;
}

现在，如果我执行类似 varThree = varOne 的操作，所有内容都会正确复制，但是尝试执行 varThree = varOne + varTwo 会出现以下错误：

counter.cpp: In function ‘int main(int, const char**)’:
counter.cpp:96: error: no match for ‘operator=’ in ‘varThree = operator+(counter&, counter&)(((counter&)(& varTwo)))’
counter.cpp:55: note: candidates are: counter& counter::operator=(counter&)
make: *** [counter] Error 1

看起来好像 counter ::operator= 无法处理 operator+ 的返回输出，并且我需要进一步重载 operator= 以接受 Operator+ 正在返回，但我运气不佳，我开始认为也许我做了一些根本性错误的事情。

Answer 1

您需要将参数作为 const 引用传递。 例如：

counter& counter::operator=( const counter &rhs )

运算符+() 也类似。 为了能够将临时值绑定到函数参数，这是必要的。 当您按值返回时，会创建临时值，因此当您说：

varOne + varTwo

创建一个无名临时值时。 这是正确的做法，但您必须确保诸如赋值操作之类的函数可以通过将其参数设置为 const 来接受此类值。

您还需要为您的类实现复制构造函数和析构函数，尽管缺少这些不会导致编译错误（不幸的是）。

Answer 2

这里的关键（正如之前的海报所提到的）但值得强调的是，C++ 中的表达式可以分为右值或左值。

这些类别背后有很多细节，但是指导您的直觉的一个有用的启发式是：如果您可以获取表达式（例如变量）的地址，那么它就是一个左值（这里的故事还有更多内容，但这是一个好的起点）。

如果它确实不是左值，那么它就是右值 - 右值的一个有用启发是它们代表编译器实例化以使代码正常工作的“隐藏”临时对象。 这些对象是由编译器在幕后创建和销毁的。

为什么这与此相关？

好吧，在 C++98/03 中（我猜你正在使用它），请记住以下两条规则：

1）只有左值表达式可以绑定到非常量引用（忽略强制转换）
2) 右值表达式只能绑定到 const 引用（忽略强制转换）

这里有一个示例会有所帮助：

// Consider the function foo below - it returns an int - 
// whenever this function is called, the compiler has
// to behave as if a temporary int object with the value 5 is returned.
// The use of 'foo()' is an expression that is an rvalue - try typing &foo() -
// [Note: if foo was declared as int& foo(), the story gets complicated, so
//   i'll leave that for another post if someone asks]

int foo() { return 5; }

void bind_r(int& r) { return; }
void bind_cr(const int& cr) { return; }

int main()
{
   int i = 10;  // ok
   int& ri = i; // ok binding lvalue to non-const reference, see rule #1
   int& ri2 = foo(); // Not ok, binding a temporary (rvalue) to a non-const reference 
        // The temporary int is created & destroyed by compiler here

   const int& cri = foo(); // ok - see rule #2, temporary int is NOT destroyed here

  //Similarly
   bind_r(i); // ok - rule #1
   bind_r(foo()); // NOT ok - rule #2
   bind_cr(foo()); // ok - rule #2


  // Since the rules above keep you out of trouble, but do not exhaust all possibilities
  // know that the following is well-formed too:
  const int& cri2 = i;
  bind_cr(i);
  bind_cr(cri);
  bind_cr(cri2); 

}

当您将右值绑定到 const 引用时，您基本上将临时对象的生命周期延长到生命周期（在本例中为作用域）引用的引用（编译器不能只是在该表达式的末尾销毁它） - 因此您最终会得到对有效对象的引用。

我希望这有助于理解为什么您必须将赋值运算符声明为接受 const 引用而不仅仅是非 const 引用，正如其他海报正确推荐的那样。

ps 您的代码还有一些其他问题（例如为什么您要销毁和创建对象在每次赋值时专门指向的内存，以及缺少复制构造函数和析构函数），并且如果没有人通过当这篇文章出现时，我会:)

ps 可能还值得知道的是，C++0x 添加了称为右值引用（非常量）的东西，它优先绑定到右值并为程序员提供极其强大的优化机会（无需依赖编译器的优化能力） - 它们还有助于解决在 C++ 中创建完美转发函数的问题 - 但现在我们离题了；）

Answer 3

解决此问题的另一种方法是使用 PImpl 模式并交换赋值运算符。 假设您仍然有一个 counter(int) 构造函数，您可以如下编写 operator= 这样做的

counter& counter::operator=(const counter& rhs) {
  counter temp(rhs.getN());
  std::swap(&pVal,rhs.pVal);
  return *this;
}

好处是，可以将混乱的内存管理函数保留在构造函数和析构函数中应在的位置。