类与对象是C++最重要的部分之一，学会了它基本就能够做成很多事情，包括基本的网页开发、类型处理。走进C++，让我们开始学习吧。

类与对象

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

C++认为万事万物皆为对象。对象上有其属性和行为

例如：人可以作为对象，属性有姓名、年龄、身高、体重…… 行为有走、跑、跳、吃饭、唱歌……

车也可以作为对象，属性有轮胎、方向盘、车灯……行为有载人、放音乐、开启空调……

具有相同性质的对象，我们可以抽象称为类，人属于人类，车属于车类

封装

封装的意义

封装是C++面向对象的三大特性之一

封装的意义：

将属性和行为作为一个整体
将属性和行为加以权限控制

封装意义1：

在设计类的时候，属性和行为写在一起，表现事物

语法：class 类名 { 访问权限: 属性 / 行为 };

设计一个圆类

求圆的周长

#include<iostream>
using namespace std;

const double PI = 3.14;
//设计一个圆类，求圆的周长
//圆求周长的公式：2 * PI * 半径
//class代表设计一个类，类后面紧跟着的就是类名称
class Circle
{
    //访问权限
    //公共权限
    public:
    
    //属性
    //半径
    int m_r;
    
    //行为
    //获取圆的周长
    double calculateZC()
    {
        return 2 * PI * m_r;
    }
    
};

int main()
{
    //通过圆类 创建一个具体的圆（对象）
    //实例化 （通过一个类 创建一个对象的过程）
    Circle c1;
    //对圆对象的属性进行赋值
    c1.m_r = 10;
    cout << "圆的周长" << c1.calculateZC() << endl;
    return 0;
}

设计一个学生类

属性有姓名学号，可以给姓名学号赋值，可以显示学生姓名和学号

#include<iostream>
#include<string>
using namespace std;

class Student
{
public:
    string m_Name;
    int m_Id;
    void showStudent()
    {
        cout << "姓名：" << m_Name << "\t" << "学号：" << m_Id << endl; 
    }
};

int main()
{
    //实例化对象
    Student s1;
    //s1对象进行属性赋值操作
    s1.m_Name = "zhangsan";
    s1.m_Id = 12345;
    s1.showStudent();
    
    //实例化对象
    Student s2;
    //s1对象进行属性赋值操作
    s2.m_Name = "lisi";
    s2.m_Id = 12346;
    s2.showStudent();
    return 0;
}

亦可以用下面的方式对类进行赋值操作

#include<iostream>
#include<string>
using namespace std;

class Student
{
public:
    //类中的属性和行为统一称为成员
    string m_Name;
    int m_Id;
public:
    void showStudent()
    {
        cout << "姓名：" << m_Name << "\t" << "学号：" << m_Id << endl; 
    }
    void setName(string name)
    {
        m_Name = name;
    }
    void setId(int id)
    {
        m_Id = id;
    }
};

int main()
{
    //实例化对象
    Student s1;
    //s1对象进行属性赋值操作
    s1.setName("zhangsan");
    s1.setId(12345);
    s1.showStudent();
    return 0;
}

封装的意义2

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

访问权限有三种：

public 公共权限

protected 保护权限

private 私有权限

示例

#include<iostream>
#include<string>
using namespace std;
//访问权限
//公共权限public    成员类内可以访问    类外也可以访问
//保护权限protected 成员类内可以访问    类外不可以访问
//私有权限private   成员类内可以访问    类外不可以访问
class Person
{
public:
    //公共权限
    string m_Name;
protected:
    //保护权限
    string m_Car;
private:
    //私有权限
    int m_Password;
public:
    void func()
    {
        m_Name = "zhangsan";
        m_Car = "Tractor";
        m_Password = 123456;
    }
    void func2()
    {
        cout << "1." << m_Name << "\t" << "2." << m_Car << "\t" << "3." << m_Password << endl;
    }
};

int main()
{
    //实例化具体对象
    Person p1;
    //p1.m_Car = "Benz";//error，保护权限内容在类外是访问不到的
    //p1.m_Password = 123;error，保护权限内容在类外是访问不到的
    p1.func();
    p1.m_Name = "Lisi";
    p1.func2();
    return 0;
}

struct和class的区别

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

struct 默认权限为公共

class 默认权限为私有

#include<iostream>
using namespace std;

class C1
{
    int m_A;//默认权限是私有权限
};

struct C2
{
    int m_A;//默认权限是公共权限
};

int main()
{
    C1 c1;
    c1.m_A = 10;//error
    struct C2 c2;
    c2.m_A = 10;//正确的
    return 0;
}

成员属性设置为私有

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

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

示例

#include<iostream>
#include<string>
using namespace std;
//成员属性设置为私有
//可以自己控制读写权限
//对于写权限可以检测数据的有效性
class Person
{
public:
    //设置姓名
    void setName(string name)
    {
        m_Name = name;
    }

    //获取姓名
    string getName()
    {
        return m_Name;
    }
    
    //获取年龄 只读
    int getAge()
    {
        return m_Age;
    }
    
    //设置年龄
    void setAge(int age)
    {
        if(age < 0 || age > 150)
        {
            m_Age = 0;
            cout << "年龄有误！" << endl;
            return;
        }
        m_Age = age;
    }
    
    //设置情人 只写
    void setLover(string lover)
    {
        m_Lover = lover;
    }
    
private:
    //姓名 可读可写
    string m_Name;
    //年龄 只读
    int m_Age;
    //情人 
    string m_Lover;
};

int main()
{
    Person p;
    p.setName("zhangsan");
    p.setLover("cangjing");//不可以访问
    cout << "姓名：" << p.getName() << endl;
    p.setAge(100);
    cout << "年龄：" << p.getAge() << endl;
    return 0;
}

设计一个立方体类

设计立方体类（Cube）求出立方体的面积和体积分别用全局函数和成员函数判断两个立方体是否相等。

代码

#include<iostream>
using namespace std;
//设计一个立方体类
class Cube
{
public:
    //行为
    //设置获取长、宽、高
    //设置长
    void setL(int l)
    {
        m_L = l;
    }
    //获取长
    int getL()
    {
        return m_L;
    }
    //设置宽
    void setW(int w)
    {
        m_W = w;
    }
    //获取宽
    int getW()
    {
        return m_W;
    }
    //设置高
    void setH(int h)
    {
        m_H = h;
    }
    //获取高
    int getH()
    {
        return m_H;
    }
    //获取立方体的面积
    int calculateS()
    {
        return 2 * m_L * m_W + 2* m_L * m_H + 2 * m_H * m_W;
    }
    //获取立方体的体积
    int calculateV()
    {
        return m_L * m_W * m_H;
    }
    
    //方法二：利用成员函数来判断两个立方体是否相等
    bool isSameByClass(Cube &c)
    {
        if((m_L == c.getL())&&(m_W == c.getW())&&(m_H == c.getH()))
        {
            return true;
        }
        return false;
    }
    
private:
    //属性
    int m_L;//长
    int m_W;//宽
    int m_H;//高
};

//方法一：利用全局函数判断 两个立方体是否相等
bool isSame(Cube &c1,Cube &c2)
{
    if((c1.getL() == c2.getL())&&(c1.getW() == c2.getW())&&(c1.getH() == c2.getH()))
    {
        return true;
    }
    return false;
}

int main()
{
    Cube c1;
    c1.setL(10);
    c1.setW(10);
    c1.setH(10);
    cout << "c1面积：" << c1.calculateS() << endl;
    cout << "c1体积：" << c1.calculateV() << endl;
    
    Cube c2;
    c2.setL(10);
    c2.setW(10);
    c2.setH(10);
    cout << "c2面积：" << c2.calculateS() << endl;
    cout << "c2体积：" << c2.calculateV() << endl;
    //全局函数判断
    bool ret = isSame(c1,c2);
    if(ret == 1)
    {
        cout << "c1和c2相等" << endl;
    }
    else
    {
        cout << "c1和c2不相等" << endl;
    }
    
    //成员函数判断
    bool ret = c1.isSameByClass(c2);
    if(ret == 1)
    {
        cout << "c1和c2相等" << endl;
    }
    else
    {
        cout << "c1和c2不相等" << endl;
    }
    return 0;
}

点和圆的关系

设计一个圆形类（Circle）和一个点类（Point）

计算点和圆的关系。

点和圆关系判断

点到圆心的距离==半径——点在圆上

点到圆心的距离 > 半径——点在圆外

点到圆心的距离 < 半径——点在圆内

#include<iostream>
using namespace std;
class Circle
{
public:
    //设置半径
    void setR(int r)
    {
        m_R = r;
    }
    //获取半径
    int getR()
    {
        return m_R;
    }
    //设置圆心
    void setCenter(Point center)
    {
        m_Center = center;
    }
    //获取圆心
    Point getCenter()
    {
        return m_Center;
    }
private:
    int m_R;//半径
    //在类中可以让另一个类作为本类中的成员
    Point m_Center;//圆心
};

