超详细的 C++中的封装继承和多态的知识总结＜1.封装与继承＞

引言

小伙伴们都知道C++面向对象难，可是大家都知道，这个才是C++和C的真正区别的地方，也是C++深受所有大厂喜爱的原因，它的原理更接近底层，它的逻辑更好，但是学习难度高，大家一定要坚持下来呀，本章呢对于C++有关的知识开始讲解封装继承和多态。好了啦废话不多说，跟着小杨一起开始吧！

冲冲冲！！！！！！

封装

封装的关键字是clas。
从上一章当中，我们已经知道了，封装就是现实生活中的事物定义为类，将事物的数据抽象为属性，将事物的行为抽象为方法。

类的数据成员和成员函数

数据成员
- 类中的数据成员描述该类对象的属性，数据成员必须在类体中定义，其定义方式须与一般变量相同，但对于数据成员的访问要手访问控制权限的限定。
- 数据成员的初始化与普通变量的初始化形式有所不同，不能使用圆括号（即对象方式初始化）可以使用=和{ }。
- 多个数据成员之间不能重名，一个类是一个作用域。
成员函数
- 成员函数描述类对象的行为，即该类对象的所执行的操作。
- 一个类的多个同名不同参数类型的成员函数可以重载。
- 类的成员函数也可以是内联函数。
- 函数成员参数也可以有默认值。
成员的访问控制
- private私有访问权限
  - 数据成员和成员函数只允许访问类本身的成员函数访问，对类的外部不可见。
- protected保护访问权限
  - 数据成员和成员函数允许类本身及其派生类的成员函数访问
- public共有访问权限
  - 数据成员和成员函数对外类外部可见，类内部也能访问

类的定义代码示例：

#include <iostream>using namespace std;
/*class关键字定义类。类名是标识符，需要满足标识符规范，类名命名规范是大驼峰，每个单词首字母大写，其他字母小写。类名后一对花括号表示类的作用域，也称为类体，分号表示类定义结束。关键字private,protected,public称为访问控制机制。默认为private。
*/
class Rect
{
private://	属性int m_length;int m_width;
public:/*类中的成员函数（方法）可以再类中直接定义，也可以只写函数声明，然后在类的外面写出函数定义。*/	//	方法void setLength(int length);//	函数成员可以内联inline void setWidth(int width = 0);int getArea();int getPerimeter();
};void Rect::setLength(int length)
{m_length = length;
}void Rect::setWidth(int width)
{m_width = width;
}int Rect::getArea()
{return m_width * m_length;
}int Rect::getPerimeter()
{return 2 * (m_width + m_length);
}int main()
{//	定义(创建)Rect类的对象r。Rect r, r1;//	.操作符访问成员，可以访问数据成员或成员函数。r.setLength(2);r.setWidth(3);cout << r.getArea() << endl;cout << r.getPerimeter() << endl;	//	多个对象之间的属性互相独立。r1.setLength(1);//	函数成员参数可以有默认值r1.setWidth();cout << r1.getArea() << endl;cout << r1.getPerimeter() << endl;return 0;
}

类的特殊成员
在类中，除了一些简单的数据成员和成员函数外，还有一些具有特殊作用，和特殊规范的函数，这些类的特殊成员正是封装的厉害之处，也是满足各种各样要求的一大利器，让我们一起来看一下吧。

构造函数

在创建对象时，利用特定的值构造对象，将对象初始化为一个特定状态。
构造函数也是类的成员函数，除具有一般成员函数的特点外，还有以下特点：
- 构造函数的函数名和类名相同
- 不能定义构造函数的类型，因为构造函数没有返回值，也就没有返回值类型。
- 构造函数不在程序中调用，在对象被创建时，被编译器调用，
- 构造函数可以被重载
- 如果类中没有构造函数，则在C++编译器中会默认自动生成一个无参的默认构造函数，一旦用户显示定义任何构造函数，默认构造函数将不再提供。
- 无论任何方式创建对象，公祖奥函数都会被调用，如果找不到和参数匹配的构造函数，编译器会产生错误。
初始化列表
- 除了在构造函数体中为数据成员初始化，还可以使用初始化列表对数据成员初始化。
- 类的常量成员需要初始化时，只能在初始化列表初始化。
构造函数代码示例：

#include <iostream>using namespace std;class Rect
{
private:	int m_length;int m_width;
public:/*构造函数和类同名且没有返回类型。构造函数允许重载。没有定义构造函数时，编译器会提供默认的无参构造函数，当定义任何构造函数后，编译器不再提供默认构造函数。*/Rect();Rect(int length, int width);void setLength(int length);	inline void setWidth(int width = 0);int getArea();int getPerimeter();
};Rect::Rect()
{cout << "Rect::Rect()" << endl;
}Rect::Rect(int length, int width)
{cout << "Rect(int length, int width)" << endl;m_length = length;m_width = width;
}void Rect::setLength(int length)
{m_length = length;
}void Rect::setWidth(int width)
{m_width = width;
}int Rect::getArea()
{return m_width * m_length;
}int Rect::getPerimeter()
{return 2 * (m_width + m_length);
}int main()
{	//	构造函数由编译器在创建对象时调用。Rect r(2, 3);Rect r1;return 0;
}

