写在前面
写本系列的目的(自用)是回顾已经学过的知识、记录新学习的知识或是记录心得理解，方便自己以后快速复习，减少遗忘。以前三天打鱼两天晒网地学习C++，一直无法对C++熟练掌握，核心的面向对象编程并不熟悉，STL语法只会部分，因此也希望自己未来能做到熟悉甚至精通C++。
Part 2面向对象编程
该部分主要通过b站黑马程序员的视频来进行学习，记录笔记。全部是概念性的东西并不能帮助理解知识，直接上代码并以注释的形式讲解会更易于理解。
二、类和对象
4、继承
(1)基本语法
继承可以减少重复的代码，继承的语法如下：
class A: public B
其中，A继承了B，A称为子类或者派生类，B成为父类或者基类。A继承了B后A就可以调用B的函数，从而减少重复代码，案例如下：
#include<iostream>
using namespace std;
class BasePage //这是基类/父类
{
public:
void header()
{
cout << "首页、公开课、登录、注册(公共头部)" << endl;
}
};
class Java :public BasePage //这是子类1，继承了父类
{
public:
void content()
{
cout << "Java学科视频" << endl;
}
};
class Python :public BasePage //这是子类2，继承了父类
{
public:
void content()
{
cout << "Python学科视频" << endl;
}
};
class CPP :public BasePage //这是子类3，继承了父类
{
public:
void content()
{
cout << "cpp学科视频" << endl;
}
};
void test1()
{
Python python;
python.header(); //都可以调用父类函数而不用重新书写
python.content();
Java ja;
ja.header();
ja.content();
CPP cpp;
cpp.header();
cpp.content();
}
int main()
{
test1();
system("pause");
return 0;
}
(2)继承方式
继承方式一共有三种：公共继承，保护继承，私有继承。它们三者的区别这张图描述的很好：
解释一下这张图：
如果在父类中是私有权限的，无论子类采用那种继承方式，都访问不到；
如果子类采用的是公有继承方式，从父类继承过来的属性原本公开的仍然公开，原本保护的仍然保护；
如果子类采用的是保护继承方式，父类继承过来的属性都会是保护；
如果子类采用的是私有继承方式，父类继承过来的属性都会是私有。
(3)继承中的对象模型
父类中所有的非静态成员都会被子类继承下去，父类中私有成员属性，是被编译器隐藏了，因此是访问不到的，但是确实被继承下去了。例如，如果对上例中的class B进行sizeof，输出会是12。
(4)继承中的构造和析构顺序
继承中先构造父类再构造子类，析构的顺序与构造的顺序相反，现有子类的析构，再有父类的析构。
(5)继承中同名成员处理方式
访问子类同名成员，直接访问即可；访问父类童名成员，需要加作用域。
看下面的例子：
#include<iostream>
using namespace std;
class Base
{
public:
Base()
{
m_A = 100; //父类中的同名成员属性
}
void func() //父类中的同名成员函数
{
cout << "Base func" << endl;
}
int m_A;
};
class Son :public Base
{
public:
Son() //子类中的同名成员属性
{
m_A = 200;
}
void func() //父类中的同名成员函数
{
cout << "Son func" << endl;
}
int m_A;
};
//同名成员属性
void test1()
{
Son s;
cout << s.m_A << endl; //直接调用会调用子类的成员属性
cout <<s.Base::m_A << endl; //加上父亲的作用域就会调用父类的
}
//同名成员函数
void test2()
{
Son s;
s.func(); //函数也同理，直接调用会调用子类的
s.Base::func(); //加上父类作用域会调用父亲的
}
int main()
{
test1();
test2();
system("pause");
return 0;
}
需要说明的是，假如父类和子类中有同名成员函数，那么子类的成员函数会屏蔽父类的所有同名成员函数，任何一个重载的版本都会被屏蔽，所以哪怕是函数重载都不能直接调用父类的函数，均需要加父类作用域。
此外，继承中同名静态成员处理方式和非静态成员的处理方式一模一样。子类中的属性直接访问，父类中的需要加作用域。
(6)多静态语法
C++允许一个类继承多个类，语法为：
class 子类：继承方式 父类1，继承方式 父类2...
只不过多继承可能会引发父类中有同名成员出现，加作用域区分即可。
(7)菱形继承
两个派生类继承同一个基类，又有某个类同时继承两个派生类，这种继承被称为菱形继承或者钻石继承：
菱形继承的问题是：
1、羊继承了动物的数据，驼同样继承了动物的数据，当羊驼使用数据时，会产生二义性。解决这个问题，只需要向上一个知识点一样指明作用域就可以了。
2、羊驼继承动物的数据继承了两份，但其实一份就够了。解决这个问题需要用到虚继承。
虚继承：在继承父类前加上virtual即可。例如class Sheep：virtual Animal，虚继承就类似于指针，使这几个属性都指向同一块地址，所以羊驼不会有两份数据，只有一份数据，示例如下：
#include<iostream>
using namespace std;
class Animal
{
public:
int m_Age;
};
//利用虚继承解决菱形继承的问题
//此时Animal类称为虚基类
class Sheep:virtual public Animal{};
class Tuo:virtual public Animal{};
class SheepTuo :public Sheep, public Tuo {};
void test1()
{
SheepTuo st;
//解决第一个问题，只要标明作用域就可以解决
st.Sheep::m_Age = 18;
st.Tuo::m_Age = 28;
//但是这份数据只要有一份就可以了，菱形继承导致了数据有两份，资源浪费
cout << st.m_Age << endl;
cout << st.Sheep::m_Age << endl;
cout << st.Tuo::m_Age << endl;
//使用虚继承后两个数据都是28
//如果没有使用虚继承，第一个数据是18，第二个数据是28
}
int main()
{
system("pause");
return 0;
}
5、多态
(1)多态的基本概念
多态分为两类：
静态多态：函数重载和运算符重载属于静态多态，复用函数名
动态多态：派生类和虚函数实现运行时多态
静态多态和动态多态的区别是：
静态多态的函数地址早绑定，在编译阶段就确定函数地址了
动态多态的函数地址晚绑定，在运行阶段才确认函数地址
动态多态的使用主要在父类的指针或者引用执行子类对象时。
现在看一个例子：
#include<iostream>
using namespace std;
class Animal
{
public:
virtual void speak() //注意，这里是虚函数
{
cout << "动物在说话" << endl;
}
};
class Cat :public Animal
{
public:
void speak()
{
cout << "小猫在说话" << endl;
}
};
//地址早绑定 在编译阶段确定函数地址
//如果想执行让猫说话，就需要在运行阶段绑定
void doSpeak(Animal& animal) //这里相当于传入了Animal &animal = cat
{ //父类的引用执行子类对象
animal.speak();
}
void test1()
{
Cat cat;
doSpeak(cat); //我们希望的是能执行小猫在说话
} //假如上面没有使用虚函数，也就是没有加virtual，这里就会执行
//动物在说话
int main()
{
test1();
system("pause");
return 0;
}
我的理解是，我们之前学过了，当父类和子类有同名函数时，子类会忽略父类默认执行子类函数。这里假如不采用虚函数，在doSpeak()函数体内部，由于在编译阶段就将地址指向Animal的speak()函数了，这样就会导致无论传进去的是哪个子函数，都只能执行父类的函数，而不能默认执行子类函数。
但如果哦我们使用了虚函数，在编译阶段编译器就不会写入speak()函数的地址，而在运行时，才会确定函数的地址，此时我们传入的是子类cat，就会默认执行子类函数。这就是虚函数的作用，也就是动态绑定，动态多态。
最后说一下多态满足的条件：
1、有继承关系
2、子类重写父类中的虚函数，函数的返回值类型，函数名，参数列表完全一致，函数体不同
多态使用的条件：
1、父类指针或引用指向子类对象
(2)多态的原理
当父类是虚函数，且在子类没有重写父类时，二者的内存空间如下：
二者都分别有个虚指针vfptr，分别指向一个虚函数表，vftable。当子类对父类进行重写后，子类的内存空间就会发生改变：
此时，当父类的指针或者引用指向子类对象时，就会发生多态，即调用了子类的函数。
(3)纯虚函数和抽象类
在多态中，通常父类的实现都是毫无意义的，主要都是调用子类重写的内容，因此可以将虚函数改为纯虚函数。当类中有了纯虚函数，这个类也称为抽象类。
抽象类是不能实例化对象的，并且抽象类的子类必须重写父类中的虚函数，否则也是抽象类，无法实例化对象。纯虚函数的语法是：virtual 返回类型 函数名() = 0。下面看一个示例：
#include<iostream>
using namespace std;
class Base
{
public:
//抽象类无法实例化对象
//抽象类的子类 必须重写父类中的纯虚函数，否则也属于抽象类
virtual void func() = 0; //这就是抽象类
};
class Son :public Base
{
public:
virtual void func() //子函数必须重写
{
cout << "func函数调用" << endl;
}
};
void test1()
{
Base* base = new Son; //这样就可以实现一个接口调用多种函数
base->func();
}
int main()
{
test1();
system("pause");
return 0;
}
(4)虚析构和纯虚析构
当子类中含有开辟在堆区的属性时，需要调用子类的析构函数去释放空间，防止内存泄漏。
但是，当父类是虚函数时，就无法调用子类的析构函数。因为，我们上面知道，当父类指针指向子类时，采用的是地址早绑定，除非为父类加上virtual变成虚函数。析构函数同样的，属于地址早绑定，父类不会调用子类的析构函数，除非使用虚析构或是纯虚析构。
1、虚析构
虚析构就是在父类析构函数前加上virtual。如下例，假如Animal的析构函数没有加virtual，那么就不会调用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 != nullptr)
{
cout << "Cat析构函数调用" << endl;
delete m_Name;
}
}
string* m_Name;
};
void test1()
{
Animal* animal = new Cat("Tom");
animal->speak();
delete animal;
}
int main()
{
test1();
system("pause");
return 0;
}
2、纯虚析构。我们知道纯虚函数的写法是virtual ~Animal() = 0。但是，语法规定，析构函数必须要实现，此时的纯虚析构没有任何实现，因此也不能调用子类的析构函数。解决方法是类外初始化，可以在类外对~Animal()进行初始化，写函数体，这样就可以正常调用了。关于纯虚析构的内容已经在上例中用注释展示。
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
