纯虚函数和抽象类

1.基本概念

2.案例

#include <iostream>
using namespace std;////面向抽象类编程(面向一套预先定义好的接口编程)//解耦合 ....模块的划分class  Figure //抽象类
{
public://阅读一个统一的界面(接口),让子类使用,让子类必须去实现virtual void getArea() = 0 ; //纯虚函数
protected:
private:
};class Circle : public Figure
{
public:Circle(int a, int b){this->a = a;this->b = b;}virtual void getArea(){cout<<"圆形的面积: "<<3.14*a*a<<endl;;}private:int a;int b;
};class Tri : public Figure
{
public:Tri(int a, int b){this->a = a;this->b = b;}virtual void getArea() {cout<<"三角形的面积: "<<a*b/2<<endl;;}private:int a;int b;
};class Square : public Figure
{
public:Square(int a, int b){this->a = a;this->b = b;}virtual void getArea() {cout<<"四边形的面积: "<<a*b<<endl;;}private:int a;int b;
};void objplay(Figure *base)
{base->getArea(); //会发生多态
}void main511()
{//Figure f; //抽象类不能被实例化Figure *base = NULL; //抽象类不能被实例化Circle c1(10, 20);Tri t1(20, 30);Square s1(50, 60);//面向抽象类编程(面向一套预先定义好的接口编程)objplay(&c1);objplay(&t1);objplay(&s1);//c1.getArea();cout<<"hello..."<<endl;system("pause");return ;
}

3.抽象类在多继承中的应用

C++中没有Java中的接口概念，抽象类可以模拟Java中的接口类。（接口和协议）

工程上的多继承
- 被实际开发经验抛弃的多继承
- 工程开发中真正意义上的多继承是几乎不被使用的
- 多重继承带来的代码复杂性远多于其带来的便利
- 多重继承对代码维护性上的影响是灾难性的
- 在设计方法上，任何多继承都可以用单继承代替
多继承中的二义性和多继承不能解决的问题
C++没有接口只有多继承和抽象类
- 绝大多数面向对象语言都不支持多继承
- 绝大多数面向对象语言都支持接口的概念
- C++中没有接口的概念
- C++中可以使用纯虚函数实现接口
- 接口类中只有函数原型定(纯虚函数)义，没有任何数据的定义。

class Interface
{public:virtual void func1() = 0;virtual void func2(int i) = 0;virtual void func3(int i) = 0;
};

实际工程经验证明
- 多重继承接口不会带来二义性和复杂性等问题
- 多重继承可以通过精心设计用单继承和接口来代替
- 接口类只是一个功能说明，而不是功能实现。
- 子类需要根据功能说明定义功能实现。
多继承的二义性

#include <iostream>
using namespace std;class  B
{
public:int b;
protected:
private:
};class  B1 : virtual public B
{
public:int b1;
protected:
private:
};class  B2 : virtual public B
{
public:int b2;
protected:
private:
};class  C : public B1, public B2
{
public:int c;
protected:
private:
};void main61()
{C myc;myc.c = 10;myc.b = 100;//二义性  error C2385: 对“b”的访问不明确cout<<"hello..."<<endl;system("pause");return ;
}

抽象类和多继承更配哦

#include <iostream>
using namespace std;class Interface1
{
public:virtual int add(int a, int b) = 0;virtual void print() = 0;
};class Interface2
{
public:virtual int mult(int a, int b) = 0;virtual void print() = 0;
};class Parent
{
public:int getA(){a = 0;return a;}
protected:
private:int a;
};class  Child : public Parent, public Interface1, public Interface2
{
public:virtual int add(int a, int b){cout<<"Child: add()已经执行\n";return a + b;}virtual void print(){cout<<"Child: print()已经执行\n";}virtual int mult(int a, int b){cout<<"Child: mult()已经执行\n";return a*b;}
protected:
private:
};void main71()
{Child c1;c1.print();Interface1 *it1 = &c1;it1->add(1, 2);Interface2 *it2 = &c1;it2->mult(3, 6);cout<<"hello..."<<endl;system("pause");return ;
}

