关于C++中的复制（拷贝）构造函数

[xingyuanxingchen]

谁能用例子告诉我什么叫“ 浅复制 和 深复制 ”

[Jalien]

程序实例如下:

#include <iostream> 
using namespace std; 

class Cat 
{ 
public: 
  Cat(); 
  Cat(const Cat &); 
  ~Cat(); 
  int GetAge() const { return *itsAge; } 
  int GetWeight() const { return *itsWeight; } 
  void SetAge(int age) { *itsAge=age; } 

private: 
  int *itsAge;    //实际编程并不会这样做， 
  int *itsWeight; //我仅仅为了示范 
}; 

Cat::Cat() 
{/*构造函数,在堆中分配内存*/ 
  itsAge=new int; 
  itsWeight=new int; 
  *itsAge=5; 
  *itsWeight=9; 
} 

Cat::Cat(const Cat & rhs) 
{/*copy constructor，实现深层复制*/ 
  itsAge=new int; 
  itsWeight=new int; 
  *itsAge=rhs.GetAge(); 
  *itsWeight=rhs.GetWeight(); 
} 

Cat::~Cat() 
{ 
  delete itsAge; 
  itsAge=0; 
  delete itsWeight; 
  itsWeight=0; 
} 

int main() 
{ 
  Cat Frisky; 
  cout << "Frisky's age: "<<Frisky.GetAge()<<endl; 
  cout << "Setting Frisky to 6...\n"; 
  Frisky.SetAge(6); 
  cout << "Create Boots from Frisky\n"; 
  Cat Boots=Frisky; //or Cat Boots(Frisky); 
  cout << "Frisky's age: " <<Frisky.GetAge()<<endl; 
  cout << "Boots' age : "<<Boots.GetAge()<<endl; 
  cout << "Set Frisky to 7...\n"; 
  Frisky.SetAge(7); 
  cout << "Frisky's age: "<<Frisky.GetAge()<<endl; 
  cout << "Boots' age: "<<Boots.GetAge()<<endl; 

  return 0; 
} 


//输出: 
//Frisky's age: 5 
//Setting Frisky to 6... 
//Create Boots from Frisky 
//Frisky's age: 6 
//Boots' age : 6 
//Set Frisky to 7... 
//Frisky's age: 7 
//Boots' age: 6 

文章出处：http://www.diybl.com/course/3_program/c++/cppjs/2008915/142884.html

[wuyu637]

class test
{
char* buffer;
}


test t1;
t1.buffer = new char[100];
test t2 = t1;


这个时候你会发现t2中的buffer和t1中的buffer实际上指向的是一个内存地址。

这样会引起很多问题，如果释放的时候，多次释放，再比如，t2改动了buffer，就会影响到t1.


正确的做法是深拷贝，写一个复制构造函数
class test
{
char* buffer;
test& operator= (test& input)
{
int nlenth = strlen(input.buffer);
buffer = new char[nlength];
strcpy(input.buffer, buffer);
return *this;

}
}

[crst_zh]

例如
class A{
public:
A(){}
~A(){};
A(A& other);//拷贝构造函数
private:
char *p;
}

A里面有指针型变量，如果
A a1;
A a2(a1);
那么a1,a2是不同的对象，
但是默认的复制构造函数仅仅是浅拷贝，会把char *p复制一份.
这样a1,a2的p指向了相同的一块内存区域

如果你不提供copy构造函数(注释掉的那个), 那么a1和a2的成员 p 指向同一个对象,
当析构的时候, 同一个对象被析构了两次, 肯定出问题了.

反之, 提供了被注释的copy构造函数, t2的_val指向了一个新对象, 这样程序就没问题了.

前者就是潜拷贝, 后者就是深拷贝.

[crushor]

看一看就知道鸟

class A
{
public:
    A():p(NULL){};
    ~A(){};
    int* p;
};

int main(int argc,char* argv[])
{
    A a;
    a.p = new int(5);
    A b ;
    b = a;
    cout<<a.p<<":"<<*(a.p)<<endl;
    cout<<b.p<<":"<<*(b.p)<<endl;
    return 0;
}

[pathuang68]

请参考：
Shallow Copy，Deep Copy，Bitwise Copy和Memberwise Copy

[febbird1984]

在类（结构）中如果有指针成员，那么自己写一个复制构造函数，参数用该类型的常量引用

[liulang19880612]

当你设计的类中 带有指针的时候就需要自己编写 拷贝构造函数.. 这就叫深拷贝???