类的接口与实现分离的技术

最新推荐文章于 2022-02-25 21:57:21 发布
最新推荐文章于 2022-02-25 21:57:21 发布
阅读量625 收藏 1
点赞数
分类专栏： C++ 文章标签： class delete iostream include c

用C++写导出类库时，只暴露接口，隐藏类的实现细节。即：提供的头文件里只暴露的公共成员函数的声明，类的其他所有信息都不会在这个头文件里面显示出来。这个时候就要用到接口与实现分离的技术。

 

下面用一个最简单的例子来说明。

 

类CExp是我们要导出的类，其中有一个私有成员变量是CTest类的对象，各个文件内容如下：

 

///  
//Test.h文件内容：  

///   
 
class CTest    
{  
public:  
    CTest();  
    virtual ~CTest();  
   
    void DoSomething();  
};   


///  
//Test.cpp文件内容：   
///  

#include "Test.h"  
 
#include <iostream>  
using namespace std;  
 
CTest::CTest()  
{  
}  
 
CTest::~CTest()  
{  
}  
 
void CTest::DoSomething()  
{  
    cout << "Do something in class CTest!" << endl;  
}  
 
///   
//Exp.h文件内容：  

///    
#include "Test.h"  
 
class CExp    
{  
public:  
    CExp();  
    virtual ~CExp();  
 
    void DoSomething();  
 
private:  
    CTest m_Test;   
    void Test();  
};   
  
///  
//Exp.cpp文件内容：  

///   

 
#include "Exp.h"  
 
CExp::CExp()  
{  
}  
 
CExp::~CExp()  
{  
}  
 
//  其实该方法在这里并没有必要，这样只是为了说明调用关系  
void CExp::Test()  
{  
    m_Test.DoSomething();   
}  
 
void CExp::DoSomething()  
{  
    Test();  
} 

 

///  
//Test.h文件内容：

///  

class CTest 
{
public:
    CTest();
    virtual ~CTest();
 
    void DoSomething();
};

 

///  
//Test.cpp文件内容：

///  

#include "Test.h"

#include <iostream>
using namespace std;

CTest::CTest()
{
}

CTest::~CTest()
{
}

void CTest::DoSomething()
{
    cout << "Do something in class CTest!" << endl;
}

 

///

//Exp.h文件内容：

///  

#include "Test.h"

class CExp 
{
public:
    CExp();
    virtual ~CExp();

    void DoSomething();

private:
    CTest m_Test;

    void Test();
};

 

///  
//Exp.cpp文件内容：

///  

#include "Exp.h"

CExp::CExp()
{
}

CExp::~CExp()
{
}

//  其实该方法在这里并没有必要，这样只是为了说明调用关系
void CExp::Test()
{
    m_Test.DoSomething();
}

void CExp::DoSomething()
{
    Test();
}

 

为了让用户能使用我们的类CExp，我们必须提供Exp.h文件，这样类CExp的私有成员也暴露给用户了。而且，仅仅提供Exp.h文件是不够的，因为Exp.h文件include了Test.h文件，在这种情况下，我们还要提供Test.h文件。那样CExp类的实现细节就全暴露给用户了。另外，当我们对类CTest做了修改（如添加或删除一些成员变量或方法）时，我们还要给用户更新Test.h文件，而这个文件是跟接口无关的。如果类CExp里面有很多像m_Test那样的对象的话，我们就要给用户提供N个像Test.h那样的头文件，而且其中任何一个类有改动，我们都要给用户更新头文件。还有一点就是用户在这种情况下必须进行重新编译！上面是非常小的一个例子，重新编译的时间可以忽略不计。但是，如果类CExp被用户大量使用的话，那么在一个大项目中，重新编译的时候我们就有时间可以去喝杯咖啡什么的了。当然上面的种种情况不是我们想看到的！你也可以想像一下用户在自己程序不用改动的情况下要不停的更新头文件和编译时，他们心里会骂些什么。其实对用户来说，他们只关心类CExp的接口DoSomething()方法。那我们怎么才能只暴露类CExp的DoSomething()方法而不又产生上面所说的那些问题呢？答案就是－－接口与实现的分离。我可以让类CExp定义接口，而把实现放在另外一个类里面。

 

