Skip to content

Latest commit

 

History

History
421 lines (310 loc) · 7.97 KB

12_对象的初始化和清理.md

File metadata and controls

421 lines (310 loc) · 7.97 KB

1. 构造函数 和 析构函数

  • 对象的 初始化和清理 也是两个非常重要的安全问题

    • 一个对象或者变量没有初始状态，对其使用后果是未知
    • 同样使用完一个对象或者变量，没有及时清理，也会造成安全问题

  • C++ 利用了构造函数和析构函数，这两个函数将会被编译器自动调用，完成对象初始化和清理工作。对象的初始化和清理工作是编译器强制要我们做的事情，因此如果我们不提供构造和析构，编译器会提供编译器提供的构造函数和析构函数时空实现

  • 构造函数： 主要作用在于创建对象时为对象的成员属性赋值，构造函数由编译器自动调用，无须手动调用

    • 语法： 类名(){}

  • 析构函数： 主要作用在于对象销毁前系统自动调用

    • 语法： ~类名(){}

2. 构造函数的分类和调用

  • 构造函数按照参数分类分为:有参和无参构造，无参又称为默认构造函数
  • 按照类型分类分为：普通构造和拷贝构造
class Person {
private:
	int age;

public:
	Person() {
		cout << "无参数构造函数" << endl;
	}

	Person(int num) {
		age = num;
		cout << "有参数构造函数" << endl;
	}

	//拷贝构造函数
	Person(const Person& p) {
		//将传入的人身上的所有属性，拷贝到我身上
		age = p.age;
	}


	~Person() {
		cout << "析构函数函数" << endl;
	}
};

//Note：调用:
void func() {

	/*
		//1.括号法
		Person p; 	     //默认构造函数（无参构造函数）
		Person p1(1);    //有参构造函数
		Person p2(p1);       //拷贝构造函数

		//注意事项：调用默认构造函数时候，不要加（）
		//Person po(); //不会创建，编译器会认为是一个 函数声明

		//2.显示法
		Person pp1;
		Person pp2 = Person(10); //有参构造
		Person pp3 = Person(pp2); //拷贝构造函数

		Person(10); //NOTE: 匿名对象 特点：当前行执行结束后，系统会立即回收掉 匿名对象

		注意事项2
		不要利用拷贝构造函数  初始化匿名对象  编译器会认为  Person（p3） === Person p3
		//Person(p3)
	*/

	//3.隐式转换法
	Person p3 = 10; //相当于 写了 Person p3=Person(10);
}


int main() {

	func();

	system("pause");

	return 0;
}

3. 拷贝构造函数调用时机

  • 使用一个已经创建完毕的对象来初始化一个新对象
  • ==值传递的方式给函数参数传值== //NOTE
  • ==以值方式返回局部对象== //NOTE
class Person {
private:
	int age;

public:
	Person() {
		cout << "无参数构造函数" << endl;
	}

	Person(int num) {
		age = num;
		cout << "有参数构造函数" << endl;
	}

	//拷贝构造函数
	Person(const Person& p) {
		//将传入的人身上的所有属性，拷贝到我身上
		age = p.age;
	}


	~Person() {
		cout << "析构函数函数" << endl;
	}
};



void doWork(Person p) {

}

Person doWork2() {
	Person p1;
	return p1;
}

void func() {
	Person p;
	doWork(p);
}

void func2() {
	Person p = doWork2();
}

int main() {

	func();

	system("pause");

	return 0;
}

4. 构造函数的调用规则

  • 默认情况下，C++编译器至少给一个类添加3个函数

    • 默认构造函数(无参，函数体为空)
    • 默认析构函数(无参，函数体为空)
    • 默认拷贝构造函数，对属性进行值拷贝

  • 构造函数的调用规则如下：

    • 如果用户定义有参构造函数，C++ 不再提供默认无参构造，但是会提供默认拷贝构造
    • 如果用户定义拷贝构造函数，C++ 不会再提供其他构造函数
class Person {
private:
	int age;

public:
	Person() {
		cout << "无参数构造函数" << endl;
	}
	Person(int num) {
		age = num;
		cout << "有参数构造函数" << endl;
	}
	//拷贝构造函数
	//Person(const Person& p) {
	//	cout << "拷贝构造函数" << endl;
	//	//将传入的人身上的所有属性，拷贝到我身上
	//	age = p.age;
	//}
	~Person() {
		cout << "析构函数函数" << endl;
	}
	void getAge();
};