析构函数

与构造函数相对的就是析构函数，在删除一个对象前被调用，释放该对象的内存空间及其他的一些清理工作。
析构函数的特征
- 析构函数的名字“~类名”
- 析构函数没有参数，也不能指定返回类型，一个类只有一个析构函数。
- 当一个类删除时，编译器会自动调用析构函数。
- 如果没有显示定义，编译器将默认生成一个默认的析构函数，函数体空。
析构函数代码示例：

#include <iostream>using namespace std;class Circle
{
private:const float PI = 3.1415926;int m_radius;char* m_name = NULL;public:Circle(int radius);Circle(const char* name, int radius);//	声明析构函数~Circle();int getArea();void info();
};//	常量必须使用初始化列表初始化
Circle::Circle(const char* name, int radius)
{int len = strlen(name) + 1;m_name = new char[len];strcpy_s(m_name, len, name);m_radius = radius;
}Circle::Circle(int radius)
{	m_radius = radius;
}Circle::~Circle()
{cout << "Circle::~Circle()";	if(m_name != NULL){cout << m_name;delete[]m_name;}	cout << endl;
}int Circle::getArea()
{return PI * m_radius * m_radius;
}void Circle::info()
{cout << "m_name: " << m_name << " m_radius:" << m_radius << endl;
}int main()
{//	动态分配的对象在使用delete删除时，调用析构函数Circle* p = new Circle("HHH", 2);delete p;//	编译器在栈中创建的对象，在编译器删除对象时调用析构函数，先创建的对象后删除。char c[20] = "test1";Circle circle(c, 1);cout << circle.getArea() << endl;circle.info();c[4] = '2';circle.info();Circle circle1(1);return 0;
}

拷贝构造函数

拷贝构造函数可以实现用一个已存在的对象初始化新对象。
拷贝构造函数的一般格式为：类名（const 类名& 形参名）
拷贝构造函数(自定义)代码示例：

#include <iostream>using namespace std;//	自定义拷贝构造函数
class Circle
{
private:const float PI = 3.1415926;int m_radius;char* m_name = NULL;public:	Circle(const char* name, int radius);/*拷贝构造函数的参数相对固定，常见方式为：(const 类名& 形参名)*/Circle(const Circle& c);~Circle();int getArea();void info();
};Circle::Circle(const char* name, int radius)
{int len = strlen(name) + 1;	  m_name = new char[len];  strcpy_s(m_name, len, name);  m_radius = radius;	
}
//	实现拷贝构造函数
Circle::Circle(const Circle& c)
{int len = strlen(c.m_name) + 1;m_name = new char[len];strcpy_s(m_name, len, c.m_name);m_radius = c.m_radius;	
}Circle::~Circle()
{ccountout << "Circle::~Circle()";if (m_name != NULL){cout << m_name;delete[]m_name;}cout << endl;}int Circle::getArea()
{return PI * m_radius * m_radius;
}void Circle::info()
{cout << "m_name: " << m_name << " m_radius:" << m_radius << endl;	
}int main()
{Circle circle1("C1", 2);circle1.info();Circle circle2(circle1);circle2.info();return 0;
}

拷贝构造函数(默认)代码示例：

#include <iostream>using namespace std;//	使用默认拷贝构造函数
class Circle
{
private:const float PI = 3.1415926;int m_radius;char* m_name = NULL;public:Circle(char* name, int radius);			void info();
};Circle::Circle(char* name, int radius)
{m_name = name;m_radius = radius;
}void Circle::info()
{cout << "m_name: " << m_name << " m_radius:" << m_radius << endl;
}int main()
{char c[] = "C1";Circle circle1(c, 2);circle1.info();Circle circle2(circle1);circle2.info();return 0;
}

赋值函数

用赋值语句将一个对象的值赋给了另一个已有同类对象时，将调用赋值函数。
赋值函数的一般格式：类名&operate=（const类名&形参名）
实现赋值函数时，一般要判断入参是否为对象本身，如果是对象本身，则不进行操作直接返回。
赋值函数代码示例：

