C++07(继承)

面向对象之继承

在C++中可重⽤性是通过继承(inheritance)这⼀机制来实现的。继承是C++的⼀个重要组成部分。

继承相关概念

继承：

在C++中，“继承”是类之间定义的⼀种重要的关系，就是在⼀个已存在的类的基础上建⽴⼀个新的类。

⽗类：被继承的类称为⽗类或基类，基类的基类或更⾼层次的基类称为间接基类。

⼦类：继承的类称为⼦类或派⽣类

• ⼀个B类继承A类或从A类派⽣B类,其中A类称为⽗类(基类),B类称为⼦类(派⽣类);

• 派⽣类成员是除了从基类继承来的所有成员之外，还包含新增加的数据和函数成员。

• 默认情况下派⽣类包含了全部基类函数中除构造函数和析构函数之外的所有成员，⼀般来说构造函数和析构函数是不能继承的，但是C++11规定可以⽤using语句继承基类构造函数。

• 继承是保留利⽤原有的类的功能，⽽派⽣是添加新的成员和功能。

多继承与单继承：

⼀个派⽣类，可以同时有多个基类，这种情况称为多继承。

⼀个派⽣类只有⼀个直接基类的情况称为单继承。

注意: c++也⽀持多继承，能⽤单继承解决，尽量使⽤单继承解决

派⽣类声明

1、派⽣类的语法定义:

class 子类名:访问控制 父类1，访问控制 父类2....
{
    类体
}

冒号后⾯的被称为基类名表,基类名表的构成: 访问控制+基类名;

访问控制表示派⽣类对基类的继承⽅式,使⽤关键字public ，private，protected,如果不写默认为private。

派⽣类经历的三个步骤：

• 吸收基类成员

• 改造基类成员

• 添加新的成员
  
  继承示例：

class father
{
 private:
 string name;
 public:
 father(){ cout << "我是⽗类中的构造函数" << endl; }
 void show()
 {
 cout << "我是类中的普通成员函数" << endl;
 }
};
// 声明⼀个派⽣类
class son :public father
{
public:
 int a;//新增的数据成员
 void test() //新增的成员函数
 {
 cout << "我是⼦类中的成员函数" << endl;
 }
};
int main()
{
 son per1;
 per1.show(); //.调⽤继承过来的⽗类成员
 per1.test(); //.调⽤⼦类的新增成员
}
//继承可以理解为⼀个类从另⼀个类获取⽅法（函数）和属性（成员变量）的过程

派⽣类的成员访问属性

派⽣类中包含基类成员和派⽣类⾃⼰增加的成员，就产⽣了这两部分成员的关系和访问属性的问题 ，实际上，对基类成员和派⽣类⾃⼰增加的成员是按不同的原则处理的，访问的原则主要通过继承⽅式来体现的。

●公有继承

⽗类成员在⼦类中保存原有的访问属性

● 私有继承

⽗类成员在⼦类中成为私有成员，⽗类的公有成员和受保护成员可以在派⽣类中内部使⽤，⽗类的私有成员在⼦类内⽆法访问。

● 保护继承

基类的public和protected成员：都以protected身份出现在派⽣类中；基类的private成员：不可在派⽣类内部直接访问

派⽣类的构造函数与析构函数

派⽣类构造函数声明与定义：

由于⼦类不能继承⽗类的构造⽅法，因此在创建⼦类对象时，为了初始化从⽗类继承来的数据成员，系统需要调⽤其⽗类的构造⽅法,如果继承多个基类，需要 给多个基类传递参数时，派生类对象在创建时，先调用父类的构造函数派⽣类的构造函数语法格式为：

派生类类名::派生类名(参数表):基类1(基类1初始化),基类2(基类1初始化),子对象(初始化列表)..
{
    本类成员初始化赋值语句;
}

派⽣类在实例化的时候 先调⽤⽗类的构造函数，然后再调⽤⾃⼰的构造函数，如果定义⼀个类，最好写⼀个默认构造函数。

● 对派⽣类构造函数作声明时，不包括基类构造函数名及其参数表列， 只在定义函数时才将它列出。

● 派⽣类构造函数执⾏的次序：参数初始化表先对基类初始化,再对⼦对象初始化,最后对⾃⼰的数据成员初始化。

调⽤基类构造函数，调⽤顺序按照它们被继承时声明的顺序（从左到右）；

调⽤内嵌成员对象的构造函数，调⽤顺序按照它们在类中声明的顺序；

派⽣类析构函数：

派⽣时，派⽣类是不能继承基类的析构函数的，也需要通过派⽣类的析构函数去调⽤基类的析构函数。在派⽣类中可以根据需要定义⾃⼰的析构函数，⽤来对派⽣类中所增加的成员进⾏清理⼯作。

调⽤的顺序与构造函数正好相反: 先执⾏派⽣类⾃⼰的析构函数，对派⽣类新增加的成员进⾏清理，然后调⽤⼦对象的析构函数，对⼦对象进⾏清理，最后调⽤基类的析构函数，对基类进⾏清理 。

面向对象编程

编程思想

定义：对现实世界问题在程序世界进行建模方法

编程思想主要分为：面向过程编程pop、面向对象编程oop

面向过程编程特点：

它的核心主要讲究“怎么做”，将问题拆分为一个个的流程，然后将每个流程封装成函数最后再按照业务的流程来分别调用函数，实现最终问题的解决。不注重职责分工，适合解决小规模问题。