class Point
{
public:
    //设置x
    void setX(int x)
    {
        m_X = x;
    }
    //获取x
    int getX()
    {
        return m_X;
    }
    //设置y
    void setY(int y)
    {
        m_Y = y;
    }
    //获取y
    int getY()
    {
        return m_Y;
    }
private:
    int m_X;
    int m_Y;
};

//判断点和圆的关系
void isInCircle(Circle &c, Point &p)
{
    //计算两点之间距离的平方
    int distance = 
    (c.getCenter().getX() - p.getX()) * (c.getCenter().getX() - p.getX()) +
    (c.getCenter().getY() - p.getY()) * (c.getCenter().getY() - p.getY());
    //计算半径的平方
    int rDistance = c.getR() * c.getR();
    //然后判断两者是否相等
    if(distance == rDistance)
    {
        cout << "点在圆上" << endl;
    }
    else if(distance > rDistance)
    {
        cout << "点在圆外" << endl;
    }
    else
    {
        cout << "点在圆内" << endl;
    }
}

int main()
{
    //创建圆
    Circle c;
    c.setR(10);
    Point center;
    center.setX(10);
    center.setY(0);
    c.setCenter(center);
    //创建点
    Point p;
    p.setX(10);
    p.setY(10);
    //判断关系
    isInCircle(c, p);
    return 0;
}

可以通过如下方式实现

主函数部分

#include<iostream>
using namespace std;
#include "circle.h"
#include "point.h"
#include "circle.cpp"
#include "point.cpp"
 
//判断点和圆关系
void isInCircle(Circle &c,Point &p)
{
    //计算两点之间的距离  平方
    int distance = (c.getCenter().getX() - p.getX())*(c.getCenter().getX() - p.getX()) +
        (c.getCenter().getY() - p.getY())*(c.getCenter().getY() - p.getY());
    //计算半径的平方
    int rDistance = c.getR()*c.getR();
    //判断关系
    if (distance == rDistance)
    {
        cout << "点在圆上" << endl;
    }
    else if (distance > rDistance)
    {
        cout << "点在圆外" << endl;
    }
    else
    {
        cout << "点在圆内" << endl;
    }
}
int main()
{
    //创建并设置点P1
    Point P1;
    P1.setX(10);
    P1.setY(9);
 
    //创建并设置点P2--圆心
    Point P2;
    P2.setX(10);
    P2.setY(0);
 
    //设置圆C1
    Circle C1;
    C1.setR(10);
    C1.setCenter(P2);
 
    isInCircle(C1, P1);
    system("pause");
    return 0;
}

circle.h

#pragma once
#include <iostream>
using namespace std;
#include "point.h"
 
class Circle//圆类5
{
public:
 
    void setR(int r);//设置半径
    
    int getR();//获取半径
    
    void setCenter(Point center);//设置圆心
    
    Point getCenter();//获取圆心
    
private:
    int m_R;//半径
 
    //在类中可以让另一个类，作为本类中的成员
    Point m_Center;//圆心
};

point.h

#pragma once   //防止头文件重复包含
#include <iostream>
using namespace std;
 
//只需要  成员函数、成员变量  的声明
class Point//点类
{
public:
    void setX(int x);//设置X
    int getX();//获取X
    void setY(int y);//设置Y
    int getY();//获取Y
private:
    int m_X;
    int m_Y;
};

circle.cpp

#include "circle.h"
 
void Circle::setR(int r)//设置半径
{
    m_R = r;
}
int Circle::getR()//获取半径
{
    return m_R;
}
void Circle::setCenter(Point center)//设置圆心
{
    m_Center = center;
}
Point Circle::getCenter()//获取圆心
{
    return m_Center;
}

point.cpp

#include "point.h"
 
//直接放在这儿，为全局函数。但 setX() 为成员函数，要加作用域Point::
void Point::setX(int x)//设置X
{
    m_X = x;
}
int Point::getX()//获取X
{
    return m_X;
}
void Point::setY(int y)//设置Y
{
    m_Y = y;
}
int Point::getY()//获取Y
{
    return m_Y;
}

对象特性

对象的初始化和清理

生活中我们买的电子产品都基本会有出厂设置。在某一天我们不用时候也会删除一些自己信息数据保证安全。
C++中的面向对象来源于生活，每个对象也都会有初始设置以及对象销毁前的清理数据的设置。

构造函数和析构函数

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

一个对象或者变量没有初始状态，对其使用后果是末知
同样的使用完一个对象或变量，没有及时清理，也会造成一定的安全问题

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

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

编译器提供的构造函数和析构函数是空实现。

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

构造函数语法：类名(){}

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

析构函数语法：~类名(){}

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

#include<iostream>
using namespace std;
//对象的初始化和清理

//构造函数 进行初始化操作
class Person
{
public:
    //构造函数
    Person()
    {
        cout << "Person 构造函数的调用" << endl;
    }
    //析构函数
    ~Person()
    {
        cout << "Person 析构函数的调用" << endl;
    }
};

//析构函数 进行清理的操作

//构造和析构都是必须有的实现，如果我们自己不提供，编译器会提供一个空实现的构造和析构
void test01()
{
    Person p;//在栈上的数据，test01执行完毕之后，释放这个对象
}

int main()
{
    test01();
    return 0;
}

析构函数的分类及调用

两种分类方式：按参数分为：有参构造和无参构造按类型分为：普通构造和拷贝构适三种调用方式：括号法显示法隐式转换法

示例

#include<iostream>
using namespace std;
//构造函数分类及调用
//分类
//按照参数分类 无参构造（默认构造）和有参构造
class Person
{
public:
    //构造函数
    Person()
    {
        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 test01()
{
    //括号法
    Person p;//默认构造函数调用，不要用()，因为编译器会认为是一个函数的声明，不会认为是在创建对象
    Person p2(10);//有参构造
    Person p3(p2);//拷贝构造函数
    cout << "p2的年龄为：" << p2.age << endl;
    cout << "p3的年龄为：" << p3.age << endl;
    
    //显示法
    Person p1 = Person(10);//调用有参构造
    Person p2 = Person(p1);//调用拷贝构造
    Person(10);//匿名对象 特点：当前行执行结束后，系统会立即回收匿名对象
    cout << "hello" << endl;//释放之后才能执行
    
    //不要利用拷贝构造函数 初始化匿名对象 编译器会认为Person(p2) === p2
    Person(p2);
    
    //隐式转换法
    Person p3 = 10;//相当于 Person p3 = Person(10);
    Person p4 = p3;//拷贝构造 Person p4 = Person(p3);
}
//调用
int main()
{
    test01();
    return 0;
}

拷贝构造函数调用时机

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

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

示例

#include<iostream>
using namespace std;

//拷贝构造函数调用时机
//使用一个已经创建完毕的对象来初始化一个对象

class Person
{
public:
    Person()
    {
        cout << "Person默认构造函数调用" << endl;
    }
    
    Person(int age)
    {
        cout << "Person有参构造函数调用" << endl;
        m_Age = age;
    }
    
    Person(const Person &p)
    {
        cout << "Person拷贝构造函数调用" << endl;
        m_Age = p.m_Age;
    }
    
    ~Person()
    {
        cout << "Person析构函数调用" << endl;
    }
    
    int m_Age;
};

void test01()
{
    Person p1(20);
    Person p2(p1);
    cout << "p2年龄为：" << p2.m_Age << endl;
}

//值传递的方式给函数参数传值

void doWork(Person p)
{
    
}

void test02()
{
    Person p;
    doWork(p);
}

//值传递的方式返回局部对象

Person doWork2()
{
    Person p1;
    cout << (int*)&p1 << endl;
    return p1;
}

void test03()
{
    Person p = doWork2();
    cout << (int*)&p << endl;
}

int main()
{
    test01();
    test02();
    test03();
    return 0;
}

构造函数调用规则

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

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

构请函数调用规则如下：

如果用户定义有参构造函数，C++不再提供默认无参构造，但是会提供默认拷贝构造
如果用户定义烤贝构造函故，C++不会再提供其他构造函数

#include<iostream>
using namespace std;

//构造函数的调用规则
//创建一个类，C++编译器会给每一个类都参加至少3个函数
//默认构造(空实现)
//析构函数(空实现)
//拷贝函数(值拷贝)

class Person
{
public:
    //Person()
    //{
        //cout << "Person默认构造函数调用" << endl;
    //}
    //若程序员自己编写有参构造函数，编译器就不再提供默认函数，仍然提供拷贝函数
    //编译器就会报错 error
    
    Person(int age)
    {
        cout << "Person有参构造函数调用" << endl;
        m_Age = age;
    }
    
    //Person(const Person &p)
    //{
        //cout << "Person拷贝构造函数调用" << endl;
        //m_Age = p.m_Age;
    //}
    //这里将拷贝函数注释掉，那么就由编译器自己提供一个默认构造
    //也就是说，若程序员自己编写有参构造函数，编译器就不再提供默认函数，仍然提供拷贝函数
    
    ~Person()
    {
        cout << "Person析构函数调用" << endl;
    }
    
    int m_Age;
};

void test01()
{
    Person p;
    p.m_Age = 18;
    
    Person p2(p);
    cout << "p2的年龄为：" << p2.m_Age << endl;
    
}

void test02()
{
    Person p(28);
    Person p2(p);
    cout << "p2的年龄为：" << p2.m_Age << endl;
}

int main()
{
    test01();
    test02();
    return 0;
}

深拷贝与浅拷贝

深浅拷贝是面试经典问题，也是常见的一个坑

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

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

示例

#include<iostream>
using namespace std;

//深拷贝与浅拷贝

class Person
{
public:
    Person()
    {
        cout << "Person默认构造函数调用" << endl;
    }
    
    Person(int age,int height)
    {
        m_Age = age;
        m_Height = new int(height);
        cout << "Person有参构造函数调用" << endl;
    }
    
    //自己实现拷贝函数来解决浅拷贝带来的问题
    Person(const Person &p)
    {
        cout << "Person拷贝构造函数调用" << endl;
        m_Age = p.m_Age;
        //m_Height = p.m_Height;编译器默认实现就是这个行代码
        //深拷贝
        m_Height = new int(*p.m_Height);
    }
    
    ~Person()
    {
        //析构函数 将堆区开辟数据做释放操作
        if(m_Height != NULL)
        {
            delete m_Height;
            m_Height = NULL;
        }
        cout << "Person析构函数构造调用" << endl;
    }
    
    int m_Age;//年龄
    int *m_Height;//身高
};

void test01()
{
    Person p1(18,160);
    cout << "p1的年龄为：" << p1.m_Age << "\t" <<"身高为：" << *p1.m_Height << endl;
    Person p2(p1);
    cout << "p1的年龄为：" << p1.m_Age << "\t" <<"身高为：" << *p1.m_Height << endl;
}
int main()
{
    test01();
    return 0;
}

p1	p2
int m_Age	int m_Age
18	18
int *m_Height	int *m_Height
0x0011-160	0x0022-160

Person p2(p1)

如果利用编译器提供的拷贝构造函数，会做浅拷贝操作

堆区

0x0011 - 160

浅拷贝带来的问题就是堆区的内存重复释放

这时候需要利用深拷贝进行解决

注意：如果属性在堆区开辟的，一定要自己提供拷贝构造函数，防止浅拷贝带来的问题

初始化列表

作用：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;
    }
    