下面是具体的方法：

　　

      首先，添加一个实现类CImplement来实现CExp的所有功能。注意：类CImplement有着跟类CExp一样的公有成员

函数，因为他们的接口要完全一致

///  
//Implement.h文件内容：  

///   
 
#include "Test.h"  
 
class CImplement    
{  
public:  
    CImplement();  
    ~CImplement();  
 
    void DoSomething();  
 
private:  
    CTest m_Test;  
 
    void Test();  
};   
 
///  
//Implement.cpp文件内容：  

///   

 
#include "Implement.h"  
 
CImplement::CImplement()  
{  
}  
 
CImplement::~CImplement()  
{  
}  
 
void CImplement::Test()  
{  
    m_Test.DoSomething();  
}  
 
void CImplement::DoSomething()  
{  
    Test();  
} 

 

///  
//Implement.h文件内容：

///  

//#include "Test.h"

///  

class CImplement 
{
public:
    CImplement();
    ~CImplement();

    void DoSomething();

private:
    CTest m_Test;

    void Test();
};

 

///  
//Implement.cpp文件内容：

///  

#include "Implement.h"

CImplement::CImplement()
{
}

CImplement::~CImplement()
{
}

void CImplement::Test()
{
    m_Test.DoSomething();
}

void CImplement::DoSomething()
{
    Test();
}

 

///  
//然后，修改类CExp。修改后的Exp.h文件内容：

///  
//  前置声明  
class CImplement;  
 
class CExp    
{  
public:  
    CExp();  
    virtual ~CExp();  
 
 void DoSomething();  
 
private:  
    //  声明一个类CImplement的指针，不需要知道类CImplement的定义  
    CImplement *m_pImpl;  
};  
 

///   
//修改后的Exp.cpp文件内容：  

//  在这里包含类CImplement的定义头文件  

/// 
#include "Implement.h"  
 
CExp::CExp()  
{  
    m_pImpl = new CImplement;  
}  
 
CExp::~CExp()  
{  
    if (m_pImpl)  
        delete m_pImpl;  
}  
 
void CExp::DoSomething()  
{  
    m_pImpl->DoSomething();  
} 


//  前置声明
class CImplement;

class CExp 
{
public:
    CExp();
    virtual ~CExp();

 void DoSomething();

private:
    //  声明一个类CImplement的指针，不需要知道类CImplement的定义
    CImplement *m_pImpl;
};

 

/// 

//   修改后的Exp.cpp文件内容：

//   在这里包含类CImplement的定义头文件

/// 
#include "Implement.h"

CExp::CExp()
{
    m_pImpl = new CImplement;
}

CExp::~CExp()
{
    if (m_pImpl)
        delete m_pImpl;
}

void CExp::DoSomething()
{
    m_pImpl->DoSomething();
}

 

通过上面的方法就实现了类CExp的接口与实现的分离。请注意两个文件中的注释。类CExp里面声明的只是接口而已，而真正的实现细节被隐藏到了类CImplement里面。为了能在类CExp中使用类CImplement而不include头文件Implement.h，就必须有前置声明class CImplement，而且只能使用指向类CImplement对象的指针，否则就不能通过编译。在发布库文件的时候，我们只需给用户提供一个头文件Exp.h就行了，不会暴露类CExp的任何实现细节。而且我们对类CTest的任何改动，都不需要再给用户更新头文件（当然，库文件是要更新的，但是这种情况下用户也不用重新编译！）。这样做还有一个好处就是，可以在分析阶段由系统分析员或者高级程序员来先把类的接口定义好，甚至可以把接口代码写好（例如上面修改后的Exp.h文件和Exp.cpp文件），而把类的具体实现交给其他程序员开发。

