如何在赋值运算符中处理引用数据成员，并复制构造函数？

Question

I have following class

class TVData
{
  private:
  int ID;
  Monitor& monitor;
  string pName;

}

I need to implement the assignment operator , and a copy-constructor usable with this class.

• How do I handle reference members, in this case TVData::monitor , in such scenario?

Answer 1

You can't reassign a reference, so if you need it to change in the assignment operator then you should make it a pointer - assignment can then be done as usual with = , although it's still encouraged to use an initialiser list in the copy constructor...

TVData(const TVData& rhs)
  : ID(rhs.ID), p_monitor(rhs.p_monitor), pNmae(rhs.pName)
{ }

Answer 2

INTRODUCTION

To correctly assign a data member variabled declares as being a reference you will need to make use of a member initialization list in your constructor (both in your default- , and your copy-constructor ).

The problem with an overload assignment operator is that since a reference cannot be bound to a new entity after it has been initialized (and it must be initialized) you cannot change what this reference is referring to after you have created your TVData .

If you'd want to be able to change what the reference refers to consider using pointers instead of references.

---

SAMPLE IMPLEMENTATION

#include <iostream>

struct Obj {
  Obj (int& r)
    : ref (r)
  { }

  Obj (Obj const& src)
    : ref (src.ref) 
  { }

  Obj& operator= (Obj const& src) {
    // we cannot reassign what `ref` is refering to,
    // but we can at least assign the value of `src.ref`
    // to `this->ref`

    ref = src.ref; // note: does not make `ref` refer to `src.ref`
  }

  int& ref;
};

int
main (int argc, char *argv[])
{
  int some_val = 0, some_other_val = 100;

  Obj a (some_val);
  Obj b (a); // copy `a`
  Obj c (some_other_val);

  b = c;

  b.ref += 23;

  std::cout << "some_val: " << some_val << std::endl;
}

some_val: 123

Answer 3

引用不可复制或不可移动，您必须回退到指针或reference_wrapper

Answer 4

First of all, using (non-const) references as class members is fairly dangerous because in that case you have to guarantee somehow that the referenced object will outlive the class's instance referencing it.

Secondly, you can implement the copy constructor for such a class but you can't make assignment because C++ references are not rebindable.

In order to manage this, you might prefer using shared_ptr/unique_ptr depending on the assignment semantics of your class (whether it should share the owned Monitor or pass the ownership). If you're not owning it, then weak_ptr (std:: or boost::) is your best bet.