    //初始化列表初始化属性
    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 test01()
{
    Person p(10, 20, 30);
    
    Person p(30,20,10);
    cout << "m_A = " << p.m_A << endl;
    cout << "m_B = " << p.m_B << endl;
    cout << "m_C = " << p.m_C << endl;
}

int main()
{
    test01();
    return 0;
}

类对象作为类成员

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

例如：

class A{}
class B
{
    A a;
}

B类中有对象A作为成员，A为对象成员

那么当创建B对象时，A与B的构造和析构的顺序是谁先谁后？

#include<iostream>
#include<string>
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:
    //Phone m_Phone = pName;隐式转换法
    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 test01()
{
    Person p("zhangsan","Apple MAX");
    cout << p.m_Name << " have a " << p.m_Phone.m_PName << endl;
}

int main()
{
    test01();
    return 0;
}

Phone构造函数调用
Person构造函数调用
zhangsan have a Apple MAX
Person析构函数调用
Phone析构函数调用

由此可知，现有Phone构造，再有Person构造函数

当其他类对象作为本类成员，构造时先构造类对象，在构造自身。

析构的顺序则是相反。

静态成员

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

静态成员分为：

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

示例1：静态成员变量

#include<iostream>
using namespace std;

//静态变量成员
class Person
{
public:
    //所有对象都共享同一份数据
    //编译阶段就分配内存
    //类内声明，类外初始化操作
    static int m_A;
    
    //静态成员变量也是有访问权限的
private:
    static int m_B;
};

int Person::m_A = 100;
int Person::m_B = 200;//error，类外访问不到私有静态成员变量

void test01()
{
    Person p;
    cout << p.m_A << endl;
    
    Person p2;
    p2.m_A = 200;
    cout << p.m_A << endl;//输出200
}

void test02()
{
    //静态成员变量 不属于某个对象，所以对象都共享同一份数据
    //因此静态成员变量有两种访问方式
    
    //通过对象进行访问
    Person p;
    cout << p.m_A << endl;
    //通过类名进行访问
    cout << Person::m_A << endl;
    cout << Person::m_B << endl;
}

int main()
{
    test01();
    test02();
    return 0;
}

示例2：静态成员函数

#include<iostream>
using namespace std;

//静态成员函数
//所有对象共享同一个函数
//静态成员函数只能访问静态成员变量
class Person
{
public:
    //静态成员函数
    static void func()
    {
        m_A = 100;//静态成员函数可以访问静态的成员变量
        m_B = 200;//error静态成员函数 不可以访问 非静态成员变量，无法区分到底是哪个对象的m_B的属性
        cout << "static void func调用" << endl;
    }
    
    static int m_A;//静态成员变量
    int m_B;//非静态成员变量
    
    //静态成员函数也是有访问权限的
private:
    static void func2()
    {
        cout << "static void func2调用" << endl;
    }
};

int Person::m_A = 0;

void test01()
{
    //1.通过对象访问
    Person p;
    p.func();
    //2.通过类名进行访问
    Person::func();
    Person::func2();//error，无法访问
}

int main()
{
    test01();
    return 0;
}

C++对象模型和this指针

成员变量和成员函数分开存储

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

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

示例

#include<iostream>
using namespace std;

class Person
{
    
};

class Person1
{
    int m_A;//非静态的成员变量
};

class Person2
{
    int m_A;
    static int m_B;//静态成员变量
};

int Person2::m_B = 0;//静态成员变量

class Person3
{
    int m_A;
    static int m_C;
    void func(){}//非静态成员函数
};

void test01()
{
    Person p;
    //空对象占用内存空间为：1
    //C++编译器会给每个空对象也分配一个字节空间，是为了区分空对象占内存的位置
    //每个空对象也应该有一个独一无二的内存地址
    cout << "size of p = " << sizeof(p) << endl;
    
    Person1 p1;
    cout << "size of p1 = " << sizeof(p1) << endl;
    
    Person2 p2;
    cout << "size of p2 = " << sizeof(p2) << endl;
    
    Person3 p3;
    cout << "size of p3 = " << sizeof(p3) << endl;//这里可以说明成员变量和成员函数是分开存储的
}

int main()
{
    test01();
    return 0;
}

size of p = 1
size of p1 = 4
size of p2 = 4
size of p3 = 4

this指针概念

根据上一个知识点，我们知道在C++中成员变量和成员函数是分开存储的

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

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

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

this指针是隐含每一个非静态成员函数内的一种指针

this指针不需要定义，直接使用即可

this指针的用途：

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

示例：

#include<iostream>
using namespace std;

class Person
{
public:
    Person(int age)
    {
        //this指针指向的是
        //this指针 指向被调用的成员函数 所属的对象
        this->age = age;
    }
    
    Person& PersonAddAge(Person &p)
    {
        this->age += p.age;
        //this指向p2的指针，而*this指向的就是p2这个对象本体
        return *this;
    }
    
    int age;
};

//1.解决名称冲突
void test01()
{
    Person p1(18);
    cout << "p1的年龄为：" << p1.age << endl;
}
//2.返回对象本身用*this
void test02()
{
    Person p1(10);
    Person p2(10);
    //链式编程思想，可以无限追加
    p2.PersonAddAge(p1).PersonAddAge(p1).PersonAddAge(p1);
    cout << "p2的年龄为：" << p2.age << endl;
}

int main()
{
    test01();
    test02();
    return 0;
}

空指针访问成员函数

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

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

示例：

#include<iostream>
using namespace std;

//空指针调用成员函数
class Person
{
public:
    void showClassName()
    {
        cout << "This is a Person class" << endl;
    }
    
    void showPersonAge()
    {
        //报错原因是因为传入的指针是NULL
        if(this == NULL)
        {
            return;
        }
        cout << "age = " << this->m_Age << endl;
    }
    
    int m_Age;
};

void test01()
{
    Person * p = NULL;
    p->showClassName();
    p->showPersonAge();
}

int main()
{
    test01();
    return 0;
}

const修饰成员变量

常函数：

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

常对象：

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

示例

#include<iostream>
using namespace std;
//常函数
class Person
{
public:
    //this指针的本质 是指针常量 指针的指针是不可以修改的
    //const Person * const this;
    void showPerson() cosnt//相当于Person前面的const
    {
        this->m_A = 100;
        //this = NULL;//this指针不可以修饰修改指针的指向
    }
    