上文还没有考虑到类与类之间的继承关系。下面我们就来具体的谈谈这个方面。

　

 

     还是以上面提到的那篇文章中的例子来说明。


　执行类：  
 

/// 
//Implement.h文件内容：  
///  
#include "Test.h"  
 
class CImplement    
{  
public:  
    CImplement();  
    ~CImplement();  
 
    void DoSomething();  
 
private:  
    CTest m_Test;  
 
    void Test();  
};  
 
　

/// 

//Implement.cpp文件内容：  

/// 
 
#include "Implement.h"  
 
CImplement::CImplement()  
{  
}  
 
CImplement::~CImplement()  
{  
}  
 
void CImplement::Test()  
{  
    m_Test.DoSomething();  
}  
 
void CImplement::DoSomething()  
{  
    Test();  
}  
 
　　接口类：   
///

//Exp.h文件内容：  

/// 
 
//  前置声明  
class CImplement;  
 
class CExp    
{  
public:  
    CExp();  
    virtual ~CExp();  
 
 void DoSomething();  
 
private:  
    //  声明一个类CImplement的指针，不需要知道类CImplement的定义  
    CImplement *m_pImpl;  
};  
 

/// 
//　　Exp.cpp文件内容：  

/// 
 
//  在这里包含类CImplement的定义头文件  
#include "Implement.h"  
 
CExp::CExp()  
{  
    m_pImpl = new CImplement;  
}  
 
CExp::~CExp()  
{  
    if (m_pImpl)  
        delete m_pImpl;  
}  
 
void CExp::DoSomething()  
{  
    m_pImpl->DoSomething();  
} 

 


　执行类：

/// 

//　　Implement.h文件内容：

/// 

#include "Test.h"

class CImplement 
{
public:
    CImplement();
    ~CImplement();

    void DoSomething();

private:
    CTest m_Test;

    void Test();
};

 

/// 

//　　Implement.cpp文件内容：

/// 

#include "Implement.h"

CImplement::CImplement()
{
}

CImplement::~CImplement()
{
}

void CImplement::Test()
{
    m_Test.DoSomething();
}

void CImplement::DoSomething()
{
    Test();
}

　　接口类：

/// 

//　　Exp.h文件内容：

/// 

//  前置声明
class CImplement;

class CExp 
{
public:
    CExp();
    virtual ~CExp();

 void DoSomething();

private:
    //  声明一个类CImplement的指针，不需要知道类CImplement的定义
    CImplement *m_pImpl;
};

/// 

//　　Exp.cpp文件内容：

/// 

//  在这里包含类CImplement的定义头文件
#include "Implement.h"

CExp::CExp()
{
    m_pImpl = new CImplement;
}

CExp::~CExp()
{
    if (m_pImpl)
        delete m_pImpl;
}

void CExp::DoSomething()
{
    m_pImpl->DoSomething();
}

 

但是，如果类CExp是另一个类的子类，而在类CExp中要调用基类的方法，那上面的方案就不行了。比如说，类CExp的基类是下面的样子：

view plaincopy to clipboardprint?
class CInF  
{  
public:  
    CInF();  
    virtual ~CInF();  
 
    bool InitSet();  
 
    virtual void DoSomething();  
}; 
class CInF
{
public:
    CInF();
    virtual ~CInF();

    bool InitSet();

    virtual void DoSomething();
};

 

相应的类CExp的声明变成了如下的形式：


class CExp : public CInF  
{  
public:  
    CExp();  
    virtual ~CExp();  
 
    void DoSomething();  
 
private:  
    CImplement *m_pImpl;  
}; 
class CExp : public CInF
{
public:
    CExp();
    virtual ~CExp();

    void DoSomething();

private:
    CImplement *m_pImpl;
};

 

现在，假设我们必须在类CExp的DoSomething()方法中根据InitSet()的返回值来确定是否执行操作。最简单的实现方法是把类CExp的DoSomething()方法改成下面的样子：
void CExp::DoSomething()  
{  
    if (InitSet())  
        m_pImpl->DoSomething();  
} 
void CExp::DoSomething()
{
    if (InitSet())
        m_pImpl->DoSomething();
}

 

