C++核心高级编程 --- 4.类和对象

文章目录

- 第四章：
- - 4.类和对象
  - - 4.1 封装
    - - 4.1.1 封装的意义
      - 4.1.2 struct与class的区别
    - 4.2 对象的初始化和清理
    - - 4.2.1 构造函数和析构函数
      - 4.2.2 构造函数的分类及调用
      - 4.2.3 拷贝构造函数调用时机
      - 4.2.4 构造函数调用规则
      - 4.2.5 深拷贝与浅拷贝
      - 4.2.6 初始化列表
      - 4.2.7 类对象作为类成员
      - 4.2.8 静态成员
    - 4.3 C++对象模型和this指针
    - - 4..3.1 成员变量和成员函数分开存储
      - 4.3.2 this指针
      - 4.3.3 空指针访问成员函数
      - 4.3.4 const修饰成员函数
    - 4.4 友元
    - - 4.4.1 全局函数做友元
      - 4.4.2 类做友元
      - 4.4.3 成员函数做友元
    - 4.5 运算符重载
    - - 4.5.1 加号运算符重载
      - 4.5.2 左移运算符重载
      - 4.5.3 递增运算符重载
      - 4.5.4 赋值运算符重载
      - 4.5.5 关系运算符重载
      - 4.5.6 函数调用运算符重载
    - 4.6 继承
    - - 4.6.1 继承基本语法
      - 4.6.2 继承方式
      - 4.6.3 继承中的对象模型
      - 4.6.4 继承中构造和析构顺序
      - 4.6.5 继承同名成员处理方式
      - 4.6.6 继承同名静态成员处理方式
      - 4.6.7 多继承语法
      - 4.6.8 菱形继承
    - 4.7 多态
    - - 4.7.1 多态基本概念
      - 4.7.2 纯虚函数和抽象类
      - 4.7.3 虚析构和纯虚析构
      - 4.7.4 多态案例
      - 案例一：制作计算器类
        案例二：制作冷饮
        案例三：组装电脑

第四章：

4.类和对象

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

4.1 封装

4.1.1 封装的意义

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

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

