类和对象（封装、继承、多态、友元）

c++面相对象的三大特性为：封装、继承、多态

c++ 认为万事万物都皆为对象，对象上有其属性和行为

一、类和对象（封装）

（一）封装的意义

封装是c++面相对象的三大特性之一

封装的意义：

• 将属性和行为作为一个整体，表现生活中的事物
• 将属性和行为加以权限控制

封装意义一：

• 在设计类的时候，属性和行为卸载一起，表现事物
• 语法： class 类名 {访问权限： 属性 / 行为}；

示例1：设计一个圆类，求圆的周长

#include <iostream>
using namespace std;
const double PI = 3.14;
//设计一个圆类，求圆的周长
//圆求周长的公式：2*PI*半径
class Circle {//访问权限//公共权限
public://属性//半径int m_r;//行为//h获取圆的周长double calculateZC() {return 2 * PI * m_r;}};int main(){//通过圆类 创建具体的圆（对象）Circle c1;//给圆对象的属性进行赋值c1.m_r = 10;cout << "圆的周长为：" << c1.calculateZC() << endl;system("pause");return 0;}

示例2：设计一个学生类，属性有姓名和学号，乐意给姓名和学号赋值，可以显示学生的姓名和学号。

#include<iostream>
#include<string>
using namespace std;
//学生类
class Student {
//类中的属性和行为 我们统一称为成员
//属性  成员属性 成员变量
//行为  成员函数 成员方法
public:string s_name;//姓名int s_id;//学号//设置姓名void setName(string name) {s_name = name;}//设置学号void setId(int id) {s_id = id;}//显示姓名void showName() {cout<<"姓名："<<s_name<<endl;}void showId() {cout << "学号：" << s_id << endl;}};int main() {Student s1;s1.setName("张三");s1.setId(1001);s1.showName();s1.showId();system("pause");return 0;
}

封装意义二：

类在设计时，可以把属性和行为放在不同的权限下，加以控制

访问权限有三种：

• public 公共权限
• protected 保护权限
• private 私有权限

#include <iostream>
using namespace std;
//访问权限
//三种
//公共权限 public 成员类内可以访问,类外可以访问
//保护权限 protected 类内可以访问，类外不能访问  儿子也可以访问父亲中保护的内容
//私有权限 private 类内可以访问，类外不能访问		儿子不可以访问父亲私有的内容
class Person {//公共权限
public:string m_Name;//姓名
protected://保护权限string m_Car;//汽车
private://私有权限int m_Password;//银行卡密码//类内可以访问
private:void func() {m_Name = "张三";m_Car = "宝马";m_Password = 123456;}
};
int main() {//实例化具体对象Person p1;p1.m_Name = "李四";//类外访问不到//p1.m_Car = "奔驰";//p1.m_Password = 654321;//p1.func();system("pause");return 0;
}

 （二）struct 和class的区别

在c++中struct和class唯一的区别就在于默认的访问权限不同

区别：

• struct 默认权限为公共
• class  默认权限为私有

#include <iostream>
using namespace std;
//struct 和class的区别
//struct 默认权限是 公共 public
//class 默认权限是 私有 private
class C1 {int m_A;//默认权限 是私有
};
struct C2 {int m_A;//默认权限 是公共};int main() {C1 c1;//c1.m_A = 10; //无法访问 访问权限是私有C2 c2;c2.m_A = 20; //可以访问 访问权限是公共system("pause");return 0;
}

（三）成员属性设置私有

优点1：将所有成员属性设置为私有，可以自己控制读写权限

优点2：对于写权限，我们可以检测数据的有效性

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <string>
using namespace std;
//成员属性设置为私有
//1、可以自己控制读写权限
//2、对于写可以检测数据的有效性//人类
class Person {
public://设置姓名void setName(string name) {m_Name = name;}//获取姓名string getName() {return m_Name;}//设置年龄void setAge(int age) {if (age >= 0 && age <= 150) {m_Age = age;}else {cout << "年龄不合法" << endl;}}//获取年龄int getAge() {return m_Age;}//设置偶像void setIdol(string idol) {m_Idol = idol;}//获取偶像string getIdol() {return m_Idol;}
private:string m_Name;//姓名 可读可写int m_Age=18;//年龄  只读string m_Idol;//偶像 只写};int main() {Person p;p.setName("张三");cout<<"姓名：" << p.getName()<<endl;p.setAge(160);cout << "年龄：" << p.getAge() << endl;//p.setIdol("小明");//cout << "偶像：" << p.getIdol() << endl;system("pause");return 0;
}

二、对象的初始化和清理

（一）构造函数和析构函数

对象的初始化和清理也是两个非常重要的安全问题

        一个对象或者变量没有初始状态，对其使用后果是未知的

        同样的使用完一个对象或变量，没有及时清理，也会造成一定的安全问题

c++利用了构造函数和析构函数解决了上述问题，这两个函数将会被编译器自动调用，完成对象的初始化和清理工作。

对象的初始化和清理工作是编译器强制要求我们做的事情，因此如果我们不提供构造和析构，编译器会提供编译器提供的构造函数和析构函数的空实现。

• 构造函数：主要作用在于创建对象时为对象的成员属性赋值，构造函数由编译器自动调用，无需手动调用
• 析构函数：主要作用在于对象销毁系统自动调用，执行一些清理工作。

构造函数语法：类名（）{ }

• 构造函数，没有返回值也不写void
• 函数名称与类名相同
• 构造函数可以有参数，因此可以发生重载
• 程序在调用对象时候会自动调用构造，无须手动调用，而且只会调用一次

析构函数语法： ~类名（）{ }

• 析构函数，没有返回值也不写void
• 函数名称与类名相同，在名称前加符号~
• 析构函数不可以有参数，因此不可以发生重载
• 程序在对象销毁前会自动调用析构，无须手动调用，而且只会调用一次

#include <iostream>
using namespace std;
//对象的初始化和清理
//1、构造函数和析构函数
class Person {//1.1 构造函数//没有返回值 不用写void//函数名 与类名相同//构造函数可以有参数，可以发生重载//创建对象时，构造函数会自动调用，而且只调用一次
public:Person() {cout<<"Person()构造函数的调用"<<endl;}
//2、析构函数//没有返回值 不用写void//函数名 与类名相同 在名称前加~//构造函数不可以有参数，不可以发生重载//对象在销毁前，析构函数会自动调用，而且只调用一次~Person() {cout<<"~Person()析构函数的调用"<<endl;}
};
void test01() {Person p1; }int main() {test01();system("pause");return 0;}

