面向抽象类编程思想强化

最新推荐文章于 2024-04-08 19:00:00 发布
最新推荐文章于 2024-04-08 19:00:00 发布
阅读量644 收藏 1
点赞数
分类专栏： C++基础
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/bbs375/article/details/52662889
版权

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

案例背景：一般的企业信息系统都有成熟的框架。软件框架一般不发生变化，能自由的集成第三方厂商的产品。

案例需求：请你在企业信息系统框架中集成第三方厂商的Socket通信产品和第三方厂商加密产品。

                     1.第三方厂商的Socket通信产品：完成两点之间的通信；

                     2.第三方厂商加密产品：发送数据时采用des加密；数据接收到时解密。

案例要求： 1）能支持多个厂商的Socket通信产品入围

2）能支持多个第三方厂商加密产品的入围

3）企业信息系统框架不轻易发生变化

 需求实现

思考1：企业信息系统框架、第三方产品如何分层

思考2：企业信息系统框架，如何自由集成第三方产品

（软件设计：模块要求松、接口要求紧）

思考3：软件分成以后，开发企业信息系统框架的程序员，应该做什么？

第三方产品入围应该做什么？

系统架构


 编码实现

分析有多少个类 CSocketProtocol  CSckFactoryImp1 CSckFactoryImp2

CEncDesProtocol  HwEncdes  ciscoEncdes

1、 定义 CSocketProtocol  抽象类

2、 编写框架函数

3、 编写框架测试函数

4、 厂商1（CSckFactoryImp1）实现CSocketProtocol、厂商2（CSckFactoryImp1）实现CSocketProtocol

5、 抽象加密接口（CEncDesProtocol）、加密厂商1(CHwImp)、加密厂商2(CCiscoImp))，集成实现业务模型

6、 框架（c语言函数方式，框架函数；c++类方式，框架类）

 几个重要的面向对象思想

继承-组合（强弱）

注入

控制反转 IOC

MVC

面向对象思想扩展aop思想

aop思想是对继承编程思想的有力的补充

编码实现：

CSocketProtocol.h

#pragma once
#include <iostream>

using namespace std;

class CSocketProtocol  
{
public:
	CSocketProtocol()
	{
		;
	}
	virtual ~CSocketProtocol()
	{

	}
	//初始化
	virtual int cltSocketInit() = 0; 
	//发报文
	virtual int cltSocketSend(unsigned char *buf,int buflen) = 0; 
	//接收报文
	virtual int cltSocketRev(unsigned char *buf,int *buflen) = 0; 
	//客户端释放资源
	virtual int cltSocketDestory() = 0;
protected:
private:
};
CSckFactoryImp1.h 
#pragma once
#include <iostream>
#include "CSocketProtocol.h"

using namespace std;

class CSckFactoryImp1 : public CSocketProtocol 
{
public:
	CSckFactoryImp1()
	{

	}
	~CSckFactoryImp1()
	{
		if (p!=NULL)
		{
			delete[] p;
		}
	}
	//初始化
	virtual int cltSocketInit() ; 
	//发报文
	virtual int cltSocketSend(unsigned char *buf,int buflen) ; 
	//接收报文
	virtual int cltSocketRev(unsigned char *buf,int *buflen) ; 
	//客户端释放资源
	virtual int cltSocketDestory();
protected:
private:
	unsigned char *p;
	int len;
};

EncDesProtocol.h 

#pragma once

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

des.h 

/*********************************************************
 *  des.h
 *  用户使用des算法头文件
 *    
 *********************************************************/
#ifndef _OPENDESS_H_
#define _OPENDESS_H_

#ifdef __cplusplus
extern "C" {
#endif

/* 厂商甲根据 "CEncDesProtocol.h" 里头定义的加密解密抽象层，实现的接口 */

//加密数据（encrypt：加密）
//pInData：明文数据
//nInDataLen：明文数据长度
//pOutData：加密后的数据
//pOutDataLen：加密数据的长度
int DesEnc(
        unsigned char *pInData,
        int            nInDataLen,
        unsigned char *pOutData,
        int           *pOutDataLen);


//解密数据(decrypt：解密)
//pInData：密文数据
//nInDataLen：密文数据长度
//pOutData：解密后的数据
//pOutDataLen：解密数据的长度
int DesDec(
       unsigned char *pInData,
       int            nInDataLen,
       unsigned char *pOutData,
       int           *pOutDataLen);

#ifdef __cplusplus
}
#endif

#endif

HwEncdes.h 

#pragma once
#include "EncDesProtocol.h"


class HwEncdes : public CEncDesProtocol
{
public:
	HwEncdes(void);
	~HwEncdes(void);
	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);
};
CSckFactoryImp1.cpp 
#pragma once
#include <iostream>
#include "CSocketProtocol.h"
#include "CSckFactoryImp1.h"

using namespace std;

//初始化
int CSckFactoryImp1::cltSocketInit()
{
    this->p = NULL;
    this->len = 0;

    return 0;
}
//发报文
int CSckFactoryImp1::cltSocketSend(unsigned char *buf,int buflen)
{
    p = new unsigned char[buflen];
    
    if (p==NULL)
    {
        return -1;
    }
    //p =(unsigned char *)p
    memcpy(p,buf,buflen);
    this->len = buflen;

    return 0;
}
//接收报文
int CSckFactoryImp1::cltSocketRev(unsigned char *buf,int *buflen)
{
    if (buf==NULL||buflen==NULL)
    {
        return -1;
    }
    memcpy(buf,p,this->len);
    *buflen = this->len;
    return 0;
}
//客户端释放资源
int CSckFactoryImp1::cltSocketDestory()
{
    if (this->p!=NULL)
    {
        delete[] p;
        this->len = 0;
        this->p =NULL;
    }
    return 0;
}

des.cpp 

/******************************************************
 *
 *  des.c
 *  common des......
 *
 ******************************************************/
 
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include "des.h"

/*********************************************************
  data type definition for Des;
**********************************************************/
#define EN0    0
#define DE1    1

#define DES_KEYBYTES    128
#define DES_KEYLONGS    32
#define DES_BLOCKLEN    8

typedef struct {
    unsigned char ek[DES_KEYBYTES];
    int    ekLen;
    unsigned char dk[DES_KEYBYTES];
    int    dkLen;
    unsigned char CbcCtx[DES_BLOCKLEN];
} DES_CTX;