#include <iostream>using namespace std;class Circle
{
private:const float PI = 3.1415926;int m_radius;char* m_name = NULL;public:Circle(const char* name, int radius);~Circle();	Circle& operator=(const Circle& c);void info();
};Circle::Circle(const char* name, int radius)
{cout << "Circle::Circle(const char* name, int radius):" << name << endl;int len = strlen(name) + 1;m_name = new char[len];strcpy_s(m_name, len, name);m_radius = radius;
}Circle::~Circle()
{count << "Circle::~Circle()";if (m_name != NULL){cout << m_name;delete[]m_name;}cout << endl;
}//	赋值函数的一般格式
Circle& Circle::operator=(const Circle& c)
{cout << "Circle::operator=(const Circle& c):" << " c.m_name: " << c.m_name << endl;//	赋值函数要判断实参是不是对象本身，如果是对象本身则直接返回。if (this != &c){if (m_name != NULL){delete[] m_name;			}int len = strlen(c.m_name) + 1;m_name = new char[len];strcpy_s(m_name, len, c.m_name);m_radius = c.m_radius;}	//	this是对象的固有指针，指向对象本身。return *this;
}void Circle::info()
{cout << "m_name: " << m_name << " m_radius:" << m_radius << endl;
}int main()
{Circle circle1("C11", 2);circle1.info();Circle circle2("C2", 3);//	调用赋值函数//	circle2 = circle1;circle2 = circle2;circle2.info();return 0;
}

继承

有关继承的知识点并不是很多，但是继承也是很重要的一环。但是其繁琐的理解的难易程度也不小。

子类继承父类的属性和方法，使得子类具备父类的特征。
继承的类型
- 单继承：子类只有一个父类（基类）
- 多继承：子类有多于一个父类（基类）
- 直接继承：顾名思义，就是他的继承来自他的父类
- 间接继承：他的继承是通过继承的子类做了父类的继承。
派生类不继承父类的构造方法（构造函数）每个子类都必须实现至少一个构造函数。
方法的隐藏：子类中定义和父类方法名完全相同时，子类的函数屏蔽掉了预期同名的所有父类函数，这叫方法的隐藏。
有关派生类继承的代码示例：

#include <iostream>#include "Pet.h"
#include "Cat.h"
#include "Dog.h"
/*我们在对应的头文件里加上了每个派生类的构造函数，还有私人属性和是实现方法的声明，。同时我们在对应的cpp文件里对函数功能的具体实现。
*/
using namespace std;int main()
{Pet pet("小强", 20);pet.info();pet.barking();pet.barking(3);pet.running();Cat cat("叮当", 10);cat.info();cat.barking();cat.barking(3);cat.running();Dog dog("旺财", 10);dog.info();dog.barking();//	dog.barking(3); 父类Pet类的barking(int n)方法被隐藏了。dog.running();dog.guardHouse();return 0;
}

类的继承方式
默认的继承方式是private。
派生类的构造和析构构成
- 派生类构造函数的执行顺序
  - 调用基类的构造函数执行派生类的构造函数体。
- 派生类的析构函数执行顺序
  - 执行子类的析构函数调用基类的析构函数
派生类的构造和析构构成代码示例：

#include <iostream>
using namespace std;class Animal
{
protected:int m_age;
public:Animal( age){cout << "Animal(int age): " << endl;m_age = age;}~Animal(){cout << "~Animal() " << endl;}void info(){cout << "Animal: m_age: " << m_age << endl;}
};class Tiger : public Animal
{
private:int m_weight;
public:Tiger(int age, int weight) : Animal(age){cout << "Tiger(int age, int weight) : Animal(age): " << endl;m_weight = weight;}~Tiger(){cout << "~Tiger() " << endl;}void info(){cout << "Tiger: m_age: " << m_age << " m_weight: " << m_weight << endl;}
};int main()
{Tiger tiger(2, 20);return 0;
}

多继承简介
- 一个派生类可以有很多基类，称之为多继承。
- 多继承时，可以按照父类声明顺序构造父类，按照构造相反的顺序析构。
多继承代码示例：

#include <iostream>using namespace std;//	基类BaseA
class BaseA
{
protected:int m_a;int m_c = 100;
public:BaseA(int a){cout << "BaseA(int a)" << endl;m_a = a;}~BaseA(){cout << "~BaseA()" << endl;}
};//	基类BaseB
class BaseB
{
protected:int m_b;int m_c = 200;
public:BaseB(int b){cout << "BaseB(int b)" << endl;m_b = b;}~BaseB(){cout << "~BaseB()" << endl;}
};class Derived : public BaseA, public BaseB
{
public:Derived(int a, int b) : BaseB(b), BaseA(a){cout << "Derived(int a, int b) : BaseA(a), BaseB(b)" << endl;}~Derived(){cout << "~Derived()" << endl;}void info(){cout << "m_a: " << m_a << " m_b: " << m_b << endl;//	当多个父类中出现同名成员时，使用 类名::成员名 访问。cout << "BaseA::m_c: " << BaseA::m_c << " BaseB::m_c: " << BaseB::m_c << endl;	}
};int main()
{Derived derived, 20);dervied.info();return 0;
}