目录
浅拷贝
深拷贝
字符串的构造
例有两个类的深拷贝：
浅拷贝
在类中，若我们不写拷贝构造函数，则程序会提供一个默认的拷贝构造函数，该函数为浅拷贝。
//默认拷贝构造 ---浅拷贝--值复制
类名(const 类名& 形参名) {成员1= 形参名.成员1; }
class A
{
public:
A(int i = 0, int j = 0) :m_i(i), m_j(j) {}//构造函数
void print() { cout << m_i << "," << m_j << endl; }
private:
int m_i;
int m_j;
};
void main()
{
A a(4, 7);
A b(a);//使用默认拷贝构造函数
a.print();//4，7
b.print();//4，7
}
浅拷贝将一个对象的所有信息直接拷贝到另一个对象中，如果是值则拷贝值；如果是引用、指针则拷贝其内存地址，这时，两个对象的该成员共用一个地址。
由于对象最后都需要析构，若浅拷贝的对象中有指针，该地址在析构的时候将会进行两次（拷贝和被拷贝的对象每个一次），导致程序出错。
class A
{
public:
A(int i = 0)
{
//m_i = new int(i);
m_i = new int;
*m_i = i;
}
~A()
{
if (m_i != NULL)
{
delete m_i;
m_i = NULL;
}
}
A(const A& a) //默认拷贝构造 ---浅拷贝--值复制
{
m_i = a.m_i; //两个对象的指针指向同一块内存单元
}
void print()
{
cout << *m_i << endl;
}
private:
int* m_i;
};
void main()
{
A a(10);
a.print();
A b(a); //调用默认拷贝构造，会导致b对象中的m_i和a对象中的m_i指向同一块内存空间
b.print();
//在即将退出时，调用析构会出问题，析构了两次
}
深拷贝
如果有指针作为数据成员，则必须要写析构函数和拷贝构造函数，拷贝资源。
深拷贝中如果对象有申请动态内存，则深拷贝中也会新申请一个（属性拷贝），析构函数中释放空间。
class A
{
public:
A(int i = 0)
{
m_i = new int;
*m_i = i;
}
A(const A& a) //深拷贝
{
m_i = new int;//开新空间
*m_i = *(a.m_i);
}
~A()
{
delete m_i;
m_i = NULL;
}
void print() { cout << *m_i << endl; }
private:
int* m_i;
};
void main()
{
A a(20);
A b(a);
a.print();//20
b.print();//20
}字符串的构造
strcpy拷贝所有字符串
strncpy拷贝n个字符串
memcpy void*memcpy(void*dest,void*src,count)都可以拷贝
class STR
{
public:
STR(const char* str)
{
m_str = new char[strlen(str) + 1];
strcpy_s(m_str, strlen(str) + 1, str);
}
STR()//什么都不传入，拿一个\0占位
{
m_str = new char[1];
m_str[0] = '\0';
}
STR(int n, char c)
{
m_str = new char[n + 1];
memset(m_str, c, n);//strcpy只能拷贝字符串，memset什么都可以拷贝
m_str[n] = '\0';
}
STR(const STR& s)//深拷贝
{
m_str = new char[strlen(s.m_str) + 1];
strcpy_s(m_str, strlen(s.m_str) + 1, s.m_str);
}
~STR()//析构
{
if (m_str != NULL)
{
delete[]m_str;
m_str = NULL;
}
}
void print()
{
cout << m_str << endl;
}
private:
char* m_str;
};
void main()
{
STR s1("12345");
STR s2;
STR s3(4, 'k');
STR s4(s1);
s1.print();
s2.print();
s3.print();
s4.print();
}如果成员是指针可以new大小（上方代码），但数组不能，只能依靠数组定大小截断（如下）
就是说指针需要先申请空间（申请需要放入的大小）再往里面放东西，而数组因为本身有大小所以直接放入数组能存的大小的内容。
class STR
{
public:
STR(const char* str)
{
int n = sizeof(m_str);
memcpy(m_str, str, n - 1);
m_str[n - 1] = '\0';
}
void print()
{
cout << m_str << endl;
}
private:
char m_str[20];
};
void main()
{
STR a("asdf");
STR b("asdfasdfasdfasddfasdfasdfadfgsdfgsdfgsdfg");
a.print();
b.print();
}例有两个类的深拷贝：
class Date
{
private:
int m_year;
int m_month;
int m_day;
public:
Date(int y, int m, int d) :m_year(y), m_month(y), m_day(d) {}
void show()
{
cout << m_year << " /" << m_month << "/" << m_day << endl;
}
Date(const Date& d) :m_year(d.m_year), m_month(d.m_month), m_day(d.m_day)
{
cout << "Data(&)" << endl;
}
};
class Student
{
private:
int m_num;
char* m_name;
char m_sex;
Date m_birthday;
public:
Student(int num, const char* name, char sex, int y, int m, int d) :m_num(num), m_sex(sex), m_birthday(y, m, d)//没有默认值必须显示的调用构造函数
{
m_name = new char[strlen(name) + 1];
strcpy_s(m_name, strlen(name) + 1, name);
}
void print()
{
cout << m_num << " " << m_name << " " << m_sex;
m_birthday.show();
}
~Student()
{
if (m_name != NULL)
{
delete[]m_name;
m_name = NULL;
}
}
Student(const Student& s) :m_num(s.m_num), m_sex(s.m_sex), m_birthday(s.m_birthday) //调用Date类的拷贝构造
{
m_name = new char[strlen(s.m_name) + 1];
strcpy_s(m_name, strlen(s.m_name) + 1, s.m_name);
}
};
void main()
{
Student s1(1001, "wangpangpang", 'm', 2000, 12, 24);
Student s2(s1);
s2.print();
s1.print();
}