typedef struct {
    unsigned char ek1[DES_KEYBYTES];
    int    ek1Len;
    unsigned char dk1[DES_KEYBYTES];
    int    dk1Len;
    unsigned char ek2[DES_KEYBYTES];
    int    ek2Len;
    unsigned char dk2[DES_KEYBYTES];
    int    dk2Len;
    unsigned char CbcCtx[DES_BLOCKLEN];
    //int    IsFirstBlock;
} DES3_CTX;


static unsigned char pc1[56] = {
    56, 48, 40, 32, 24, 16,  8,  0, 57, 49, 41, 33, 25, 17,
     9,  1, 58, 50, 42, 34, 26, 18, 10,  2, 59, 51, 43, 35,
    62, 54, 46, 38, 30, 22, 14,  6, 61, 53, 45, 37, 29, 21,
    13,  5, 60, 52, 44, 36, 28, 20, 12,  4, 27, 19, 11,  3 };

static unsigned char pc2[48] = {
    13, 16, 10, 23,  0,  4,         2, 27, 14,  5, 20,  9,
    22, 18, 11,  3, 25,  7,     15,  6, 26, 19, 12,  1,
    40, 51, 30, 36, 46, 54,        29, 39, 50, 44, 32, 47,
    43, 48, 38, 55, 33, 52,     45, 41, 49, 35, 28, 31 };

static unsigned short bytebit[8] = {0200,0100,040,020,010,04,02,01 };
static unsigned char totrot[16] = {1,2,4,6,8,10,12,14,15,17,19,21,23,25,27,28};
static unsigned long bigbyte[24] = {
    0x800000L,    0x400000L,    0x200000L,    0x100000L,
    0x80000L,    0x40000L,    0x20000L,    0x10000L,
    0x8000L,    0x4000L,    0x2000L,    0x1000L,
    0x800L,        0x400L,        0x200L,        0x100L,
    0x80L,        0x40L,        0x20L,        0x10L,
    0x8L,        0x4L,        0x2L,        0x1L    };

//insert digits
static unsigned long SP1[64] ={
       0x01010400l,0x00000000l,0x00010000l,0x01010404l,
       0x01010004l,0x00010404l,0x00000004l,0x00010000l,
       0x00000400l,0x01010400l,0x01010404l,0x00000400l,
       0x01000404l,0x01010004l,0x01000000l,0x00000004l,
       0x00000404l,0x01000400l,0x01000400l,0x00010400l,
       0x00010400l,0x01010000l,0x01010000l,0x01000404l,
       0x00010004l,0x01000004l,0x01000004l,0x00010004l,
       0x00000000l,0x00000404l,0x00010404l,0x01000000l,
       0x00010000l,0x01010404l,0x00000004l,0x01010000l,
       0x01010400l,0x01000000l,0x01000000l,0x00000400l,
       0x01010004l,0x00010000l,0x00010400l,0x01000004l,
       0x00000400l,0x00000004l,0x01000404l,0x00010404l,
       0x01010404l,0x00010004l,0x01010000l,0x01000404l,
       0x01000004l,0x00000404l,0x00010404l,0x01010400l,
       0x00000404l,0x01000400l,0x01000400l,0x00000000l,
       0x00010004l,0x00010400l,0x00000000l,0x01010004l };
       
       
static unsigned long SP2[64]={
       0x80108020l,0x80008000l,0x00008000l,0x00108020l,
       0x00100000l,0x00000020l,0x80100020l,0x80008020l,
       0x80000020l,0x80108020l,0x80108000l,0x80000000l,
       0x80008000l,0x00100000l,0x00000020l,0x80100020l,
       0x00108000l,0x00100020l,0x80008020l,0x00000000l,
       0x80000000l,0x00008000l,0x00108020l,0x80100000l,
       0x00100020l,0x80000020l,0x00000000l,0x00108000l,
       0x00008020l,0x80108000l,0x80100000l,0x00008020l,
       0x00000000l,0x00108020l,0x80100020l,0x00100000l,
       0x80008020l,0x80100000l,0x80108000l,0x00008000l,
       0x80100000l,0x80008000l,0x00000020l,0x80108020l,
       0x00108020l,0x00000020l,0x00008000l,0x80000000l,
       0x00008020l,0x80108000l,0x00100000l,0x80000020l,
       0x00100020l,0x80008020l,0x80000020l,0x00100020l,
       0x00108000l,0x00000000l,0x80008000l,0x00008020l,
       0x80000000l,0x80100020l,0x80108020l,0x00108000l };
       
       
static unsigned long SP3[64]={ 
       0x00000208l,0x08020200l,0x00000000l,0x08020008l,
       0x08000200l,0x00000000l,0x00020208l,0x08000200l,
       0x00020008l,0x08000008l,0x08000008l,0x00020000l,
       0x08020208l,0x00020008l,0x08020000l,0x00000208l,
       0x08000000l,0x00000008l,0x08020200l,0x00000200l,
       0x00020200l,0x08020000l,0x08020008l,0x00020208l,
       0x08000208l,0x00020200l,0x00020000l,0x08000208l,
       0x00000008l,0x08020208l,0x00000200l,0x08000000l,
       0x08020200l,0x08000000l,0x00020008l,0x00000208l,
       0x00020000l,0x08020200l,0x08000200l,0x00000000l,
       0x00000200l,0x00020008l,0x08020208l,0x08000200l,
       0x08000008l,0x00000200l,0x00000000l,0x08020008l,
       0x08000208l,0x00020000l,0x08000000l,0x08020208l,
       0x00000008l,0x00020208l,0x00020200l,0x08000008l,
       0x08020000l,0x08000208l,0x00000208l,0x08020000l,
       0x00020208l,0x00000008l,0x08020008l,0x00020200l };
       
       
static unsigned long SP4[64]={             
       0x00802001l,0x00002081l,0x00002081l,0x00000080l,
       0x00802080l,0x00800081l,0x00800001l,0x00002001l,
       0x00000000l,0x00802000l,0x00802000l,0x00802081l,
       0x00000081l,0x00000000l,0x00800080l,0x00800001l,
       0x00000001l,0x00002000l,0x00800000l,0x00802001l,
       0x00000080l,0x00800000l,0x00002001l,0x00002080l,
       0x00800081l,0x00000001l,0x00002080l,0x00800080l,
       0x00002000l,0x00802080l,0x00802081l,0x00000081l,
       0x00800080l,0x00800001l,0x00802000l,0x00802081l,
       0x00000081l,0x00000000l,0x00000000l,0x00802000l,
       0x00002080l,0x00800080l,0x00800081l,0x00000001l,
       0x00802001l,0x00002081l,0x00002081l,0x00000080l,
       0x00802081l,0x00000081l,0x00000001l,0x00002000l,
       0x00800001l,0x00002001l,0x00802080l,0x00800081l,
       0x00002001l,0x00002080l,0x00800000l,0x00802001l,
       0x00000080l,0x00800000l,0x00002000l,0x00802080l };
       
       