 （二）构造函数的分类及调用

两种分类方式：

• 按参数分为：有参构造和无参构造
• 按类型分为：普通构造和拷贝构造

三种调用方式：

• 括号法
• 显示法
• 隐式转换法

#include<iostream>
using namespace std;
//1.构造函数的分类及调用
//分类
// 按照参数分类 无参构造和有参构造
// 按照类型分类 普通构造函数和拷贝构造函数
class Person {//构造函数//无参构造(默认构造函数)
public:Person() {age = 18;cout << "Person()构造函数调用" << endl;}//有参构造Person(int a) {age = a;cout << "Person()构造函数调用" << endl;}//拷贝构造函数Person(const Person& p) {//将传入的人身上的属性，拷贝到我身上age = p.age;cout << "Person()拷贝构造函数调用" << endl;}//析构函数~Person() {cout << "~Person()析构函数调用" << endl;}int age;
};
//调用
void test02(){//1.括号法Person p1; //调用无参构造函数Person p2(10); //调用有参构造函数Person p3(p2); //调用拷贝构造函数//注意事项1//调用默认构造函数时不要加（）//因为下面这行代码，编译器会认为是一个函数的声明Person p4;void func(); //声明一个函数，但是没有定义cout << "p2.age=" << p2.age << endl;cout << "p3.age=" << p3.age << endl;//2.显示法Person p5 = Person(10); //调用有参构造函数Person p6 = Person(p2); //调用拷贝构造函数Person(10); //匿名对象 特点当前行指向结束后，系统会立即回收掉匿名对象//注意事项2//不要利用拷贝构造函数初始化匿名对象  编译器会认为 Person(p3)==Person(p3) 重定义//Person(p3);//错误//3.隐式转换法Person p7 = 10; //调用有参构造函数  相当于 Person p7 =Person（10） Person p8 = p2; //调用拷贝构造函数  相当于 Person p8 =Person（p2）//注意事项3
}
int main() {test02();}

（三）拷贝构造函数调用时机

c++中拷贝构造函数调用时机通常有三种情况

• 使用一个已经创建完毕的对象来初始化一个新对象
• 值传递的方式给函数参数传值
• 以值方式返回局部对象

#include <iostream>
using namespace std;
//拷贝构造函数调用时机//1.使用一个已经创建完毕的对象来初始化一个新对象//2.值传递的方式给函数参数传值//3.以值方式返回局部对象
class Person {
public:Person() {cout << "Person()默认构造函数调用" << endl;}Person(int age) {m_Age = age;cout << "Person(int age)构造函数调用" << endl;}Person(const Person& p) {m_Age = p.m_Age;cout << "Person(const Person& p)拷贝构造函数调用" << endl;}~Person() {cout << "~Person()析构函数调用" << endl;}int m_Age;
};
//1.使用一个已经创建完毕的对象来初始化一个新对象
void test001() {Person p1(20);Person p2(p1);cout << "p1.m_Age=" << p1.m_Age << endl;cout << "p2.m_Age=" << p2.m_Age << endl;}
//2.值传递的方式给函数参数传值
void doWork(Person p) {}
void test002() {Person p3;doWork(p3);
}
//3.以值方式返回局部对象
Person doWork2() {Person p4;cout << (int*)&p4 << endl;return p4;
}
void test003() {Person p5 = doWork2();cout << (int*)&p5 << endl;
}
int main() {//test001();//test002();test003();system("pause");return 0;
}

（四）构造函数调用规则

默认情况下，c++编译器至少给一个类添加3个函数

1. 默认构造函数（无参，函数体为空）
2. 默认析构函数（无参，函数体为空）
3. 默认拷贝构造函数，对属性进行拷贝

构造函数调用规则如下：

• 如果用户定义有参构造函数，c++不在提供无参构造，但是会提供默认拷贝构造
• 如果用户定义拷贝构造函数，c++不会再提供其它构造函数

#include <iostream>
using namespace std;
//默认情况下，c++编译器至少给一个类添加3个函数//默认构造函数（无参，函数体为空）
//默认析构函数（无参，函数体为空）
//默认拷贝构造函数，对属性进行拷贝class Person {
public://Person() {//	cout << "Person 的默认构造函数调用" << endl;//}//Person(int age) {//	m_age = age;//	cout << "Person 的有参构造函数调用" << endl;//}Person(const Person& p) {m_age = p.m_age;cout << "Person 的拷贝构造函数调用" << endl;}//~Person() {//	cout << "Person 的默认析构函数调用" << endl;//}int m_age;
};
void test12() {Person p1;p1.m_age = 18;Person p2(p1);cout << "p2 age: " << p2.m_age << endl;}
int main() {system("pause");return 0;
}

（五）深拷贝与浅拷贝

浅拷贝：简单的赋值拷贝操作

深拷贝：在堆区重新申请空间，进行拷贝操作