    void func()
    {
        m_A = 100;
    }
    int m_A;
    mutable int m_B;//特殊变量，即使在常函数中，也可以修改这个值，加上关键字mutable
};

void test01()
{
    Person p;
    p.showPerson();
}

//常对象
void test02()
{
    const Person p;//在对象前加const，变为常对象
    p.m_A = 100;//error
    p.m_B = 100;//m_B是特殊值，在常对象下也可以修改
    
    //常对象只能调用常函数
    p.showPerson();
    p.func();
}

int main()
{
    test01();
    return 0;
}

友元

提及友元之前，我们先举个例子：

生活中你的家有客厅(Public)，有你的卧室(Private) 客厅所有来的客人都可以进去。但是你的卧室是私有的，也就是说只有你能进去但是呢，你也可以允许你的好闺蜜、好基友进去

在程序里，有些私有属性也想让类外特殊的一些函数或者类进行访问，就需要用到友元的技术

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

友元的关键字为friend

友元的三种实现

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

全局函数做友元

示例：

#include<iostream>
#include<string>
using namespace std;

class Building
{
    //goodGay全局函数 Build好朋友，可以访问Building中私有成员
    friend void goodGay(Building *building);

public:
    Building()
    {
        m_SittingRoom = "客厅";
        m_BedRoom = "卧室";
    }
    
public:
    string m_SittingRoom;//客厅
    
private:
    string m_BedRoom;//卧室
};

//全局函数
void goodGay(Building *building)
{
    cout << "好基友基友全局函数正在访问：" << building->m_SittingRoom << endl;
    cout << "好基友基友全局函数正在访问：" << building->m_BedRoom << endl;
}

void test01()
{
    Building building;
    goodGay(&building);
}

int main()
{
    test01();
    return 0;
}

类做友元

#include<iostream>
#include<string>
using namespace std;

class Building
{
    //GoodGay类是友元类，可以访问本类中私有的成员
    friend class GoodGay;
public:
    Building();
    
public:
    string m_SittingRoom;//客厅
    
private:
    string m_BedRoom;//卧室
};

//类做友元
class GoodGay
{
public:
    GoodGay();
    void visit();//参观函数，访问Building中的属性
    Building * building;
    
};

//类外写成员函数
Building::Building()
{
    m_SittingRoom = "客厅";
    m_BedRoom = "卧室";
}

GoodGay::GoodGay()
{
    //创建建筑物对象
    building = new Building;
}

void GoodGay::visit()
{
    cout << "好基友基友全局函数正在访问：" << building->m_SittingRoom << endl;
    cout << "好基友基友全局函数正在访问：" << building->m_BedRoom << endl;
}

void test01()
{
    GoodGay gg;
    gg.visit();
}

int main()
{
    test01();
    return 0;
}

成员函数做友元

#include<iostream>
#include<string>
using namespace std;

class Building;
class GoodGay
{
public:
    GoodGay();
    
    void visit();//让visit函数可以访问Building中私有成员
    void visit2();//让visit2函数不可以访问Building中私有成员

private:
    Building * building;
};

class Building
{
    //告诉编译器 GoodGay类下的visit成员函数作为本类的友元，可以访问私有成员
    friend void GoodGay::visit();

public:
    Building();

public:
    string m_SittingRoom;//客厅
private:
    string m_BedRoom;//卧室
};


//类外实现成员函数
Building::Building()
{
    m_SittingRoom = "客厅";
    m_BedRoom = "卧室";
}

GoodGay::GoodGay()
{
    building = new Building;
}

void GoodGay::visit()
{
    cout << "visit函数正在访问：" << building->m_SittingRoom << endl;
    cout << "visit函数正在访问：" << building->m_BedRoom << endl;
}

void GoodGay::visit2()
{
    cout << "visit2函数正在访问：" << building->m_SittingRoom << endl;
}

void test01()
{
    GoodGay gg;
    gg.visit();
    gg.visit2();
}

int main()
{
    test01();
    return 0;
}

C++运算符重载

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

加法运算符重载

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

对于内置数据类型，编译器知道如何进行运算

int a = 10;
int b = 20;
int c = a + b;//c = 30;

但是对于其他的自定义数据类型而言，是实现不了的

class Person
{
public:
    int m_A;
    int m_B;
};

Person p1;
p1.m_A = 10;
p1.m_B = 20;

Person p2;
p2.m_A = 10;
p2.m_B = 20;

Person p3 = p1 + p2;//这个是实现不了的

通过自己写成员函数，实现两个对象相加属性后返回的对象，如下：

Person PersonAddPerson(Person &p)
{
    Person temp;
    temp.m_A = this->m_A + p.m_A;
    temp.m_B = this->m_B + p.m_B;
    return temp;
}

编译器给起了一个通用名称，写成如下代码即可：

//通过成员函数重载
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;
}

Person p3 = p1.operator+(p2);
//简化为：
Person p3 = p1 + p2;

//通过全局函数重载
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;
}

Person p3 = operator*(p1,p2);
//简化为：
Person p3 = p1 + p2;

完整示例1：成员函数重载+号

#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;
};

void test01()
{
    Person p1;
    p1.m_A = 10;
    p1.m_B = 10;
    
    Person p2;
    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;
}

int main()
{
    test01();
    return 0;
}

完整示例2：全局函数重载+号

#include<iostream>
using namespace std;

//加号运算符重载
class Person
{
public:
    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;
    p1.m_A = 10;
    p1.m_B = 10;
    
    Person p2;
    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;
}

int main()
{
    test01();
    return 0;
}

小习题：重载+号

实现要求：

Person p2 = p1 + 10;

函数重载版本

#include<iostream>
using namespace std;

class Person
{
public:
    int m_A;
    int m_B;
};

Person operator+(Person &p,int num)
{
    Person temp;
    temp.m_A = p.m_A + num;
    temp.m_B = p.m_B + num;
    return temp;
}

void test01()
{
    Person p1;
    p1.m_A = 10;
    p1.m_B = 20;
    
    Person p2 = p1 + 10;
    cout << "p2.m_A = " << p2.m_A << endl;
    cout << "p2.m_B = " << p2.m_B << endl;
}

int main()
{
    test01();
    return 0;
}

左移运算符重载

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

int a = 10;
cout << a << endl;//可以通过cout左移输出

Person p;
p.m_A = 10;
p.m_B = 10;
cout << p << endl;//error，直接做肯定是不可以的

所以接下来就将为您演示，如何操作左移运算符重载的代码

左移运算符重载版本

#include<iostream>
using namespace std;

//左移运算符重载
class Person
{
public:
    //利用成员函数重载 左移运算符 p.operator<<(cout) 简化版本 p << cout
    //不会利用成员函数重载<<运算符，因为无法实现cout在左侧
    //void operator<<(cout){}
    
    int m_A;
    int m_B;
};

//只能利用全局函数重载左移运算符
ostream & operator<<(ostream &cout,Person p)//本质 operator << (cout ,p) 简化 cout << p;
{
    cout << "m_A = " << p.m_A << "\t" << "m_B = " << p.m_B << endl;
    return cout;
    
    //out << "m_A = " << p.m_A << "\t" << "m_B = " << p.m_B << endl;
    //return out;
    //这么写实际上也没有问题
}

void test01()
{
    Person p;
    p.m_A = 10;
    p.m_B = 20;
    
    Person p1;
    p1.m_A = 20;
    p1.m_B = 30;
    
    cout << p << p1;//链式编程思想，通过调用ostream函数来连续
}

int main()
{
    test01();
    return 0;
}

如果把class里面的内容设置为private形式

可以活学活用友元操作，

#include<iostream>
using namespace std;

//左移运算符重载
class Person
{
    friend ostream &operator<<(ostream &cout, Person &p);
public:
    Person(int a,int b)
    {
        m_A = a;
        m_B = b;
    }
    
private:
    //利用成员函数重载 左移运算符 p.operator<<(cout) 简化版本 p << cout
    //不会利用成员函数重载<<运算符，因为无法实现cout在左侧
    //void operator<<(cout){}
    
    int m_A;
    int m_B;
};

//只能利用全局函数重载左移运算符
ostream & operator<<(ostream &cout,Person &p)//本质 operator << (cout ,p) 简化 cout << p;
{
    cout << "m_A = " << p.m_A << "\t" << "m_B = " << p.m_B << endl;
    return cout;
    
    //out << "m_A = " << p.m_A << "\t" << "m_B = " << p.m_B << endl;
    //return out;
    //这么写实际上也没有问题
}

void test01()
{
    Person p(10,20);
    
    Person p1(30,30);
    
    cout << p << p1;//链式编程思想，通过调用ostream函数来连续
}

int main()
{
    test01();
    return 0;
}

递增运算符重载

作用：通过重载递增运算荷，实现自己的整型数据

递增运算符重载 ++
int a = 10;
cout << ++a << endl;//11
cout << a << endl;//11

int b = 10;
cout << b++ << endl;

class MyInteger
{
public:
    MyInteger()
    {
        m_Num;
    }
private:
    int m_Num;
};

MyInteger myint;
cout << myint << endl;//0
cout << ++myint << endl;//1
cout << myint++ << endl;//1
cout << myint << endl;//2

完整代码

#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;
    }
    
    //重载后置++运算符 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 test01()
{
    MyInteger myint;
    cout << ++myint << endl;
    cout << myint << endl;
}

void test02()
{
    MyInteger myint;
    cout << myint++ << endl;
    cout << myint << endl;
}

int main()
{
    test01();
    
    test02();
    return 0;
}

自己实现的递减运算符

#include<iostream>
using namespace std;

//重载递减运算符
//自定义类型
class MyInteger
{
    friend ostream &operator<<(ostream& cout,MyInteger);
public:
    MyInteger()
    {
        m_Num = 0;
    }
    