static unsigned long SP5[64]={   
       0x00000100l,0x02080100l,0x02080000l,0x42000100l,
       0x00080000l,0x00000100l,0x40000000l,0x02080000l,
       0x40080100l,0x00080000l,0x02000100l,0x40080100l,
       0x42000100l,0x42080000l,0x00080100l,0x40000000l,
       0x02000000l,0x40080000l,0x40080000l,0x00000000l,
       0x40000100l,0x42080100l,0x42080100l,0x02000100l,
       0x42080000l,0x40000100l,0x00000000l,0x42000000l,
       0x02080100l,0x02000000l,0x42000000l,0x00080100l,
       0x00080000l,0x42000100l,0x00000100l,0x02000000l,
       0x40000000l,0x02080000l,0x42000100l,0x40080100l,
       0x02000100l,0x40000000l,0x42080000l,0x02080100l,
       0x40080100l,0x00000100l,0x20000000l,0x42080000l,
       0x42080100l,0x00080100l,0x42000000l,0x42080100l,
       0x02080000l,0x02000100l,0x40000100l,0x00080000l,
       0x00080100l,0x02000100l,0x40000100l,0x00080000l,
       0x00000000l,0x40080000l,0x02080100l,0x40000100l };
       
       
static unsigned long SP6[64]={ 
       0x20000010l,0x20400000l,0x00004000l,0x20404010l,
       0x20400000l,0x00000010l,0x20404010l,0x00400000l,
       0x20004000l,0x00404010l,0x00400000l,0x20000010l,
       0x00400010l,0x20004000l,0x20000000l,0x00004010l,
       0x00000000l,0x00400010l,0x20004010l,0x00004000l,
       0x00404000l,0x20004010l,0x00000010l,0x20400010l,
       0x20400010l,0x00000000l,0x00404010l,0x20404000l,
       0x00004010l,0x00404000l,0x20404000l,0x20000000l,
       0x20004000l,0x00000010l,0x20400010l,0x00404000l,
       0x20404010l,0x00400000l,0x00004010l,0x20000010l,
       0x00400000l,0x20004000l,0x20000000l,0x00004010l,
       0x20000010l,0x20404010l,0x00404000l,0x20400000l,
       0x00404010l,0x20404000l,0x00000000l,0x20400010l,
       0x00000010l,0x00004000l,0x20400000l,0x00404010l,
       0x00004000l,0x00400010l,0x20004010l,0x00000000l,
       0x20404000l,0x20000000l,0x00400010l,0x20004010l };  
            
static unsigned long SP7[64] = {
    0x00200000L, 0x04200002L, 0x04000802L, 0x00000000L,
    0x00000800L, 0x04000802L, 0x00200802L, 0x04200800L,
    0x04200802L, 0x00200000L, 0x00000000L, 0x04000002L,
    0x00000002L, 0x04000000L, 0x04200002L, 0x00000802L,
    0x04000800L, 0x00200802L, 0x00200002L, 0x04000800L,
    0x04000002L, 0x04200000L, 0x04200800L, 0x00200002L,
    0x04200000L, 0x00000800L, 0x00000802L, 0x04200802L,
    0x00200800L, 0x00000002L, 0x04000000L, 0x00200800L,
    0x04000000L, 0x00200800L, 0x00200000L, 0x04000802L,
    0x04000802L, 0x04200002L, 0x04200002L, 0x00000002L,
    0x00200002L, 0x04000000L, 0x04000800L, 0x00200000L,
    0x04200800L, 0x00000802L, 0x00200802L, 0x04200800L,
    0x00000802L, 0x04000002L, 0x04200802L, 0x04200000L,
    0x00200800L, 0x00000000L, 0x00000002L, 0x04200802L,
    0x00000000L, 0x00200802L, 0x04200000L, 0x00000800L,
    0x04000002L, 0x04000800L, 0x00000800L, 0x00200002L };
    
static unsigned long SP8[64] = {
    0x10001040L, 0x00001000L, 0x00040000L, 0x10041040L,
    0x10000000L, 0x10001040L, 0x00000040L, 0x10000000L,
    0x00040040L, 0x10040000L, 0x10041040L, 0x00041000L,
    0x10041000L, 0x00041040L, 0x00001000L, 0x00000040L,
    0x10040000L, 0x10000040L, 0x10001000L, 0x00001040L,
    0x00041000L, 0x00040040L, 0x10040040L, 0x10041000L,
    0x00001040L, 0x00000000L, 0x00000000L, 0x10040040L,
    0x10000040L, 0x10001000L, 0x00041040L, 0x00040000L,
    0x00041040L, 0x00040000L, 0x10041000L, 0x00001000L,
    0x00000040L, 0x10040040L, 0x00001000L, 0x00041040L,
    0x10001000L, 0x00000040L, 0x10000040L, 0x10040000L,
    0x10040040L, 0x10000000L, 0x00040000L, 0x10001040L,
    0x00000000L, 0x10041040L, 0x00040040L, 0x10000040L,
    0x10040000L, 0x10001000L, 0x10001040L, 0x00000000L,
    0x10041040L, 0x00041000L, 0x00041000L, 0x00001040L,
    0x00001040L, 0x00040040L, 0x10000000L, 0x10041000L };

void deskey(unsigned char *key,short edf, unsigned long *kn);
void cookey(register unsigned long *raw1, unsigned long *dough);
//void cpkey(register unsigned long *into);
//void usekey(register unsigned long *from);
//void des(unsigned char *inblock,unsigned char *outblock);
void scrunch(register unsigned char *outof, register unsigned long *into);
void unscrun(register unsigned long *outof, register unsigned char *into);
void desfunc(register unsigned long *block,register unsigned long *keys);

/*****************  DES Function  *****************/
unsigned long OPENCOMM_DesExpandEncKey(
        unsigned char *pbDesKey,
        unsigned long  ulDesKeyLen,
        unsigned char *pbDesEncKey,
        unsigned long *ulDesEncKeyLen);

