刚入职行业不到一年的菜鸟的心得体会，真实感受，不喜勿喷。
为什么想到封装呢？还不是因为踩过坑，最近越来越感觉，直接用一些开源库很不方便，而且用起来总是忘塞。
1.在工程开发过程中，我们不可避免的会用到其他人封住好的库。当然，作为程序员的基础素养之一，我们也得会封住一些好用的库,不仅仅是为了更好的迭代工程，更为了更好的使用一些开源库。
2.说到开源库，最近蛮烦恼塞。因为刚入职从事程序员行业，这段时间一直在接触开源库还有一些开源框架。(我感觉看多了，开始习惯看源码了，之前都直接看博客。额，看不可的效果不可描述，总感觉很多时候看不明白，所以塞，不如看源码里的例子，遇到具体的点没明白的再去百度或者请教前辈。)
3.最最重要的一点就是很多开源库为了支持更多的功能，在使用过程中会比较繁琐，并且很多时候我们只想使用一部分功能，通常我们会选择提前做一层封装。(自己封装的塞，肯定用得爽，虽然封住过程有点痛苦塞，长痛不如短痛塞)
封住一定要很规范
个人觉得如果业务很简单，其实好用就行了，封装最初的目的也是为了好用。如果比较复杂的设计，比如好几个库杂糅在一起，而且之后会有功能扩展的需求，那么这个时候就得先考虑下，如何设计会比较好了。
对于第一种情况，就不过多的描述了，很简单的。通常可以用C方式，也可以采用C++类的方式(看情况决定，为了自己方便)。
详细说下第二种情况
接口设计注意事项:
1.避免过度封装，过度封装会导致调bug很难理清楚逻辑，而且很不好维护
2.接口名称，通常使用驼峰规则就行，做到见名思意
3.参数尽量提炼，不要搞一堆没必要的参数，用起来很麻烦。无非必要，就不要
4.注释清晰，明了。不写注释是王八
接口设计的最佳效果
1.隔离用户操作与底层逻辑
(说人话，无非就是我给你这个接口就可以让你实现这个功能，不需要你去了解里面怎么玩的，想那么多干嘛，那是我封住接口的人需要考虑的塞)
接口封装的两种方法
1.PIMP(Pointer to Implementation)在接口类成员中包含一个指向实现类的指针，这样就可以最大限度的做到接口和实现进行分离的原则。
说白了，就是A实现了某种方法(类A不对外使用)，而在A-inerface中声明一个A *pA，并且这套接口的方法内部就是调用了A的方法，有时候可能会做一些扩展，比如一个基础事件的集合，也就是有很多这样的事件
示例:
class A_interface
{
public:
A_interface& operator+(const A_interface& com );
A_interface& operator-(const A_interface& com );
A_interface& operator*(const A_interface& com );
A_interface& operator/(const A_interface& com );
private:
A *p_A;
}
class A{
public:
A& operator+(const A& com );
A& operator-(const A& com );
A& operator*(const A& com );
A& operator/(const A& com );
private:
double real_;
double imaginary_;
};
===> 不可多说，这个方法反正我基本不用塞，自己体会塞
2.Object-Interface方法，采用c++继承多态，实现类继承接口类，功能接口定义成虚函数。
这个纯虚函数给你朋友用，其他部分搞成.so或者.dll (.lib\.a)
如果不满足塞，再来个管理类。说白了就一个工厂类塞，如果你觉得好玩，可以搞个反射塞。
//纯虚函数，接口成员函数
class Complex{
public:
static std::unique_ptr<Complex> Create(); // 用来做工厂方法
virtual Complex& operator+(const Complex& com ) = 0;
virtual Complex& operator-(const Complex& com ) = 0;
virtual Complex& operator*(const Complex& com ) = 0;
virtual Complex& operator/(const Complex& com ) = 0;
};
//Complex类功能的内部实现类
class ComplexImpl : public Complex{
public:
virtual Complex& operator+(const Complex& com ) override;
virtual Complex& operator-(const Complex& com ) override;
virtual Complex& operator*(const Complex& com ) override;
virtual Complex& operator/(const Complex& com ) override;
private:
double real_;
double imaginary_;
}
>>>将要暴露出去的接口都设置为纯虚函数,然后通过工厂模式Create获取不同基类的指针
std::unique_ptr<Complex> Complex::Create()
{
return std::make_unique<ComplexImpl>();
}
>>>如此,我们完成将Complex类的实现细节全部封装隐藏起来了
>>>如果对于用户来说,是有必要获取实体的数据部分时,只需要添加响应的set和get方法
Object_interface抽象基类示例代码:
1.首先，声明一个接口 ---> 一般设置为纯虚函数
// circle.h
// 圆的接口类
class Circle {
public:
virtual ~Circle() {};
virtual double area() = 0; // 接口方法：面积
};
2.通过继承的方式实现这个接口
// circle_impl.h
#include "circle.h"
// 圆的具体实现类
class CircleImpl : public Circle {
private:
double radius;
public:
CircleImpl(double radius);
double area() override;
};
// circle_impl.cpp
#include <cmath>
#include "circle_impl.h"
inline double pi() {
return std::atan(1) * 4;
};
CircleImpl::CircleImpl(double _radius) : radius(_radius) {
};
double CircleImpl::area() {
return pi() * radius * radius;
};
3.最后，通过管理类创建接口派生类的实例，或者销毁接口派生类的实例
// circle_manager.h
#include "circle.h"
// 圆的创建工厂类
class CircleManager {
public:
static Circle* create(double radius); // 创建circle实例
static void destroy(Circle* circlePtr); // 销毁circle实例
};
// circle_manager.cpp
#include "circle_manager.h"
#include "circle_impl.h"
Circle* CircleManager::create(double radius) {
Circle* circlePtr = new CircleImpl(radius);
return circlePtr;
};
void CircleManager::destroy(Circle* circlePtr) {
delete circlePtr;
};
// 使用示例
// main.cpp
#include <iostream>
#include "circle_manager.h"
#include "circle.h"
int main()
{
Circle* circlePtr = CircleManager::create(3);
cout << circlePtr->area() <<endl;
CircleManager::destroy(circlePtr);
system("pause");
return 0;
}
