引言

  小伙伴们都知道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;
}

结语

  由于篇幅有限，暂不能写完有关继承和多态的知识，剩下的就留着下一篇章，超详细的 C++中的封装继承和多态的知识总结<2.多态>,小伙伴们，虽然没有写完，但是本章的内容也不少，小伙伴们一定要认真复习，这个理解起来挺费劲的，但是也是我们学习后续必不可少的内容。小伙伴们加油呀~
  冲冲冲！！！！