unsigned long OPENCOMM_DesExpandDecKey(
        unsigned char *pbDesKey,
        unsigned long  ulDesKeyLen,
        unsigned char *pbDesDecKey,
        unsigned long *ulDesDecKeyLen);

unsigned long OPENCOMM_DesEncRaw(
        unsigned char *pbDesEncKey,
        unsigned long  ulDesEncKeyLen,
        unsigned char *pbInData,
        unsigned long  ulInDataLen,
        unsigned char *pbOutData,
        unsigned long *ulOutDataLen);

unsigned long OPENCOMM_DesDecRaw(
        unsigned char *pbDesDecKey,
        unsigned long  ulDesDecKeyLen,
        unsigned char *pbInData,
        unsigned long  ulInDataLen,
        unsigned char *pbOutData,
        unsigned long *ulOutDataLen);


int myic_DESDecrypt(
        unsigned char *pDesKey,
        int            nDesKeyLen,
        unsigned char *pInData,
        int            nInDataLen,
        unsigned char *pOutData,
        int           *pOutDataLen);

int myic_DESEncrypt(
        unsigned char *pDesKey,
        int            nDesKeyLen,
        unsigned char *pInData,
        int            nInDataLen,
        unsigned char *pOutData,
        int           *pOutDataLen);


void deskey(unsigned char *key,short edf, unsigned long *kn)
{
    register int i, j, l, m, n;
    unsigned long pc1m[56],pcr[56];
    
    
    for ( j = 0; j < 56; j++ ) 
    {
        l = pc1[j];
        m = l & 07;
        pc1m[j] = (((unsigned long) key[l >> 3] & (unsigned long)bytebit[m] ) ? 1:0);
    }
    for ( i = 0;i < 16; i++)
    {
        if ( edf == DE1 )    m = (15 - i) << 1;
        else    m = i << 1;
        n = m + 1;
        kn[m] = kn[n] = 0L;
        for ( j = 0; j < 28; j++ )
        {
            l = j + totrot[i];
            if ( l < 28 )    pcr[j] = pc1m[l];
            else    pcr[j] = pc1m[l-28];
        }
        for (j = 28; j < 56; j++ ) 
        {
            l = j + totrot[i];
            if ( l < 56 )    pcr[j] = pc1m[l];
            else    pcr[j] = pc1m[l-28];
        } 
        for ( j = 0; j < 24; j++ ) 
        {
            if ( pcr[pc2[j]] )    kn[m] |= bigbyte[j];
            if ( pcr[pc2[j+24]] )    kn[n] |= bigbyte[j];
        }
    }
    return;
}

void cookey(register unsigned long *raw1, unsigned long *dough)
{
    register unsigned long *cook,*raw0;
    register int i;
    
    cook = dough;
    for ( i = 0; i < 16; i++, raw1++ ) {
        raw0 = raw1++;
        *cook     = (*raw0 & 0x00fc0000L) << 6;
        *cook    |= (*raw0 & 0x00000fc0L) << 10;
        *cook    |= (*raw1 & 0x00fc0000L) >> 10;
        *cook++    |= (*raw1 & 0x00000fc0L) >> 6;
        *cook     = (*raw0 & 0x0003f000L) << 12;
        *cook    |= (*raw0 & 0x0000003fL) << 16;
        *cook    |= (*raw1 & 0x0003f000L) >> 4;
        *cook++    |= (*raw1 & 0x0000003fL);
    }
    return;
}

void scrunch(register unsigned char *outof, register unsigned long *into)
{
    *into     = (*outof++ & 0xffL) << 24;
    *into    |= (*outof++ & 0xffL) << 16;
    *into    |= (*outof++ & 0xffL) << 8;
    *into++    |= (*outof++ & 0xffL);
    *into     = (*outof++ & 0xffL) << 24;
    *into    |= (*outof++ & 0xffL) << 16;
    *into    |= (*outof++ & 0xffL) << 8;
    *into++    |= (*outof   & 0xffL);
    return;
}

void unscrun(register unsigned long *outof, register unsigned char *into)
{
    *into++     = (unsigned char)((*outof >> 24) & 0xffL);
    *into++     = (unsigned char)((*outof >> 16) & 0xffL);
    *into++     = (unsigned char)((*outof >>  8) & 0xffL);
    *into++     = (unsigned char)( *outof++      & 0xffL);
    *into++     = (unsigned char)((*outof >> 24) & 0xffL);
    *into++     = (unsigned char)((*outof >> 16) & 0xffL);
    *into++     = (unsigned char)((*outof >>  8) & 0xffL);
    *into     = (unsigned char)( *outof          & 0xffL);
    return;
}

void desfunc(register unsigned long *block,register unsigned long *keys)
{
    register unsigned long fval, work, right, leftt;
    register int round;
    
    leftt = block[0];
    right = block[1];
    work = ((leftt >> 4) ^ right) & 0x0f0f0f0fL;
    
    right ^= work;
    leftt ^= (work << 4);
    work = ((leftt >> 16) ^ right) & 0x0000ffffL;
    
    right ^= work;
    leftt ^= (work << 16);
    work = ((right >> 2) ^ leftt) & 0x33333333L;
    
    leftt ^= work;
    right ^= (work << 2);
    work = ((right >> 8) ^ leftt) & 0x00ff00ffL;
    
    leftt ^= work;
    right ^= (work << 8);
    right = ((right << 1) | ((right >>31) & 1L)) & 0xffffffffL;
    work = (leftt ^ right) & 0xaaaaaaaaL;
    
    leftt ^= work;
    right ^= work;
    leftt = ((leftt << 1) | ((leftt >> 31)&1L)) & 0xffffffffL;
    
    for (round = 0; round < 8; round++) {
        work  = (right << 28) | (right >> 4);
        work ^= *keys++;
        fval  = SP7[ work    & 0x3fL];
        fval |= SP5[(work >>  8) & 0x3fL];
        fval |= SP3[(work >> 16) & 0x3fL];
        fval |= SP1[(work >> 24) & 0x3fL];
        work  = right ^ *keys++;
        fval |= SP8[ work     & 0x3fL];
        fval |= SP6[(work >>  8) & 0x3fL];
        fval |= SP4[(work >> 16) & 0x3fL];
        fval |= SP2[(work >> 24) & 0x3fL];
        leftt ^= fval;
        work  = (leftt << 28) | (leftt >> 4);
        work ^= *keys++;
        fval  = SP7[ work     & 0x3fL];
        fval |= SP5[(work >>  8) & 0x3fL];
        fval |= SP3[(work >> 16) & 0x3fL];
        fval |= SP1[(work >> 24) & 0x3fL];
        work  = leftt ^ *keys++;
        fval |= SP8[ work     & 0x3fL];
        fval |= SP6[(work >>  8) & 0x3fL];
        fval |= SP4[(work >> 16) & 0x3fL];
        fval |= SP2[(work >> 24) & 0x3fL];
        right ^= fval;
    }
    
    right = (right << 31) | (right >> 1);
    work = (leftt ^ right) & 0xaaaaaaaaL;
    leftt ^= work;
    right ^= work;
    leftt = (leftt << 31) | (leftt >> 1);
    work = ((leftt >>  8) ^ right) & 0x00ff00ffL;
    right ^= work;
    leftt ^= (work << 8);
    work = ((leftt >>  2) ^ right) & 0x33333333L;
    right ^= work;
    leftt ^= (work << 2);
    work = ((right >> 16) ^ leftt) & 0x0000ffffL;
    leftt ^= work;
    right ^= (work << 16);
    work = ((right >>  4) ^ leftt) & 0x0f0f0f0fL;
    leftt ^= work;
    right ^= (work << 4);
    *block++ = right;
    *block = leftt;
    return;
}