4.面向抽象类编程

计算程序猿工资

#include <iostream>
using namespace std;class programer{
public:virtual int getSal() = 0;
};class junior_programer :public programer
{
private:char *name;char *obj;int sal;
public:junior_programer(char *_name,char *_obj,int _sal){name = _name;obj = _obj;sal = _sal;}virtual int getSal(){cout << name << " " << obj << ": " << sal << endl;return sal;}
protected:
};class mid_programer :public programer
{
private:char *name;char *obj;int sal;
public:mid_programer(char *_name, char *_obj, int _sal){name = _name;obj = _obj;sal = _sal;}virtual int getSal(){cout << name << " " << obj << ": " << sal << endl;return sal;}
protected:
};class adv_programer :public programer
{
private:char *name;char *obj;int sal;
public:adv_programer(char *_name, char *_obj, int _sal){name = _name;obj = _obj;sal = _sal;}virtual int getSal(){cout << name << " " << obj << ": " << sal << endl;return sal;}
protected:
};class arch_programer :public programer
{
private:char *name;char *obj;int sal;
public:arch_programer(char *_name, char *_obj, int _sal){name = _name;obj = _obj;sal = _sal;}virtual int getSal(){cout << name << " " << obj << ": " << sal << endl;return sal;}
protected:
};void CalProgSal(programer *base)
{base->getSal();
}int main(void)
{junior_programer jp("小王", "初级", 4000);mid_programer mp("小张", "中级", 8600);adv_programer ap("小李", "高级", 15000);//系统扩展arch_programer ar("高水平学员", "架构师", 24000);CalProgSal(&jp);CalProgSal(&mp);CalProgSal(&ap);CalProgSal(&ar);cout<<"Hello!"<<endl;system("pause");return 0;
}

5.socket库c++模型设计和实现

企业信息系统框架集成第三方产品

案例背景：一般的企业信息系统都有成熟的框架。软件框架一般不发生变化，能自由的集成第三方厂商的产品。
案例需求：请你在企业信息系统框架中集成第三方厂商的Socket通信产品和第三方厂商加密产品。
- 第三方厂商的Socket通信产品：完成两点之间的通信
- 第三方厂商加密产品：完成数据发送时加密；数据解密时解密。

案例要求：
1）能支持多个厂商的Socket通信产品入围
2）能支持多个第三方厂商加密产品的入围
3）企业信息系统框架不轻易发生框架
需求实现

思考1：企业信息系统框架、第三方产品如何分层
思考2：企业信息系统框架，如何自由集成第三方产品
（软件设计：模块要求松、接口要求紧）
思考3：软件分成以后，开发企业信息系统框架的程序员，应该做什么？第三方产品入围应该做什么？
编码实现

分析有多少个类 CSocketProtocol CSckFactoryImp1 CSckFactoryImp2
CEncDesProtocol HwEncdes ciscoEncdes

1、定义 CSocketProtocol 抽象类
2、编写框架函数
3、编写框架测试函数
4、厂商1（CSckFactoryImp1）实现CSocketProtocol、厂商2（CSckFactoryImp1）实现CSocketProtoco
5、抽象加密接口（CEncDesProtocol）、加密厂商1(CHwImp)、加密厂商2(CCiscoImp))，集成实现业务模型
6、框架（c语言函数方式，框架函数；c++类方式，框架类）

几个重要的面向对象思想
* 继承-组合（强弱）
* 注入
* 控制反转 IOC
* MVC
* 面向对象思想扩展aop思想:aop思想是对继承编程思想的有力的补充

实现步骤

定义socket的抽象类和纯虚函数

