【Essential C++学习笔记】第五章 面向对象编程风格

本章节书里讲的比较杂，索性用自己的方式总结了一波，有些没有实质内容的章节就跳过了

第五章 面向对象编程风格

5.1 面向对象编程概念

面向对象编程概念最主要特质：继承和多态

1）继承

• 继承是将一群相关的类组织起来，分享这些类之间的共通数据和操作行为
• 继承允许我们依据另一个类来定义一个类，这使得创建和维护一个应用程序变得更容易。这样做，也达到了重用代码功能和提高执行效率的效果。
• 当创建一个类时，不需要重新编写新的数据成员和成员函数，只需指定新建的类继承了一个已有的类的成员即可。这个已有的类称为基类，新建的类称为派生类。
• 继承呈现了面向对象程序设计的层次结构，体现了由简单到复杂的认知过程。之前接触的复用都是函数复用，继承是类设计层次的复用。
• 间接利用指向抽象基类的指针或引用来操作一个类系统中的各个类对象，而非直接操作各个实际对象，这有什么好处呢？就是可以不在改动原有程序的前提下，加入或移除任何一个派生类。

1.继承格式

class 新类的名字:继承方式 继承类的名字{};
 // 基类
 class Animal {
     // eat() 函数
     // sleep() 函数
 };
 
 //派生类
 class Dog : public Animal {
     // bark() 函数
 };
1
2
3
4
5
6
7
8
9
10
11

2.访问权限和继承

① 访问权限

• 基类private成员无论以什么方式继承到派生类中都是不可见的。
• 使用关键字class时默认的继承方式是private，使用struct时默认的继承方式是public。

② 继承后的子类成员访问权限

③ 派生类继承了什么？

一个派生类继承了所有的基类方法，但下列情况除外：

• 基类的构造函数、析构函数和拷贝构造函数。
• 基类的重载运算符。
• 基类的友元函数。

④ 同名的成员变量和成员函数

在有些时候，父类和子类中出现了同一个成员变量，如下name，这个时候编译器是以子类为优先。想要访问父类的name成员变量，就需要加上修饰

cout << people::name<< endl;
1

同样一个函数print在父类和子类中都存在，编译器会默认调用子类中匹配的函数，（函数重载是在同一个作用域，这里父类和子类是两个作用域）

3.派生类和基类构造函数初始化列表的执行顺序

构造函数调用顺序：基类 > 成员类 > 派生类

析构函数和构造函数相反，编译器默认先调用子类的析构函数，再调用父类的析构函数。

#include 
using namespace std;

class A {
	public:
		A() {
			cout << "call A()" << endl;
		}
		~A() {
			cout << "call ~A()" << endl;
		}
};

class B : A {
	public:
		B(int val) : A(), value(val) {
			val = 0;    // 重新赋值
			cout << "call B()" << endl;
		}
		~B() {
			cout << "call ~B()" << endl;
		}

	private:
		int value;
};

int main() {
	B b(10);
	return 0;
}

/*
* 结果如下
* call A()
* call B()
* call ~B()
* call ~A()
* 说明放在初始化列表的部分在构造函数之前执行
*/
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

2）多态

多态字面意思就是多种形态。

多态的概念：通俗来说，就是多种形态，具体点就是去完成某个行为，当不同的对象去完成时会产生出不同的状态。

举个例子：买票

普通人全价，学生半价，军人全价但优先购票…

这就是对买票这一个具体行为，不同人去完成时产生的不同结果。

1.多态的实现

C++的多态必须满足两个条件:

1. 必须通过基类的指针或者引用调用虚函数
2. 被调用的函数必须是虚函数，且派生类必须对基类的虚函数进行重写

#include 
using namespace std;

class Person
{
public:
	virtual void display()
	{
		cout << "全价票" << endl;
	}
};

class Student :public Person
{
public:
	virtual void display() // //子类完成对父类虚函数的重写
	{
		cout << "半价票" << endl;
	}
};

void BuyTicket(Person* p)
{
	p->display();
}

int main(){
	Student st;
	Person p;

	BuyTicket(&st);  //半价票
	BuyTicket(&p);	//全价票

	system("PAUSE");
	return 0;
}
/*  将传地址改为传对象，不满足多态条件后，调用的都是父类的函数
void BuyTicket(Person p)
{
	p.display();
}
int main(){
	Student st;
	Person p;

	BuyTicket(st);  //全价票
	BuyTicket(p);	//全价票

	system("PAUSE");
	return 0;
}
*/
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

如果满足多态，编译器会调用指针指向对象的虚函数，而与指针的类型无关。如果不满足多态，编译器会直接根据指针的类型去调用虚函数。

2.虚函数

• 用virtual修饰的关键字就是虚函数，且虚函数只能是类中非静态的成员函数。

• 子类和父类中的虚函数拥有相同的名字，返回值，参数列表，那么称子类中的虚函数重写了父类的虚函数