/*****************************************************************
    OPENCOMM_DesExpandEncKey    : Expand Des Enc Key 扩展des加密密钥
    Return value:
        0         : Success
        other     : failed
    Parameters:
        pbDesKey        : 扩展前的DES密钥(8字节)       input
        ulDesKeyLen     : 扩展前的DES密钥长度          input
        pbDesEncKey     : 扩展后的DES加密密钥(128字节)  output
        *ulDesEncKeyLen : 扩展后的DES加密密钥长度       output
*****************************************************************/
unsigned long OPENCOMM_DesExpandEncKey(
        unsigned char *pbDesKey,
        unsigned long  ulDesKeyLen,
        unsigned char *pbDesEncKey,
        unsigned long *ulDesEncKeyLen)
{
    unsigned long kn[32], dough[32];
    
    if (ulDesKeyLen != 8)
        return 0xEE20;

    deskey(pbDesKey, EN0, kn);
    cookey(kn, dough);
    *ulDesEncKeyLen = DES_KEYBYTES;  //32 long = 128 bytes
    memcpy(pbDesEncKey, dough, *ulDesEncKeyLen);
    
    return 0;
}

/*****************************************************************
    OPENCOMM_DesExpandDecKey    : Expand Des Dec Key 扩展des解密密钥
    Return value:
        0       : Success
        other   : failed
    Parameters:
        pbDesKey        : 扩展前的DES密钥(8字节)      input
        ulDesKeyLen     : 扩展前的DES密钥长度         input
        pbDesDecKey     : 扩展后的DES解密密钥(128字节) output
        *ulDesDecKeyLen : 扩展后的DES解密密钥长度      output
*****************************************************************/
unsigned long OPENCOMM_DesExpandDecKey(
        unsigned char *pbDesKey,
        unsigned long  ulDesKeyLen,
        unsigned char *pbDesDecKey,
        unsigned long *ulDesDecKeyLen)
{
    unsigned long kn[32], dough[32];
    
    if (ulDesKeyLen != 8)
        return 0xEE20;

    deskey(pbDesKey, DE1, kn);
    cookey(kn, dough);
    *ulDesDecKeyLen = DES_KEYBYTES;  //32 long = 128 bytes
    memcpy(pbDesDecKey, dough, *ulDesDecKeyLen);
    
    return 0;
}

/****************************************************************
    OPENCOMM_DesEncRaw        : Des算法加密小整块明文8字节 
    Return value:
        0       : Success
        other   : failed
    Parameters:
        pbDesEncKey    : DES加密密钥    input
        ulDesEncKeyLen : DES加密密钥长度 input
        pbInData       : 待加密的明文    input
        ulInDataLen    : 待加密的明文长度 input
        pbOutData      : 加密后的密文    output
        *ulOutDataLen  : 加密后的密文长度 output
*****************************************************************/
unsigned long OPENCOMM_DesEncRaw(
        unsigned char *pbDesEncKey,
        unsigned long  ulDesEncKeyLen,
        unsigned char *pbInData,
        unsigned long  ulInDataLen,
        unsigned char *pbOutData,
        unsigned long *ulOutDataLen)
{
    unsigned long work[2], ek[DES_KEYLONGS];
    unsigned char cp[DES_BLOCKLEN];

    if (ulInDataLen != DES_BLOCKLEN)
        return 0xEE20;
    
    if (ulDesEncKeyLen != DES_KEYBYTES)
        return 0xEE20;

    memcpy(cp, pbInData, DES_BLOCKLEN);
    scrunch(cp,work);  // 8 bytes -> 2 long
    memcpy(ek, pbDesEncKey, ulDesEncKeyLen);
    desfunc(work,ek);
    unscrun(work,cp); // 2 long -> 8 bytes
    memcpy(pbOutData, cp, DES_BLOCKLEN);
    *ulOutDataLen = DES_BLOCKLEN;

    return 0;
}

/*****************************************************************
    OPENCOMM_DesDecRaw : Des算法解密小整块密文8字节 
    Return value:
        0     : Success
        other : failed
    Parameters:
        pbDesDecKey    : DES解密密钥     input
        ulDesDecKeyLen : DES解密密钥长度  input
        pbInData       : 待解密的密文     input
        ulInDataLen    : 待解密的密文长度  input
        pbOutData      : 解密后的明文     output
        *ulOutDataLen  : 解密后的明文长度  output
*****************************************************************/
unsigned long OPENCOMM_DesDecRaw(
        unsigned char *pbDesDecKey,
        unsigned long  ulDesDecKeyLen,
        unsigned char *pbInData,
        unsigned long  ulInDataLen,
        unsigned char *pbOutData,
        unsigned long *ulOutDataLen)
{
    unsigned long work[2], dk[DES_KEYLONGS];
    unsigned char cp[DES_BLOCKLEN];

    if (ulInDataLen != DES_BLOCKLEN)
        return 0xEE20;
    
    if (ulDesDecKeyLen != DES_KEYBYTES)
        return 0xEE20;

    memcpy(cp, pbInData, DES_BLOCKLEN);
    scrunch(cp,work);  // 8 bytes -> 2 long
    memcpy(dk, pbDesDecKey, ulDesDecKeyLen);
    desfunc(work,dk);
    unscrun(work,cp); // 2 long -> 8 bytes
    memcpy(pbOutData, cp, DES_BLOCKLEN);
//    des_enc(pbDesEncKey, pbInData, pbOutData);
    *ulOutDataLen = DES_BLOCKLEN;

    return 0;
}