void Person::getAge() {
	cout << age << endl;
}

void call() {
	Person p(18);
	Person p2(p);
	p2.getAge();
}

int main() {
	call();
	system("pause");
	return 0;
}

5. 深拷贝和浅拷贝

  • 浅拷贝： 简单的赋值拷贝操作
  • 深拷贝： 在堆区重新申请空间，进行拷贝操作
class Person {
private:
	int age;
	int* w;

public:
	Person() {
		cout << "无参数构造函数" << endl;
	}
	Person(int num) {
		age = num;
		cout << "有参数构造函数" << endl;
	}

	Person(int num, int weight) {
		age = num;
		w = new int(weight);
		cout << "有参数构造函数2" << endl;
	}

	//自己实现拷贝构造函数来实现浅拷贝带来的问题：如果在堆上定义了数据，堆上内存重复释放，具体可以看图片
	Person(const Person& p)
	{
		w = new int(*p.w); //w=w 是编译器默认是实现
		age = age;
	}

	//析构代码，将堆区开辟数据做释放操作
	~Person() {
		if (w != NULL) {
			delete w;
			w = NULL;
		}

		cout << "析构函数函数" << endl;
	}
	void printProp();
};

void Person::printProp() {
	cout << age << "\t" << *w << endl;
}

void call() {

	Person p(18, 1111);
	p.printProp();

	Person p2(p);
	p2.printProp();
}

int main() {
	call();
	system("pause");
	return 0;
}

6. 初始化列表

  • 作用： 初始化属性
  • 语法： 构造函数(): 属性1(值1)，属性2(值2)...{}
class Person {
private:
	int age;
	string name;

public:
	//Person() {
	//	cout << "无参数构造函数" << endl;
	//}

	//Person(int num, string name) {
	//	age = num;
	//	name = name;
	//	cout << "有参数构造函数2" << endl;
	//}

	//初始化列表初始化属性
	//Person() :age(10), name("daming") {

	//}

	Person(int a, string b) :age(a), name(b) {

	}


	//析构代码，将堆区开辟数据做释放操作
	~Person() {

		cout << "析构函数函数" << endl;
	}
	void printProp();
};

void Person::printProp() {
	cout << age << "\t" << name << endl;
}

void call() {

	//Person p(18, "xiaoming");

	//Person p;
	Person p(18, "xiaoming");

	p.printProp();

}

int main() {

	call();
	system("pause");
	return 0;
}

7. 类对象作为类成员

  • C++ 类中的成员可以是另一个类的对象，我们称该成员为 对象成员
  • 构造的顺序是：先调用对象成员的构造，再调用本类构造
  • 析构顺序与构造相反

8.静态成员

  • 静态成员就是在成员变量和成员函数前加上关键字static ,称为静态成员
  • 分类：
    • 静态成员变量
      • 所有对象共享同一份数据，不属于某个对象
      • 在编译阶段分配内存
      • 类内声明，类外初始化
    • 静态成员函数
      • 所有对象共享同一个函数
      • 静态成员函数只能访问静态成员变量
class Person {
private:
	int age;
	string name;
	//static int sex;

public:

	static int sex;

	Person(int a, string b) :age(a), name(b) {

	}


	//析构代码，将堆区开辟数据做释放操作
	~Person() {

		cout << "析构函数函数" << endl;
	}

	void printProp();

	static void funcTest();
};


void Person::printProp() {
	cout << age << "\t" << name << endl;

	cout << sex << endl;
}

void Person::funcTest() {

	cout << "调用 funcTest" << endl;

}

//类外初始化，初始化静态成员变量
int Person::sex = 10;

void call() {

	//Person p(18, "xiaoming");

	//Person p;
	Person p(18, "xiaoming");

	cout << p.sex << endl;

	//Person 作用域下的 sex
	cout << Person::sex << endl;

	//p.printProp();

	p.funcTest();

	Person::funcTest();

	//Person::printProp();  //错误
}

int main() {

	call();
	system("pause");
	return 0;
}