#pragma  once#include <iostream>
using namespace std;class CSocketProtocol
{
public:CSocketProtocol(){;}virtual ~CSocketProtocol() //虚析构函数的细节{;}//客户端初始化 获取handle上下virtual int cltSocketInit( /*out*/) = 0; //客户端发报文virtual int cltSocketSend( unsigned char *buf /*in*/,  int buflen /*in*/)  = 0; //客户端收报文virtual int cltSocketRev( unsigned char *buf /*in*/, int *buflen /*in out*/) = 0;//客户端释放资源virtual int cltSocketDestory() = 0;};

2.厂商一的功能实现

类的头文件

#pragma  once#include <iostream>
using namespace std;
#include "CSocketProtocol.h"class  CSckFactoryImp1 : public CSocketProtocol
{
public://客户端初始化 获取handle上下virtual int cltSocketInit( /*out*/); //客户端发报文virtual int cltSocketSend( unsigned char *buf /*in*/,  int buflen /*in*/); //客户端收报文virtual int cltSocketRev( unsigned char *buf /*in*/, int *buflen /*in out*/);//客户端释放资源virtual int cltSocketDestory();private:unsigned char *p;int len ;
};

类的实现文件

#include <iostream>
using namespace std;#include "CSckFactoryImp1.h"//客户端初始化 获取handle上下int CSckFactoryImp1::cltSocketInit( /*out*/){p = NULL;len = 0 ;return 0;}//客户端发报文int CSckFactoryImp1::cltSocketSend( unsigned char *buf /*in*/,  int buflen /*in*/){p  = (unsigned char * ) malloc(sizeof(unsigned char)  * buflen);if (p == NULL){return -1;}memcpy(p, buf, buflen);len = buflen;return 0;}//客户端收报文int CSckFactoryImp1::cltSocketRev( unsigned char *buf /*in*/, int *buflen /*in out*/){if (buf==NULL || buflen==NULL){return -1;}*buflen  = this->len ;memcpy(buf, this->p, this->len);return 0;}//客户端释放资源int CSckFactoryImp1::cltSocketDestory(){if (p != NULL){free(p);p = NULL;len = 0;}return 0;}

3.厂商二的功能实现

类的头文件

#pragma  once#include <iostream>
using namespace std;
#include "CSocketProtocol.h"class  CSckFactoryImp2 : public CSocketProtocol
{
public://客户端初始化 获取handle上下virtual int cltSocketInit( /*out*/); //客户端发报文virtual int cltSocketSend( unsigned char *buf /*in*/,  int buflen /*in*/); //客户端收报文virtual int cltSocketRev( unsigned char *buf /*in*/, int *buflen /*in out*/);//客户端释放资源virtual int cltSocketDestory();private:unsigned char *p;int len ;
};

类的实现文件

#include <iostream>
using namespace std;#include "CSckFactoryImp2.h"//客户端初始化 获取handle上下
int CSckFactoryImp2::cltSocketInit( /*out*/)
{p = NULL;len = 0 ;return 0;
}//客户端发报文
int CSckFactoryImp2::cltSocketSend( unsigned char *buf /*in*/,  int buflen /*in*/)
{p  = (unsigned char * ) malloc(sizeof(unsigned char)  * buflen);if (p == NULL){return -1;}memcpy(p, buf, buflen);len = buflen;return 0;
}//客户端收报文
int CSckFactoryImp2::cltSocketRev( unsigned char *buf /*in*/, int *buflen /*in out*/)
{if (buf==NULL || buflen==NULL){return -1;}*buflen  = this->len ;memcpy(buf, this->p, this->len);return 0;
}//客户端释放资源
int CSckFactoryImp2::cltSocketDestory()
{if (p != NULL){free(p);p = NULL;len = 0;}return 0;
}

4.测试socket功能文件

#define  _CRT_SECURE_NO_WARNINGS
#include <iostream>
using namespace std;#include "CSocketProtocol.h"
#include "CSckFactoryImp1.h"
#include "CSckFactoryImp2.h"//面向抽象类编程,框架实现完毕
int SckSendAndRec01(CSocketProtocol *sp, unsigned char *in, int inlen, unsigned char *out, int *outlen)
{int ret = 0;ret = sp->cltSocketInit();if (ret != 0){goto End;}ret = sp->cltSocketSend(in, inlen);if (ret != 0){goto End;}ret = sp->cltSocketRev(out, outlen);if (ret != 0){goto End;}End:ret = sp->cltSocketDestory();return 0;
}//写一个框架
int main011()
{int ret = 0;unsigned char in[4096];int inlen;unsigned char out[4096];int outlen = 0;strcpy((char *)in, "aadddddddddddaaaaaaaaaaa");inlen = 9;CSocketProtocol *sp = NULL;//sp = new CSckFactoryImp1sp = new CSckFactoryImp2; //ret = SckSendAndRec01(sp, in, inlen, out, &outlen);if (ret != 0){printf("func SckSendAndRec() err:%d \n", ret);return ret;}delete sp; //想通过父类指针 释放所有的子类对象的资源 ..cout<<"hello..."<<endl;system("pause");return ret;
}

5.加密协议抽象类的定义

#pragma  onceclass CEncDesProtocol
{
public:CEncDesProtocol(){}virtual ~CEncDesProtocol(){}virtual int EncData(unsigned char *plain, int plainlen, unsigned char *cryptdata, int *cryptlen) = 0;virtual int DecData(unsigned char *cryptdata, int cryptlen, unsigned char *plain, int *plainlen) = 0;};

6.厂商一的加密功能实现

类的头文件

#include <iostream>
using namespace std;#include "CEncDesProtocol.h"class HwEncDec : public CEncDesProtocol
{
public:virtual int EncData(unsigned char *plain, int plainlen, unsigned char *cryptdata, int *cryptlen);virtual int DecData(unsigned char *cryptdata, int cryptlen, unsigned char *plain, int *plainlen);
};

类的实现文件

#include <iostream>
using namespace std;
#include "HwEncDec.h"
#include "des.h"int HwEncDec::EncData(unsigned char *plain, int plainlen, unsigned char *cryptdata, int *cryptlen)
{int ret = 0;//用户使用的函数ret =  DesEnc(plain,plainlen, cryptdata, cryptlen);if (ret != 0){printf("func DesEnc() err:%d \n ", ret);return ret;}return ret;
}int HwEncDec::DecData(unsigned char *cryptdata, int cryptlen, unsigned char *plain, int *plainlen)
{int ret = 0;//用户使用函数des解密ret =  DesDec(cryptdata, cryptlen, plain, plainlen);if (ret != 0){printf("func DesDec() err:%d \n ", ret);return ret;}return ret;
}

7.加密功能的测试文件

#define  _CRT_SECURE_NO_WARNINGS
#include <iostream>
using namespace std;#include "CSocketProtocol.h"
#include "CSckFactoryImp1.h"
#include "CSckFactoryImp2.h"#include "CEncDesProtocol.h"
#include "HwEncDec.h"//面向抽象类编程,框架实现完毕
int SckSendAndRec(CSocketProtocol *sp, unsigned char *in, int inlen, unsigned char *out, int *outlen)
{int ret = 0;ret = sp->cltSocketInit();if (ret != 0){goto End;}ret = sp->cltSocketSend(in, inlen);if (ret != 0){goto End;}ret = sp->cltSocketRev(out, outlen);if (ret != 0){goto End;}End:ret = sp->cltSocketDestory();return 0;
}//面向抽象类编程,框架实现完毕
//c函数
int SckSendAndRec_EncDec(CSocketProtocol *sp, CEncDesProtocol *ed, unsigned char *in, int inlen, unsigned char *out, int *outlen)
{int ret = 0;unsigned char data[4096];int datalen = 0;ret = sp->cltSocketInit();if (ret != 0){goto End;}ret = ed->EncData(in,inlen, data, &datalen);if (ret != 0){goto End;}ret = sp->cltSocketSend(data, datalen); //发送数据之前对数据加密 ..if (ret != 0){goto End;}ret = sp->cltSocketRev(data, &datalen); //收到的数据是密文,需要进行解密if (ret != 0){goto End;}ret = ed->DecData(data, datalen, out, outlen );if (ret != 0){goto End;}End:ret = sp->cltSocketDestory();return 0;
}//写一个框架
int main022()
{int ret = 0;unsigned char in[4096];int inlen;unsigned char out[4096];int outlen = 0;strcpy((char *)in, "aadddddddddddaaaaaaaaaaa");inlen = 9;CSocketProtocol *sp = NULL;CEncDesProtocol *ed = NULL;//sp = new CSckFactoryImp1sp = new CSckFactoryImp2; //ed = new HwEncDec;ret = SckSendAndRec_EncDec(sp, ed, in, inlen, out, &outlen);if (ret != 0){printf("func SckSendAndRec() err:%d \n", ret);return ret;}delete sp; //想通过父类指针 释放所有的子类对象的资源 ..cout<<"hello..."<<endl;system("pause");return ret;
}

加解密的代码是des.h和des.c，可在前面“08文件操作”查看源代码。

8.将测试框架从函数形式升级为类的形式

#define  _CRT_SECURE_NO_WARNINGS
#include <iostream>
using namespace std;#include "CSocketProtocol.h"
#include "CSckFactoryImp1.h"
#include "CSckFactoryImp2.h"#include "CEncDesProtocol.h"
#include "HwEncDec.h"//抽象类在多继承中的应用
/*
class  MainOp : public CSocketProtocol, public CEncDesProtocol
{
public:
protected:
private:};
*/class MainOp
{
public:MainOp(){this->sp = NULL;this->ed = NULL;}MainOp(CSocketProtocol *sp, CEncDesProtocol *ed){this->sp = sp;this->ed = ed;}//void setSp(CSocketProtocol *sp){this->sp = sp;}void setEd(CEncDesProtocol *ed){this->ed = ed;}public://面向抽象类编程,框架实现完毕int SckSendAndRec_EncDec3(CSocketProtocol *sp, CEncDesProtocol *ed, unsigned char *in, int inlen, unsigned char *out, int *outlen){int ret = 0;unsigned char data[4096];int datalen = 0;ret = sp->cltSocketInit();if (ret != 0){goto End;}ret = ed->EncData(in,inlen, data, &datalen);if (ret != 0){goto End;}ret = sp->cltSocketSend(data, datalen); //发送数据之前对数据加密 ..if (ret != 0){goto End;}ret = sp->cltSocketRev(data, &datalen); //收到的数据是密文,需要进行解密if (ret != 0){goto End;}ret = ed->DecData(data, datalen, out, outlen );if (ret != 0){goto End;}End:ret = sp->cltSocketDestory();return 0;}int SckSendAndRec_EncDec3(unsigned char *in, int inlen, unsigned char *out, int *outlen){int ret = 0;unsigned char data[4096];int datalen = 0;ret = this->sp->cltSocketInit();if (ret != 0){goto End;}ret = this->ed->EncData(in,inlen, data, &datalen);if (ret != 0){goto End;}ret = this->sp->cltSocketSend(data, datalen); //发送数据之前对数据加密 ..if (ret != 0){goto End;}ret = sp->cltSocketRev(data, &datalen); //收到的数据是密文,需要进行解密if (ret != 0){goto End;}ret = ed->DecData(data, datalen, out, outlen );if (ret != 0){goto End;}End:ret = sp->cltSocketDestory();return 0;}private:CSocketProtocol *sp;CEncDesProtocol *ed;};//写一个框架
int main()
{int ret = 0;unsigned char in[4096];int inlen;unsigned char out[4096];int outlen = 0;strcpy((char *)in, "aadddddddddddaaaaaaaaaaa");inlen = 9;MainOp *myMainOp = new MainOp;CSocketProtocol *sp = NULL;CEncDesProtocol *ed = NULL;//sp = new CSckFactoryImp1sp = new CSckFactoryImp2; //ed = new HwEncDec;myMainOp->setSp(sp);myMainOp->setEd(ed);ret = myMainOp->SckSendAndRec_EncDec3(in, inlen, out, &outlen);if (ret!= 0){printf("myMainOp SckSendAndRec_EncDec3() err\n ", ret);}delete sp;delete ed;delete myMainOp;cout<<"hello..."<<endl;system("pause");return ret;
}

无非就是将之前的全局函数封装在一个测试用的类里面，然后该测试类拥有socket和加解密协议的基类对象作为该测试类的成员变量。

6.C语言回调函数和函数指针

结论：回调函数的本质：提前做了一个协议的约定（把函数的参数、函数返回值提前约定）

动态库升级为框架的编码实现
1、动态库中定义协议，并完成任务的调用

typedef int (*EncData)(unsigned char *inData,int inDataLen,unsigned char *outData,int *outDataLen,void *Ref, int RefLen);
typedef int (*DecData)(unsigned char *inData,int inDataLen,unsigned char *outData,int *outDataLen,void *Ref, int RefLen);

2、加密厂商完成协议函数的编写
3、对接调试。
4、动态库中可以缓存第三方函数的入口地址，也可以不缓存，两种实现方式。

案例总结

回调函数：利用函数指针做函数参数，实现的一种调用机制，具体任务的实现者，可以不知道什么时候被调用。
回调机制原理：
- 当具体事件发生时，调用者通过函数指针调用具体函数
- 回调机制将调用者和被调函数分开，两者互不依赖
- 任务的实现和任务的调用可以耦合（提前进行接口的封装和设计）

C++之纯虚函数和抽象类相关推荐

c++ 纯虚函数和抽象类那些事(一)
1.纯虚函数与抽象类 C++中的纯虚函数(或抽象函数)是我们没有实现的虚函数!我们只需声明它!通过声明中赋值0来声明纯虚函数! 纯虚函数:没有函数体的虚函数抽象类:包含纯虚函数的类 /*** @br ...
C++纯虚函数和抽象类
基本概念纯虚函数和抽象类纯虚函数是一个在基类中说明的虚函数,但是在基类中没有定义,要求任何派生类都定义自己的版本纯虚函数为个派生类提供一个公共界面(接口的封装和设计.软件模块功能的划分) 纯虚函 ...
C++基本概念复习之二：多重继承、虚继承、纯虚函数（抽象类）
一.多重继承: #include <iostream> using namespace std; class Horse { public: Horse(){cout<<&qu ...
C++纯虚函数与抽象类
纯虚函数 1.1纯虚函数是在声明虚函数时被"初始化"为0的函数.声明纯虚函数的一般形式为: virtual 函数类型函数名 (参数列表) =0; 如 virtual float ...
9-2：C++多态之纯虚函数和抽象类以及接口继承和实现继承
文章目录 (1)纯虚函数和抽象类的概念 (2)抽象类的意义 (3)接口继承与实现继承 (1)纯虚函数和抽象类的概念如果一个类的虚函数后面写上=0,同时不写它的实现,那么这样的虚函数称之为纯虚函数,包 ...
C++ 虚函数，纯虚函数，抽象类整理
抽象类,类中包含纯虚函数的为抽象类,其中抽象类的子类必须实现抽象类的纯虚函数方法. 抽象类无法实例化虚函数,子类可以实现或者不实现该方法都可以如果父类调用子类的基类指针时,有虚函数的则使用子类的实 ...
c/c++入门教程 - 2.4.7 多态、函数地址晚绑定（重写，虚函数，纯虚函数，抽象类，虚析构，纯虚析构）
目录 4.7 多态 4.7.1 多态的基本概念(超级重要) 4.7.2 多态的原理刨析(超级重要) 4.7.2 多态案例一:计算器类 4.7.3 纯虚函数和抽象类 4.7.4 多态案例二 - 制作饮品 ...
C++ 纯虚函数与抽象类
1.虚函数 1.1 虚函数简介可以毫不夸张地说虚函数是C++最重要的特性之一,我们先来看一看虚函数的概念. 在基类的定义中,定义虚函数的一般形式为: virtual 函数返回值类型虚函数名(形参表 ...
cc32a_demo-32dk2j_cpp_纯虚函数与抽象类-txwtech
//32dk2j_cpp_纯虚函数与抽象类cc32a_demo-txwtech //纯虚函数是用来继承用的 //纯虚函数 //抽象类-抽象数据类型 //*任何包含一个或者多个纯虚函数的类都是抽象类 / ...

C++之纯虚函数和抽象类