/*********************   DES    *********************/

int myic_DESEncrypt(
        unsigned char *pDesKey,
        int            nDesKeyLen,
        unsigned char *pInData,
        int            nInDataLen,
        unsigned char *pOutData,
        int           *pOutDataLen)
{
    unsigned char DesKeyBuf[32];
    unsigned char DesEncKeyBuf[128];
    int EncKeyLen, KeyLen = 0;
    int retval = 0, loops, i;
    
    if(nInDataLen%8 != 0)
        return 0xEE20;
    
    if(nDesKeyLen != 8)
        return 0xEE20;
    KeyLen = nDesKeyLen;
    memcpy(DesKeyBuf, pDesKey, nDesKeyLen);

    
    retval = OPENCOMM_DesExpandEncKey(DesKeyBuf, KeyLen,
        DesEncKeyBuf, (unsigned long *)&EncKeyLen);
    if(retval != 0)
        return retval;

    loops = nInDataLen/8;
    for(i = 0; i < loops; i++)
    {
        retval = OPENCOMM_DesEncRaw(DesEncKeyBuf, EncKeyLen, pInData + i*8,
            8, pOutData + i*8, (unsigned long *)pOutDataLen);
        if(retval != 0)
            return retval;
    }
    *pOutDataLen = nInDataLen;
    return retval;
}


int myic_DESDecrypt(
        unsigned char *pDesKey,
        int            nDesKeyLen,
        unsigned char *pInData,
        int            nInDataLen,
        unsigned char *pOutData,
        int           *pOutDataLen)
{
    unsigned char DesKeyBuf[32];
    unsigned char DesDecKeyBuf[128];
    int DecKeyLen, KeyLen = 0;
    int retval = 0, loops, i;
    
    if(nInDataLen%8 != 0)
        return 0xEE20;
    
    if(nDesKeyLen != 8)
        return 0xEE20;
    KeyLen = nDesKeyLen;
    memcpy(DesKeyBuf, pDesKey, nDesKeyLen);

    retval = OPENCOMM_DesExpandDecKey(DesKeyBuf, KeyLen,
        DesDecKeyBuf, (unsigned long *)&DecKeyLen);
    if(retval != 0)
        return retval;
    
    loops = nInDataLen/8;
    for(i = 0; i < loops; i++)
    {
        retval = OPENCOMM_DesDecRaw(DesDecKeyBuf, DecKeyLen, pInData + i*8,
            8, pOutData + i*8, (unsigned long *)pOutDataLen);
        if(retval != 0)
            return retval;
    }
    *pOutDataLen = nInDataLen;
    return retval;
}


//对称明文数据打pading
void  CW_dataPadAdd(int tag, unsigned char *date, unsigned int dateLen, 
                    unsigned char **padDate, unsigned int *padDateLen)
{
    int           i, padLen;
    unsigned char *pTmp   = NULL;
    
    pTmp = (unsigned char *)malloc(dateLen+24);
    if (pTmp == NULL)
    {
        *padDate = NULL;
        return ;
    }
    memset(pTmp, 0, dateLen+24);
    memcpy(pTmp, date, dateLen);
    
    if (tag == 0)
    {
        padLen = 8 - dateLen % 8;
        for (i=0; i<padLen; i++)
        {
            pTmp[dateLen+i] = (char)padLen;
        }
        *padDateLen = dateLen + padLen;
    }
    else
    {
        padLen = 16 - dateLen % 16;
        for (i=0; i<padLen; i++)
        {
            pTmp[dateLen+i] = (char)padLen;
        }        
    }
    
    *padDateLen = dateLen + padLen;    
    *padDate = pTmp;
}

#define  USER_PASSWORD_KEY "abcd1234"


//数据加密
int DesEnc(
         unsigned char *pInData,
         int            nInDataLen,
         unsigned char *pOutData,
         int           *pOutDataLen)
{
    int                rv;
    unsigned char    *padDate = NULL;
    unsigned int    padDateLen = 0;

    CW_dataPadAdd(0, pInData, (unsigned int )nInDataLen, &padDate, &padDateLen);

    rv = myic_DESEncrypt((unsigned char *)USER_PASSWORD_KEY, strlen(USER_PASSWORD_KEY),
        padDate, (int)padDateLen, pOutData, pOutDataLen);
    if (rv != 0)
    {
        if (padDate != NULL)
        {
            free(padDate);
        }
        return rv;    
    }

    if (padDate != NULL)
    {
        free(padDate);
    }
    return 0;
}


//数据加密
int DesEnc_raw(
    unsigned char *pInData,
    int            nInDataLen,
    unsigned char *pOutData,
    int           *pOutDataLen)
{
    int                rv;
    unsigned char    *padDate = NULL;
    unsigned int    padDateLen = 0;

    rv = myic_DESEncrypt((unsigned char *)USER_PASSWORD_KEY, strlen(USER_PASSWORD_KEY),
        pInData, (int)nInDataLen, pOutData, pOutDataLen);
    if (rv != 0)
    {
        return rv;    
    }
    return 0;
}

//解密分配内存错误
#define  ERR_MALLOC 20
//密码长度不是8的整数倍, 不合法
#define  ERR_FILECONT 20


//用户使用函数des解密
int DesDec(
           unsigned char *pInData,
           int            nInDataLen,
           unsigned char *pOutData,
           int           *pOutDataLen)
{
    int                rv;
    char            padChar;
    unsigned char     *tmpPlain = NULL;
    
    tmpPlain =        (unsigned char *)malloc(nInDataLen+24);
    if (tmpPlain == NULL)
    {
        return ERR_MALLOC;
    }
    memset(tmpPlain, 0, nInDataLen+24);

    //解密
    rv = myic_DESDecrypt((unsigned char *)USER_PASSWORD_KEY, strlen(USER_PASSWORD_KEY),
        pInData, nInDataLen, tmpPlain, pOutDataLen);
    if (rv != 0)
    {
        if (tmpPlain != NULL) free(tmpPlain);
        return rv;
    }

    //去pading
    padChar = tmpPlain[*pOutDataLen - 1];
    if ( (int)padChar<=0 || (int)padChar>8) //异常处理
    {
        if (tmpPlain) free(tmpPlain);
        return ERR_FILECONT;
    }

    *pOutDataLen = *pOutDataLen - (int)padChar;    
    //memset(tmpPlain + *pOutDataLen, 0, (int)padChar);    
    memcpy(pOutData, tmpPlain, *pOutDataLen);
    if (tmpPlain) free(tmpPlain);    
    return 0;
}