#include <iostream>
#include <string>
using namespace std;
//深拷贝与浅拷贝
class Person {
public:Person() {cout << "Person的默认函数调用" << endl;}Person(int age,int height) {p_age = age;p_Height = new int(height);cout << "Person的有参构造函数调用" << endl;}//自己实现拷贝构造函数 解决浅拷贝带来的问题Person(const Person& p) {p_age = p.p_age; //浅拷贝p_Height = new int(*p.p_Height);//深拷贝cout << "Person的拷贝构造函数调用" << endl;}~Person() {//析构代码，将堆区开辟数据做释放操作if (p_Height!= NULL) {delete p_Height;p_Height = NULL;}	cout<<"Person的析构函数调用"<<endl;}
public:int p_age;int* p_Height;
};
void test006() {Person p1(18, 170);Person p2(p1);//值传递 浅拷贝cout << "p1的年龄为：" << p1.p_age <<"p1身高为："<< *p1.p_Height << endl;cout << "p2的年龄为：" << p2.p_age << "p2身高为：" << *p2.p_Height << endl;}
int main() {test006();system("pause");return 0;
}

（六）初始化列表

作用：

C++提供了初始化列表语法，用来初始化属性

语法：构造函数（）：属性1（值1），属性2（值2）....{ }

#include <iostream>
using namespace std;class Person {
public:// 使用初始化列表正确初始化属性Person(int a , int b , int c ) : m_A(a), m_B(b), m_C(c) {}int m_A;int m_B;int m_C;
};void testt() {Person p(10, 20, 30);cout << "m_A:" << p.m_A << endl;cout << "m_B:" << p.m_B << endl;cout << "m_C:" << p.m_C << endl;
}int main() {testt();system("pause");return 0;
}

（七）类对象作为类成员

c++类中的成员可以是另一个类的对象，我们称该成员为对象成员

#include <iostream>
using namespace std;
//类对象作为类成员
class Phone {
public:Phone(string Pname) {cout << "Phone对象构造函数" << endl;m_Pname = Pname;}~Phone() {cout << "Phone对象析构函数" << endl;}//品牌string m_Pname;
};
class Person
{public:Person(string name, string pName):m_name(name), m_phone(pName){cout << "Person对象构造函数" << endl;}~Person() {cout << "Person对象析构函数" << endl;}//姓名string m_name;//手机Phone m_phone;
};
// 当其他类对象作为本类成员，构造时候先构造类对象再构造自身，析构的顺序与构造相反
void testt02() {Person p1("张三", "小米");cout << p1.m_name << "的手机品牌是：" << p1.m_phone.m_Pname << endl;
}
int main() {testt02();system("pause");return 0;
}

（八）静态成员

静态成员就是在成员变量和成员函数前加上关键字static，称为静态成员

静态成员分为：

• 静态成员变量
  • 所有对象共享同一份数据
  • 在编译阶段分配内存
  • 类内声明，类外初始化
• 静态成员函数
  • 所有对象共享一个函数
  • 静态成员函数只能访问静态成员变量

#include <iostream>
using namespace std;
//静态成员变量
class Person {
public://静态成员函数static void func() {m_A = 100; //修改静态成员变量//m_B = 200; 静态函数不能访问非静态的成员变量cout << "static void func()调用" << endl;}//1.所有对象都共享同一份数据//2.编译阶段就分配内存//3.类内声明，类外初始化操作static int m_A; //类内声明int m_B; 
};
int Person::m_A = 10;//类外初始化
void test66() {Person p;cout << p.m_A << endl; //输出10Person p2;p2.m_A = 200; //修改静态成员变量cout << p.m_A << endl; //输出200
}
void test67() {//静态成员变量 不属于某个对象，所有对象都共享同一份数据// 因此静态成员变量有两种访问方式//1.通过对象进行访问Person p;cout << p.m_A << endl; //2.通过类名进行访问cout << Person::m_A << endl; //输出10
}
void test68() {
//1.通过对象来访问Person p;p.func(); //调用静态成员函数//2.通过类名来访问Person::func(); //调用静态成员函数
}
int main() {test66();test67();test68();system("pause");return 0;
}

三、c++对象模型和this指针

（一）成员变量和成员函数分开存储

在c++中，类内的成员变量和成员函数分开存储

只有非静态成员变量才属于类的对象上

#include<iostream>
using namespace std;
//成员变量和成员函数分开存储
class Person {
public:int m_A;//非静态成员变量,属于类的对象
static	int m_B;//非静态成员变量
void func() {//不属于类的对象  不计在类的对象大小中}
static void staticFunc() {}//静态成员函数,属于类本身,不属于类的对象  不计在类的对象大小中
};
int Person::m_B = 100; //静态成员变量,属于类本身,不属于类的对象  不计在类的对象大小中
void test01() {Person p;//空对象占用的内存空间为： 1 //c++编译器会给每个空对象也分配一个字节的空间，是为了区分空对象占内存的位置//每个空对象也应该有一个独一无二的地址 所以分配1字节的内存空间 来区分空对象cout << "sizeof(Person)=" << sizeof(p) << endl; // 1字节}int main() {test01();system("pause");return 0;
}

（二）this指针概念

每一个非静态成员函数智慧诞生一份函数实例，也就是说多个同类型的对象会共用一块代码

那么问题是：这一块代码是如何区分哪个对象调用的自己呢？

c++通过提供特殊的对象指针，this指针，解决上述问题，this指针指向被调用的成员函数所属的对象。

• this指针是隐含每一个非静态成员函数内的一种指针
• this指正不需要定义，直接使用即可

this指针的用途

• 当形参和成员变量同名时，可以用this指针来区分
• 在类的非静态成员函数中返回对象本身，可使用return *this

#include <iostream>
using namespace std;class Person {
public:Person(int age) {//this指针指向被调用的成员函数所属的对象，谁调用指向谁this->age = age;}Person& PersonAddAge(Person& p) {this->age += p.age;return *this;}int age;
};
//1.解决名称冲突
void test03() {Person p(20);cout << "age:" << p.age << endl;
}
//返回对象使用 *this
void test04() {Person p1(10);Person p2(10);p2.PersonAddAge(p1).PersonAddAge(p1).PersonAddAge(p1);cout << "p2age:" << p2.age << endl;
}
int main() {test03();test04();system("pause");return 0;
}

（三）空指针访问成员函数

c++中空指针也是可以调用成员函数的，但是也要注意有没有用到this指针

如果用到this指正，需要加以判断保证代码的健壮性

#include <iostream>
using namespace std;
//空指针调用成员函数
class Person {
public:void showClassName() {cout << "Person" << endl;}//报错原因是因为传入的指针是位NULLvoid showPersonAge() {if (this == NULL) {cout << "this is NULL" << endl;return;}cout << "Person age is " << this->m_Age << endl;}int m_Age;
};
void test05() {Person* p = NULL;p->showClassName(); //空指针调用成员函数，会导致程序崩溃p->showPersonAge();//空指针调用成员函数，会导致程序崩溃}int main() {test05();system("pause");return 0;}

（四）const修饰成员函数

常函数

• 成员函数后加const后我们称为这个函数为常函数
• 常函数内不可以修改成员属性
• 成员属性声明时加关键字mutable后，在常函数中依然可以修改

常对象：

• 声明对象前加const称改对象为常对象
• 常对象只能调用函数

#include <iostream>
using namespace std;
//常函数
class Person {
public://this指针的本质 是指针常量 指针的指向是不可以修改的//Person * const this;指针指向的值可以修改void showPerson() const//限定指针指向的值不可以修改{//this-> m_A = 100;this指针不可以修改指针的指向this->m_B = 200; //可以修改变量的值cout << "m_B=" << this->m_B << endl;}void showPerson2() { this->m_A = 100;}int m_A;
mutable	int m_B; //特殊变量，即使在常函数中，也能修改变量的值
};//常对象
void test06() {const Person p; //常对象//p.m_A = 100; //常对象不能修改变量的值p.m_B = 200; //可以修改变量的值//常对象只能调用常函数p.showPerson(); //调用常函数//常对象不能调用普通成员函数//p.showPerson2(); //调用常函数}int main() {Person p;p.showPerson(); //调用常函数system("pause");return 0;}

四、友元

友元的目的就是让一一个函数或者类访问另一个类中的私有成员

友元的关键字为 friend

友元的三种实现：

• 全局函数做友元
• 类做友元
• 成员函数做友元

（一）全局函数做友元

#include <iostream>
#include <string>
using namespace std;
//建筑物类
class Building {//声明 goodGay全局函数作为Buildding 类的好朋友 可以访问私有成员
friend	void goodGay(Building* building);
public:Building() {m_SettingRoom = "客厅";m_Bedroom = "卧室";}string m_SettingRoom;//客厅private:string m_Bedroom; //卧室};
//全局函数
void goodGay(Building* building)  {cout << "好基友全局函数 正在访问：" << building->m_SettingRoom << endl;cout << "好基友全局函数 正在访问：" << building->m_Bedroom << endl;
}
void test01() {
Building building;
goodGay(&building);
}int main() {test01();system("pause");return 0;
}

 （二）类做友元

#include <iostream>
using namespace std;
//类做友元
class Building;
class GoodGay {public:GoodGay();void visit();//参观函数访问Building中的属性Building *building;};
class Building {
friend	class GoodGay;//声明GoodGay为友元类
public:Building();string m_SettingRoom;//客厅private:string m_Bedroom; //卧室};
//类外写成员函数
Building::Building() {string m_SettingRoom;//客厅string m_Bedroom; //卧室
}
GoodGay::GoodGay() {
//创建建筑物对象
building = new Building;}
void GoodGay::visit() {
cout << "GoodGay正在参观" << building->m_SettingRoom << "客厅" << endl;
//访问building对象的私有属性
cout << "GoodGay正在参观" << building->m_Bedroom << "卧室" << endl;}
void test01() {GoodGay gg;gg.visit();}
int main() {test01();system("pause");return 0;
}

（三）成员函数做友元

#include <iostream>
#include <string>
using namespace std;
class Building;
class GoodGay {public:GoodGay();void visit();//让 visit()函数能够访问Builing类的私有成员变量void visit2();//让 visit2()函数不能够访问Builing类的私有成员变量Building* building;};
class Building {//告诉编译器 GoodGay类下的visit()函数可以访问Building类的私有成员变量
friend	void GoodGay:: visit();public:Building();public:string m_SittingRoom;//客厅private:string m_BedRoom;//卧室};
Building::Building() {m_SittingRoom = "客厅";m_BedRoom = "卧室";
}
void GoodGay:: visit() {cout<<"visit函数正在访问"<<building->m_SittingRoom<<endl;cout<<"visit函数正在访问"<<building->m_BedRoom<<endl;
}
void GoodGay:: visit2() {cout<<"visit2函数正在访问"<<building->m_SittingRoom<<endl;//cout<<"visit2函数正在访问"<<building->m_BedRoom<<endl;
}
GoodGay::GoodGay() {
building = new Building();}
void test01() {GoodGay g;g.visit();g.visit2();}int main() {test01();system("pause");return 0;
}

五、运算符重载

运算符重载概念：对已有的运算符重新进行定义，赋予其另一种功能，以适应不同的数据类型

（一）加号运算符重载

作用：实现两个自定义数据类型相加的运算

#include <iostream>
using namespace std;
//加号运算符重载
class Person {public://1.成员函数重载+号//Person operator+(Person& p) {//Person temp;//temp.m_A =this -> m_A + p.m_A;//temp.m_B =this -> m_B + p.m_B;//return temp;//}int m_A;int m_B;};
//2.全局函数重载+号
Person operator+(Person& p1, Person& p2) {Person temp;temp.m_A = p1.m_A + p2.m_A;temp.m_B = p1.m_B + p2.m_B;return temp;
//运算符重载 函数也可以重载}
void test01(){Person p1, p2;p1.m_A = 10;p1.m_B =10;p2.m_A = 10;p2.m_B = 10;Person p3 = p1 + p2;cout << "p3.m_A = " << p3.m_A << endl;cout << "p3.m_B = " << p3.m_B << endl;
}
//2.全局函数重载+号
int main() {test01();system("pause");return 0;
}

（二）左移运算符重载

作用：可以输出自定义数据类型

#include <iostream>using namespace std;//左移运算符重载
class Person
{
public://利用成员函数 重载左移运算符 p.operator <<(cout) 简化版本 p<< cout// 不会利用成员函数重载<<运算符，因为无法实现 cout在左侧///*void operator <<() {}*/int m_A;int m_B;};
//只能利用全局函数重载<<运算符
// 不能利用成员函数重载<<运算符
ostream& operator << ( ostream& cout, Person& p) {cout << "m_A = " << p.m_A << " m_B = " << p.m_B << endl;return cout;
}
void test02() {Person p1;p1.m_A = 10;p1.m_B = 10;cout << "p1.m_A = " << p1.m_A << endl;cout << "p1.m_B = " << p1.m_B << endl;cout << p1<<endl;
}int main() {test02();system("pause");return 0;
}

 （三）递增运算符重载

#include <iostream>
using namespace std;
//递增运算符重载//自定义整型
class MyInteger {
friend	ostream& operator <<(ostream& cout, MyInteger myInt);
public:MyInteger() {m_Num = 0;}//重载前置++运算符 返回引用是为了一直对一个数据进行递增操作MyInteger& operator ++() {//先进行++运算m_Num++;//将自身返回return *this;}//重载后置++运算符//void operator ++(int) int 代表占位参数，可以用于区分前置和后置递增MyInteger  operator ++(int){ //后置递增返回值 前置递增返回引用//先记录当时结果MyInteger temp = *this;//后递增m_Num++;//最后将记录结果返回return temp; //局部变量 函数结束后销毁 所以只能返回值}private:int m_Num;
};
//重载左移运算符
ostream& operator <<(ostream& cout, MyInteger myInt) {cout<<myInt.m_Num;return cout;
}void test03() {MyInteger myInt;cout << ++myInt << endl;
}
void test04() {MyInteger myInt;cout << myInt++ << endl;
}
int main() {test03();test04();system("pause");return 0;
}

（四）赋值运算符重载

c++编译器至少给一个类添加4个函数

1. 默认构造函数（无参，函数体为空）
2. 默认析构函数（无参，函数体为空）
3. 默认拷贝构造函数，对属性进行值拷贝
4. 赋值运算符 operator =，对属性进行值拷贝

如果类中有属性指向堆区，做赋值操作时也会出现深浅拷贝的问题

#include <iostream>
using namespace std;
//赋值运算符重载
class Person {public:Person(int age) {m_Age = new int(age);}~Person() {if (m_Age != NULL) {delete m_Age;m_Age = NULL;}}//重载赋值运算符Person& operator=(Person& p) {//编译器提供浅拷贝//this->m_Age = p.m_Age;//应该先判断是否有属性在堆区，如果有先释放干净，然后再深拷贝if (m_Age != NULL) {delete m_Age;m_Age = NULL;}//深拷贝m_Age = new int(*p.m_Age);return *this;}int * m_Age;};
void test06() {Person p1(20);Person p2(30);Person p3(40);p2 = p1= p3;//赋值操作cout << "p1 age: " <<* p1.m_Age << endl;cout << "p2 age: " <<* p2.m_Age << endl;cout << "p3 age: " <<* p3.m_Age << endl;}
int main() {test06();system("pause");return 0;}

（五）关系运算符重载

#include <iostream>
using namespace std;
//关系运算符重载class Person{public:Person(string name, int age) {m_Name = name;m_Age = age;}//重载==号bool operator ==(Person& p) {if (this->m_Name == p.m_Name && this->m_Age == p.m_Age) {return true;}return false;}string m_Name;int m_Age;
};
void test08() {Person p1("Tom", 18);Person p2("Tom", 18);if (p1 == p2) {cout << "p1 == p2" << endl;}else{cout << "p1!= p2" << endl;}
}
int main() {test08();system("pause");return 0;
}

（六）函数调用运算符重载

• 函数调用运算符（）也可以重载
• 由于重载后使用方式非常想函数的调用，因此称为仿函数
• 仿函数没有固定写法，非常灵活。

#include <iostream>
#include <string>
using namespace std;
//函数调用运算符重载//打印输出类
class MyPrint {
public://重载函数调用运算符void operator()(string test) {cout << test << endl;}};
class MyAdd {
public://重载函数调用运算符int operator()(int a, int b) {return a + b;}};
void test09() {MyPrint myPrint;myPrint("Hello, world!");//由于重载后使用方式非常想函数的调用，因此称为仿函数MyAdd myAdd;cout << myAdd(10, 20) << endl;//匿名对象调用cout << "MyAdd()(100, 200)=" << MyAdd()(100, 200) << endl;
}
int main() {test09();system("pause");return 0;
}

六、继承

（一）继承的基本语法

总结：

继承的好处：可以减少重复的代码

继承语法  class 子类:继承方式 父类名称{};
子类也称为派生类
 父类也称为基类

#include <iostream>
using namespace std;//普通实现页面
//class Java {
//public:
//	void header() {
//		cout << "首页、公开课、登录、注册...(公共头部)" << endl;
//	}
//	void footer() {
//		cout<<"帮助中心、交流合作、站内地图...(公共底部)"<<endl;
//	}
//	void left() {
//		cout << "Java、Python、C++、...（公共分类列表）" << endl;
//	}
//	void content() {
//		cout << "Java学科视频" << endl;
//	}
//
//};
//class Python {
//public:
//	void header() {
//		cout << "首页、公开课、登录、注册...(公共头部)" << endl;
//	}
//	void footer() {
//		cout << "帮助中心、交流合作、站内地图...(公共底部)" << endl;
//	}
//	void left() {
//		cout << "Java、Python、C++、...（公共分类列表）" << endl;
//	}
//	void content() {
//		cout << "Python学科视频" << endl;
//	}
//
//};
//class Cpp{
//public:
//	void header() {
//		cout << "首页、公开课、登录、注册...(公共头部)" << endl;
//	}
//	void footer() {
//		cout << "帮助中心、交流合作、站内地图...(公共底部)" << endl;
//	}
//	void left() {
//		cout << "Java、Python、C++、...（公共分类列表）" << endl;
//	}
//	void content() {
//		cout << "Python学科视频" << endl;
//	}
//
//};
//继承实现页面
// 继承好处 减少代码重复
// 继承语法  class 子类:继承方式 父类名称{};
// 子类也称为派生类
// 父类也称为基类
//公共页面类class BasePage {
public:void header() {cout << "首页、公开课、登录、注册...(公共头部)" << endl;}void footer() {cout << "帮助中心、交流合作、站内地图...(公共底部)" << endl;}void left() {cout << "Java、Python、C++、...（公共分类列表）" << endl;}};
//Java页面
class Java:public BasePage
{public:void content() {cout << "Java学科视频" << endl;}
};
//Python页面
class Python :public BasePage
{
public:void content() {cout << "Python学科视频" << endl;}
};
//C++页面
class Cpp :public BasePage
{
public:void content() {cout << "cpp学科视频" << endl;}
};void test01() {cout << "Java下载视频页面如下：" << endl;Java java;java.header();java.left();java.content();java.footer();cout<<"------------------------------------------"<<endl;cout << "Python下载视频页面如下：" << endl;Python python;python.header();python.left();python.content();python.footer();cout<<"-"<<endl;cout << "------------------------------------------" << endl;cout << "C++下载视频页面如下：" << endl;Cpp cpp;cpp.header();cpp.left();cpp.content();cpp.footer();
}int main() {test01();system("pause");return 0;}

（二）继承方式

继承的语法：class 子类：继承方式  父类

继承方式一共有三种：

• 公共继承
• 保护继承
• 私有继承

#include <iostream>
using namespace std;
//继承方式//公共继承
class Base1 {public:int m_A;protected:int m_B;private:int m_C;
};class Son1 :public Base1 {
public:void func() {m_A = 10;m_B = 20;//父类中的保护变量可以访问//	m_C = 30; 父类中的私有变量不能访问}};
void test02() {Son1 s1;s1.m_A = 100;//s1.m_B = 100; 保护权限类外不能访问}
//保护继承
class Base2 {
public:int m_A;
protected:int m_B;
private:int m_C;};
class Son2 :protected Base2 {
public:void func() {m_A = 100;//父类中公共成员到子类中变为了保护m_B = 200;//m_C = 30; 私有权限类外不能访问}
};
void test03() {Son2 s2;//s2.m_A = 1000; 保护继承类外访问不到//s2.m_B = 2000;}
//私有继承
class Base3 {
public:int m_A;
protected:int m_B;
private:int m_C;};
class Son3 :private Base3 {
public:void func() {m_A = 1000;//父类中公共成员到子类变成私有成员m_B = 2000;//父类中保护成员到子类变成私有成员//m_C = 3000; 私有权限类外不能访问}
};
void test04() {Son3 s3;//s3.m_A = 10000; 私有继承类外访问不到//s3.m_B = 20000;//s3.m_C = 30000;
}
int main() {test02();test03();test04();system("pause");return 0;
}

（三）继承中的对象模型

问题：从父类继承过来的成员，哪些属于子类对象中？

父类中私有成员属性，是被编译器隐藏了，因此访问不到，但是确实被继承了下去

#include <iostream>
using namespace std;
// 继承中的对象模型
class Base {public:int m_A;protected:int m_B;private:int m_C;};
class Son :public Base {
public:int m_D;
};
void test05() {//16//父类中所有非静态的成员属性都会被子类继承下去//父类中私有成员属性，是被编译器隐藏了，因此访问不到，但是确实被继承了下去cout<<"Size of Son=" <<sizeof(Son)<<endl;
}
int main() {test05();system("pause");return 0;
}

（四）继承中的构造和析构顺序

子类继承父类后，当创建子类对象，也会调用父类的构造函数

问题：父类和子类的构造和析构顺序谁先谁后？

继承中的构造和析构顺序：先构造父类，再构造子类，析构的顺序与构造的顺序相反

#include <iostream>
using namespace std;
// 继承中构造和析构顺序
class Base {
public:Base() {cout << "Base构造函数" << endl;}~Base() {cout << "Base析构函数" << endl;}};
class Son:public Base {
public:Son() {cout << "Son构造函数" << endl;}~Son() {cout << "Son析构函数" << endl;}};void test001() {//Base b;Son s;}
int main() {test001();system("pause");return 0;}

（五）继承同名成员处理方式

问题：当子类与父类出现同名成员，如何通过子类对象，访问到子类或父类中同名的数据呢？

• 访问子类同名成员 直接访问即可
• 访问父类同名成员 需要加作用域

    如果子类中出现和父类同名的成员函数，子类的同名成员会隐藏掉父类中所有同名成员函数
    如果想访问到父类中被隐藏的同名成员函数，需要使用Base::成员函数名（需要加作用域）

总结

• 子类对象可以直接访问到子类中的同名成员
• 子类对象加作用域可以访问到父类同名成员
• 当子类与父类拥有同名的成员函数，子类会隐藏父类只能怪同名成员函数，加作用域可以访问到父类中的同名函数

#include <iostream>
using namespace std;//继承中同名的成员处理方式
class Base {
public:Base() {m_A = 100;}void func() {cout << "Base-func()调用" << endl;}int m_A;
};
class Son :public Base {
public:Son() {m_A = 200;}void func() {cout << "Son-func()调用" << endl;}int m_A;
};
void test002() {Son s;cout<<"Son 下的m_A:" << s.m_A << endl; //输出200cout<<"Base 下的m_A:" << s.Base::m_A << endl; //输出100//如果子类中出现和父类同名的成员函数，子类的同名成员会隐藏掉父类中所有同名成员函数//如果想访问到父类中被隐藏的同名成员函数，需要使用Base::成员函数名（需要加作用域）s.func(); //调用Son的func()//如何调用到父类中同名成员函数？s.Base::func(); //调用Base的func()
}
//同名的函数处理方式
void test003() {}
int main() {test002();system("pause");return 0;
}

（六）继承同名静态成员处理方式

问题：继承中同名静态成员在子类对象上如何进行访问？

静态成员和非静态成员出现同名，处理方式一致

• 访问子类同名成员 直接访问即可
• 访问父类同名成员 需要加作用域

#include <iostream>
using namespace std;
//继承同名静态成员处理方式
class Base {public:static int m_A;static void func() {cout << "Base下的静态函数调用" << endl;}
};
int Base::m_A = 100;
class Son : public Base {
public:static int m_A;static void func() {cout<<"Son下的静态函数调用"<<endl;}
};
int Son::m_A = 200;
//同名静态成员属性void test003() {//1、通过对象访问Son s;cout<<"Son下的m_A："<<s.m_A<<endl;cout<<"Base下的m_A："<<s.Base::m_A<<endl;//2、通过类名访问cout<<"Son下的m_A："<<Son::m_A<<endl;//第一个：：代表通过类名的方式访问 第二个：：代表访问父类作用域下cout<<"Base下的m_A："<<Son::Base::m_A<<endl;
}
void test004() {//1、通过对象访问Son s;s.func(); //Son下的静态函数调用s.Base::func(); //Base下的静态函数调用//2、通过类名访问Son::func(); //Son下的静态函数调用Son::Base::func(); //Base下的静态函数调用}int main() {test003();test004();system("pause");return 0;
}

（七）多继承语法

c++允许一个类继承多个类

语法：class 子类：继承方式 父类1，继承方式 父类2...

多继承可能会引发父类中有同名的成员出现，需要加作用域区分

c++实际开发中不建议用多继承

#include <iostream>
using namespace std;
// 多继承语法
class Base1 {
public:Base1(){m_A = 100;}int m_A;
};
class Base2 {
public:Base2() {m_A = 100;}int m_A;
};
//子类 需要继承Base1和Base2
//语法：class 子类：继承方式 父类1，继承方式 父类2...
class Son :public Base1, public Base2 {
public:Son() {m_C = 300;m_D = 400;}int m_C;int m_D;};
void test07() {Son s;cout<<"sizeof(Son)="<<sizeof(s)<<endl;//当父类中出现了不同的成员，需要加作用域cout<<"Base1m_A="<<s.Base1::m_A<<endl;cout<<"Base2m_A="<<s.Base2::m_A<<endl;}
int main() {test07();system("pause");return 0;
}

（八）菱形继承

#include <iostream>
using namespace std;
//动物类
class Animal{
public:int m_Age;};
//利用虚继承 解决菱形继承的问题
// 继承之前 加上关键字 virtual 变为虚继承
// Animal类称为 虚基类
//羊类
class Sheep:virtual public Animal{};
//驼类
class Tuo :virtual public Animal {};//羊驼类
class SheepTuo :public Sheep, public Tuo {};
void test09() {SheepTuo st;st.Sheep::m_Age = 10;st.Tuo::m_Age = 28;//当菱形继承，两个父类拥有相同数据，需要加以作用域区分cout<<"st.Sheep::m_Age:" << st.Sheep::m_Age << endl;cout<<"st.Tuo::m_Age:" << st.Tuo::m_Age << endl;cout<<"st.m_Age"<<st.m_Age<<endl; //这份数据我们知道只要有一份就可以了，菱形继承导致有两份导致了资源的浪费
}int main() {test09();system("pause");return 0;
}

七、多态

（一）多态的基本概念

多态是c++面相对象三大特性之一

多态分为两类：

• 静态多态：函数重载和运算符重载属于静态多态，复用函数名
• 动态多态：派生类和虚函数实现运行时多态

静态多态和动态多态的区别：

• 静态多态的函数地址早绑定 -编译阶段确定函数地址
• 动态多态的函数地址晚绑定-运行阶段确定函数地址

#include <iostream>
using namespace std;
// 多态的基本概念
class Animal {
public://虚函数  地址晚绑定
virtual	void speak() {cout << "动物在说话" << endl;}
};
//猫类
class Cat :public Animal {
public://虚函数  地址晚绑定void speak() {cout << "猫在叫" << endl;}
}; 
//狗类
class Dog :public Animal {
public://虚函数  地址晚绑定void speak() {cout << "狗在汪汪叫" << endl;}
};
//执行说话的函数
//地址早绑定  在编译阶段确定函数地址
//如果想执行让猫说话，那么这个函数地址就不能提前绑定，需要在运行阶段进行绑定，地址晚绑定
void doSpeak(Animal& animal) { //Animal & animal =cat;animal.speak();
}
//动态多态满足条件
//1.有继承关系
//2.子类要重写父类的虚函数//动态多态的使用
//父类的指针或者引用指向子类的对象
void test01() {Cat cat;doSpeak(cat); // 调用的是猫类的speak函数  动物在说话Dog dog;doSpeak(dog);
}
void test02() {cout<<"sizeof(Animal)="<<sizeof(Animal)<<endl; //8字节（两个指针）
}
int main() {test01();test02();system("pause");return 0;
}

（二）多态案例一 计算器类

案例描述：

分别用普通写法和多态技术，设计实现两个操作数进行运算的计算器类

多态的优点：

• 代码组织结构清晰
• 可读性强
• 利于前期后期的扩展以及维护

#include <iostream>
#include <string>
using namespace std;
//分别利用普通写法和多态技术实现计算器//普通写法
class Calculator {
public:int getResult(string oper) {if (oper == "+") {return m_Num1 + m_Num2;}else if (oper == "-") {return m_Num1 - m_Num2;}else if (oper == "*") {return m_Num1 * m_Num2;}//如果想要扩展新的功能，需要修改源码//在真实的开发中 提倡 开闭原则//开闭原则：对扩展进行开放，对修改进行关闭}int m_Num1; //操作数1int m_Num2; //操作数2};
void test03() {//创建计算器对象Calculator c;c.m_Num1 = 10;c.m_Num2 = 10;cout<<c.m_Num1<<"+"<<c.m_Num2<<"="<<c.getResult("+")<<endl;cout<<c.m_Num1<<"-"<<c.m_Num2<<"="<<c.getResult("-")<<endl;cout<<c.m_Num1<<"*"<<c.m_Num2<<"="<<c.getResult("*")<<endl;	}
//利用多态实现计算器
//实现计算器抽象类
class AbstracatCalculator {
public:
virtual	int getResult() {return 0;}int m_Num1; //操作数1int m_Num2; //操作数2};
//加法计算器类
class AddCalculator :public AbstracatCalculator {
public:int getResult() {return m_Num1 + m_Num2;	}
};
//减法计算器类
class SubCalculator :public AbstracatCalculator {	public:int getResult() {return m_Num1 - m_Num2;}
};
//乘法计算器类
class MulCalculator :public AbstracatCalculator {
public:int getResult() {return m_Num1 * m_Num2;}
};
//利用多态技术实现计算器
void test04() {//创建加法计算器对象AbstracatCalculator* abc = new AddCalculator();abc->m_Num1 = 10;abc->m_Num2 = 10;cout << abc->m_Num1 << "+" << abc->m_Num2 << "=" << abc->getResult() << endl;//用完记得销毁delete abc;//创建减法计算器对象abc=new SubCalculator();abc->m_Num1 = 100;abc->m_Num2 = 100;cout << abc->m_Num1 << "-" << abc->m_Num2 << "=" << abc->getResult() << endl;delete abc;//创建乘法计算器对象abc = new MulCalculator();abc->m_Num1 = 100;abc->m_Num2 = 100;cout << abc->m_Num1 << "*" << abc->m_Num2 << "=" << abc->getResult() << endl;delete abc;
}int main() {test03();test04();system("pause");return 0;}

（三）纯虚函数和抽象类

在多态中，通常父类中虚函数的实现是毫无意义的，主要都是调用子类重写的内容

因此可以将虚函数改为纯虚函数

纯虚函数语法：virtual 返回值类型 函数名 (参数列表)=0；

当类中有了纯虚函数，这个类也称为抽象类

抽象类的特点：

• 无法实例化对象
• 子类必须重写抽象类中的纯虚函数，负责也属于抽象类

#include <iostream>
using namespace std;//纯虚函数和抽象类
class Base {
public://纯虚函数//只要有一个纯虚函数 这个类称为抽象类//抽象类特点：//1.无法实例化对象//2.抽象类的子类必须重写父类中的纯虚函数virtual void fun() = 0; //纯虚函数};
class Son : public Base {void fun() {//重写父类纯虚函数cout << "Son::fun()" << endl;}};
void test06() {//Base base; // 抽象类无法实例化对象//Son son; // 子类为重写父类纯虚函数不可以实例化对象Son son;Base *base =new Son(); // 指针指向子类对象base->fun();
}
int main() {test06();system("pause");return 0;}

（四）多态案例二 -制作饮品

#include<iostream>
using namespace std;
//多态的案例2：制作饮品
class AbstractDrinking {
public://注水virtual void boil() = 0;//冲泡virtual void brew() = 0;//倒入杯子virtual void pourInCup() = 0;//加入辅料virtual void PutSomething() = 0;//制作饮品void makeDrink() {boil();brew();pourInCup();PutSomething();cout << "制作完成！" << endl;}};
//制作咖啡
class Coffee :public AbstractDrinking {//煮水virtual void boil() {cout<<"煮水"<<endl;}//冲泡virtual void brew() {cout << "用沸水冲泡咖啡" << endl;}//倒入杯子virtual void pourInCup() {cout << "倒入杯子" << endl;}//加入辅料virtual void PutSomething() {cout << "加入糖和牛奶" << endl;}
};
//制作茶
class Tea :public AbstractDrinking {//煮水virtual void boil() {cout << "煮矿泉水" << endl;}//冲泡virtual void brew() {cout << "用沸水冲泡茶叶" << endl;}//倒入杯子virtual void pourInCup() {cout << "倒入杯子" << endl;}//加入辅料virtual void PutSomething() {cout << "加入茶辅料" << endl;}};
void doWork(AbstractDrinking* abs) {abs->makeDrink();delete abs; //释放}
void test07() {//制作咖啡doWork(new Coffee());//制作茶doWork(new Tea());}
int main() {test07();system("pause");return 0;}

（五）虚析构和纯虚析构

多态使用时，如果子类中有属性开辟到堆区，那么父类指针在释放时无法调用到子类的析构代码

解决方式：将父类中的析构函数改为虚析构或者纯虚析构

虚析构和纯虚析构工性：

• 可以解决父类指针释放子类对象
• 都需要有具体的函数实现

虚析构和纯虚析构的区别：

• 如果是纯虚析构，该类属于抽象类，无法实例化对象

虚析构语法：

virtual ~类名（）{实现}

纯虚析构语法：

virtual ~类名（）=0；

类名：：~类名（）{ 实现}

总结：

1. 虚析构或者纯虚析构就是用来解决父类指针释放子类对象
2. 如果子类中没有堆区数据，可以不写为虚析构或者纯虚析构
3. 拥有纯虚析构函数的类也属于抽象类

#include <iostream>
#include <string>
using namespace std;
//虚析构和纯虚析构class Animal {
public:Animal() {cout << "Animal构造函数调用" << endl;}//纯虚函数virtual void speak() = 0;//virtual ~Animal() {//cout  << "Animal析构函数调用" << endl;//}//纯虚析构virtual ~Animal() = 0;
};Animal:: ~Animal(){cout << "Animal纯虚析构函数调用" << endl;}
class Cat :public Animal {
public:Cat(string name) {cout << "Cat构造函数调用" << endl;m_Name=	new string(name);}void speak() {cout<<*m_Name << "喵喵喵" << endl;}~Cat(){if (m_Name != NULL) {cout << "Cat析构函数调用" << endl;delete m_Name;m_Name = NULL;}}string* m_Name;
};
void test08() {Animal* a = new Cat("TOM");a->speak();//父类指针在析构时候 不会调用子类中析构函数，导致子类如果有堆区属性，出现内存泄漏delete a;
}
int main() {test08();system("pause");return 0;
}

（六）多态案例三-电脑组装

#include <iostream>
using namespace std;
//抽象不同零件类
//抽象CPU类
class CPU {
public://抽象的计算函数virtual void calculate() = 0;};
//抽象显卡类
class VideoCard {
public://抽象的显示函数virtual void display() = 0;
};
class Memory {
public://抽象的存储函数virtual void memory() = 0;
};
//电脑类
class Computer {
public:Computer(CPU* cpu, VideoCard* videoCard, Memory* memory) {m_cpu = cpu;m_videoCard = videoCard;m_memory = memory;}//工作函数void work() {m_cpu->calculate();m_videoCard->display();m_memory->memory();}//提供析构函数 释放三个电脑零件~Computer() {//释放CPU零件if (m_cpu != NULL) {delete m_cpu;m_cpu = NULL;}//释放显卡零件if (m_videoCard != NULL) {delete m_videoCard;m_videoCard = NULL;}//释放内存条零件if (m_memory != NULL) {delete m_memory;m_memory = NULL;}}
private:CPU* m_cpu; //CPU的零件指针VideoCard* m_videoCard;//显卡零件指针Memory* m_memory;//内存条零件指针
};//具体厂商
//Intel厂商
class IntelCPU :public CPU {
public:void calculate() {cout << "Intel CPU is calculating..." << endl;}
};
class IntelVideoCard :public VideoCard {
public:void display() {cout << "Intel VideoCard is displaying..." << endl;}
};
class IntelMemory :public Memory {
public:void memory() {cout << "Intel Memory is storing..." << endl;}
};
//AMD厂商
class AMDCPU :public CPU {
public:void calculate() {cout << "AMD CPU is calculating..." << endl;}
};
class AMDVideoCard :public VideoCard {
public:void display() {cout << "AMD VideoCard is displaying..." << endl;}
};
class AMDMemory :public Memory {
public:void memory() {cout << "AMD Memory is storing..." << endl;}
}; 
//联想厂商
class LenovoCPU :public CPU {
public:void calculate() {cout << "Lenovo CPU is calculating..." << endl;}
};	class LenovoVideoCard :public VideoCard {void display() {cout << "Lenovo VideoCard is displaying..." << endl;}
};class LenovoMemory :public Memory {
public:void memory() {cout << "Lenovo Memory is storing..." << endl;}
};
void test02() {//第一台电脑零件CPU * intelCpu = new IntelCPU();VideoCard * intelVideoCard = new IntelVideoCard();Memory * intelMemory = new IntelMemory();//第一台电脑Computer * computer1 = new Computer(intelCpu, intelVideoCard, intelMemory);computer1->work();delete computer1;//第二台电脑零件Computer computer2(new LenovoCPU, new AMDVideoCard, new IntelMemory);computer2.work();}int main() {test02();system("pause");return 0;}