day06_类的声明周期.md

构造函数

构造函数(也叫构造器)，在对象创建的时候自动调用，一般用于完成对象的初始化工作

• 特点

  • 函数名与类同名，无返回值(void都不能写)，可以有参数，可以重载，可以有多个构造函数
  • 一旦自定义了构造函数，必须用其中一个自定义的构造函数来初始化对象

• 注意 : 通过malloc分配的对象不会调用构造函数

• 在某些特定的情况下，编译器才会为类生成空的无参的构造函数

  • 成员变量在声明的同时进行了初始化
  • 有定义虚函数
  • 虚继承了其他类
  • 包含了对象类型的成员，且这个成员有构造函数(编译器生成或自定义)
  • 父类有构造函数(编译器生成或自定义)

  总结:

  **对象创建后，需要做一些额外操作时(比如内存操作、函数调用)，编译器一般都会为其自动生成无参的构造函数 **

struct Person {
	int m_age;

	Person() {
		cout << "Person()" << endl;
		// this->m_age = 0;
		memset(this, 0, sizeof(Person));
	}

	Person(int age) {
		cout << "Person(int age)" << endl;
		this->m_age = age;
	}
};

// 全局区
Person g_person1; // Person()
Person g_person2(); // 这是一个函数声明，函数名叫g_person2，无参，返回值类型是Person
Person g_person3(10); // Person(int age)

int main() {
	// 栈空间
	Person person1; // Person()
	Person person2(); // 函数声明，函数名叫person2，无参，返回值类型是Person
	Person person3(20);  // Person(int age)

	// 堆空间
	Person *p1 = new Person; // Person()
	Person *p2 = new Person(); // Person()
	Person *p3 = new Person(30);  // Person(int age)

	// 4次无参构造函数
	// 3次有参构造函数

	getchar();
	return 0;
}


/*
编译器会为每个类生成一个默认的无参的构造函数
*/

class Person {
public:
	int m_age = 0;
};

class Student : public Person {

};

int main() {
	Student student;

	getchar();
	return 0;
}

默认情况下，成员变量的初始化

如果自定义了构造函数，除了全局区，其他内存空间的成员变量默认都不会被初始化，需要开发人员手动初始化

struct Person {
	int m_age;

	/*Person() {
		cout << "Person()" << endl;
		this->m_age = 0;
	}*/
};

void test() {
	//int *p = new int();
	//memset(p, 1, 4);
	//// 0000 0001 0000 0001 0000 0001 0000 0001 
	//cout << *p << endl;

	//int *p = (int *) malloc(8);
	//free(p);

	/*int *p = (int *) malloc(2); 
	*p = 5;*/

	// 0000 0000 0000 0000 0000 0000 0000 0101
}

// 全局区（成员变量初始化为0）
Person g_person;

int main() {
	// 栈空间（成员变量没有初始化）
	Person person;

	// 堆空间
	Person *p1 = new Person; // 成员变量没有初始化
	Person *p2 = new Person(); // 成员变量有初始化

	cout << "g_person " << g_person.m_age << endl;
	cout << "p1 " << p1->m_age << endl;
	cout << "p2 " << p2->m_age << endl;

	getchar();
	return 0;
}

析构函数

析构函数(也叫析构器)，在对象销毁的时候自动调用，一般用于完成对象的清理工作

• 特点
  • 函数名以~开头，与类同名，无返回值(void都不能写)，无参，不可以重载，有且只有一个析构函数

注意:通过malloc分配的对象free的时候不会调用构造函数

class Person {
	int m_age;
public:
	// 对象创建完毕的时候调用
	Person() {
		cout << "Person()" << endl;
		this->m_age = 0;
	}

	Person(int age) {
		cout << "Person(int age)" << endl;
		this->m_age = age;
	}

	// 对象销毁(内存被回收)的时候调用
	~Person() {
		cout << "~Person()" << endl;
	}
};

//void test() {
//	Person person;
//}

int main() {
	Person person;

	/*{
		Person person;
	}*/

	/*Person *p = new Person();

	delete p;*/

	/*Person *p = (Person *) malloc(sizeof(Person));

	free(p);*/

	getchar();
	return 0;
}

对象的内存管理

对象内部申请的堆空间，由对象内部回收

多注意setter和析构的内存管理

struct Car {
	int m_price;
	Car() {
		cout << "Car()" << endl;
	}

	~Car() {
		cout << "~Car()" << endl;
	}
};

struct Person {
	int m_age; // 4
	Car *m_car; // 4

	// 初始化工作
	Person() {
		cout << "Person()" << endl;

		 this->m_car = new Car();

		/*Car car;
		this->m_car = &car;*/
	}

	// 内存回收、清理工作(回收Person对象内部申请的堆空间)
	~Person() {
		cout << "~Person()" << endl;

		delete this->m_car;
	}
};

void test() {
	Person *p = new Person();

	delete p;
}