    //前置--
    MyInteger& operator--()
    {
        m_Num--;
        return *this;
    }
        
    //后置--
    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 test01()
{
    MyInteger myint;
    cout << --myint << endl;
    cout << myint << endl;
}

//后置--
void test02()
{
    MyInteger myint;
    cout << myint-- << endl;
    cout << myint << endl;
}

int main()
{
    test01();
    test02();
    return 0;
}

赋值运算符重载

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

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

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

我们打开VS编译时，会发现下面代码会出错

#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;
        }
    }
    
    int *m_Age;
};

void test01()
{
    Person p1(18);
    Person p2(20);
    p2 = p1;
    cout << "p1的年龄为：" << *p1.m_Age << endl;
    cout << "p2的年龄为：" << *p2.m_Age << endl;
}

int main()
{
    test01();
    return 0;
}

因为当我们调用p1时已经将析构函数调用，再调用p2时，就会发生重复释放堆区空间的问题。但是，对于我们vscode的小伙伴来说，这个没有任何影响，程序能够正常执行和结束的。为了使代码更加普适，我们不妨再写一个更加完善的深拷贝的赋值运算符重载代码。

#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)
    {
        //编译器是提供浅拷贝
        //应该先判断是否有属性在堆区，如果有先释放干净，然后再进行拷贝
        if(m_Age != NULL)
        {
            delete m_Age;
            m_Age = NULL;
        }
        //深拷贝操作
        m_Age = new int(*p.m_Age);
        return *this;
    }
    
    int *m_Age;
};

void test01()
{
    Person p1(18);
    Person p2(20);
    Person p3(30);
    p3 = p2 = p1;
    cout << "p1的年龄为：" << *p1.m_Age << endl;
    cout << "p2的年龄为：" << *p2.m_Age << endl;
    cout << "p3的年龄为：" << *p3.m_Age << endl;
}

int main()
{
    test01();
    return 0;
}

关系运算符重载

作用：重载关系运算符，可以让两个自定义类型对象进行对比操作

示例：

#include<iostream>
#include<string>
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;
    }
    
    //重载!=号
    bool operator!=(Person &p)
    {
        if(this->m_Name == p.m_Name && this->m_Age == p.m_Age)
        {
            return false;
        }
        return true;
    }
    
    string m_Name;
    int m_Age;
};

void test01()
{
    Person p1("Tom", 18);
    Person p2("Tom", 18);
    //判断==
    if(p1 == p2)
    {
        cout << "p1和p2是相等的" << endl;
    }
    else
    {
        cout << "p1和p2是不相等的" << endl;
    }
    //判断!=
    if(p1 != p2)
    {
        cout << "p1和p2是不相等的" << endl;
    }
    else
    {
        cout << "p1和p2是相等的" << endl;
    }
}

int main()
{
    test01();
    return 0;
}

函数调用运算符重载

函数调用运算符()也可以重载

由于重载后使用的方法非常像函数的调用，因此称为仿函数

仿函数没有固定的写法，非常灵活

示例：

#include<iostream>
#include<string>
using namespace std;

//函数调用运算符重载
class MyPrint
{
public:
    //重载函数调用运算符
    void operator()(string test)
    {
        cout << test << endl;
    }
};

//普通函数调用
void MyPrint02(string test)
{
    cout << test << endl;
}

void test01()
{
    MyPrint myPrint;
    myPrint("hello world!");
    
    MyPrint02("hello C++!");
}

//仿函数非常灵活，没有固定的写法
//加法类
class MyAdd
{
public:
    int operator()(int num1, int num2)
    {
        return num1 + num2;
    }
};

void test02()
{
    MyAdd myadd;
    int ret = myadd(100,100);
    cout << "ret = " << ret << endl;
    
    //匿名函数对象，如下也是可以调用的
    cout << MyAdd()(100,200) << endl;
}

int main()
{
    test01();
    test02();
    return 0;
}

继承

继承是面向对象三大特性之一

有些类与类之间存在特殊的关系，比如猫类和狗类，猫类下有波斯猫、加菲猫等，狗类下有哈士奇、边牧等。

我们发现，定义这些类的时候，下级别的成员除了拥有上一级成员的共性，还有自己的特性。这时候我们就可以考虑利用继承的技术，减少重复代码。

继承的基本语法

如我们看到很多网站中，都有公共的头部，公共的底部，甚至公共的左侧列表，只有中心内容不同。接下来我们份利用普通写法和继承的写法来实现网页中的内容，看一下继承存在的意义以及好处。

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

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

子类也称为派生类

父类也称为基类

普通实现：

#include<iostream>
using namespace std;

//普通实现页面

//Java的页面
class Java
{
public:
    void header()
    {
        cout << "首页、公开课、登录、注册...（公共头部）" << endl;
    }
    void footer()
    {
        cout << "帮助中心、交流合作、站内地图..." << endl;
    }
    void left()
    {
        cout << "Java、Python、C++...（公共分类列表）" << endl;
    }
    void content()
    {
        cout << "Java学科视频" << endl;
    }
};

//Python页面
class Python
{
public:
    void header()
    {
        cout << "首页、公开课、登录、注册...（公共头部）" << endl;
    }
    void footer()
    {
        cout << "帮助中心、交流合作、站内地图..." << endl;
    }
    void left()
    {
        cout << "Java、Python、C++...（公共分类列表）" << endl;
    }
    void content()
    {
        cout << "Python学科视频" << endl;
    }
};

//Python页面
class Cpp
{
public:
    void header()
    {
        cout << "首页、公开课、登录、注册...（公共头部）" << endl;
    }
    void footer()
    {
        cout << "帮助中心、交流合作、站内地图..." << endl;
    }
    void left()
    {
        cout << "Java、Python、C++...（公共分类列表）" << endl;
    }
    void content()
    {
        cout << "C++学科视频" << endl;
    }
};

void test01()
{
    cout << "Java下载视频页面如下：" << endl;
    Java ja;
    ja.header();
    ja.footer();
    ja.left();
    ja.content();
    cout << "-------------------------" << endl;
    
    cout << "Python下载视频页面如下：" << endl;
    Python py;
    py.header();
    py.footer();
    py.left();
    py.content();
    cout << "-------------------------" << endl;
    
    cout << "C++下载视频页面如下：" << endl;
    Cpp cpp;
    cpp.header();
    cpp.footer();
    cpp.left();
    cpp.content();
}

int main()
{
    test01();
    return 0;
}

继承实现页面

#include<iostream>
using namespace std;

//继承实现页面
//公共页面类
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 << "C++学科视频" << endl;
    }
};

void test01()
{
    cout << "Java下载视频页面如下：" << endl;
    Java ja;
    ja.header();
    ja.footer();
    ja.left();
    ja.content();
    cout << "-------------------------" << endl;
    
    cout << "Python下载视频页面如下：" << endl;
    Python py;
    py.header();
    py.footer();
    py.left();
    py.content();
    cout << "-------------------------" << endl;
    
    cout << "C++下载视频页面如下：" << endl;
    Cpp cpp;
    cpp.header();
    cpp.footer();
    cpp.left();
    cpp.content();
}

int main()
{
    test01();
    return 0;
}

总结：继承的好处：可减少重复的代码 class A : public B;

A类称为子类或派生类

B类称为父类或甚类

派生类中的成员，包含两大部分：一类是从基类继承过来的，一类是自己增加的成员。从基类继承过来的表现其共性，而新增的成员体现了其个性。

继承方式

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

继承方式有三种：

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

通用演示

父类

class A
{
public:
    int a;
protected:
    int b;
private:
    int c;
};

公用继承

class B:public A
{
public:
    int a;
protected:
    int b;
不可访问:
    int c;
};

保护继承

class B:protected A
{
protected:
    int a;
    int b;
不可访问:
    int c;
};

私有继承

class B:private A
{
private:
    int a;
    int b;
不可访问:
    int c;
};

完整示例

#include<iostream>
using namespace std;

//继承方式
//公共继承
class Base1
{
public:
    int m_A;
protected:
    int m_B;
private:
    int m_C;
};

class S1:public Base1
{
public:
    void func()
    {
        m_A = 10;//父类中的公共权限成员 到子类中依然是公共权限
        m_B = 10;//父类中的保护权限成员 到子类中依然是保护权限
        //m_C = 10;//父类中的私有权限成员 到子类无法访问
    }
};

void test01()
{
    S1 s1;
    s1.m_A = 100;//类内可以访问，类外也可以访问
    //s1.m_B = 100;//m_B是保护权限，不支持类外访问
}

//保护继承
class Base2
{
public:
    int m_A;
protected:
    int m_B;
private:
    int m_C;
};

class S2:protected Base2
{
public:
    void func()
    {
        m_A = 100;//父类中的公共权限成员 到子类中变为保护权限
        m_B = 100;//父类中的保护权限成员 到子类中变为保护权限
        //m_C = 10;//父类中的私有权限成员 到子类无法访问
    }
};