可是如果这样的话，接口与实现就没有彻底的分离，因为实现细节被暴露到了接口类中。为了避免这种情况发生，我们就必须把对基类CInF的方法InitSet()调用放到执行类CImplement当中。可是怎么在执行类CImplement当中调用接口类CExp的基类CInF的方法呢？其实很简单，因为类CExp是类CInF的子类，那么它也就继承了类CInF的方法，只要把类CExp的this指针传给类CImplement，就可以通过这个指针来调用类CExp的方法，当然也可以调用类CExp从基类CInF继承来的方法。下面是修改后的代码：

 

/// 

//Implement.h文件内容:  

/// 
 
#include "Test.h"  
// 包含声明类CExp的头文件  
#include "Exp.h"  
 
class CImplement    
{  
public:  
    //  构造函数，传入类的CExp的指针  
    CImplement(CExp *pExp);  
    ~CImplement();  
 
    void DoSomething();  
 
private:  
    CTest m_Test;  
    //  定义一个类CExp的指针，可以通过该指针调用类CExp从基类继承下来的方法  
    CExp *m_pExp;  
 
    void Test();  
};  
 

/// 
//　　Implement.cpp文件内容：  

/// 
 
#include "Implement.h"  
 
CImplement::CImplement(CExp *pExp)  
{  
    m_pExp = pExp;  
}  
 
CImplement::~CImplement()  
{  
}  
 
void CImplement::Test()  
{  
    m_Test.DoSomething();  
}  
 
void CImplement::DoSomething()  
{  
    if (m_pExp->InitSet())  
        Test();  
} 

 

/// 
//Implement.h文件内容:

/// 

#include "Test.h"
// 包含声明类CExp的头文件
#include "Exp.h"

class CImplement 
{
public:
    //  构造函数，传入类的CExp的指针
    CImplement(CExp *pExp);
    ~CImplement();

    void DoSomething();

private:
    CTest m_Test;
    //  定义一个类CExp的指针，可以通过该指针调用类CExp从基类继承下来的方法
    CExp *m_pExp;

    void Test();
};

 /// 

//　　Implement.cpp文件内容：

/// 

#include "Implement.h"

CImplement::CImplement(CExp *pExp)
{
    m_pExp = pExp;
}

CImplement::~CImplement()
{
}

void CImplement::Test()
{
    m_Test.DoSomething();
}

void CImplement::DoSomething()
{
    if (m_pExp->InitSet())
        Test();
}

 

对于类CExp来说，只要修改一下它的构造函数就行了，其他都不用修改。

CExp::CExp()
{
    m_pImpl = new CImplement(this);
}

　　这样，我们就解决了前面所提到的问题。

　　当然，也许有人会说，让类CImplement也从类CInF继承不是更简单吗？那样就可以在类CImplement中直接调用类

CInF的方法，也不用添加什么代码。可是我们知道公有继承是的子类与基类是IS-A的关系。也就是说子类是一种基类，就

像说轿车是一种汽车一样。可是，在我们例子中，类CImplement只是类CExp的一个执行类而已，跟类CExp的基类

CInF没有一点儿关系，更不要说是一种CInF了。所以不能让类CImplement从类CInF继承。


本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/amossavez/archive/2009/07/29/4390652.aspx

