C++面向对象完结

发表于 | 分类于 ， | | 本文总阅读数 次
| 字数统计: 1.3k | 阅读时长 ≈ 5
C++面向对象完结

2

C++面向对象完结

  C++面向对象终于来到了完结篇，最后剩下的内容也是最最重要的内容——多态和虚函数，虽然在自己写代码时很少用到，但是在企业级开发中是必不可少的部分，在最终章会为大家详细介绍。

函数重写

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
#include<iostream>
using namespace std;

class Person {
public:

	//父类中存在一个成员方法，名为program
	void program() {
		cout << "我的名字是程序员，我会写代码" << endl;
	}
};

class CppProgrammer :public Person {
public:
	//函数重写，发生在继承关系中，子类的方法名和参数列表和父类一样，则会发生函数重写。
	//特点是创建子类对象会优先调用子类方法。
	void program() {
		cout << "我的名字是Cpp程序员，我会写Cpp代码" << endl;
	}
};

class JavaProgrammer :public Person {
public:

	void program() {
		cout << "我的名字是Java程序员，我会写Java代码" << endl;
	}
};

class PythonProgrammer :public Person {
public:

	void program() {
		cout << "我的名字是Python程序员，我会写Python代码" << endl;
	}
};

int main() {

	Person p;
	CppProgrammer cp;
	JavaProgrammer jp;
	PythonProgrammer pp;

	//调用父类对象的成员方法时，会使用父类的成员方法。
	p.program();
	//调用子类对象的成员方法时，会使用子类的成员方法。
	cp.program();
	jp.program();
	pp.program();

	return 0;
}

1

多态

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
#include<iostream>
using namespace std;

class Person {
public:

	//虚函数：在成员函数前面加上virtual关键字，称这个函数为虚函数。
	//如果将父类中的函数实现舍去，并且在函数的参数列表后面加上=0;则称为纯虚函数。
	//当有了纯虚函数，这个类就被称为抽象类，抽象类无法实例化对象，而且子类必须重写抽象类中的纯虚函数，否则也是抽象类。
	virtual void program() {
		cout << "我的名字是程序员，我会写代码" << endl;
	}
};

class CppProgrammer :public Person {
public:
	
	//多态的本质：父类指针或者引用指向子类对象，调用时会调用子类的成员方法。
	//多态的两个必要条件：有继承关系，子类要重写父类的虚函数。
	void program() {
		cout << "我的名字是Cpp程序员，我会写Cpp代码" << endl;
	}
};

class JavaProgrammer :public Person {
public:

	void program() {
		cout << "我的名字是Java程序员，我会写Java代码" << endl;
	}
};

class PythonProgrammer :public Person {
public:

	void program() {
		cout << "我的名字是Python程序员，我会写Python代码" << endl;
	}
};


void test(Person& p) {
	p.program();
}


int main() {
	
	//因为Person类中的program方法有具体的实现，因此不是一个抽象类，可以创建实例对象。
	Person p;
	CppProgrammer cp;
	JavaProgrammer jp;
	PythonProgrammer pp;

	//将父类的实例对象传给父类的引用，程序正常执行。
	test(p);
	//将子类的实例对象传给父类的引用，将产生多态，会执行子类的成员方法。
	test(cp);
	test(jp);
	test(pp);

	return 0;
}

1

虚析构与纯虚析构

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
#include<iostream>
using namespace std;

class Person {
public:

	Person() {
		cout << "父类的构造函数被调用" << endl;
	}

	virtual void program() {
		cout << "我的名字是程序员，我会写代码" << endl;
	}

	~Person() {
		cout << "父类的析构函数被调用" << endl;
	}
};

class CppProgrammer :public Person {
public:
	
	CppProgrammer() {
		cout << "子类的构造函数被调用" << endl;
	}

	void program() {
		cout << "我的名字是Cpp程序员，我会写Cpp代码" << endl;
	}

	~CppProgrammer() {
		cout << "子类的析构函数被调用" << endl;
	}
};


int main() {
	{
		//当使用new在堆区中开辟子类对象数据，并返回给父类指针时。
		//delete父类指针，无法看到子类的析构函数，这就不会调用子类的析构函数，因此有内存泄漏的风险。
		//解决办法有两种，一个是在父类的析构函数前加virtual关键字，变成一个虚析构函数。
		//第二种方法是将父类的析构函数变为一个纯虚析构函数，但是此时运行会产生错误，因为父类的一些成员变量可能无法析构，所以还要在类外通过作用域进行实现。
		//此时两者的区别是，虚析构函数的父类不是一个抽象类，而纯虚析构函数的父类是一个抽象类。
		Person* p = new CppProgrammer();
		p->program();
		delete p;
	}

	return 0;
}

1

C++小结

  到今天为止，面向对象的所有内容都已经给小伙伴们分享完了，至于其中包含的奇技淫巧，需要小伙伴们慢慢磨砺，多态是设计模式的基础，以后会给小伙伴们详细介绍设计模式，在这里一定要掌握多态的用法。

-------------本文结束感谢您的阅读-------------
0%