• 虚函数可以不实现（定义）。不实现（定义）的虚函数是纯虚函数。 virtual int area() = 0;` = 0 告诉编译器，函数没有主体。那么纯虚函数有什么用呢？

  1，强制子类重写虚函数，完成多态。
  2，表示某些抽象类。

• 虚函数重写的两个例外：

  1. 协变：子类的虚函数和父类的虚函数的返回值可以不同，也能构成重载。但对返回值有要求：需要子类的返回值是一个子类的指针或者引用，父类的返回值是一个父类的指针或者引用，且返回值代表的两个类也成继承关系。这个叫做协变。
  2. 析构函数的重写：析构函数名字天生不一样，怎么实现多态？

  /*test.1
  B继承了A，他们的析构函数没有重写。
  */
  class A
  {
    public:
    ~A()
    {
       cout << "~A()" << endl;
    }
  };
  class B : public A
  {
    public:
    ~B()
    {
      cout << "~B()" << endl;
    }
  };
  
   A* a = new B; //把B的对象切片给A类型的指针。
   delete a; //实际调用的是A的析构函数
  
  /*test.2
  B继承了A，他们的析构函数没有重写。
  */
  class A {
  	public:
  		virtual ~A() {
  			cout << "~A()" << endl;
  		}
  };
  
  class B : public A {
  	public:
  		~B() {
  			cout << "~B()" << endl;
  		}
  };
  
   A* a = new B; //把B的对象切片给A类型的指针。
   delete a; //有进行了重写，会先调用B的析构函数，后调用A的析构函数
  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

3.C++11新增的 override 和 final

① override

检查派生类虚函数是否重写了基类某个虚函数，如果没有重写编译报错。（定义在子类）

感觉没多大意义，有点画蛇添足，既然都想到了要写override,那还能忘记要重写基类的虚函数？或者说写错？

② final

用final修饰的虚函数无法重写。用final修饰的类无法被继承。final像这个单词的意思一样，这就是最终的版本，不用再更新了。（定义在父类）

子类对有final修饰的虚函数进行重写，会报错

4.重载，覆盖(重写)，重定义（隐藏）

5.接口继承和实现继承

普通函数的继承就是实现继承，虚函数的继承就是接口继承。子类继承了函数的实现，可以直接使用。虚函数重写后只会继承接口，重写实现。所以如果不用多态，不要把函数写成虚函数。

#include 
using namespace std;

class A
{
public:
	virtual void fun(int val = 0)
	{
		cout << "A->val = " << val << endl;
	}
	void Fun()
	{
		fun();//传过来一个子类指针调用fun()
	}
};

class B:public A
{
public:
	virtual void fun(int val = 1)
	{
		cout << "B->val = " << val << endl;
	}
};

int main(){
	B b;
	b.Fun();

	system("PAUSE");
	return 0;
}
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

3）总结

• 继承特性让我们可以定义一整群互有关联的类，并共享通用的接口
• 多态则让我们可以用一种与类型无关的方式来操作类对象，通过抽象基类的指针或引用来操纵一整群互有关联的类的共同接口
• 动态绑定在程序执行时隐居抽象基类的指针或引用所指的是基类对象的类型才能决定。

5.4 不带继承的多态

定义一个抽象基类

第一，找出所有子类（一些类）共通的操作行为

所有子类共通的操作行为，这些行为代表的是基类的公有接口

第二，找出哪些操作行为（基类成员函数）必须根据不同的派生类而有不同的实现方式

找出哪些操作行为（基类成员函数）必须根据不同的派生类而有不同的实现方式。
如果某操作行为（基类成员函数）必须根据不同的派生类而有不同的实现方式，这个操作行为就要成为整个类继承体系的虚函数，即该成员函数（至少在基类中）的声明前加virtual。

第三，找出每个操作行为（基类成员函数）的访问层级

①某个操作行为（类成员函数）能让一般程序（在该类主体和该类的派生类如果有派生类的话外）访问这个成员函数，那么我们将这个成员函数的声明/定义放进基类的public:里。
②某个操作行为（类成员函数））在基类之外不需要被用到，自然不用在基类之外访问这个成员函数。我们就把这个成员函数的声明/定义放进基类的private:里
③某个操作行为（类成员函数）在该类的派生类（如果有的话）主体/对象可以被访问，却不许一般程序访问。 那么我们就把这个成员函数的声明/定义放进基类的protected:里。

5.10 运行时的鉴定机制

typeid运算符

• 这是运行时类型鉴定机制得一部分，由程序语言支持。
• typeid运算符让我们得以查询多态化的类指针/引用，来获得类指针/引用所指对象的实际类型。用法举例

#include
inline const char* num_sequence::what_am_i()const{return typeid(*this).name();}
1
2

type_info类

• type_info类支持相等和不相等两个操作，举个例子：

num_sequence *ps=&fib;
//...
if(typeid(*ps)==typeid(Fibonacci))
{}
//...
1
2
3
4
5

这一堆代码是测试ps这个基类指针是否指向某个派生类类对象。

static_cast运算符

用static_cast运算符来强制转换（无条件转换）基类指针变为派生类指针。用法举例：

if(typeid(*ps)==typeid(Fibonacci))
{
	Fibonacci *pf=static_cast(*ps);
	pf->gen_elems(64);//经过static_cast运算符转换指针变为派生类指针
	//这种写法得以被编译器承认
}
1
2
3
4
5
6

不过static_cast有个潜在危险，就是编译器无法确定转换类指针从基类到派生类是不是转换对了，所以我们加了if(typeid(*ps)==typeid(Fibonacci)){}如果typeid运算符（这里是==和()）运算结果为真,就执行类指针的无条件转换。

dynamic_cast运算符

dynamic_cast运算符没有这种潜在危险。其用法举例：

	if(Fibonacci *pf=dynamic_cast(ps))
	{
		pf->gen_elems(64);//经过dynamic_Cast运算符转换指针变为派生类指针
		//这种写法得以被编译器承认
	}
	
1
2
3
4
5
6