总结：

1,含有纯虚函数的类,称为抽象基类,不可实列化。即不能创建对象,存在 的意义就是被继承,提供族类的公共接口。

2,纯虚函数只有声明,没有实现,被“初始化”为 0。

3,如果一个类中声明了纯虚函数,而在派生类中没有对该函数定义,则该虚函数在派生类中仍然为纯虚函数,派生类仍然为纯虚基类。

1、基本概念

纯虚函数是一个在基类中说明的虚函数，在基类中没有定义，要求任何派生类都定义自己的版本

    纯虚函数为个派生类提供一个公共界面（接口的封装和设计、软件的模块功能划分）

2、纯虚函数的语法

        virtual 类型 函数名（参数表） = 0;

一个具有纯虚函数的基类称为抽象类。

3、C++中没有接口的概念,C++中可以使用纯虚函数实现接口

      接口类中只有函数原型定义，没有任何数据的定义.

代码示例：

01纯虚函数：
 

#if 1
#include<iostream>
using namespace std;//图形类
//如果说一个类只要有拥有纯虚函数，就称此类为抽象类。（不管这个类有没有其他数据成员）
//抽象类 不能实例化
class Shape {
public://求图形类的面积//表示图形类声明一个方法getArea（）,它是一个纯虚函数。灭有函数的实现virtual double getArea() = 0;   //纯虚函数int a;int b;
};//正方形
//如果说一个普通类继承了一个抽象类，则必须重写纯虚函数。
//若不重写所有纯虚函数，则子类仍为抽象类，依然不能被实例化
//
class Rect :public Shape {
public:Rect(int a) {this->a = a;}virtual double getArea() {cout << "Rect:getArea" << endl;return a*a;}
private:int a;  //正方形边长
};//不需要关心Rect的实现
class Circle :public Shape {
public:Circle(int r) {this->r = r;}virtual double getArea() {cout << "Circle:getArea" << endl;return 3.14*a*a;}
private:int r;  //圆半径
};class Tri :public Shape {
public:Tri(int d,int h) {this->d = d;this->h = h;}virtual double getArea() {cout << "Circle:getArea" << endl;return d*h/2;}
private:int d;   //底int h;   //高
};//面向抽象类写一个架构函数
void printArea(Shape *sp) {sp->getArea();
}//业务层 面向的抽象类编程
void test01() {//main中所有使用的变量地址 都是抽象类Shape的类型//Shape s;  //编译错误 抽象类不能实例化Shape *sp1 = new Rect(3);  //父类指针指向子类对象sp1->getArea();   //多态实现Shape *sp2 = new Circle(3);  //父类指针指向子类对象sp2->getArea();Shape *sp3 = new Tri(3,3);  //父类指针指向子类对象sp3->getArea();
}
/*
Rect:getArea
Circle:getArea
Circle:getArea
*/
int main() {test01();return 0;
}
#endif

02抽象类练习：

#if 1
#include<iostream>
using namespace std;
class Boss {
public:virtual void fight() = 0;
};
class DongFangBuBai :public Boss {
public:virtual void fight() {cout << "东方不败使出了葵花宝典" << endl;}
};
class DuanYu :public Boss {
public:virtual void fight() {cout << "段誉使出了六脉神剑" << endl;}
};
class WuYaZi :public Boss {
public:virtual void fight() {cout << "无崖子使出了北冥神功" << endl;}
};
void test01() {Boss *Dong = new DongFangBuBai;Dong->fight();Boss *Duan = new DuanYu;Duan->fight();Boss *Wu = new WuYaZi;Wu->fight();delete Dong;delete Duan;delete Wu;
}
/*
东方不败使出了葵花宝典
段誉使出了六脉神剑
无崖子使出了北冥神功
*/
int main() {test01();return 0;
}
#endif

03纯虚函数和多继承练习：