namtaerg
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
GridFTP数据存储接口框架的研究与实现 (2008年)
05-26
数据存储接口(DSI)为存储系统...该文提出一个可扩展的GridFFP数据存储接口框架，分离并实现DSI共有的核心功能，提炼一个更为简洁的开发接口。实验表明，该框架简化了存储系统DSI的开发流程，满足具体应用对数据的需求。
C语言接口与实现--创建可重用软件的技术
12-16
创建可重用软件的技术(英文版)》介绍用一种基于接口的设计方法创建可重用的API，这一方法将接口与实现分离开来，且与语言无关书中详细描述了24个接口及其实现，便于读者深入了解此方法这些接口涉及很多计算机领域的...
基于CPLD的USB总线的隔离接口实现
10-22
在工业环境自动化程度较高的现场，医疗设备对人体信息的提取和诊断，大量信息数据的获取与存储往往应用快速的 USB接口来实现，而目前的 USB接口对工业干扰非常敏感，在医疗上对人身安全存在隐患，USB的隔离应用是...
信息系统（软件）数据接口快速开发与管理平台-技术手册
02-12
（1）内部系统集成：规范系统间API数据接口，快速完成内部系统的解耦及前后端分离，实现可观可控的相互访问； （2）企业级云服务能力：利用接口标准化、可复用特点，沉淀公共技术组件资产，搭建企业级云数据服务，...
区块链原理与技术大作业-供应链管理.zip
02-08
用 FISCO-BCOS 平台提供的 CRUD 接口实现企业信息和收据的存储。CRUD 接口通过在 Solidity 合约中支持分布式存储预编译合约，可以实现将 Solidity 合约中数据存储在 FISCOBCOS 平台 A存储设计 采用 FISCO-BCOS 平台...
K8s 很难么？带你从头到尾捋一遍，不信你学不会
民工哥的博客
02-23 8717
点击关注公众号，回复“1024”获取2TB学习资源！为什么要学习 Kubernetes?虽然 Docker 已经很强大了，但是在实际使用上还是有诸多不便，比如集群管理、资源调度、文件管理等...
10天智能锁项目实战第1天（了解单片机STM32F401RET6和C语言基础）
北豼不太皮的博客
02-21 3108
10天智能锁项目实战第1天（了解单片机STM32F401RET6和C语言基础）一、学习目标二、了解单片机STM32F401RET6三、C语言基础 一、学习目标 二、了解单片机STM32F401RET6 4、STM32F401RE特征 三、C语言基础 1.数据类型 常用2的次方： 2^7 = 128 2^8 = 256 2^15 = 32768 2^16= 65536 51单片机常见的数据类型： char: 占内存1字节 取值范围：-128~127 -2^7 ~ 2
Android开发（1） | Fragment 的应用——新闻应用
Jormungand_V的博客
02-21 3562
文章目录 news_item.xml： <TextView xmlns:android="http://schemas.android.com/apk/res/android" android:id="@+id/news_title" android:layout_width="match_parent" android:layout_height="wrap_content" android:lines="1" android:ellipsize="
系统学习 TypeScript（四）——变量声明的初步学习
编程三昧
02-25 1463
认识了 TypeScript 中的基础类型，接下来当然是变量声明的相关学习了，我在这里记录一下我学习过程中的一些总结。
清除浮动的五种方法
weixin_52212950的博客
02-22 2163
为什么要清除浮动？因为往往浮动后的子元素因为脱离了标准流，不能自动撑起父元素的高度，所以会对后续布局产生影响，对此清除浮动不如理解为清除浮动产生的影响更为合理。 例如：我们设置了两个盒子如图所示，粉色为父盒子，只有宽度没有高度，蓝色盒子有宽有高，粉色盒子的高由蓝盒子的高度撑开。 但是给蓝色的子盒子设置了左浮动后，脱离了标准流，无法再撑开粉盒子，可以看到粉盒子高度变成了0； 清除浮动有五种方法： 直接设置父元素的高度 额外标签法 单伪元素法 双伪元素法 ove.
HTML实现学习网站首页
做技术，坚持才是最重要的，一时的热情只是暂时的进步
02-20 3890
项目访问 reset.css /* http://meyerweb.com/eric/tools/css/reset/ v2.0 | 20110126 License: none (public domain) */ html, body, div, span, applet, object, iframe, h1, h2, h3, h4, h5, h6, p, blockquote, pre, a, abbr, acronym, address, big, cite, code, del
C语言经典小游戏之----推箱子
嵌入式技术开发
02-25 4562
在进行推箱子的实验中，可以使用对应的API函数来改变对应箱子的颜色，也需要根据，人在移动的过程中，可以通过方向键，并改变对应的颜色，从而实现控制人物的目的。 代码实现如下： #include<stdio.h> #include<stdlib.h> #include<string.h> #include<windows.h> #include<conio.h> int x = 0, y = 0; //存储当前使用的...
关于Dubbo的mock=true降级无法调用降级类ServiceMock的解决方案
weixin_45754452的博客
02-25 1269
问题 消费者使用mock=“true”，想调用TestServiceMock进行服务降级无法调用 原因 我的项目结构如下，首先要知道服务降级代码应该是谁执行的，服务降级是服务消费者也就是controller包处对应的服务执行的，因为我只是测试dubbo怎么使用，所以并没有分多模块，但完全可以把一个包理解为一个模块，再看下面配置文件 为什么可以把一个包当成一个模块呢，因为我把配置文件的scan改成controller包然后启动一个服务器，即消费者，如果把scan改成service则可以启动服务提供者服务器
Vue---Vue基础
前端与计算机相关知识的分享，博主的qq523235674
02-25 1337
一.Vue概述 二.Vue的基本使用 2.1Vue.js之hello world 基本实例 <!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <meta http-equiv="X-UA-Compatible" content="IE=edge"> <title>Document</title> </.
如此优秀的JS轮播图，写完老师都沉默了
陈新科的博客
02-17 5831
雷迪森安的乡亲们，欢迎来到老实人的前端课堂，今天我们来写个骚气磅礴的轮播图吧，内容太干，建议收藏起来慢慢看，最后我还会教大家如何免费部署上线哦~ 正片 小轮播图滑动滚播，好不好看你说了算。 结构就两行 <div id="main"> <h1>something</h1> <div class="content"> <p>You can press <kbd>▲</kbd> <kbd&
TCP/IP网络编程---Linux系统下的TCP套接字编程
xxyneymar的博客
02-21 4176
目录 第一章 理解网络编程和套接字 1.1 网络编程和套接字概要 1.2 基于Linux的文件操作 1.2.1 底层文件访问和文件描述符 1.2.2 打开文件 1.2.3 关闭文件 1.2.4 将数据写入文件 1.2.5 读取文件中的数据 第二章 套接字类型与协议设置 2.1 套接字协议及其数据传输特性 2.1.1 关于协议 2.1.2 创建套接字 第三章 地址族与数据序列 3.1 分配给套接字的IP地址与端口号 3.1.1 网络地址 3.1.2 用于区分套接字的端口号 3
CSS -- 移动端适配技术学习
秋天，黄叶坠地，凉风有信。
02-20 1446
CSS中常用的计量单位，em，rem，px的区别，vwvh，vmin，vmax 的使用，移动端适配中使用到的技术，媒体查询CSS和JS的实现方法，Flex弹性布局，flexibleJS的介绍，rem + viewPort 缩放的技术
Docker整理篇（网络与数据卷）
weixin_43118617的博客
02-23 1283
docker网络与数据卷操作和基础命令
搭建React Native开发环境
dear_Wally的博客
02-24 3461
1、参考搭建开发环境 · React Native 中文网 2、安装依赖 必须安装的依赖有：Node、JDK 和 Android Studio 2.1、安装Node 安装包下载地址下载 | Node.js注意 Node 的版本应大于等于 12 下载node对应版本的安装文件，直接安装即可，安装完成之后。打开命令行，输入node --version 能够显示版本时，说明安装成功。 如果提示找不到该命令，可能是环境变量没有添加。把Node安装目录添加到环境...
C++ 接口和实现的分离
最新发布
06-08
C++ 接口和实现的分离是一种常见的编程技术，常用于实现类库或模块化设计。它的主要思想是将接口和实现分开，使得接口可以独立于实现进行设计和修改，从而提高代码的可读性、可维护性和可扩展性。 具体来说，通过...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值