//用户使用函数des解密
int DesDec_raw(
    unsigned char *pInData,
    int            nInDataLen,
    unsigned char *pOutData,
    int           *pOutDataLen)
{
    int                rv;
    //char            padChar;
    //unsigned char     *tmpPlain = NULL;

    /*
    tmpPlain =        (unsigned char *)malloc(nInDataLen+24);
    if (tmpPlain == NULL)
    {
        return ERR_MALLOC;
    }
    memset(tmpPlain, 0, nInDataLen+24);
    */

    //解密
    rv = myic_DESDecrypt((unsigned char *)USER_PASSWORD_KEY, strlen(USER_PASSWORD_KEY),
        pInData, nInDataLen, pOutData, pOutDataLen);
    if (rv != 0)
    {
        //if (tmpPlain != NULL) free(tmpPlain);
        return rv;
    }
    /*
    //去pading
    padChar = tmpPlain[*pOutDataLen - 1];
    if ( (int)padChar<=0 || (int)padChar>8) //异常处理
    {
        if (tmpPlain) free(tmpPlain);
        return ERR_FILECONT;
    }

    *pOutDataLen = *pOutDataLen - (int)padChar;    
    //memset(tmpPlain + *pOutDataLen, 0, (int)padChar);    
    memcpy(pOutData, tmpPlain, *pOutDataLen);
    if (tmpPlain) free(tmpPlain);    
    */
    return 0;
}

HwEncdes.cpp 

#include "HwEncdes.h"
#include "des.h"
#include <iostream>

HwEncdes::HwEncdes(void)
{
}


HwEncdes::~HwEncdes(void)
{
}

int HwEncdes::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 HwEncdes::DecData(unsigned char *cryptdata,int cryptlen,unsigned char *plain,int *plainlen)
{
	int ret =0;
	
	ret = DesDec(cryptdata,cryptlen,plain,plainlen);

	if (ret!=0)
	{
		printf("func DesEnc() err :%d\n",ret);
		return ret ;
	}
	return ret;
}

mainclass_框架类.cpp 

#define  _CRT_SECURE_NO_WARNINGS 
#include <iostream>
#include "CSocketProtocol.h"
#include "CSckFactoryImp1.h"
#include "CSckFactoryImp2.h"
#include "HwEncdes.h"
using namespace std;

//框架类 组合   M（厂商socket 和 des）  V（main函数）   C（框架）
class MainOp
{
public:
	MainOp()
	{
		this->sp = NULL;
		this->des = NULL;
	}
	MainOp(CSocketProtocol *sp,CEncDesProtocol*des)
	{
		this->des = des;
		this->sp = sp;
	}
	//注入 
	void setSp(CSocketProtocol*sp)
	{
		this->sp = sp;
	}
	void setDes(CEncDesProtocol*des)
	{
		this->des = des;
	}
	//带加密的发送接收
	int sendAndRecv(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)
		{
			return -1;
		}

		//发送前对数据加密

		ret = this->des->EncData(in,inlen,data,&datalen);

		printf("密文:%d\n",data);
		printf("长度:%d\n",datalen);

		ret = this->sp->cltSocketSend(data,datalen);

		if (ret!=0)
		{
			return -1;
		}
		ret = this->sp->cltSocketRev(data,&datalen);
		if (ret!=0)
		{
			return -1;
		}
		//对收到的数据进行解密
		ret = this->des ->DecData(data,datalen,out,outlen);

		ret = this->sp->cltSocketDestory();
		if (ret!=0)
		{
			return -1;
		}
		return 0;
	}
protected:
private:
	CSocketProtocol *sp;//类组合
	CEncDesProtocol *des;
};
int main()
{
	MainOp *op = new MainOp ;
	CSocketProtocol *sp = NULL;
	CEncDesProtocol *des = NULL;

	sp = new CSckFactoryImp1;
	des = new HwEncdes;

	op->setSp(sp);//注入
	op->setDes(des);

	unsigned char in[4096];
	int inlen =0;
	unsigned char out[4096];
	int outlen;
	int ret = 0;

	strcpy((char*)in,"abcdefghijklmnopq");

	inlen = strlen((char*)in)+1;//长度包括后面的‘\0’

	op->sendAndRecv(in,inlen,out,&outlen);

	printf("接收到的明文:%s\n",out);

	system("pause");
	return 0;

}



