C++ 中的“深拷贝”构造函数

Question

我想构建一个复制构造函数Pair(const Pair& other)。它的参数是对另一个Pair 的只读引用。它应该将新构建的Pair 设置为“深拷贝”。但是我不知道如何在这些新位置设置整数，应该根据另一个Pair指向的整数来分配值。

class Pair {
public:
  int *pa,*pb;
  Pair(int a, int b);
  Pair(const Pair & other);
  ~Pair();
};

Pair::Pair(int a, int b){
  pa = new int;
  pb = new int;
  *pa = a;
  *pb = b;
}

Pair::Pair(const Pair & other){
  pa = new int;
  pb = new int;
  *pa = *(other.pa);
  *pb = *(other.pb);
}

Pair::~Pair(){
  delete pa；
  delete pb；
}

int main() {
  Pair p(15,16);
  Pair q(p);
  Pair *hp = new Pair(23,42);
  delete hp;

  std::cout << "If this message is printed,"
    << " at least the program hasn't crashed yet!\n"
    << "But you may want to print other diagnostic messages too." << std::endl;
  return 0;
}

Answer 1

您的第一个构造函数可能如下所示：

Pair::Pair(int a, int b)
    : pa(new int(a))
    , pb(new int(b))
{
}

而且你不需要通过转发到第一个构造函数来多次编写复杂的代码。

Pair::Pair(const Pair & other) 
    : Pair(*other.pa, *other.pb) 
{
}

另一件事是您还必须实现赋值运算符。否则，如果您不小心进行了赋值，您的代码将非常容易出错（因为假设您的析构函数已正确实现，您将有一个双重 delete。

话虽如此，你的析构函数应该是：

Pair::~Pair()
{
    delete pa;
    delete pb;
}

正如其他人所说，直接将int 用于成员会更简单，因为您不必自己定义副本和分配。

// Inside class declaration
Pair &operator=(const Pair &other);

// With other definitions.
Pair &Pair::operator=(const Pair &other)
{
    *pa = *other.pa;
    *pb = *other.pb;
    return *this;
}

如果你真的需要指针，那么我建议你改用std::unique_ptr。

在您的班级中，声明变为std::unique_ptr<int> pa; 和pb 类似。那时你的析构函数变成空的。其余代码可以保持不变。

此外，最好避免创建变量成员public，在动态分配内存的情况下甚至更多。

Answer 2

您的 converting 构造函数没有将值分配给它分配的ints，也没有将这些指针分配给类成员。

您的 copy 构造函数同样没有将分配的指针分配给类成员。在访问other 的成员时，它也没有正确使用* 运算符。

你的析构函数需要delete构造函数分配的类成员。

您需要添加一个复制赋值运算符来正确完成Rule of 3。

试试这个：

class Pair {
public:
  int *pa,*pb;
  Pair(int a, int b);
  Pair(const Pair & other);
  ~Pair();
  Pair& operator=(const Pair & other);
};

Pair::Pair(int a, int b){
  pa = new int;
  pb = new int;
  *pa = a;
  *pb = b;

  /* alternatively:
  pa = new int(a);
  pb = new int(b);
  */
}

Pair::Pair(const Pair & other){
  pa = new int;
  pb = new int;
  *pa = *(other.pa);
  *pb = *(other.pb);

  /* alternatively:
  pa = new int(*(other.pa));
  pb = new int(*(other.pb));
  */
}

Pair::~Pair(){
  delete pa;
  delete pb;
}

Pair& Pair::operator=(const Pair & other){
  *pa = *(other.pa);
  *pb = *(other.pb);
  return *this;
}

int main() {
  Pair p(15,16);
  Pair q(p);
  Pair *hp = new Pair(23,42);
  p = *hp;
  delete hp;

  std::cout << "If this message is printed,"
    << " at least the program hasn't crashed yet!\n"
    << "But you may want to print other diagnostic messages too." << std::endl;
  return 0;
}

Answer 3

您可以使用自定义构造函数，复制构造函数如下：

 class Pair {
 public:
   int *pa,*pb;
   Pair(int, int);
   Pair(const Pair &);
  ~Pair();
 };

 /*
 * Implement its member functions below.
 */
 Pair::Pair(int a, int b){
  pa = new int;
  pb = new int;
  *pa = a;
  *pb = b;
}

Pair::Pair(const Pair & other){
  pa = new int;
  pb = new int;
  *pa = *(other.pa);
  *pb = *(other.pb);
}

Pair::~Pair(){
  delete pa;
  delete pb;
}

 /* Here is a main() function you can use
  * to check your implementation of the
  * class Pair member functions.
  */

int main() {
  Pair p(15,16);
  Pair q(p);
  Pair *hp = new Pair(23,42);
  delete hp;

  std::cout << "If this message is printed,"
    << " at least the program hasn't crashed yet!\n"
    << "But you may want to print other diagnostic messages too." << std::endl;
  return 0;
}

Answer 4

你的初始化构造函数和拷贝构造函数可能有一些错误。

初始化构造函数应该是：

Pair::Pair(int a, int b){
  pa = new int;
  pb = new int;
  *pa = a;
  *pb = b;
}

而拷贝构造函数应该是：

Pair::Pair(const Pair & other){
  pa = new int;
  pb = new int;
  *pa = *(other.pa);
  *pb = *(other.pb);
}