#include <iostream>
using namespace std;const int PI = 3.14;class Circle
{//访问权限//public - 公共权限
public://属性//半径int m_r;//行为//计算圆的面积double calculateCircleArea(){return PI * (m_r * m_r);}};int main()
{//创建一个具体的圆(对象)Circle c1;//对圆(对象)的属性进行赋值操作c1.m_r = 3;cout << "半径为" << c1.m_r << "的面积为" << c1.calculateCircleArea() << endl;system("pause");return 0;
}

#include <iostream>
#include <string>
using namespace std;class Student
{
public:void getID(int id){m_id = id;}void getName(string name){m_name = name;}void getAge(int age){m_age = age;}void showStudent(){cout << m_name << "学号是" << m_id << "年龄是" << m_age << endl;}public:int m_id;string m_name;int m_age;
};
int main()
{Student s1;s1.getID(123456);s1.getName("小明");s1.getAge(18);s1.showStudent();system("pause");return 0;
}

三种访问权限：

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

#include <iostream>
using namespace std;// public    - 类内可访问，类外可访问
// protected - 类内可访问，类外不可访问
// private   - 类内可访问，类外不可访问class Person
{
public:string m_Name;
protected:string m_Phone;
private:string m_Password;public:void func(){m_Name = "小红";m_Phone = "HW";m_Password = "ABC123";}
};int main()
{Person p1;p1.m_Name = "小明";p1.m_Phone = "HW";        //报错,protected类外不可访问p1.m_Password = "abc123"; //报错,private类外不可访问system("pause");return 0;
}

4.1.2 struct与class的区别

默认访问权限不同：

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

#include <iostream>
#include <string>
using namespace std;struct Person1
{string m_Name;
};class Person2
{string m_Name;
};int main()
{Person1 p1;p1.m_Name = "小明";Person2 p2;p2.m_Name = "小红"; //报错system("pause");return 0;
}

4.2 对象的初始化和清理

4.2.1 构造函数和析构函数

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

一个对象或变量没有初始状态，对于其使用后的结果是未知的。
使用完一个对象或变量，没及时清理会造成一定的安全问题。

在C++中使用构造函数和析构函数来解决以上问题，如果我们不提供构造和析构函数，编译器会提供构造函数和析构函数(空实现)。

构造函数：作用于创建对象时对对象的成员属性进行赋值，构造函数有编译器自动调用，无需手动调用。
析构函数：作用于在对象销毁前系统自动调用，进行清理工作。

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

无返回值，无需写void
函数名和类型相同
可以有参数，因此可发生重载
程序在调用对象时会自动调用，无序手动调用，指挥调用一次

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

无返回值，无需写void
函数名于类名相同，在名称前加上符号~
不可有参数，由此不可发生重载
程序在对象销毁前会自动调用，无序手动调用，只会调用一次。

#include <iostream>
using namespace std;class Student
{
public:Student(){cout << "Student的构造函数调用" << endl;}~Student(){cout << "Student的析构函数调用" << endl;}
};void test()
{Student s;
}int main()
{test();system("pause");return 0;
}

在这里插入图片描述

4.2.2 构造函数的分类及调用

两种分类方式：

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

三种调用方式：

括号法
显示法
隐式转换法

#include <iostream>
using namespace std;class Student
{
public:Student(){cout << "Student的默认构造函数调用" << endl;}Student(int a){age = a;cout << "Student的有参构造函数调用" << endl;}Student(const Student& s){age = s.age;cout << "Student的拷贝构造函数调用" << endl;}~Student(){cout << "Student的析构函数调用" << endl;}int age;
};void test()
{//1.括号法//Student s1();   //调用默认构造函数时，不要加(),编译器会认为是一个函数的声明 Student s1;       //默认构造函数调用Student s2(18);   //有参构造函数调用Student s3(s2);   //拷贝构造函数调用cout << "s2的年龄是" << s2.age << endl;cout << "s3的年龄是" << s3.age << endl;//2.显示法Student s4;Student s5 = Student(19);Student s6 = Student(s5);//Student(20);    //匿名对象，当前行执行结束后，系统自动回收掉。//Student(s6);      //不要用拷贝构造函数，初始化匿名对象，编译器会认为Student(s5）= Student s5；// //3.隐式转换法Student s7 = 17;  //相当于Student s7 = Student(17)Student s8 = s7;
}
int main()
{test();system("pause");return 0;
}

4.2.3 拷贝构造函数调用时机

三种情况：

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

#include <iostream>
using namespace std;class Student
{
public:Student(){cout << "Student的默认构造函数调用" << endl;}Student(int age){cout << "Student的有参构造函数调用" << endl;m_age = age;}Student(const Student& s){cout << "Student的拷贝构造函数调用" << endl;m_age = s.m_age;}~Student(){cout << "Student的析构构造函数调用" << endl;}int m_age;
};//使用一个已经创建完毕的对象来初始化一个新的对象
void test01()
{Student s1(18);Student s2(s1);cout << "s2的年龄是" << s2.m_age << endl;
}void Work1( Student s)
{}
//值传递的方式给函数参数传值
void test02()
{Student s3;Work1(s3);
}Student work2()
{Student s5;cout << &s5 << endl;return s5;
}//以值方式返回局部对象
void test03()
{Student s4 = work2();cout << &s4 << endl;
}int main()
{test01();test02();test03();system("pause");return 0;
}

4.2.4 构造函数调用规则

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

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

调用规则：

如果用户定义了有参构造函数，C++将不会提供默认无参构造函数，但会提供默认拷贝构造函数。
如果用户定义了拷贝构造函数，C++将不会提供其他的构造函数。

//如果用户定义了有参构造函数，C++将不会提供默认无参构造函数，但会提供默认拷贝构造函数。
#include <iostream>
using namespace std;class Student
{
public:Student(){cout << "Student的默认构造函数调用" << endl;}Student(int age){cout << "Student的有参构造函数调用" << endl;m_age = age;}/*Student(const Student& s){cout << "Student的拷贝构造函数调用" << endl;m_age = s.m_age;}*/~Student(){cout << "Student的析构函数调用" << endl;}int m_age;
};void test01()
{Student s1;s1.m_age = 18;Student s2(s1);cout << "s2的年龄是：" << s2.m_age << endl;
}//void test02()
//{
//    Student s3(20);
//    Student s4(s3);
//    cout << "s4的年龄是" << s4.m_age << endl;
//}int main()
{test01();//test02();system("pause");return 0;
}

在这里插入图片描述

#include <iostream>
using namespace std;class Student
{
public:/*Student(){cout << "Student的默认构造函数调用" << endl;}*/Student(int age){cout << "Student的有参构造函数调用" << endl;m_age = age;}Student(const Student& s){cout << "Student的拷贝构造函数调用" << endl;m_age = s.m_age;}~Student(){cout << "Student的析构函数调用" << endl;}int m_age;
};//void test01()
//{
//    Student s1;
//    s1.m_age = 18;
//    Student s2(s1);
//    cout << "s2的年龄是：" << s2.m_age << endl;
//}void test02()
{Student s3(20);Student s4(s3);cout << "s4的年龄是" << s4.m_age << endl;
}int main()
{/*test01();*/test02();system("pause");return 0;
}

在这里插入图片描述

4.2.5 深拷贝与浅拷贝

浅拷贝：赋值拷贝操作

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

#include <iostream>
using namespace std;class Student
{
public:Student(){cout << "Student的默认构造函数调用" << endl;}Student(int age, int weight){m_age = age;m_weight = new int(weight);cout << "Student的有参构造函数调用" << endl;}Student(const Student& s){cout << "Student的拷贝构造函数调用" << endl;m_age = s.m_age;m_weight = new int(*s.m_weight);}~Student(){if (m_weight != NULL){delete m_weight;m_weight = NULL;}cout << "Student的析构函数调用" << endl;}int m_age;int* m_weight;
};void test01()
{Student s1(18, 120);cout << "s1的年龄是" << s1.m_age << ",体重是：" << *s1.m_weight << endl;Student s2(s1);cout << "s2的年龄是" << s2.m_age << ",体重是：" << *s2.m_weight << endl;
}int main()
{test01();system("pause");return 0;
}

4.2.6 初始化列表

作用：初始化属性

语法结构：构造函数():属性1(值1), 属性2(值2)…{}

#include <iostream>
using namespace std;class Student
{
public:Student():m_age(18),m_height(180){}Student(int age, int height) :m_age(age), m_height(height){}int m_age;int m_height;
};void test01()
{Student s1;cout << "s1的年龄是" << s1.m_age << endl;cout << "s1的身高是" << s1.m_height << endl;Student s2(20,175);cout << "s2的年龄是" << s2.m_age << endl;cout << "s2的身高是" << s2.m_height << endl;
}int main()
{    test01();system("pause");return 0;
}

在这里插入图片描述

4.2.7 类对象作为类成员

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

#include <iostream>
#include <string>
using namespace std;class Phone
{
public:Phone(string pName){m_PName = pName;cout << "Phone的构造函数调用" << endl;}~Phone(){cout << "Phone的析构函数调用" << endl;}string m_PName;
};class Student
{
public:Student(string name, string pName):m_Name(name), m_Phone(pName){/*    m_Name = name;m_Phone = pName;*/cout << "Student的构造函数调用" << endl;}~Student(){cout << "Student的析构函数调用" << endl;}string m_Name;Phone m_Phone;
};void test01()
{Student s1("小明", "HW");cout << s1.m_Name << "使用" << s1.m_Phone.m_PName << "手机" << endl;
}int main()
{test01();system("pause");return 0;
}

在这里插入图片描述

总结：当其他类对象作为本类成员时，构造时先构造类对象，再构造自身，析构的顺序与构造相反。

4.2.8 静态成员

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

分类：

静态成员变量

  所有对象共享同一份数据在编译阶段时分配内存类内声明，类外初始化

静态成员函数
所有对象共享同个函数
静态成员函数只能访问静态成员变量

静态成员变量：

#include <iostream>
using namespace std;class Student
{
public:static int m_A;private:static int m_B;
};int Student::m_A = 10;
int Student::m_B = 20;void test01()
{//静态成员变量两种访问方式//通过对象Student s1;s1.m_A = 100;cout << "s1的m_A值为：" << s1.m_A << endl;Student s2;s2.m_A = 200;cout << "s1的m_A值为：" << s1.m_A << endl; //共享同一份数据cout << "s2的m_A值为：" << s2.m_A << endl;//通过类名cout << "s1的m_A值为：" << Student::m_A << endl;cout << "s2的m_A值为：" << Student::m_A << endl;
}int main()
{test01();system("pause");return 0;
}

静态成员函数：

#include <iostream>
using namespace std;class Student
{
public:static void func(){m_A = 10; //静态成员函数可访问静态成员变量//m_B = 20; //报错，静态成员函数不可访问非静态成员变量cout << "statc void func函数的调用" << endl;}
private:static void func2(){m_A = 10;//m_B = 20;cout << "statc void func2函数的调用" << endl;}
public:static int m_A;int m_B;
};int Student::m_A = 10;
//int Student::m_B = 20; //报错，非静态成员变量不可在类外定义void test01()
{//通过对象访问Student s1;s1.func();//通过类名访问Student::func();//Student::func2(); //报错，类外访问不到私有静态成员函数
}int main()
{test01();system("pause");return 0;
}

4.3 C++对象模型和this指针

4…3.1 成员变量和成员函数分开存储

在C++中，只有非静态成员变量才属于类的对象上。

#include <iostream>
using namespace std;class Student
{
public:int m_A;        //非静态成员变量 属于类的对象上static int m_B; //静态成员变量 不属于类的对象上void func(){}   //非静态成员函数 属于类的对象上void func2(){}  //静态成员变量 不属于类的对象上
};void test01()
{Student s1;cout << sizeof(s1) << endl;
}int main()
{test01();system("pause");return 0;
}

补充：空对象占用内存空间为1，C++编译器会给每个空对象也分配一个字节空间，以便区分对象占用内存的位置。

4.3.2 this指针

定义：this指针指向被调用的成员函数所属的对象，隐含每一个非静态成员函数内的一种指针。

作用：

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

#include <iostream>
using namespace std;class Student
{
public:Student(int age){//当形参和成员变量同名时，可用this指针来进行区分this->age = age;}Student& stuAddAge(Student &s){this->age += s.age;//在类的非静态成员函数中返回对象本身，可用return *thisreturn *this;}int age;
};void test01()
{Student s1(18);cout << "s1的年龄是" << s1.age << endl; //s1的年龄是18Student s2(20); s2.stuAddAge(s1);cout << "s2的年龄是" << s2.age << endl; //s2的年龄是38}int main()
{test01();system("pause");return 0;
}

4.3.3 空指针访问成员函数

#include <iostream>
using namespace std;class Student
{
public:void showClassName(){cout << "This is Student" << endl;}void showClassAge(){if (this == NULL)return;//如果没有if判断的话会报错，因为传入的指针为NULLcout << "m_age = " << this->m_age << endl;}int m_age;
};void test01()
{Student* s = NULL;s->showClassName();s->showClassAge();
}int main()
{test01();system("pause");return 0;
}

补充：空指针是可以调用成员函数的，但要注意是否用到this指针，用到的话需要加以判断来保证代码的健壮性。

4.3.4 const修饰成员函数

常函数：

成员函数后加上const后，称该函数为常函数
常函数内不可修改成员的属性
成员属性声明时加上关键字mutable后，在常函数依旧可修改

常对象：

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

#include <iostream>
using namespace std;class Student
{
public://this指针本质上是一个指针常量，指针的指向是不可修改的//在成员函数后加上const，修饰的是this指向，让指针指向的值也不可被修改//const Student * const thisvoid modifyStudent() const{//this->m_A = 100; //报错this->m_B = 200;//this = NULL; //this指针不能修改指针的指向}void func(){cout << "This is func" << endl;}int m_A;mutable int m_B;   //特殊变量，即使在常函数中，也可修改
};void test01()
{Student s;s.modifyStudent();
}//常对象
void test02()
{const Student s2; //常对象//s2.m_A = 100;     //报错s2.m_B = 200;s2.modifyStudent();//s2.func();        //报错，常对象只能调用常函数,不能调用普通成员函数，普通成员函数可以修改属性
}int main()
{test01();test02();system("pause");return 0;
}

4.4 友元

作用：让一个函数或类访问另一个类中私有成员。

关键字：friend

三种实现：

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

4.4.1 全局函数做友元

#include <iostream>
using namespace std;class House
{friend void Visit(House* house);
public:House(){m_LivingRoom = "客厅";m_BedRoom = "卧室";}
public:string m_LivingRoom;
private:string m_BedRoom;
};void Visit(House* house)
{cout << "正在参观" << house->m_LivingRoom << endl;cout << "正在参观" << house->m_BedRoom << endl;
}void test01()
{House h;Visit(&h);
}int main()
{test01();system("pause");return 0;
}

4.4.2 类做友元

#include <iostream>
#include <string>
using namespace std;class House;
class goodfriend
{
public:goodfriend();void visit();private:House* house;};class House
{friend class goodfriend;public:House();public:string m_LivingRoom;
private:string m_BedRoom;
};House::House()
{this->m_LivingRoom = "客厅";this->m_BedRoom = "卧室";
}goodfriend::goodfriend()
{house = new House;
}void goodfriend::visit()
{cout << "正在参观" << house->m_LivingRoom << endl;cout << "正在参观" << house->m_BedRoom << endl;
}void test01()
{goodfriend gf;gf.visit();
}int main()
{test01();system("pause");return 0;
}

4.4.3 成员函数做友元

#include <iostream>
#include <string>
using namespace std;class House;
class goodfriend
{
public:goodfriend();void visit();void visit2();private:House* house;};class House
{friend void goodfriend::visit();public:House();public:string m_LivingRoom;
private:string m_BedRoom;
};House::House()
{this->m_LivingRoom = "客厅";this->m_BedRoom = "卧室";
}goodfriend::goodfriend()
{house = new House;
}void goodfriend::visit()
{cout << "正在参观" << house->m_LivingRoom << endl;cout << "正在参观" << house->m_BedRoom << endl;
}void goodfriend::visit2()
{cout << "正在参观" << house->m_LivingRoom << endl;//cout << "正在参观" << house->m_BedRoom << endl;
}void test01()
{goodfriend gf;gf.visit();gf.visit2();
}int main()
{test01();system("pause");return 0;
}

4.5 运算符重载

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

4.5.1 加号运算符重载

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

#include <iostream>
using namespace std;class Student
{
public://成员函数加号运算符重载/*Student operator+(Student& s){Student temp;temp.m_A = this->m_A + s.m_A;temp.m_B = this->m_B + s.m_B;return temp;}*/int m_A;int m_B;
};//全局函数加号运算符重载
Student operator+(Student& s1, Student& s2)
{Student temp;temp.m_A = s1.m_A + s2.m_A;temp.m_B = s1.m_B + s2.m_B;return temp;
}//函数重载
Student operator+(Student& s, int val)
{Student temp;temp.m_A = s.m_A + val;temp.m_B = s.m_B + val;return temp;
}void test01()
{Student s1;s1.m_A = 10;s1.m_B = 20;Student s2;s2.m_A = 10;s2.m_B = 20;Student s3 = s1 + s2;Student s4 = s1 + 10;//成员函数本质调用//Student s3 = s1.operator+(s2);//全局函数本质调用//Student s3 = operator+(s1, s3);cout << "s3 - m_A = " << s3.m_A << endl;cout << "s3 - m_B = " << s3.m_B << endl;cout << "s4 - m_A = " << s4.m_A << endl;cout << "s4 - m_B = " << s4.m_B << endl;
}int main()
{test01();system("pause");return 0;
}

4.5.2 左移运算符重载

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

#include <iostream>
using namespace std;class Student
{friend ostream& operator<<(ostream& cout, Student& s);
public:Student(int a, int b){m_A = a;m_B = b;}private:int m_A;int m_B;
};//使用成员函数重载左移运算符 s1.operator<<(cout) s1 << cout，但无法实现，因为cout在左侧
//只能使用全局函数重载左移运算符
//全局函数重载调用本质 operator<< (cout , p)  cout << p
ostream& operator<<(ostream &cout, Student &s)
{cout << "m_A = " << s.m_A << " " << "m_B = " << s.m_B << endl;return cout;
}void test01()
{Student s1(10, 20);cout << s1 << endl;cout << "hello C++" << endl;
}int main()
{test01();system("pause");return 0;
}

4.5.3 递增运算符重载

作用：实现自己的整型数据。

#include <iostream>
using namespace std;class MyIntData                        
{friend ostream& operator<<(ostream& cout, MyIntData myInt);
public:MyIntData(){m_Num = 0;}//前置++MyIntData& operator++(){m_Num++;return *this; //将自身返回}//后置++MyIntData operator++(int){MyIntData temp = *this; //先记录当前结果m_Num++;                //递增return temp;            //将记录结果返回}
private:int m_Num;
};ostream& operator<<(ostream& cout, MyIntData myInt)
{cout << myInt.m_Num;return cout;
}void test01()
{MyIntData myInt;cout << ++myInt << endl;cout << myInt << endl;
}void test02()
{MyIntData myInt2;cout << myInt2++ << endl;cout << myInt2 << endl;
}int main()
{test01();test02();system("pause");return 0;
}

4.5.4 赋值运算符重载

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

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

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

#include <iostream>
using namespace std;class Student
{
public:Student(int age){m_Age = new int(age);}~Student(){if (m_Age != NULL){delete m_Age;m_Age = NULL;}}Student& operator=(Student& s){if (m_Age != NULL){delete m_Age;m_Age = NULL;}m_Age = new int(*s.m_Age);return *this;}int *m_Age;
};void test01()
{Student s1(18);Student s2(20);Student s3(19);s1 = s2 = s3;cout << "s1的年龄是：" << *s1.m_Age << endl;cout << "s2的年龄是：" << *s2.m_Age << endl;cout << "s3的年龄是：" << *s2.m_Age << endl;
}int main()
{test01();system("pause");return 0;
}

4.5.5 关系运算符重载

作用：可让两个自定义类型对象进行比较操作。

#include <iostream>
#include <string>
using namespace std;class Student
{
public:Student(string name, int age){m_Name = name;m_Age = age;}bool operator==(Student& s){if (this->m_Age == s.m_Age && this->m_Name == s.m_Name)return true;return false;}bool operator!=(Student& s){if (this->m_Age == s.m_Age && this->m_Name == s.m_Name)return false;return true;}string m_Name;int m_Age;
};void test01()
{Student s1("小明", 18);Student s2("小红", 18);if (s1 == s2){cout << "s1 = s2" << endl;}else{cout << "s1 != s2" << endl;}if (s1 != s2){cout << "s1 != s2" << endl;}else{cout << "s1 = s2" << endl;}
}int main()
{test01();system("pause");return 0;
}

4.5.6 函数调用运算符重载

函数调用运算符()也可重载
重载后使用的方式极其像函数的调用方式，因此称为仿函数
仿函数无固定写法，比较灵活

#include <iostream>
using namespace std;class Printf
{
public:void operator()(string test){cout << test << endl;}
};void Printf02(string test)
{cout << test << endl;
}class numAdd
{
public:int operator()(int value1, int value2){return value1 + value2;}
};void test01()
{Printf p;p("Hello C++");  //仿函数Printf02("Hello C++");
}void test02()
{numAdd a;int result = a(10, 20);cout << "result = " << result << endl;cout << " numAdd()(20, 20) = " << numAdd()(20, 20) << endl; //匿名对象调用}int main()
{test01();test02();system("pause");return 0;
}

4.6 继承

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

类与类存在着特殊的关系：

在这里插入图片描述

下级成员不仅有上一级的共性，还会有自己的特性，利用继承技术，可减少重复代码。

4.6.1 继承基本语法

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

#include <iostream>
using namespace std;class BasePage
{
public:void top(){cout << "欢迎来到abc线上购物中心" << endl;}void left(){cout << "Shoes、Water、Paper、Clothes...(公共分类列表)" << endl;}void bottom(){cout << "服务中心、购物指导、联系我们...(公共底部)" << endl;}
};class Shoes :public BasePage
{
public:void conter(){cout << "You can buy shoes" << endl;}
};class Water :public BasePage
{
public:void conter(){cout << "You can buy water" << endl;}
};class Paper :public BasePage
{
public:void conter(){cout << "You can buy paper" << endl;}
};class Clothes :public BasePage
{
public:void conter(){cout << "You can buy clothes" << endl;}
};void test01()
{cout << "鞋子购买页面如下：" << endl;Shoes sh;sh.top();sh.bottom();sh.left();sh.conter();cout << "--------------------" << endl;cout << "矿泉水购买页面如下：" << endl;Water wt;wt.top();wt.bottom();wt.left();wt.conter();cout << "--------------------" << endl;cout << "纸巾购买页面如下：" << endl;Paper pr;pr.top();pr.bottom();pr.left();pr.conter();cout << "--------------------" << endl;cout << "衣服购买页面如下：" << endl;Clothes cl;cl.top();cl.bottom();cl.left();cl.conter();
}int main()
{test01();return 0;
}

补充：

子类也称派生类
父类也称基类

派生类成员含两大部分：

从积累继承过来的
自己增加的成员

基类继承来的成员体现其共性，新增成员体现其个性。

4.6.2 继承方式

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

三种继承方式：

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

在这里插入图片描述

#include <iostream>
using namespace std;class Father
{
public:int m_A;
protected:int m_B;
private:int m_C;
};class Son1 :public Father
{
public:void func(){m_A = 10; //父类中的公共权限成员，到子类依然是公共权限m_B = 20; //父类中的保护权限成员，到子类依然是保护权限//m_C = 30; //报错，父类中的私有权限成员，子类没权限访问}
};class Son2 :protected Father
{
public:void func(){m_A = 10;    //父类中的公共权限成员，到子类变保护权限m_B = 20;    //父类中的保护权限成员，到子类依然是保护权限//m_C = 30;  //报错，父类中的私有权限成员，子类没权限访问}
};class Son3 :private Father
{
public:void func(){m_A = 10;      //父类中的公共权限成员，到子类变私有权限m_B = 20;      //父类中的保护权限成员，到子类变私有权限//m_C = 30;      报错，父类中的私有权限成员，子类没权限访问}
};class GrandSon :public Son3
{
public:void func(){//m_A = 10;      //报错，m_A变为私有权限，访问不到//m_B = 20;      //报错，m_B变为私有权限，访问不到}
};void test01()
{Son1 s1;s1.m_A = 10;//s1.m_B = 20;  //报错，m_B是保护权限，类外访问不到Son2 s2;//s2.m_A = 10;   //报错，m_A是保护权限，类外访问不到//s2.m_B = 20;   //报错，m_B是保护权限，类外访问不到Son3 s3;//s3.m_A = 10;   //报错，m_A是私有权限，类外访问不到//s3.m_B = 20;     //报错，m_B是私有权限，类外访问不到
}int main()
{test01();system("pause");return 0;
}#include <iostream>
using namespace std;class Father
{
public:int m_A;
protected:int m_B;
private:int m_C;
};class Son1 :public Father
{
public:void func(){m_A = 10; //父类中的公共权限成员，到子类依然是公共权限m_B = 20; //父类中的保护权限成员，到子类依然是保护权限//m_C = 30; //报错，父类中的私有权限成员，子类没权限访问}
};class Son2 :protected Father
{
public:void func(){m_A = 10;    //父类中的公共权限成员，到子类变保护权限m_B = 20;    //父类中的保护权限成员，到子类依然是保护权限//m_C = 30;  //报错，父类中的私有权限成员，子类没权限访问}
};class Son3 :private Father
{
public:void func(){m_A = 10;      //父类中的公共权限成员，到子类变私有权限m_B = 20;      //父类中的保护权限成员，到子类变私有权限//m_C = 30;      报错，父类中的私有权限成员，子类没权限访问}
};class GrandSon :public Son3
{
public:void func(){//m_A = 10;      //报错，m_A变为私有权限，访问不到//m_B = 20;      //报错，m_B变为私有权限，访问不到}
};void test01()
{Son1 s1;s1.m_A = 10;//s1.m_B = 20;  //报错，m_B是保护权限，类外访问不到Son2 s2;//s2.m_A = 10;   //报错，m_A是保护权限，类外访问不到//s2.m_B = 20;   //报错，m_B是保护权限，类外访问不到Son3 s3;//s3.m_A = 10;   //报错，m_A是私有权限，类外访问不到//s3.m_B = 20;     //报错，m_B是私有权限，类外访问不到
}int main()
{test01();system("pause");return 0;
}

4.6.3 继承中的对象模型

从父类继承过来的成员，哪些是属于子类对象中呢?

#include <iostream>
using namespace std;class Father
{
public:int a;
protected:int b;
private:int c;
};class Son : public Father
{
public:int d;
};void test01()
{//父类中的所有非静态成员属性都被被子类所继承下去//父类中的私有成员属性也会被继承下去，只是被编译器隐藏了，因此访问不到cout << "sizeof(Son)的结果为" << sizeof(Son) << endl; //16
}int main()
{test01();system("pause");return 0;
}

4.6.4 继承中构造和析构顺序

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

#include <iostream>
using namespace std;class Father
{
public:Father(){cout << "Father的构造函数调用" << endl;}~Father(){cout << "Father的析构函数调用" << endl;}
};class Son : public Father
{
public:Son(){cout << "Son的构造函数调用" << endl;}~Son(){cout << "Son的析构函数调用" << endl;}
};void test01()
{Son s1;
}int main()
{test01();system("pause");return 0;
}

在这里插入图片描述

总结：先构造父类，再构造子类，析构的顺序跟构造相反。

4.6.5 继承同名成员处理方式

子类与父类中有同名的成员，怎样通过子类对象，访问到子类或父类中同名的数据呢？

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

#include <iostream>
using namespace std;class Father
{
public:Father(){m_A = 10;}void func(){cout << "Father - func调用" << endl;}void func(int ){cout << "Father - func(int)调用" << endl;}int m_A;
};class Son :public Father
{
public:Son(){m_A = 20;}void func(){cout << "Son - func调用" << endl;}int m_A;
};void test01()
{Son s1;cout << "s1 m_A = " << s1.m_A << endl;cout << "Father m_A = " << s1.Father::m_A << endl;Son s2;s2.func();s2.Father::func();//s2.func(30)  //报错//子类中如果出现与父类同名的成员函数，子类会将父类中的所有同名成员函数隐藏
}int main()
{test01();system("pause");return 0;
}

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

4.6.6 继承同名静态成员处理方式

继承中同名的静态成员怎样在子类对象上进行访问呢？

静态成员与非静态成员出现同名的情况，处理方式一样

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

#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){cout << "Son - static void func(int)调用" << endl;}
};
int Base::m_A = 10; //类外初始化class Son :public Base
{
public:static int m_A;static void func(){cout << "Son - static void func调用" << endl;}
};
int Son::m_A = 20;//同名静态成员属性
void test01()
{//通过对象访问Son s1;cout << "s1 m_A = "  << s1.m_A << endl;cout << "Base m_A = " << s1.Base::m_A << endl;//通过类名访问cout << "s1 m_A = " << Son::m_A << endl;cout << "Base m_A = " << Son::Base::m_A << endl;
}//同名静态成员函数
void test02()
{//通过对象访问Son s2;s2.func();s2.Base::func();//通过类名访问Son::func();Son::Base::func();Son::Base::func(10);}int main()
{test01();test02();system("pause");return 0;
}

总结：非静态成员有两种访问方式，对象访问和类名访问。

4.6.7 多继承语法

在C++中允许一个类继承一个类

语法结构：class 子类 : 继承方式父类1, 继承方式父类2…

#include <iostream>
using namespace std;class Base1
{
public:Base1(){m_A = 10;}int m_A;
};class Base2
{
public:Base2(){m_A = 20;}int m_A;
};class Son :public Base1, public Base2
{
public:Son(){m_B = 30;m_C = 40;}int m_B;int m_C;
};void test01()
{Son s1;cout << "sizeof(Son) = " << sizeof(Son) << endl;//父类中出现同名成员，需加作用域区分cout << "Base1 m_A = " << s1.Base1::m_A << endl;cout << "Base2 m_A = " << s1.Base2::m_A << endl;
}int main()
{test01();system("pause");return 0;
}

在这里插入图片描述

4.6.8 菱形继承

概念：

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

在这里插入图片描述

1.羊继承了动物的数据，驼也继承了动物的数据，羊驼使用数据时，会产生二义性。

2.羊驼继承动物的数据两份，其实该数据只需要一份即可。

#include <iostream>
using namespace std;class Animal
{
public :int m_Age;
};class Sheep :virtual public  Animal //加上关键字virtual变成虚继承
{};
//Animal类称为虚基类
class Camel :virtual public Animal  //加上关键字virtual变成虚继承
{};class SheepCamel :public Sheep, public Camel
{};void test01()
{SheepCamel sc;sc.Sheep::m_Age = 18;sc.Camel::m_Age = 18;//菱形继承，两个父类拥有相同数据，需加作用域区分cout << "sc.Sheep::m_Age = " << sc.Sheep::m_Age << endl;cout << "sc.Camel::m_Age = " << sc.Camel::m_Age << endl;cout << "sc.m_Age = " << sc.m_Age << endl;//菱形继承导致数据有两份，资源浪费，可使用虚继承来解决该问题 
}int main()
{test01();system("pause");return 0;
}

在这里插入图片描述

4.7 多态

多态的优点：

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

多态使用条件：父类指针或引用指向子类对象。

4.7.1 多态基本概念

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

多态分两类：

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

静态多态与动态多态区别:

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

//静态多态的函数地址早绑定 - 编译阶段确定函数地址
#include <iostream>
using namespace std;class Afternoon 
{
public:void Drink(){cout << "Water" << endl;}
};class Person1 :public Afternoon
{
public:void Drink(){cout << "Coffee" << endl;}
};class Person2 : public Afternoon
{
public:void Drink(){cout << "Tea" << endl;}
};void doWork(Afternoon &af) 
{af.Drink();
}void test01()
{Person1 p1;doWork(p1); //结果：Water
}int main()
{test01();system("pause");return 0;
}

//动态多态的函数地址晚绑定 - 运行阶段确定函数地址
#include <iostream>
using namespace std;class Afternoon
{
public:virtual void Drink() //虚函数{cout << "Water" << endl;}
};class Person1 :public Afternoon
{
public:void Drink(){cout << "Coffee" << endl;}
};class Person2 : public Afternoon
{
public:void Drink(){cout << "Tea" << endl;}
};//如果想要喝咖啡，需要让函数地址不提前绑定，在运行时绑定，地址晚绑定
void doWork(Afternoon& af)
{af.Drink();
}void test01()
{Person1 p1;doWork(p1); //结果：CoffeePerson2 p2;doWork(p2); //结果：Tea
}int main()
{test01();system("pause");return 0;
}

补充：

动态多态满足条件：

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

重写：函数返回值类型函数名参数列表完全一致。

4.7.2 纯虚函数和抽象类

父类中虚函数实现是无意义的，主要用来调用子类重写内容，我们可将虚函数改成纯虚函数。

语法结构：virtual 返回值类型函数名（参数列表） = 0 ;

当某个类中有了纯虚函数，那么也称该类为抽象类。

抽象类特点：

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

#include <iostream>
using namespace std;class Base
{
public:virtual void func() = 0; //纯虚函数
};class Son : public Base      //抽象类的子类必须重写父类中的纯虚函数，不然也属于抽象类
{
public:virtual void func(){cout << "Son - func调用" << endl;}
};void test01()
{//Base b1;   //报错,抽象类无法实例化对象//new Base;  //报错,抽象类无法实例化对象//Son s1;    //类必须重写父类中的纯虚函数，否则无法实例化对象Base* bs = new Son;bs->func();  //结果：Son - func调用
}int main()
{test01();system("pause");return 0;
}

4.7.3 虚析构和纯虚析构

多态使用时，如子类有属性开辟到堆区上，那父类指针在释放时无法调用子类的析构代码
将父类的析构函数改为虚析构或者纯虚析构即可解决以上问题
虚析构和纯虚析构的共性：

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

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

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

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

纯虚析构语法结构：virtual ~类名() = 0；

                               类名::类名(){}

#include <iostream>
#include <string>
using namespace std;class Eat
{
public:Eat(){cout << "Eat 构造函数调用" << endl;}virtual void Drinking() = 0;//virtual ~Eat() //加上virtual，变成虚析构函数//{//    cout << "Drinking 虚析构函数调用" << endl;//}virtual ~Eat() = 0;
};Eat::~Eat() //纯虚析构，该类属于抽象类，无法实例化对象
{cout << "Eat 纯虚析构函数调用" << endl;
}class Coffee :public Eat
{
public:Coffee(string feeding){cout << "Coffee 构造函数调用" << endl;m_Feeding = new string(feeding);}virtual void Drinking(){cout << *m_Feeding << "加入咖啡" << endl;}~Coffee(){cout << "Coffee 析构函数调用" << endl;if (this->m_Feeding != NULL){delete m_Feeding;m_Feeding = NULL;}}
public:string *m_Feeding;
};void test01()
{Eat* eat = new Coffee("牛奶");eat->Drinking();//通过父类指针释放，导致子类对象清理不干净，容易造成内存泄漏//给基类加一个虚析构函数即可解决父类指针释放子类对象问题delete eat;
}int main()
{test01();system("pause");return 0;
}

4.7.4 多态案例

案例一：制作计算器类

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

普通写法：

#include <iostream>
#include <string>
using namespace std;class calculator
{
public:int operation(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 == "/"){return m_Num1 / m_Num2;}else{return 0;}}int m_Num1;int m_Num2;
};void test01()
{calculator calc;calc.m_Num1 = 10;calc.m_Num2 = 20;cout << calc.m_Num1 << " + " << calc.m_Num2 << " = " << calc.operation("+") << endl;cout << calc.m_Num1 << " - " << calc.m_Num2 << " = " << calc.operation("-") << endl;cout << calc.m_Num1 << " * " << calc.m_Num2 << " = " << calc.operation("*") << endl;cout << calc.m_Num1 << " / " << calc.m_Num2 << " = " << calc.operation("/") << endl;}int main()
{test01();system("pause");return 0;
}

多态技术：

#include <iostream>
using namespace std;class AbstractCalculator //定义一个计算器抽象类
{
public:virtual int operation(){return 0;}int m_Num1;int m_Num2;
};class AddCalculator :public AbstractCalculator  //加法
{int operation(){return m_Num1 + m_Num2;}
};class SubCalculator :public AbstractCalculator  //减法
{int operation(){return m_Num1 - m_Num2;}
};class MulCalculator :public AbstractCalculator   //乘法
{int operation(){return m_Num1 * m_Num2;}
};class divCalculator :public AbstractCalculator   //除法
{ int operation(){return m_Num1 / m_Num2;}
};void test01()
{//加法AbstractCalculator* calc = new AddCalculator;calc->m_Num1 = 10;calc ->m_Num2 = 20;cout << calc->m_Num1 << " + " << calc->m_Num2 << " = " << calc->operation() << endl; //30delete calc; //用完销毁//减法calc = new SubCalculator;calc->m_Num1 = 10;calc->m_Num2 = 20;cout << calc->m_Num1 << " - " << calc->m_Num2 << " = " << calc->operation() << endl; //-10delete calc; //用完销毁//乘法calc = new MulCalculator;calc->m_Num1 = 10;calc->m_Num2 = 20;cout << calc->m_Num1 << " * " << calc->m_Num2 << " = " << calc->operation() << endl; //200delete calc; //用完销毁//除法calc = new divCalculator;calc->m_Num1 = 10;calc->m_Num2 = 20;cout << calc->m_Num1 << " / " << calc->m_Num2 << " = " << calc->operation() << endl; //0delete calc; //用完销毁}int main()
{test01();system("pause");return 0;
}

案例二：制作冷饮

大致流程：煮水 - 冲泡 - 倒杯 - 加料 - 加冰

利用多态技术实现，提供抽象制作冷饮基类，提供子类制作拿铁和柠檬红茶

#include <iostream>
using namespace std;class AbstractDrinking
{
public:virtual void Boil() = 0;      //煮水virtual void Brew() = 0;      //冲泡virtual void PoutGlass() = 0; //倒杯virtual void Feeding() = 0;   //加料virtual void AddIce() = 0;    //加冰void MakeDrink()              //制作冷饮{Boil();Brew();PoutGlass();Feeding();AddIce();}
};class Latte :public AbstractDrinking //拿铁
{
public:virtual void Boil() //煮水{cout << "煮矿泉水" << endl;}virtual void Brew() //冲泡{cout << "冲泡咖啡粉" << endl;}virtual void PoutGlass() //倒杯{cout << "倒入玻璃杯中" << endl;}virtual void Feeding() //加料{cout << "加入牛奶" << endl;}virtual void AddIce()  //加冰{cout << "加入冰块" << endl;}
};class LemonBlackTea :public AbstractDrinking //柠檬红茶
{
public:virtual void Boil() //煮水{cout << "煮矿泉水" << endl;}virtual void Brew() //冲泡{cout << "冲泡红茶" << endl;}virtual void PoutGlass() //倒杯{cout << "倒入玻璃杯中" << endl;}virtual void Feeding() //加料{cout << "加入柠檬片" << endl;}virtual void AddIce()  //加冰{cout << "加入冰块" << endl;}
};void doWork(AbstractDrinking* abd) //制作函数
{abd->MakeDrink();delete abd;
}void test01()
{doWork(new LemonBlackTea);cout << "-----------" << endl;doWork(new Latte);
}int main()
{test01();system("pause");return 0;
}

案例三：组装电脑

说明：电脑主要组成部件、CPU、内存条、显示器。

将每个零件封装出抽象类，并提供不同厂商生产不同的零件，如Intel厂商和Nvidia厂商
创建电脑类提供让电脑工作的函数，并调用每个零件工作接口
测试时组装三台不同的电脑进行工作

#include <iostream>
using namespace std;class CPU
{
public:virtual void calculate() = 0;
};class Memory
{
public:virtual void storage() = 0;
};class Display
{
public:virtual void display() = 0;
};class Computer
{
public:Computer(CPU* cpu, Memory* mem, Display* dp){m_cpu = cpu;m_mem = mem;m_dp = dp;}void doWork() //工作函数{//调用接口m_cpu->calculate();m_mem->storage();m_dp->display();}~Computer(){if (m_cpu != NULL) //释放CPU部件{delete m_cpu;m_cpu = NULL;}if (m_dp != NULL)  //释放显示器部件{delete m_cpu;m_dp = NULL;}if (m_mem != NULL)  //释放内存条部件{delete m_cpu;m_mem = NULL;}}
private:CPU* m_cpu;    Memory* m_mem;Display* m_dp;};class IntelCPU :public CPU
{
public:virtual void calculate(){cout << "Intel - CPU 开始运行工作" << endl;}
};class NvidiaCPU :public CPU
{
public:virtual void calculate(){cout << "Nvidia - CPU 开始运行工作" << endl;}
};class IntelDisplay :public Display
{
public:virtual void display(){cout << "Intel - 显示器 开始显示工作" << endl;}
};class NvidiaDisplay :public Display
{
public:virtual void display(){cout << "Nvidia - 显示器 开始显示工作" << endl;}
};class IntelMemory :public Memory
{
public:virtual void storage(){cout << "Intel - 内存条 开始存储工作" << endl;}
};class NvidiaMemory :public Memory
{
public:virtual void storage(){cout << "Nvidia - 内存条 开始存储工作" << endl;}
};void test01()
{//第一台电脑零部件/*CPU* intelCpu = new IntelCPU;Display* intelDisplay = new IntelDisplay;Memory* intelMem = new IntelMemory;*///创建第一台电脑cout << "第一台电脑开始工作" << endl;Computer* computer1 = new Computer(new IntelCPU, new IntelMemory, new IntelDisplay);  //第一台电脑computer1->doWork();delete computer1;cout << "----------------------" << endl;cout << "第二台电脑开始工作" << endl;Computer* computer2 = new Computer(new NvidiaCPU,new NvidiaMemory, new NvidiaDisplay);//第二胎电脑computer2->doWork();delete computer2;cout << "----------------------" << endl;cout << "第三台电脑开始工作" << endl;Computer* computer3 = new Computer(new IntelCPU, new NvidiaMemory, new IntelDisplay); //第三台电脑computer3->doWork();delete computer3;
}int main()
{test01();system("pause");return 0;
}