C++-面向对象(二)

memset

memset函数是将较大的数据结构（比如对象、数组等）内存清零的比较快的方法

对象的内存

• 对象的内存可以存在于3种地方
  • 全局区（数据段）：全局变量
  • 栈空间：函数里面的局部变量
  • 堆空间：动态申请内存（malloc、new等）

构造函数（Constructor）

• 构造函数（也叫构造器），在对象创建的时候自动调用，一般用于完成对象的初始化工作
• 特点
  • 函数名与类同名，无返回值（void都不能写），可以有参数，可以重载，可以有多个构造函数
  • 一旦自定义了构造函数，必须用其中一个自定义的构造函数来初始化对象
• 注意
  • 通过malloc分配的对象不会调用构造函数
• 一个广为流传的、很多教程\书籍都推崇的错误结论：
  • 默认情况下，编译器会为每一个类生成空的无参的构造函数
    正确理解：在某些特定的情况下，编译器才会为类生成空的无参的构造函数

#include <iostream>
using namespace std;

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

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

成员变量的初始化

#include <iostream>
using namespace std;

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

析构函数（Destructor）

• 析构函数（也叫析构器），在对象销毁的时候自动调用，一般用于完成对象的清理工作
• 特点:函数名以~开头，与类同名，无返回值（void都不能写），无参，不可以重载，有且只有一个析构函数
• 注意:通过malloc分配的对象free的时候不会调用构造函数
• 构造函数、析构函数要声明为public，才能被外界正常使用

#include <iostream>
using namespace std;

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和析构的内存管理

#include <iostream>
using namespace std;

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

int main() {
	test();

	getchar();
	return 0;
}