面向对象编程：

它的核心讲究“谁来做”，将待解决问题中涉及到的角色先进行构建并进行分装，再按照业务流程分别调用不同角色中的方法来实现问题的解决。注重职责分工，适合解决中大规模的问题。

面向对象编程涉及到两个重要的概念

类class：一类事物的抽象描述(共有属性和行为的集合)

对象object:某种类型的具体存在(由类构建的具体实例)，类是构建对象的模板，一个类可以构建多个对象

类类型的定义

类类型和结构体类型是C++提供给程序员进行自定义类型的两种手段

类类型是在结构体的基础上做发展起来的一个类型，是结构体的加强版

class 类型名
{
    类体(数据成员+函数成员+访问范围修饰符)
};

数据成员-----主要来描述事物的特征
函数成员-----主要用来描述事物的行为
访问范围修饰符：设置某个成员的可见性,如果省略，默认是私有成员

类中数据成员的定义

数据成员：格式： 数据类型 成员名；

数据成员分类：

普通数据成员 int a;通过构造函数实现初始化

常数据成员 const int a;通过构造函数的初始化列表初始化

静态数据成员 static int a;类外初始化 int stu::a=100

函数成员： 格式：

类内 ： 返回类型 函数名([形参列表])——类内定义系统会认为是内置函数

​ {

​ }

类外定义： 类内声明 返回类型 函数名([形参列表]);

​ 返回类型 类名::函数名([形参列表])

​ {

​ }

函数成员分类：

普通函数成员： int test(){}

特殊函数成员:构造函数，拷贝构造函数，析构函数

常函数成员: int test([形参列表]) const {}

静态函数成员: static int test([形参列表])

虚函数成员:virtual int test([形参列表])

运算符重载函数成员:int operator+(){}

友元函数:friend int test([形参列表]){}

构建对象

栈上构建对象:

[class] 类名 对象列表;//class 关键字可以省略

构建单个对象： stu s1;

构建对象数组: stu arr[10];

销毁方式:自动销毁

堆上构建对象:

类名 指针名 = new 类名[(实参列表)];

构建单个对象:new stu;

构建对象数组:new stu[size];

销毁方式:delete 对象指针名,delete [] 对象指针名

匿名对象：类名([实参列表])

成员访问

类外：

数据成员访问：

对象名.数据成员名;

函数成员：

对象名.成员函数名([实参列表]);

类内：

数据成员访问:数据成员名或this->数据成员；

函数成员：成员函数名([实参列表])

特殊情况：数据成员只有类型没有成员名

类名::类型名 对象列表;

成员访问修饰符——限制成员的可见性

public:设置公有成员的访问属性，类内和类外都可以对其进行访问

protected:设置受保护的访问属性，类内和该类的派生类内部可以对其进行访问

private:设置私有的访问属性

构造函数

作用:初始化类中的数据成员，它也可以调用类中其他成员函数。

特点：函数名必须和当前的类名要一样；没有返回类型；不需要用户主动调用；

构造函数也可以被重载

分类：

​ 普通构造函数：创建对象时自动触发

​ 默认构造函数：没有形参的构造函数或有形参且每个形参都提供默认值

​ 拷贝构造函数：只有一个形参且该形参必须是当前的类类型

​ 移动构造函数

​ 转型构造函数

初始化列表依附于构造函数才有意义

格式：

​ 函数名([形参列表])：对象1(值1)，对象2(值2)，…,对象n(值n)

​ {

​ }

小括号的值可以是一个某个常量也可以来自构造函数进行的某个形参

拷贝构造函数——设置对象间的拷贝原则

格式：类名(const 类名&形参)

​ {

​ }

触发场景:

用一个对象初始化另一个对象 stu s1(s2) stu s1=s2;

用对象当做值传递

函数在返回某个对象时

应用场景:当类中存在指针数据成员且该数据成员指向一个堆内存

析构函数

作用：清理收尾工作或销毁对象

特点：函数名必须是~+类名；没有返回类型；没有形参；不需要用户主动调用，如果用户没有提供，系统会自动生成

触发时机：当对象离开了它的域或对一个堆对象施加delete

静态成员

作用：减少内存占用，从而提供程序的指向效率。

静态数据成员:static int a;

特点：静态成员属于类，在内存中只占一份，可以供该类创建的所有对象所共享

静态成员可以被该类的对象所调用，也可以直接通过类名去调用

在静态成员函数中不能调用类中的非静态成员

在类中的非静态成员函数中可以调用类中的静态成员

静态成员函数可以调用静态成员

静态数据成员必须在类外先初始化然后才能使用

静态函数成员:static int test(){}

共用数据的保护

作用：让类中的数据既呈现了一定的开放性，同时又对用户使用时做出了限制

const修饰的三个层：

• const修饰对象：const stu s1;
• const修饰函数成员：void test() const{}
• const修饰数据成员：const int a;

友元

作用：通过友元，可以实现将某个类中的私有成员可以实现访问

缺点:破坏类的封装性

友元函数：需要先在类中声明 friend int test(形参1,…){}

在类外实现，它不是类的真正成员(不可以通过类对象对其进行访问)

友元类：声明友元类 friend class 类;

嵌套类

在C++中，可以在类内定义另外一个类类型