#if 1
#include<iostream>
using namespace std;
class Interface1 {
public:virtual void func1(int a, int b) = 0;
};
class Interface2 {
public:virtual void func2(int a) = 0;
};
class Child :public Interface1, public Interface2 {
public:virtual void func1(int a, int b) {cout << "func1" << endl;}virtual void func2(int a) {cout << "func2" << endl;}
};
void test01() {Child d;Interface1 *if1 = new Child;if1->func1(1,2);   //只能看见func1，看不见func2
}
/*
func1
*/
int main() {test01();return 0;
}
#endif

抽象类练习2：

Animal1.h

#pragma once
#include<iostream>
using namespace std;
class Animal1
{
public:virtual void voice() = 0;Animal1();virtual ~Animal1();};//架构函数
//让动物叫
void letAnimalCry(Animal1 *animal);
void letAnimalCrys(Animal1 *animal);

Animal1.cpp

#include "Animal1.h"Animal1::Animal1()
{cout << "Animal1()" << endl;
}Animal1::~Animal1()
{cout << "~Animal1()" << endl;
}void letAnimalCrys(Animal1 * animal)
{animal->voice();delete animal;  //这里删除，调用时不必删除
}
void letAnimalCry(Animal1 *animal) {animal->voice();
}

Cat1.h

#pragma once
#include "Animal1.h"
class Cat1 :public Animal1
{
public:Cat1();~Cat1();virtual void voice();
};

Cat1.cpp

#include "Cat1.h"
Cat1::Cat1()
{cout << "Cat1()" << endl;
}Cat1::~Cat1()
{cout << "~Cat1()" << endl;
}
void Cat1::voice() {cout << "cat is crying" << endl;
}

Dog1.h

#pragma once
#include "Animal1.h"
class Dog1 :public Animal1
{
public:Dog1();~Dog1();virtual void voice();
};

Dog1.cpp

#include "Dog1.h"
Dog1::Dog1()
{cout << "Dog1()" << endl;
}Dog1::~Dog1()
{cout << "~Dog()" << endl;
}
void Dog1::voice() {cout << "dog is crying" << endl;
}

main.cpp

#include"Animal1.h"
#include"Dog1.h"
#include"Cat1.h"void test01() {Animal1 *dog = new Dog1;dog->voice();delete dog;  //如果Animal的析构函数没有声明为虚函数，运行delete不会调用子类析构函数如果Animal的析构函数声明为虚函数，运行delete会调用子类析构函数Animal1 *cat = new Cat1;cat->voice();delete cat;
}
/*
Animal1()
Dog1()
dog is crying
~Dog()
~Animal1()
Animal1()
Cat1()
cat is crying
~Cat1()
~Animal1()
*/
void test02() {Animal1 *dog = new Dog1;Animal1 *cat = new Cat1;letAnimalCry(dog);letAnimalCry(cat);delete dog;   //架构函数中未执行删除对象操作 调用时执行删除操作delete cat;  
}
/*
Animal1()
Dog1()
Animal1()
Cat1()
dog is crying
cat is crying
~Dog()
~Animal1()
~Cat1()
~Animal1()
*/
void test03() {Animal1 *dog = new Dog1;Animal1 *cat = new Cat1;letAnimalCrys(dog);//架构函数中执行删除对象操作 调用时不需要执行letAnimalCrys(cat);}
/*
Animal1()
Dog1()
Animal1()
Cat1()
dog is crying
~Dog()
~Animal1()
cat is crying
~Cat1()
~Animal1()
*/
//test03 等价于 test04
void test04() {letAnimalCrys(new Dog1);letAnimalCrys(new Cat1);
}
/*
Animal1()
Dog1()
dog is crying
~Dog()
~Animal1()
Animal1()
Cat1()
cat is crying
~Cat1()
~Animal1()
*/
int main() {//test01();cout << "-------"<<endl;//test02();cout << "-------" << endl;//test03();cout << "-------" << endl;//test04();return 0;}