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

您的转换构造函数没有为其分配的int分配值，也没有将这些指针分配给 class 成员。

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

您的析构函数需要delete构造函数分配的 class 成员。

并且您需要添加一个复制赋值运算符才能正确完成规则 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 2

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

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 。

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

此外，最好避免将变量成员public ，甚至在动态分配 memory 的情况下避免公开变量成员。

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

您的 init 构造函数和复制构造函数可能有一些错误。

init 构造函数应该是：

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);
}