void test02()
{
    S2 s2;
    //s2.m_A = 1000;//在S2中变保护权限，在类外访问不到
    //s1.m_B = 1000;//m_B是保护权限，不支持类外访问
}

//私有继承
class Base3
{
public:
    int m_A;
protected:
    int m_B;
private:
    int m_C;
};

class S3:private Base3
{
public:
    void func()
    {
        m_A = 100;//父类中的公共权限成员 到子类中变为私有权限
        m_B = 100;//父类中的保护权限成员 到子类中变为私有权限
        //m_C = 10;//父类中的私有权限成员 到子类无法访问
    }
};

void test03()
{
    S3 s3;
    //s2.m_A = 1000;//在S2中变为私有权限，在类外访问不到
    //s1.m_B = 1000;//在S2中变为私有权限，不支持类外访问
}

//子类的子类

class GS:public S3
{
public:
    void func()
    {
        //m_A = 1000;
        //m_B = 1000;
        //m_C = 1000;
        //均为S3中的私有成员，均无法访问
    }
};

int main()
{
    test01();
    test02();
    test03();
    return 0;
}

继承中的对象模型

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

父类中所有非静态的成员属性都会被子类继承下去

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

示例：

#include<iostream>
using namespace std;

//继承中的对象模型

class Base
{
public:
    int m_A;
protected:
    int m_B;
private:
    int m_C;
};

class S :public Base
{
public:
    int m_D;
};

void test01()
{
    //16
    //父类中所有非静态的成员属性都会被子类继承下去
    //父类中私有成员属性 被编译器隐藏了，因此是访问不到的，但是确实被继承了
    cout << "size of S = " << sizeof(S) << endl;
}

//VS上面可以利用开发人员命令查看对象模型
//跳转盘符 F:
//跳转文件路径 cd 具体路径下
//查看命名 - 通过绝对路径可以看到

int main()
{
    test01();
    return 0;
}

继承中构造和析构顺序

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

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

示例

#include<iostream>
using namespace std;

//继承中的构造和析构顺序
class Base
{
public:
    Base()
    {
        cout << "Base构造函数！" << endl;
    }
    
    ~Base()
    {
        cout << "Base析构函数！" << endl;
    }
};

class S:public Base
{
public:
    S()
    {
        cout << "S构造函数！" << endl;
    }
    
    ~S()
    {
        cout << "S析构函数！" << endl;
    }
};

void test01()
{
    S s;
}

int main()
{
    test01();
    return 0;
}

Base构造函数！
S构造函数！
S析构函数！
Base析构函数！

继承中的构造和析构顺序如下：

先构造父类，在构造子类，析构的顺序与构造的顺序相反

继承同名成员处理方式

访问子类同名成员直接访问即可

访问父类同名成员需要加作用域

示例：

#include<iostream>
using namespace std;

//继承中同名成员处理
class Base
{
public:
    Base()
    {
        m_A = 100;
    }
    
    void func()
    {
        cout << "Base - func()调用" << endl;
    }
    
    void func(int a)
    {
        cout << "Base - func(int a)调用" << endl;
    }
    
    int m_A;
};

class S:public Base
{
public:
    S()
    {
        m_A = 200;
    }
    
    void func()
    {
        cout << "S - func()调用" << endl;
    }
    
    int m_A;
};

//同名成员属性处理
void test01()
{
    S s;
    cout << "S 下 m_A = " << s.m_A << endl;
    //如果通过子类对象 访问到父类中同名成员，需要加作用域
    cout << "Base 下 m_A = " << s.Base::m_A << endl;
}

//同名成员函数处理
void test02()
{
    S s;
    s.func();
    //调用父类同名成员函数
    s.Base::func();
    //如果想访问到父类同名函数，需要加作用域
    s.Base::func(100);
}

int main()
{
    test01();
    test02();
    return 0;
}

总结：

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

继承同名静态成员处理方法

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

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

示例

#include<iostream>
using namespace std;

//继承中的同名静态成员处理方式
class Base
{
public:
    static int m_A;
    
    static void func()
    {
        cout << "Base - static void func()" << endl;
    }
    
    static void func(int a)
    {
        cout << "Base - static void func(int a)" << endl;
    }
};
//类内声明，类外初始化
int Base::m_A = 100;

class S:public Base
{
public:
    static int m_A;
    
    static void func()
    {
        cout << "C - static void func()" << endl;
    }
};
int S::m_A = 200;

//同名静态成员属性
void test01()
{
    //1.通过对象访问
    cout << "通过对象访问" << endl;
    S s;
    cout << "S 下m_A = " << s.m_A << endl;
    cout << "Base 下m_A = " << s.Base::m_A << endl;
    //2.通过类名访问
    cout << "通过类名访问" << endl;
    cout << "S 下m_A = " << S::m_A << endl;
    cout << "Base 下m_A = " << Base::m_A << endl;//这是直接通过父类访问成员对象
    cout << "Base 下m_A = " << S::Base::m_A << endl;//通过子类S访问到父类作用域下的成员对象
    //第一个::代表通过类名方式来访问  第二个::代表访问父类作用域下
}

//同名静态成员函数
void test02()
{
    //1.通过对象访问
    cout << "通过对象访问" << endl;
    S s;
    s.func();
    s.Base::func();
    
    //2.通过类名访问
    cout << "通过类名访问" << endl;
    S::Base::func();
    
    //子类出现和父类同名静态成员函数，也会隐藏父类中所有同名成员函数
    //如果想访问父类同名静态成员函数，需要加作用域
    S::Base::func(100);
}

int main()
{
    test01();
    test02();
    return 0;
}

总结：

同名静态成员处理方式和非静态处理方式一样，只不过有两种访问的方式通过对象和通过类名实现的。

继承语法

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

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

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

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

示例：

#include<iostream>
using namespace std;

//继承语法
class Base1
{
public:
    Base1()
    {
        m_A = 100;
    }
    
    int m_A;
};

class Base2
{
public:
    Base2()
    {
        m_B = 200;
    }
    
    int m_B;
};

class Base3
{
public:
    Base3()
    {
        m_A = 300;
    }
    
    int m_A;
};

//子类    需要继承Base1和Base2
//语法    class  子类  :  继承方式  父类1, 父类2...
class S:public Base1, public Base2, public Base3
{
public:
    S()
    {
        m_C = 300;
        m_D = 400;
    }
    int m_C;
    int m_D;
};

void test01()
{
    S s;
    cout << "Size of S = " << sizeof(S) << endl;//20
    //当父类中出现同名成员，需要加作用域区分
    cout << "Base1::m_A = " << s.Base1::m_A << endl;
    cout << "Base2::m_A = " << s.Base3::m_A << endl;
}

int main()
{
    test01();
    return 0;
}

菱形继承

菱形继承概念：

两个派生类继承同一个基类

又有某个类同时继承两个派生类

这种继承被称为菱形继承，或者钻石继承

二义性是指编译器在寻找函数的时候不确定哪一个函数是正确的。

菱形继承问题：

羊继承了动物的数据，范同样维承了动物的教据，当草泥马使用数据时，就会产生二义性。
草泥马继承自动物的数据继承了两份，其实我们应该清楚，这份数据我们只需要一份就可以了。

#include<iostream>
using namespace std;

//动物类
class Animal
{
public:
    int m_Age;
};

//羊类
class Sheep:virtual public Animal{};

//驼类
class Tuo:virtual public Animal{};

//羊驼类
class SheepTuo:public Sheep, public Tuo{};

void test01()
{
    SheepTuo st;
    st.Sheep::m_Age = 18;
    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;
    //st.m_Age = 18;//这个数据在Sheep上有一份，在Tuo上也有一份，不明确
    
    //这份数据我们知道 又要一份就可以了，菱形继承导致数据有两份，资源浪费
    cout << "st.m_Age = " << st.m_Age << endl;
}

int main()
{
    test01();
    return 0;
}

virtual关键字可以进行虚继承

vbptr - 虚基类指针 v - virtual b - base ptr - 指针

这个vbptr指针会指向一个vbtable（虚基类表）

就图而言，Sheep指向了下面的vbtable Sheep这个虚基类表，这个表内记录了一个数据的偏移量，这个偏移量的大小为8，上面的0+8，就找到下面的那个m_Age部分了。如下：

然后分析Tuo的部分，它的虚基类指针指向的位置为4，它的虚基类表中的偏移量为4，4+4=8，所以和上面的Sheep指向的位置是一致的，如下图：

综上而言，无论是Sheep还是Tuo，都是继承了同一份指针。

总结：

菱形继承带来的主要问题是子类继承两份相同的数据，导致资源浪费以及毫无意义
利用虚继承可以解决菱形继承问题

虚继承

虚继承是面向对象编程中的一种技术，是指一个指定的基类，在继承体系结构中，将其成员数据实例共享给也从这个基类型直接或间接派生的其它类。

虚拟继承是多重继承中特有的概念。虚拟基类是为解决多重继承而出现的。如下图所示。

类D继承自类B1、B2，而类B1、B2都继承自类A，因此出现如右图所示的局面（非虚基类）。

多态

多态的基本概念

多态是C++面向对象三大特性之一

多态分为两类：

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

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

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

