构造函数
构造函数是指创建对象的时候，会调用的函数。
C++构造函数可以重载，指针或者对象均可调用构造函数。
class Person
{
public:
int m_age;
Person() {
this->m_age = 10;
}
Person(int age) {
this->m_age = age;
}
};
Person* p0 = new Person(20);
Person p1;
cout << p0->m_age << endl; //输出20
cout << p1.m_age << endl; //输出10
析构函数
析构函数是指对象即将销毁的时候，会调用的函数，析构函数无参，不可重载，只有一个。
class Person {
public:
~Person() {}
};
构造与析构的顺序
构造从父类到子类进行构造，
析构从子类到父类进行析构。
如下打印顺序为：
Person() -> Student() -> ~Student() -> ~Person()
class Person
{
public:
Person() { cout << "Person()" << endl; }
~Person() { cout << "~Person()" << endl; }
};
class Student: Person
{
public:
Student() { cout << "Student()" << endl; }
~Student() { cout << "~Student()" << endl; }
};
初始化列表
初始化列表是一种便捷初始化成员变量的方式，而且只能在构造函数中使用，初始化的顺序只和声明顺序有关。
class Person
{
int m_age;
int m_heighht;
Person(int m_age, int m_height) {
this->m_age = m_age;
this->m_heighht = m_heighht;
}
};
//初始化列表
class Person
{
int m_age;
int m_heighht;
Person(int age, int height): m_age(age), m_heighht(height) {}
};
初始化列表-构造函数调用构造函数
//调用自身构造
class Person
{
public:
int m_age;
int m_height;
Person(int age, int height): m_age(age), m_height(height) {}
Person() : Person(18, 180) {}
};
//调用父类构造
class Student: Person
{
int m_no;
Student(int age, int height, int no) : Person(age, height), m_no(no) {}
};
拷贝构造函数
- 拷贝构造函数是构造函数中的一种。
- 拷贝构造函数是指在用已存在的对象创建新对象的时候，调用的构造函数方法。比如在new 类(对象)，或者=赋值时会调用。
- 拷贝构造函数写法都是固定的，const XX &x。
class Car
{
public:
int m_price;
Car(int price) : m_price(price) {}
Car(const Car& car) {
this->m_price = car.m_price;
}
};
Car a(100);
Car b = a;
Car c(a);
深拷贝和浅拷贝
浅拷贝（编译器默认为浅拷贝）
- 浅拷贝是将一个对象成员变量的所有值拷贝到另一个对象
- 即便成员变量是指针，也会原封不动的拷贝过去，这样就有可能导致内存多次释放的问题。
深拷贝（用户手动控制的）
深拷贝是对象中指针类的成员变量，在构造函数或者拷贝构造函数中，单独申请内存来存放数据，该内存的生命周期由对象来控制，如以下例子即是深拷贝用法：
class Car
{
void copyName(const char* name) {
if (name == nullptr) return;
this->m_name = new char[strlen(name) + 1]{};
strcpy(this->m_name, name);
}
public:
int m_price;
char* m_name;
Car(int price, const char* name) : m_price(price) {
copyName(name);
}
Car(const Car& car) {
this->m_price = car.m_price;
copyName(car.m_name);
}
~Car() {
if (this->m_name != nullptr) {
delete[] this->m_name;
this->m_name = nullptr;
}
}
};
Car* c1 = new Car(10000, "Toyota");
Car* c2 = new Car(15000, "BMW");
Car c3 = *c2;
Car* c4 = new Car(*c1);
delete c1, c2, c4;
隐式调用拷贝构造函数
- 函数参数中使用对象型参数，会调用隐式拷贝，增加内存开销，尽量采用引用&来传递，而不要直接使用对象，如下所示，则在传参过程中，调用了拷贝构造。
class Car
{
public:
int m_price;
Car() : m_price(0) {}
Car(int price) : m_price(price) {}
Car(const Car& car) : m_price(car.m_price) {}
};
//调用该函数的时候，会触发传参 Car car = 传入的car
//因此会调用拷贝构造函数，造成额外的开销
void test1(Car car) {
}
- 作为函数的返回值的时候。
Car test2() {
Car car(20);
return car;
}
//会调用两次构造函数，
//第一次是Car(int price)
//第二次是Car(const Car& car) : m_price(car.m_price)
Car car2 = test2();