BUS375
关注
专栏目录
软件架构师成长之路
03-13
本次课程以培养Java软件架构师为核心，以机械工业出版社出版的世界首发“软件架构师成长之路”系列丛书为教材，通过初、中、高三个阶段20季课程的学校，使学员能够成为具有工匠精神的栋梁之才。第一季 为软件架构师基础，使学员掌握架构基本理论与实践。
Java基础篇---------抽象类
ArtemisC的博客
09-05 229
在之间的文章中说到了继承就像儿子继承父亲，其实抽象类的思想类似继承思想，我们从武侠小说的角度来解析一番何为抽象类思想。郭靖向洪七公学降龙十八掌的时候是一招一式一板一眼老老实实的学，师傅怎么教，徒弟就怎么学，这对应着继承。而张无忌像张三丰学太极拳法的时候，需要先将招式忘光，才能学会真正的太极拳法，注重其意而非其形，这种武学思想映射到编程里就是抽象类。 抽象类除了不能实例化对象之外，类的其它功能依然...
深入理解Java（四）——抽象思想
弄鹊
10-01 1123
抽象类往往用来表征对问题领域进行分析、设计中得出的抽象概念，是对一系列看上去不同，但是本质上相同的具体概念的抽象。而接口泛指实体把自己提供给外界的一种抽象化物（可以为另一实体），用以由内部操作分离出外部沟通方法，使其能被内部修改而不影响外界其他实体与其交互的方式。在Java中，抽象类和接口都体现了OPP的抽象思想，故在本文中，我们会对这两类知识点做一个详细的阐述。
Java中的抽象类与接口类：自上而下的设计思想
最新发布
五更钟动的博客
04-08 535
在抽象类中，一些方法可能已经有了默认的实现，而其他方法可能需要子类提供具体的实现。抽象类的设计思想是自下而上的，即从具体的实现逐步向上抽象出通用的行为。接口类的设计思想是自上而下的，即从更抽象的层次定义了一组方法，然后由具体的类去实现这些方法。抽象类更关注于从具体的实现向上抽象出通用的行为，而接口类更关注于从更抽象的层次定义一组行为。综上所述，抽象类和接口类是Java面向对象编程中的重要概念，深入理解它们的特点和区别，并根据设计需求灵活运用，能够更好地设计出灵活、可扩展的软件系统。是一个接口类，它定义了。
11.面向对象编程思想——抽象
weixin_43893483的博客
08-11 345
1. 如何理解抽象 我们在前面去定义一个结构体时，实际上就是把一类事物的共有的属性（字段）和行为（方法）提取出来，形成一个物理模型（模板）。这种研究问题的方法称为抽象。 package main import ( "fmt" ) // 定义一个结构体Account type Account struct { AccountNo string Pwd string Balance float64 } // 方法 // 1. 存款 func (account *Account) D.
C++编程思想
03-12
此外，C++11引入了纯虚函数和抽象类，进一步强化了多态性设计。 `bitset`是C++标准库中的一个模板类，用于表示固定大小的位集。它可以高效地存储和操作二进制数据，支持位运算，如按位与、按位或、按位异或和按位非...
Delphi面向对象编程思想
01-15
《Delphi面向对象编程思想》是由刘艺编著的一本专著，主要探讨了如何在Delphi编程环境中应用面向对象的思想和技术。面向对象编程（Object-Oriented Programming, OOP）是现代软件开发中的核心概念，它通过封装、继承...
Visual C++编程思想
01-31
在Visual C++中，编程思想的核心是面向对象编程（OOP）。C++是一种支持OOP的强类型语言，它允许程序员创建类、对象，并通过继承、封装和多态性等概念来实现代码复用和模块化。MFC库则进一步强化了这些特性，为...
《Java 编程基础》期末考试题（卷A）
02-01
Java编程基础是计算机科学教育中的重要一环，尤其对于初学者而言，掌握好Java语言的基本概念、语法和编程思想是至关重要的。这份“《Java 编程基础》期末考试题（卷A）”资料，旨在帮助学生巩固所学，检测对Java编程...
《C&C++编程思想》
09-23
同时，读者还将接触到虚函数、纯虚函数和抽象类，理解它们在接口设计中的作用。 模板是C++的一个强大工具，它允许编写泛型代码，提高代码的复用性。模板元编程是C++中一种高级技术，可以在编译时进行计算，极大地...
socket库C++模型设计和实现--企业信息系统框架集成第三方产品案例
07-25
C++面向对象编程的一个综合示例代码：socket库C++模型设计和实现--企业信息系统框架集成第三方产品案例
Java面向抽象编程的思想
张启明
11-24 2763
在设计程序时，经常会使用abstract类，其原因是，abstract类只关心操作，但不关心这些操作具体实现的细节，可以是程序的设计者把主要精力放在程序的设计上，而不必拘泥于细节的实现，既避免设计者把大量的时间和经理花费在具体的算法上。 在设计一个程序时，可以通过在abstract类中声明若干个abstract方法，表明这些方法在整个系统设计中的重要性，方法体的内容细节有有它的费abstra
从面向对象思想上去理解抽象类和接口的区别
[hm]
06-02 798
abstract class和interface是Java语言中对于抽象类定义进行支持的两种机制，正是由于这两种机制的存在，才赋予了Java强大的面向对象能力。 abstract class和interface之间在对于抽象类定义的支持方面具有很大的相似性，甚至可以相互替换，因此很多开发者在进行抽象类定义时对于 abstract class和interface的选择显得比较随意。其实，两者之间还是有
一种基于抽象类的思想
牵佳一诺的博客
07-19 292
如果CRUD是很多Service要做的，那么可以抽象出一个BaseService抽象父类，里面去实现一些CRUD方法（非抽象方法）。但会有一个问题，就是里面的DAO（Mapper）是不一样的，抽象类也不能用注入，那怎么办？ 解决方法：在抽象父类中提供一个获取DAO（Mapper）的抽象方法（比如getMapper()），让子类各自实现。那么抽象父类的CRUD方法中就可以使用getMapper()
java编程思想——抽象类
a879365197的专栏
07-26 708
一、抽象类 1、什么是抽象类 对于类的某个方法可以描述这个的某个特性。比如动物的跑等，但是不同的对象可能方法是不一样的。 这就需要对方法进行抽象。这样就可以根据不同的类的特点，进行继承，然后再对抽象的方法进行重写。 abstract class ** { abstract void **（）； } 2、抽象类的特点 （1）抽象类不可以被实例化 （2）抽象类的抽象
面向对象编程思想-抽象
aiyan8271的博客
08-25 128
如何理解抽象： 我们在前面去定义一个结构体的时候，实际上就是把一类事物的共有的属性(字段)和行为(方法)提取出来，形成一个物理模型(模板)。这种研究问题的方法称为抽象。 案例演示： type Account struct { 　　AccountNo string 　　Pwd string 　　Balance float64} //方法//1.存款func (account *...
文件加解密（任意文件类型的文件）
agentky的博客
11-10 1148
直接上代码： 支持任意类型的文件的加密和解密 可以自由修改密钥 文件加解密. #define _CRT_SECURE_NO_WARNINGS #include <stdlib.h> #include <string.h> #include <stdio.h> #include "des.h" int file_encrypt(const char* file1,const char* file2) { int ret=0; unsigned char buf[4
Java编程思想之抽象过程
YiYang15848184726的专栏
06-07 721
 所有编程语言都提供抽象（abstraction）机制。可以认为，你所能够解决的问题的复杂性直接取决于抽象的类型和质量。我所谓的“类型”是指“你所抽象的是什么？”汇编语言是对底层机器的小型抽象。接着出现的许多所谓“命令式（Imperative）”语言（诸如FORTRAN、BASIC、C等）都是对汇编语言的抽象。这些语言在汇编语言之上有了大幅的改进，但是它们所作的主要抽象仍要求你在解决问题时要基于计
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值