下面通过案例进行讲解多态：

#include<iostream>
using namespace std;

//多态
class Animal
{
public:
    //虚函数
    virtual void speak()
    {
        cout << "动物在说话" << endl;
    }
};

//猫类
class Cat:public Animal
{
public:
    //重写 函数返回值的类型 函数名 参数列表 完全相同
    virtual void speak()
    {
        cout << "小猫在说话" << endl;
    }
};

//狗类
class Dog:public Animal
{
public:
    virtual void speak()
    {
        cout << "小狗在说话" << endl;
    }
};

//执行说话的函数
//地址早绑定 在编译阶段确定函数地址
//如果想执行让猫说话，那么这个函数地址就不能提前绑定，需要在运行阶段进行绑定，地址晚绑定

//动态多态满足条件
//1.有继承关系
//2.子类重写父类的虚函数

//动态多态使用
//父类的指针或者引用 执行子类对象

void doSpeak(Animal &animal) //Animal & animal = Cat
{
    animal.speak();
}

void test01()
{
    Cat cat;
    doSpeak(cat);
    
    Dog dog;
    doSpeak(dog);
}

int main()
{
    test01();
    return 0;
}

执行说话的函数地址早绑定在编译阶段确定函数地址如果想执行让猫说话，那么这个函数地址就不能提前绑定，需要在运行阶段进行绑定，地址晚绑定

动态多态满足条件

有继承关系
子类重写父类的虚函数

动态多态使用：父类的指针或者引用执行子类对象

重写：函数返回值的类型函数名参数列表完全相同

动态多态的原理剖析

将上题的内容进行深入研究

#include<iostream>
using namespace std;

//多态
class Animal
{
public:
    //虚函数
    void speak()
    {
        cout << "动物在说话" << endl;
    }
};

//猫类
class Cat:public Animal
{
public:
    //重写 函数返回值的类型 函数名 参数列表 完全相同
    void speak()
    {
        cout << "小猫在说话" << endl;
    }
};

//狗类
class Dog:public Animal
{
public:
    void speak()
    {
        cout << "小狗在说话" << endl;
    }
};

//执行说话的函数
//地址早绑定 在编译阶段确定函数地址
//如果想执行让猫说话，那么这个函数地址就不能提前绑定，需要在运行阶段进行绑定，地址晚绑定

//动态多态满足条件
//1.有继承关系
//2.子类重写父类的虚函数

//动态多态使用
//父类的指针或者引用 执行子类对象

void doSpeak(Animal &animal) //Animal & animal = Cat
{
    animal.speak();
}

void test01()
{
    Cat cat;
    doSpeak(cat);
    
    Dog dog;
    doSpeak(dog);
}

void test02()
{
    cout << "size of Animal = " << sizeof(Animal) << endl;//空类内存为1，而virtual下虚函数则显示为4
}

int main()
{
    //test01();
    test02();
    return 0;
}

调用void test02() 的时候，发现没有virtual下的sizeof(Animal) = 1，有virtual的sizeof(Animal) = 4；

Animal类内部结构中有vfptr

vfptr - 虚函数（表）指针 v - virtual; f - function;

vftable - 虚函数表 - table

当子类重写父类的虚函数

子类中的虚函数表内部，会替换成子类的虚函数地址

&Cat::speak会覆盖原来父类的内容

当父类的指针或者指引指向子类对象时候，发生多态

Animal & animal = cat;

animal.speak();

1.多态案例 - 计算器

案例描述：

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

多态的优点：

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

示例

分别利用普通写法和多态技术实现计算器

普通写法

#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;
        }
        else if(oper == "/" && m_Num2 != 0)
        {
            return m_Num1 / m_Num2;
        }
        else 
        {
            cout << "输入错误！" << endl;
        }
        //如果想拓展新的功能，需要修改源码，比如添加取余
    }
    
    int m_Num1;//操作数1
    int m_Num2;//操作数2
};
    
void test01()
{
    //计算器对象创建
    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;
    cout << c.m_Num1 << " / " << c.m_Num2 << " = " << c.getResult("/") << endl;
}

int main()
{
    test01();
    return 0;
}

如果想拓展新的功能，需要修改源码，比如添加取余

在真实的开发过程中提倡开闭原则

开闭原则：对扩展进行开发，对修改进行关闭

多态实现

#include<iostream>
#include<string>
using namespace std;

//实现计算器抽象类
class Calculator
{
public:
    virtual int getResult()
    {
        return 0;
    }

    int m_Num1;//操作数1
    int m_Num2;//操作数2
};

//加法计算器类
class AddCalculator:public Calculator
{
public:
    virtual int getResult()
    {
        return m_Num1 + m_Num2;
    }
};

//减法计算器类
class SubCalculator:public Calculator
{
public:
    virtual int getResult()
    {
        return m_Num1 - m_Num2;
    }
};

//乘法计算器类
class MulCalculator:public Calculator
{
public:
    virtual int getResult()
    {
        return m_Num1 * m_Num2;
    }
};

//除法计算器类
class DelCalculator:public Calculator
{
public:
    virtual int getResult()
    {
        if(m_Num2 != 0)
            return m_Num1 / m_Num2;
    }
};

void test01()
{
    //多态的使用条件
    //父类指针或者引用指向子类对象
    
    //加法运算
    Calculator * 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 = 10;
    abc->m_Num2 = 10;
    cout << abc->m_Num1 << " - " << abc->m_Num2 << " = " << abc->getResult() << endl;
    delete abc;//用完销毁

    //乘法运算
    abc = new MulCalculator;
    abc->m_Num1 = 10;
    abc->m_Num2 = 10;
    cout << abc->m_Num1 << " * " << abc->m_Num2 << " = " << abc->getResult() << endl;
    delete abc;//用完销毁

    //除法运算
    abc = new DelCalculator;
    abc->m_Num1 = 10;
    abc->m_Num2 = 10;
    cout << abc->m_Num1 << " / " << abc->m_Num2 << " = " << abc->getResult() << endl;
    delete abc;//用完销毁
}

int main()
{
    test01();
    return 0;
}

再提一遍多态的好处：

组织结构清晰
可读性强
对于前期和后期扩展以及维护性高

总而言之，C++开发提倡利用多态设计程序架构，因为多态上面的那些优点。

纯虚函数和抽象类

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

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

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

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

抽象类特点：

无法实例化对象
子类必须重写抽象类中的纯虚函数。否则也属于抽象类

示例：

#include<iostream>
using namespace std;

//纯虚函数和抽象类
class Base
{
public:
    //纯虚函数
    //只要有一个纯虚函数，这个类就被称为抽象类
    //抽象类特点：1.无法实际化对象
    virtual void func() = 0;
};

class S:public Base
{
public:
    virtual void func()
    {
        cout << "func函数调用" << endl;
    }
};

void test01()
{
    //Base b;//error，抽象类无法实体化对象
    //new Base;//error，抽象类是无法实例化对象
    
    S s;//子类必须重写父类中的纯虚函数，否则无法实例化对象
    
    Base * base = new S;
    base->func();
}

int main()
{
    test01();
    return 0;
}

2.多态案例 - 制作饮品

案例描述：

制作饮品的大致流程为：煮水 - 冲泡 - 倒入杯中 - 加入辅料

利用多态技术实现本案例，提供抽象制作饮品甚黄，提供子类到作加啡和茶叶

#include<iostream>
using namespace std;

//多态实现制作饮品
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();
    }
};

//制作咖啡
class Coffee:public AbstractDrinking
{
public:
    //煮水
    virtual void Boil()
    {
        cout << "煮农夫山泉" << endl;
    }
    
    //冲泡
    virtual void Brew()
    {
        cout << "冲泡咖啡" << endl;
    }
    
    //倒入杯中
    virtual void PourInCup()
    {
        cout << "倒入杯中" << endl;
    }
    
    //倒入辅料
    virtual void PutSomething()
    {
        cout << "加入糖和牛奶" << endl;
    }
};

//制作茶水
class Tea:public AbstractDrinking
{
public:
    //煮水
    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 test01()
{
    //制作咖啡
    doWork(new Coffee);
    
    cout << "---------------------------" << endl;
    
    //制作茶水
    doWork(new Tea);
}

int main()
{
    test01();
    return 0;
}

虚析构和纯虚析构

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

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

虚析构和纯虚析构共性：

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

虚析构和纯虚析构区别：

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

虚析构语法：virtual ~类名(){}

纯虚析构语法：virtual ~类名()

示例：

#include<iostream>
#include<string>
using namespace std;

//虚析构和纯虚析构

class Animal
{
public:
    
    Animal()
    {
        cout << "Animal构造函数调用" << endl;
    }
    
    ~Animal()
    {
        cout << "Animal析构函数调用" << endl;
    }
    
    //纯虚函数
    virtual void speak() = 0;
};

class Cat:public Animal
{
public:
    Cat(string name)
    {
        cout << "Cat构造函数调用" << endl;
        m_Name = new string(name);
    }
    
    virtual void speak()
    {
        cout << *m_Name << "小猫在说话" << endl;
    }
    
    ~Cat()
    {
        if(m_Name != NULL)
        {
            cout << "Cat析构函数调用" << endl;
            delete m_Name;
            m_Name = NULL;
        }
    }
    
    string * m_Name;
};

void test01()
{
    Animal * animal = new Cat("Tom");
    animal->speak();
    delete animal;
}

int main()
{
    test01();
    return 0;
}
Animal构造函数调用
Cat构造函数调用
Tom小猫在说话
Animal析构函数调用
发现Cat的析构函数没有调用，那么析构函数内的指针也没有释放干净，造成了内存泄漏。

所以要对代码进行修改和完善：

完整代码如下：

#include<iostream>
#include<string>
using namespace std;

//虚析构和纯虚析构

class Animal
{
public:
    
    Animal()
    {
        cout << "Animal构造函数调用" << endl;
    }
    
    virtual ~Animal()
    {
        cout << "Animal析构函数调用" << endl;
    }
    
    //或者使用纯虚析构，但是这里会报错，文件或程序会无法运行的
    //这时候需要在外面进行定义
    //virtual ~Animal() = 0;
    
    //纯虚函数
    virtual void speak() = 0;
};

Animal::~Animal()
{
    cout << "Animal纯虚析构函数调用" << endl;
}

class Cat:public Animal
{
public:
    Cat(string name)
    {
        cout << "Cat构造函数调用" << endl;
        m_Name = new string(name);
    }
    
    virtual void speak()
    {
        cout << *m_Name << "小猫在说话" << endl;
    }
    
    ~Cat()
    {
        if(m_Name != NULL)
        {
            cout << "Cat析构函数调用" << endl;
            delete m_Name;
            m_Name = NULL;
        }
    }
    
    string * m_Name;
};

void test01()
{
    Animal * animal = new Cat("Tom");
    animal->speak();
    //父类指针在析构时候 不会调用子类中析构函数，导致子类如果有堆区属性，就会造成内存泄漏
    delete animal;
}

int main()
{
    test01();
    return 0;
}

Animal构造函数调用
Cat构造函数调用
Tom小猫在说话
Cat析构函数调用//通过virtual 利用虚析构可以解决父类指针释放子类对象时不干净的问题
Animal析构函数调用

总结：

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

3.多态案例 - 电脑组装

案例猫述：

电脑主要组成部件为CPU(用于计算)，显卡（用于显示），内存条（用于存储）

将每个零件封装出抽象基类，并且提供不同的厂商生产不同的零件，例如inter厂商和Lenovo厂商

创建电脑类提供让电脑工作的函数，并且调用每个零件工作的接口

测试时组装三台不同的电脑进行工作

让我们来对其进行抽象，如抽象出每个零件的类，如下就是其伪代码

class CUP 抽象类
{
public:
    //抽象计算函数
    virtual void calculator() = 0;
};

class VideoCard 抽象类
{
public:
    //抽象显示函数
    virtual void display() = 0;
};

class Memory 抽象类
{
public:
    //抽象存储函数
    virtual void storage() = 0;
};

电脑的类
class Computer
{
public:
    构造函数中传入三个零件指针
    提供一个工作的函数
    {
        调用每个零件工作的接口
    }
};

具体零件厂商
Inter厂商提供三个部件
class InterCpu :public CUP
{
public:
    void calculator()
    {
        cout << "Inter的CPU开始计算" << endl;
    }
};

Lenove厂商提供
class Lenovo :public CUP
{
public:
    void calculator()
    {
        cout << "Lenove的CPU开始计算" << endl;
    }
};

示例：

#include<iostream>
using namespace std;

//抽象不同零件类
class CPU //抽象类
{
public:
    //抽象计算函数
    virtual void calculator() = 0;
};

class VideoCard //抽象类
{
public:
    //抽象显示函数
    virtual void display() = 0;
};

class Memory //抽象类
{
public:
    //抽象存储函数
    virtual void storage() = 0;
};

//电脑的类
class Computer
{
public:
    //构造函数中传入三个零件指针
    Computer(CPU * cpu, VideoCard * vc, Memory * mem)
    {
        m_cpu = cpu;
        m_vc = vc;
        m_mem = mem;
    }
    
    //提供工作的函数
    void work()
    {
        m_cpu->calculator();
        m_vc->display();
        m_mem->storage();
    }
    
    //提供析构函数 释放3个电脑零件
    ~Computer()
    {
        //释放CPU零件
        if(m_cpu != NULL)
        {
            delete m_cpu;
            m_cpu = NULL;
        }
        
        //释放显卡零件
        if(m_vc != NULL)
        {
            delete m_vc;
            m_vc = NULL;
        }
        
        //释放内存条零件
        if(m_mem != NULL)
        {
            delete m_mem;
            m_mem = NULL;
        }
    }
    
private:
    CPU * m_cpu;//CPU的零件指针
    VideoCard * m_vc;//显卡零件指针
    Memory * m_mem;//内存条零件指针
};

//具体零件厂商
//Inter厂商提供三个部件
class IntelCpu :public CPU
{
public:
    virtual void calculator()
    {
        cout << "Intel的CPU开始计算" << endl;
    }
};

class IntelVideoCard :public VideoCard
{
public:
    virtual void display()
    {
        cout << "Intel的VideoCard开始显示" << endl;
    }
};

class IntelMemory :public Memory
{
public:
    virtual void storage()
    {
        cout << "Intel的内存条开始存储" << endl;
    }
};

//Lenove厂商提供
class LenovoCpu :public CPU
{
public:
    virtual void calculator()
    {
        cout << "Lenovo的CPU开始计算" << endl;
    }
};

class LenovoVideoCard :public VideoCard
{
public:
    virtual void display()
    {
        cout << "Lenovo的VideoCard开始显示" << endl;
    }
};

class LenovoMemory :public Memory
{
public:
    virtual void storage()
    {
        cout << "Lenovo的内存条开始存储" << endl;
    }
};

void test01()
{
    //第一台电脑零件
    CPU * intelCup = new IntelCpu;
    VideoCard * intelCard = new IntelVideoCard;
    Memory * intelMem = new IntelMemory;
    
    //创建第一台电脑
    cout << "第一台电脑开始工作" << endl;
    Computer * computer1 = new Computer(intelCup, intelCard, intelMem);
    computer1->work();
    delete computer1;
    
    cout << "-------------------------" << endl;
    
    
    //创建第二台电脑
    cout << "第二台电脑开始工作" << endl;
    Computer * computer2 = new Computer(new LenovoCpu, new LenovoVideoCard, new LenovoMemory);
    computer2->work();
    delete computer2;

    cout << "-------------------------" << endl;
    
    //创建第三台电脑
    cout << "第三台电脑开始工作" << endl;
    Computer * computer3 = new Computer(new IntelCpu, new LenovoVideoCard, new IntelMemory);
    computer3->work();
    delete computer3;
}

int main()
{
    test01();
    return 0;
}

结果：

第一台电脑开始工作
Intel的CPU开始计算
Intel的VideoCard开始显示
Intel的内存条开始存储
-------------------------
第二台电脑开始工作
Lenovo的CPU开始计算
Lenovo的VideoCard开始显示
Lenovo的内存条开始存储
-------------------------
第三台电脑开始工作
Intel的CPU开始计算
Lenovo的VideoCard开始显示
Intel的内存条开始存储

最后的最后，再来提一下。C++的精华——类与对象大全集，封装、对象特性、C++对象模型和this指针、友元、C++运算符重载、继承以及多态，最全面最容易理解的，进一步学习C++。本篇文章字数达到42.2k字，祝愿每一位看过的小伙伴都能拿到42k的月薪！！！感谢大家的支持，同时希望能得到大家的建议和意见。祝大家在学习过程中，修炼基本功，做出色程序员！

C++的精华——类与对象大全集，封装、对象特性、C++对象模型和this指针、友元、C++运算符重载、继承以及多态，最全面最容易理解的，进一步学习C++的知识体系

类与对象

封装

封装的意义

封装意义1：

设计一个圆类

设计一个学生类

封装的意义2

struct和class的区别

成员属性设置为私有

点和圆的关系

可以通过如下方式实现

对象特性

对象的初始化和清理

构造函数和析构函数

析构函数的分类及调用

拷贝构造函数调用时机

构造函数调用规则

深拷贝与浅拷贝

初始化列表

类对象作为类成员

静态成员

C++对象模型和this指针

成员变量和成员函数分开存储

this指针概念

空指针访问成员函数

const修饰成员变量

友元

全局函数做友元

类做友元

成员函数做友元

C++运算符重载

加法运算符重载

小习题：重载+号

左移运算符重载

递增运算符重载

完整代码

赋值运算符重载

关系运算符重载

函数调用运算符重载

继承

继承的基本语法

继承方式

继承中的对象模型

继承中构造和析构顺序

继承同名成员处理方式

继承同名静态成员处理方法

继承语法

菱形继承

虚继承

多态

多态的基本概念

动态多态的原理剖析

1.多态案例 - 计算器

纯虚函数和抽象类

2.多态案例 - 制作饮品

虚析构和纯虚析构

3.多态案例 - 电脑组装

猜你喜欢