还在为频繁变动的需求而苦恼吗？学会这个原则，让你从容应对

工作过程中，开发人员根据需求文档完成程序的开发任务，但是，程序投入测试使用的时候，经常因为各种各样的原因，比如，用户体验不好、操作不方便等，需要变动需求，甚至添加新功能，这可能就会导致开发人员原来设计的方案不能满足新变动的需求。

那么，如何应对频繁变动的需求呢，那么就需要本文将要介绍的原则登场了，即开闭原则。

介绍开闭原则之前，首先会结合例子来讲解C++提供的std::sort排序函数的用法，主要是为辅助后续要说明的开闭原则的示例，然后介绍开闭原则的两个特性，接着再叙述开闭原则常用应用场景，最后会详细介绍一个应用开闭原则的经典例子，该例子可以细细推敲，相信对加深开闭原则的理解。

一、排序函数的用法

1、std::sort的一般用法

首先创建测试存储整数类型向量，然后写入乱序的整数数据。

std::vector<int> JDebugSort::Build()
{
    std::vector<int> vec_data;
    vec_data.push_back(2);
    vec_data.push_back(1);
    vec_data.push_back(3);
    vec_data.push_back(4);
    return vec_data;
}

调用std::sort对上面创建的向量变量进行排序。

std::vector<int> vec_data_01 = Build();
std::sort(vec_data_01.begin(), vec_data_01.end());
Print(vec_data_01);

运行程序，依次输出向量存储的数据如下图所示，可以看出std::sort默认按照升序进行排列。

如果想要降序排列，怎么办呢，首先需要自定义比较函数，具体实现如下所示

bool compare(int a, int b)
{
    return (a > b);
}

同样调用std::sort对上面的向量进行排序，但是std::sort的第三个参数为上面定义实现的比较函数compare。

std::vector<int> vec_data_02 = Build();
std::sort(vec_data_02.begin(), vec_data_02.end(), compare);
Print(vec_data_02);

再次运行程序，其输出的信息如下，可以看出std::sort已经按照降序进行排列。注意如果将compare内部实现使用的大于号(>)修改为小于号(<), 那么就会变成升序排序。

除了自定义比较函数来决定std::sort的排序顺序之外，如果排序的的类型是普通数据类型， 比如整数类型，那么可以直接使用标准库使用提供的函数std::less或者std::greater来决定是升序还是降序排列。

从输出的打印信息看，std::less是升序排列，std::greater是降序排列。

2、类内部重载

上面讲述的是std::sort的一般用法，接下来将讲解类内部重载operator<来控制升降序。假设需要对部门的ID进行排序，定义实现如下所示的部门类，该类主要存储部门id和部门的名称，并且重载了operator<运算符。

class Department
{
public:
    explicit Department(int id, const std::string &name)
        : m_id(id)
        , m_name(name)
    {}
    Department(){}
    ~Department(){}

    bool operator<(const Department& deparment) const
    {
        //return m_id < deparment.m_id; // 升序
        return m_id > deparment.m_id;  // 降序
    }

    int GetId() const { return m_id;}
    std::string GetName() const {return m_name;}

private:
    int m_id;
    std::string m_name;
};

为了验证效果，首先定义存储Department类型的向量，同样存入部门id号为乱序的部门信息

std::vector<Department> JDebugSort::BuildDeparment()
{
    std::vector<Department> vec_data;
    vec_data.push_back(Department(3,"li"));
    vec_data.push_back(Department(2,"zheng"));
    vec_data.push_back(Department(5,"xxx"));

    return vec_data;
}

调用std::sort对上面的Department类型的向量进行排序

std::vector<Department> vec_data_05 = BuildDeparment();
std::sort(vec_data_05.begin(), vec_data_05.end());
PrintDepartment(vec_data_05);

运行打印结果如下所示，输出的部门信息按照部门id进行降序排列。

3、自定义比较类

除了自定义函数来确定升降序之外，还可以自定义类来确定升降序，而自定义类需要重载operator()运算符。这里还是采用上面的部门类来进行说明。operator()运算符传入两个表示部门信息的参数，函数内部还是通过部门id号来确定升降序。

class JLess
{
public:
    bool operator()(const Department& d1, const Department& d2)
    {
        return d1.GetId() < d2.GetId(); //升序排列
    }
};

调用方法如下所示，从实际的测试结果看，std::sort会优先调用operator()中定义排序顺序，不管自定义类中是否重载了operator<运算符。

std::vector<Department> vec_data_06 = BuildDeparment();
std::sort(vec_data_06.begin(), vec_data_06.end(), JLess());
PrintDepartment(vec_data_06);

还可以定义如下所示的自定义比较类，还是内部直接通过部门对象进行比较，实际上最终是调用部门类重载的operator<运算符来确定排序顺序的。

class JLess2
{
public:
    bool operator()(const Department& d1, const Department& d2)
    {
        return d1 < d2;
    }
};

二、开闭原则的特性

开闭原则意思就是可以扩展，但是又不能修改。体现在代码上就是添加新的代码，但是不需要改变已经运行的代码。概况来说，它的两个基本特性是：1)、对于扩展是开放的，2)、对于更改是封闭的。

那么如何在不改变模块原有的代码的情况下，添加新的功能点呢？

三、开闭原则的应用

关键是抽象，即有一个抽象的基类，而可能变动的行为则由派生类来实现。

客户端与服务端的通信。client类使用的是抽象类client interface,  而实际功能由server去实现，当使用的时候，创建具体的server对象，然后将其传递给client对象，如果希望client类使用不同的server类，那么只要新的server类是从client interface类派生出来，那么新的server对象就可以传递给client对象，而且client类不需要进行任何修改。

上面的例子是遵循开闭原则，而另一个比较常见并且遵循开闭原则的是模版方法，简单来说就是，基类实现基本通用的逻辑，并且该逻辑过程包含虚函数或纯虚函数，而虚函数或者纯虚函数的具体功能则由派生子类来实现。例如，下图的模版方法，TemplateMethod是实现通用的逻辑，primitive1和primitive2则是虚函数或纯虚函数，需要子类SubClass1和SubClass2来实现。

四、经典示例

现在需要制作一个绘制正方形和圆形的应用程序，并且按照指定顺序进行绘制。那么如何实现才能遵循开闭原则呢。

根据前面介绍的std::sort用法，如果需要按照指定顺序来绘制图形，那么可以利用std::sort函数，并且自定义比较类模版，重载operator<运算符。

自定义比较类模版如下，该模版类重载operator()运算符。

template <typename T>
class Less
{
public:
    bool operator()(const T t1, const T t2)
    {
        return (*t1) < (*t2);
    }
};

定义形状基类，Draw是纯虚函数，需要子类实现，重载运算符operator<主要是为了控制绘制形状的顺序。静态成员变量m_OrderTable存放绘制形状顺序的名称。

class Shape
{
public:
    Shape();
    virtual ~Shape();
    virtual void Draw() = 0;

    bool Precedes(const Shape&) const;
    bool operator<(const Shape&) const;
private:
    static const char* m_OrderTable[];
};

实现形状基类，operator<运算符内部调用Precedes，Precedes实现升序绘制形状。m_OrderTable的赋值需要实现具体子类之后才能给出。

Shape::Shape(){}

Shape::~Shape(){}


bool Shape::Precedes(const Shape& s) const
{
    const char * this_type = typeid(*this).name();
    const char * arg_type = typeid(s).name();
    int i_thisord = -1;
    int i_argord = -1;

    int i_size = sizeof(m_OrderTable)/sizeof(m_OrderTable[0]);
    for(int i = 0; i < i_size; i++)
    {
        const char* p_table_entry = m_OrderTable[i];
        if (p_table_entry != nullptr)
        {
            if (strcmp(p_table_entry, this_type) == 0)
            {
                i_thisord = i;
            }
            if (strcmp(p_table_entry, arg_type) == 0)
            {
                i_argord = i;
            }
            if (i_thisord >= 0 && i_argord >= 0)
            {
                break;
            }
        }
    }
    return i_thisord < i_argord;
}

bool Shape::operator<(const Shape& s) const
{
    return Precedes(s);
}

定义实现正方形

/// 定义
class Square : public Shape
{
public :
    Square();
    virtual ~Square() override;
    virtual void Draw() override;
};

/// 实现
Square::Square(){}

Square::~Square(){}

void Square::Draw()
{
    LOG(INFO) << "draw Square";
}

定义实现圆形

/// 定义
class Circle : public Shape
{
public :
    Circle();
    virtual ~Circle() override;
    virtual void Draw() override;
};

/// 实现
Circle::Circle(){}

Circle::~Circle(){}

void Circle::Draw()
{
    LOG(INFO) << "draw Circle";
}

实现完成正方形和圆形之后，就可以给m_OrderTable赋值，其先后顺序就确定了对应形状的绘制顺序。

const char* Shape::m_OrderTable [] =
{
    typeid(Circle).name(),
    typeid (Square).name()
};

实现绘制所有形状的逻辑，函数DrawAllShape接受存储类型为Shape*的向量，内部实现如下所示，调用std::sort对向量进行排序，然后再循环调用向量中的每一个对象的Draw进行绘制。

void JDebugOCP::DrawAllShape(std::vector<Shape*> &allShape)
{
    std::vector<Shape*> order_all_shape = allShape;
    std::sort(order_all_shape.begin()
             ,order_all_shape.end()
             ,Less<Shape*>());

     std::vector<Shape*>::const_iterator iter_const;
     for(iter_const = order_all_shape.begin(); iter_const != order_all_shape.end(); iter_const++)
     {
         (*iter_const)->Draw();
     }
}

最后使用的方式如下，创建存储各个形状的的向量，并且创建的形状不需要按照顺序。再将其向量传入上面定义实现的函数DrawAllShape。

std::vector<Shape*> vec_shape;
vec_shape.push_back(new Square());
vec_shape.push_back(new Circle());

DrawAllShape(vec_shape);

运行的结果如下，程序按照m_OrderTable赋值的顺序绘制图形。并且后续添加新的形状，并且指定输出顺序，那么也只要调整驱动表m_OrderTable即可，其他代码都不需要改变，这也满足了开闭原则。

[virtual void Circle::Draw():66] draw Circle
[virtual void Square::Draw():57] draw Square

五、总结

std::sort默认按照升序进行排列，如果重载使用大于号，那么按照降序排列，如果使用小于号，那么按照升序排列。开发过程中，遵循开闭原则能够有效解决预防频繁变动的需求，开闭原则的特性就是：对于扩展是开放的，对于更改是封闭的。开闭原则的关键就是抽象，抽象体现在C++就是虚函数或者纯虚函数。

没想到bind的功能这么强大，赶紧来看看

std::bind是C++11中一个函数模版，就像函数适配器，接受一个可调用对象（callable object），生成一个新的可调用对象。通过它，我们可以实现类似传统的函数指针，函数回调等功能，并且能够降低代码的复杂度。

本文首先详细说明std::bind的基本用法以及解释使用过程中疑问点，然后再介绍如何利用传统函数指针搭建基础结构，再说明如何用std::bind来代替函数指针，最后介绍如何用std::bind来实现函数回调的功能。

一、std::bind的基本用法

首先看下std::function, 它就是std::bind返回的新的可调用对象。如下图，定义实现了普通加法函数Add,  然后将该函数指针赋值给std::function类型的变量，这里可以注意到，使用了Add和&Add进行赋值。两者是等效的，这是因为使用Add的时候，会隐式转换成函数指针。

static int Add(int a, int b)
{
    return (a+b);
}

std::function<int (int, int)> fun = Add;
std::function<int (int, int)> fun2 = &Add;
LOG(INFO) << "fun(1, 1):"<< fun(1, 1);
LOG(INFO) << "fun2(1, 2):"<< fun2(1, 2);

运行程序之后的输出信息，可以看出std::function类型的变量的使用与普通函数的使用是一样的。

[2020-01-05 17:43:05,243189] [void JDebugBind::StartDebug():184] fun(1, 1):2
[2020-01-05 17:43:05,243206] [void JDebugBind::StartDebug():185] fun2(1, 2):3

我们不直接采用普通函数对std::function进行赋值，而是采用stb::bind，首先看下简单的实例，其中std::placeholders::_1和std::placeholders::_2是占位符，代表函数的入参。如果调用的时候，需要传递具体实参，那么就需要使用placeholders来占位。这里需要注意std::placeholders::_1并不是代表函数的第一个入参数，至于为什么，请继续往下阅读，下面将会通过实例进行阐述。

std::function<int (int, int)> fun3 = std::bind(Add, std::placeholders::_1, std::placeholders::_2);
std::function<int (int, int)> fun4 = std::bind(&Add, std::placeholders::_1, std::placeholders::_2);

LOG(INFO) << "fun3(1, 3):"<< fun3(1, 3);
LOG(INFO) << "fun4(1, 4):"<< fun4(1, 4);

如果函数的第二个入参是一个固定值，那么第一个入参就需要使用占位符std::placeholders::_1，如下所示，函数第二个参数固定位数值5，那么使用std::function类型变量的时候，也只需要传递一个参数，该参数代表Add函数的第一个参数。

std::function<int (int)> fun5 = std::bind(Add, std::placeholders::_1, 5);
LOG(INFO) << "fun5(1):"<< fun5(1);

如果Add函数的第一个入参是一个固定值，那么第二个入参就需要使用占位符std::placeholders::_1（注意不是std::placeholders::_2），如下所示，函数第一个参数固定位数值6，那么使用std::function类型变量的时候，也只需要传递一个参数，该参数代表Add函数的第二个参数。

std::function<int (int)> fun6 = std::bind(Add, 6, std::placeholders::_1);
LOG(INFO) << "fun6(1):"<< fun6(1);

当然，如果函数Add的两个参数都是固定值，那么使用std::function类型变量的时候，就不需要参数了。

std::function<int()> fun7 = std::bind(Add, 3, 7);
LOG(INFO) << "fun7():"<< fun7();

这里有个小技巧，如果不想要书写std::function那么繁琐的信息表示，那么可以采用auto代替，但是注意不要滥用auto.

auto fun8 = std::bind(Add, std::placeholders::_1, std::placeholders::_2);
LOG(INFO) << "fun8(1, 8):"<< fun8(1,8);

二、std::bind的扩展

上面说明的是stb::bind使用普通函数的方法，那么如果是类的成员函数呢？应该如何使用呢？首先s td::bind的第一个参数是类成员函数指针，第二个参数为类对象的指针，其他的用法与使用普通函数的用法是一样的。

class JBindClass
{
public:
    int Multi(int a, int b)
    {
        return (a * b);
    }
};


JBindClass bind_class;
auto fun9 = std::bind(&JBindClass::Multi, &bind_class, std::placeholders::_1, std::placeholders::_2);
LOG(INFO) << "fun9(1, 9):"<< fun9(1,9);

std::bind参数值是默认按照值传递的，首先实现函数Print, 该函数的入参是一个引用，函数内部将参数自增1，然后输出打印信息。接着再通过输出std::bind使用前后日志信息来确认是否是按照值传递。

static void Print(int &value)
{
    value++;
    LOG(INFO) << value;
}

int i_value = 10;
LOG(INFO) << "before i_value:" << i_value;
std::function<void()> fun10 = std::bind(Print,i_value);
fun10();
LOG(INFO) << "after i_value:" << i_value;

从输入的打印信息看，std::bind使用前后的信息没有发生变化，说明std::bind是默认按照值传递的。

[void JDebugBind::StartDebug():207] before i_value:10
[void Print(int &):24] 11
[void JDebugBind::StartDebug():210] after i_value:10

如果想要按照引用来传递变量，应该如何操作呢，那么就是std::ref登场的时候，std::ref是用于包装引用传递的值。

LOG(INFO) << "before i_value:" << i_value;
std::function<void()> fun11 = std::bind(Print,std::ref(i_value));
fun11();
LOG(INFO) << "after i_value:" << i_value;

从输出打印信息看，采用std::ref传递变量之后，std::bind使用前后的信息发生变化了。

[void JDebugBind::StartDebug():213] before i_value:10
[void Print(int &):24] 11
[void JDebugBind::StartDebug():216] after i_value:11

另外补充一点，std::cref用于包装const引用传递的值。

static void Printc(const int &value)
{
    LOG(INFO) << value;
}

int i_value_c = 12;
std::function<void()> fun12 = std::bind(Printc,std::cref(i_value_c));
fun12();

三、传统函数指针

函数指针变量用于存储函数指针，以便后续的调用。有时候可以利用它实现多个消息对象的处理，并且一定程度满足开闭原则。

首先实现抽象基类JAbstractBaseTest，接着再实现继承JAbstractBaseTest的两个子类JObjA和JObjB

/// 基类
class JAbstractBaseTest
{
public:
    JAbstractBaseTest(){}
    virtual ~JAbstractBaseTest(){}

    virtual void run() = 0;

};

/// 子类JObjA
class JObjA: public JAbstractBaseTest
{
public:
    void run(){LOG(INFO) << "JObjA Run";}

    static JAbstractBaseTest* create_instance()
    {
        return new JObjA();
    }

};

/// 子类JObjB
class JObjB: public JAbstractBaseTest
{
public:
    void run(){LOG(INFO) << "JObjB Run";}

    static JAbstractBaseTest* create_instance()
    {
        return new JObjB();
    }
};

完成上面的测试类，接着实现基础的框架，定义函数指针CreateObj，该函数指针用于动态创建对象，然后再分别实现初始化创建对象的函数指针映射表以及通过id从映射表中获取函数对象的两个函数。

class JDebugMain
{
public:
    JDebugMain()
    {
        InitObj();
    }

    // 定义函数指针
    typedef JAbstractBaseTest* (*CreateObj)();
    
    enum E_OBJ_ID
    {
        E_OBJ_A,
        E_OBJ_B,
    };

    // 初始化创建对象的函数指针映射表
    void InitObj()
    {
         m_mapRegisterClass[E_OBJ_A] = &JObjA::create_instance;
         m_mapRegisterClass[E_OBJ_B] = &JObjB::create_instance;
    }

    // 通过id从映射表中获取函数对象
    JAbstractBaseTest* GetObj(E_OBJ_ID eObjId)
    {
        std::map<E_OBJ_ID,CreateObj>::iterator iter;
        iter = m_mapRegisterClass.find(eObjId);
        if (iter != m_mapRegisterClass.end())
        {
            return m_mapRegisterClass[eObjId]();
        }
        return nullptr;
    }

private:
    std::map<E_OBJ_ID, CreateObj> m_mapRegisterClass;
};

使用调用方式如下，通过id获取对象指针，然后执行对象的run函数。通过这样的方式，可以做到主体循环不变，如果需要添加新的对象处理，那么只要实现新的类，然后添加到映射表中即可。

JDebugMain debug_main;
JAbstractBaseTest* p_obj = debug_main.GetObj(JDebugMain::E_OBJ_A);
if (p_obj)
{
    p_obj->run();
    delete p_obj;
    p_obj = nullptr;
}

四、std::bind代替函数指针

std::bind和std::function的结合，可以实现函数指针的功能。通过using Funtor = std::function<void (void)>来实现类似函数指针的声明。其中Funtor表示std::function<void (void)>的别名。然后在初始化表函数InitTab中，通过使用std::bind将类的函数成员一一映射到map中。

/// 类定义
class JDebugBind
{
public:
    using Funtor = std::function<void (void)>;
    enum
    {
        E_TEST_FUN_01,
        E_TEST_FUN_02,
    };

    JDebugBind();
    /// 根据测试id来执行对应的测试函数
    void RunTest(int iType);

protected:
    void Test01();
    void Test02();

private:
    void InitTab();

private:
    std::map<int, Funtor> m_mapTab;
};

/// 类实现
JDebugBind::JDebugBind()
{
    InitTab();
}

void JDebugBind::InitTab()
{
    m_mapTab.clear();
    m_mapTab[E_TEST_FUN_01] = std::bind(&JDebugBind::Test01, this);
    m_mapTab[E_TEST_FUN_02] = std::bind(&JDebugBind::Test02, this);
}

void JDebugBind::RunTest(int iType)
{
    std::map<int, Funtor>::iterator iter;
    for(iter = m_mapTab.begin(); iter != m_mapTab.end(); iter++)
    {
        if (iType == iter->first)
        {
            iter->second();
        }
    }
}

void JDebugBind::Test01()
{
    LOG(INFO) << "Test01";
}

void JDebugBind::Test02()
{
    LOG(INFO) << "Test02";
}

调用JDebugBind的方式如下，只需要传递函数的id给函数RunTest，即可执行到对应的函数。同样的，后续如果想要添加新的功能，那么只要实现新的函数，并且将其添加到map中即可。

JDebugBind debug_bind;
debug_bind.RunTest(JDebugBind::E_TEST_FUN_01);

五、std::bind实现函数回调

函数回调在编程实现是一个特别重要的特性，它经常会在一些架构中使用到。而std::bind是可以实现函数回调的特性的。下图实现的类JDebugCallback中，构造函数接受一个类型为std::function的参数之后，将其赋值给类的成员函数m_callback，后续调用函数Start的时候，Start函数内部再调用m_callback，从而实现函数回调。这里只是一个简单的例子说明，可能还不能充分看到函数回调的强大。希望这里作为一个引入，后续在实际工作中，再慢慢的体会。

class JDebugCallback
{
public:
    JDebugCallback(std::function<void()> callback)
        : m_callback(callback)
    { }

    void Start()
    {
        m_callback();
    }

private:
    std::function<void()> m_callback;
};

最后看下怎么使用JDebugCallback类，实现类两个函数CallBack01和CallBack02，然后通过std::bind传递给JDebugCallback，接着JDebugCallback对象调用Start来执行传递进来的函数。

static void CallBack01()
{
    LOG(INFO) << "CallBack01";
}

static void CallBack02()
{
    LOG(INFO) << "CallBack02";
}

JDebugCallback debug_cb_01(std::bind(CallBack01));
debug_cb_01.Start();

JDebugCallback debug_cb_02(std::bind(CallBack02));
debug_cb_02.Start();

五、总结

至此，C++11提供的std::bind的用法和扩展已经介绍完毕，虽然工作中有各种各样的需求场景，但是只要掌握了知识的基本原理，就能够以不变应万变。本文介绍了std::bind的各种基本应用场景，并结合了例子进行说明，相信应该已经说明白了。

学会了这么神奇的模版模式，让你C++模版编程之路事半功倍

最近由于开发工作的需要，项目引入了boost::statechart的状态机，它大量了引用了CRTP,  它的全称是Curiously Recurring Template Pattern，奇异递归模版模式，C++模版编程中很常用的一种用法。那么它神奇的地方到底在哪里呢，接下来就一一来揭开它神秘的面纱。

一、奇异递归模版模式的简介

奇异递归模版模式的基本思想要点是：派生类要作为基类的模版参数。它是C++模版编程中常用的手法。理解它之后，学习模版编程过程中也会事半功倍，而不会觉得云里雾里的。

二、奇异递归模版模式的基本格式

奇异递归模版模式的基本格式如下：JCrtpDerived继承JCrtpBase，并且JCrtpDerived作为基类JCrtpBase的模版参数。通过这样的方式，基类就可以使用子类的方法。并且不需要使用到虚函数，一定程度上减少程序的开销。

template <typename T>
class JCrtpBase
{
public:
};

class JCrtpDerived : public JCrtpBase<JCrtpDerived>
{
public:

};

三、奇异递归模版模式的入门

从上面的给出的奇异递归模版模式的基本格式中可以看出，子类是作为基类的模版参数，但是如果传递给基类的模版参数不是基类的子类，那就会造成混乱错误。如下图所示，JCrtpDerived2子类继承了基类JCrtpBase，但是传递给基类的模版参数不是JCrtpDerived2。

template <typename T>
class JCrtpBase
{
public:
    void Do()
    {
        T* derived = static_cast<T *>(this);
    }

};

class JCrtpDerived1 : public JCrtpBase<JCrtpDerived1>
{
public:

};

class JCrtpDerived2 : public JCrtpBase<JCrtpDerived1>
{
public:

};

那么如何解决上面的问题呢，可以将基类的默认构造函数设置为私有，并且模版参数T设置为基类的友元。通过这样的方式，基类的构造函数只能由模版参数T调用。当创建JCrtpDerived2子类对象的时候，会调用基类的构造函数，而这时候发现JCrtpDerived2不是基类的友元，那么就无法调用基类构造函数而出错。

template <typename T>
class JCrtpBase
{
public:
    void Do()
    {
        T* derived = static_cast<T *>(this);
    }

private:
   JCrtpBase();
   friend T;
};

调用运行JCrtpDerived2，就会出现错误

JCrtpDerived1 crtp_derived1;
crtp_derived1.Do();

JCrtpDerived2 crtp_derived2;
crtp_derived2.Do();

四、奇异递归模版模式的应用场景

1、静态多态

奇异递归模版模式可以实现静态多态的效果，顾名思义，就是有多态的特性，但是不需要使用虚函数，是编译的时候确定，因此，能够减少运行时的开销。接下来就来看看两个示例。

基类JCrtpBase实现函数Do，该函数内部对象通过static_cast转换为模版参数对象，模版参数对象再调用对应的实现函数，而模版参数对象由子类来实现。

template <typename T>
class JCrtpBase
{
public:
    void Do()
    {
        T* derived = static_cast<T *>(this);
        derived->DoSomething();
    }

private:
    JCrtpBase(){}
    friend T;
};

class JCrtpDerived1 : public JCrtpBase<JCrtpDerived1>
{
public:
    void DoSomething()
    {
        LOG(INFO) << "I'am is JCrtpDerived1";
    }

};

class JCrtpDerived2: public JCrtpBase<JCrtpDerived2>
{
public:
    void DoSomething()
    {
        LOG(INFO) << "I'am is JCrtpDerived2";
    }
};

调用运行的效果如下所示，从中可以看出，对象调用基类的函数，而基类函数实际上又去调用子类的函数DoSomething。基于这样的思想，我们可以将通用的逻辑放在基类Do中实现，而不同的放到对应的子类函数DoSomething实现。

/// 调用   
JCrtpDerived1 crtp_derived1;
crtp_derived1.Do();

JCrtpDerived2 crtp_derived2;
crtp_derived2.Do();

/// 运行信息
[void JCrtpDerived1::DoSomething():33] I'am is JCrtpDerived1
[void JCrtpDerived2::DoSomething():43] I'am is JCrtpDerived2

这样需要注意的一点是，如果子类再被其他子类继承，那么其他子类就不能按照上面的方式实现。具体可以看下示例：JCrtpSub子类再继承JCrtpDerived1。

class JCrtpSub: public JCrtpDerived1
{
public:
    void DoSomething()
    {
        LOG(INFO) << "I'am is JCrtpSub";
    }
};

调用运行的效果如下所示，JCrtpSub调用基类的函数Do，但是运行没有调用到JCrtpSub类自身的函数DoSomething。

/// 调用
JCrtpDerived1 crtp_derived1;
crtp_derived1.Do();

JCrtpDerived2 crtp_derived2;
crtp_derived2.Do();

JCrtpSub ctrp_sub;
ctrp_sub.Do();

/// 运行信息
[void JCrtpDerived1::DoSomething():33] I'am is JCrtpDerived1
[void JCrtpDerived2::DoSomething():43] I'am is JCrtpDerived2
[void JCrtpDerived1::DoSomething():33] I'am is JCrtpDerived1

上面的例子是子类调用基类函数，由基类再转换调用子类函数，效果类似于策略模式。下面将要说明的例子，更像多态特性，但是不需要虚函数。基类和子类都实现相同的函数DoSomething

template <typename T>
class JCrtpBase
{
public:
    void DoSomething()
    {
        static_cast<T *>(this)->DoSomething();
    }

private:
    JCrtpBase(){}
    friend T;
};

class JCrtpDerived1 : public JCrtpBase<JCrtpDerived1>
{
public:
    void DoSomething()
    {
        LOG(INFO) << "I'am is JCrtpDerived1";
    }

};

class JCrtpDerived2: public JCrtpBase<JCrtpDerived2>
{
public:
    void DoSomething()
    {
        LOG(INFO) << "I'am is JCrtpDerived2";
    }
};

然后实现模版方法，该方法入参为基类JCrtpBase的引用，内部调用基类函数DoSomething。

template<typename T>
void DoAction(JCrtpBase<T> &ctrpbase)
{
    ctrpbase.DoSomething();
}

调用运行效果如下，向模版方法传递不同的子类，调用对应子类的函数。

/// 调用
JCrtpDerived1 crtp_derived1;
JCrtpDerived2 crtp_derived2;
DoAction(crtp_derived1);
DoAction(crtp_derived2);

// 打印信息
[void JCrtpDerived1::DoSomething():38] I'am is JCrtpDerived1
[void JCrtpDerived2::DoSomething():48] I'am is JCrtpDerived2

2、boost::statechart状态机

Boost.Statechart大量使用了CRTP,   派生类必须作为第一个参数传递给所有基类模版，Boost.Statechart状态机后续考虑作为一个专题来研究讨论。

struct Greeting : sc::simple_state< Greeting, Machine >

3、std::enable_shared_from_this特性

C++的特性enable_shared_from_this通常是用于在当你要返回一个被shared_ptr管理的对象。JObj继承enable_shared_from_this，并且JObj作为参数模版传递给enable_shared_from_this，这里就运用到了CRTP。

class JObj : public std::enable_shared_from_this<JObj>
{
public:
    std::shared_ptr<JObj> GetObj() {
        return shared_from_this();
    }
};

正确的调用方式，JObj是被shared_ptr管理，因此，如果要获取对象，那么JObj需要继承enable_shared_from_this。

std::shared_ptr<JObj> share_obj1 = std::make_shared<JObj>();
// JObj对象被shared_ptr管理，因此，如果要获取对象，那么JObj需要继承enable_shared_from_this
std::shared_ptr<JObj> share_obj2 = share_obj1->GetObj();

五、总结

到这里，奇异递归模版模式已经基本讲解完成，我们首先介绍了它的基本格式，使用注意要点，然后重点讲解了它的应用场景，包括静态多态、boost::statechart状态机、std::enable_shared_from_this特性。理解了奇异递归模版模式，不但有利于模版编程的学习，而且对于以后应用的开发也是有好处的。

最全面的android入门知识，请好好收藏

Android一款基于Linux的开放源代码的操作系统，主要用于移动设备，现在许多公司都会基于Android做各种定制开发工作。所以，在开发工作之前，需要全面熟悉了解Android的基础知识，有了基础入门知识之后，才能做好方案设计，并且利于以后更加深入的学习发展。

古人说，工欲善其事，必先利其器，所以，本文首先会介绍环境搭建流程，再简单介绍android的系统架构，接着实现第一个程序Hello World!, 让新手对android在视觉上有个比较清晰的概念。然后再介绍程序的目录功能。紧接着就是本文的重头戏，分别介绍布局管理器、android的重要程序组件、Activity的生命周期、Service的生命周期、BroadcastRecevier的应用，Intent的应用。最后再扩展的知识点，包括分辨率问题、应用程序签名。

一、环境搭建

  • 安装JDK7

  • 下载Eclipse(eclipse-jee-kepler-SR1-win32)，Eclipse不需要安装, 下载解压后即可使用
  • 安装ADT扩充套件， 双击eclipse.exe，点击help -> install new software -> Add -> 在Location处输入网址：http://dl-ssl.google.com/android/eclipse/site.xml

  • 下载android SDK， 解压SDK，设定SDK: window -> preferences -> android -> 在SDK Location选择SDK路径

  • 安装mysql
  • 安装tomcat，修改默认端口号为8010，数据库驱动（mysql-connector-java-5.1.13-bin.jar ，用于tomcat和mysql之间的连接）放到目录..\Apache Software Foundation\Tomcat 8.0\lib下

修改文件tomcat-users.xml

  • 设置环境变量，计算机->右键属性—>环境变量->修改变量，进行如下设置

如果想要测试效果，那么在cmd下输入以下命令 java，javac，java-version

  • 上面搭建的环境，只是在本机上，如果开发的程序涉及到服务器端，并且需要将程序推荐给别人使用，就需要购买空间和域名（当然，现在也有免费的空间，但是受到限制，无法商用）

二、 系统架构

Android平台是基于Linux内核。上图是其系统架构。大致可以分为四层。从下到上为：

  1. Linux内核层： 包含了Linux内核和一些驱动模块(比如蓝牙驱动，USB驱动等)
  2. Libraries层： 提供动态库， Android运行时库，Dalvik虚拟机等。这一层大部分都是用C或者C++编写，也可以称为Native层（init、Audio系统、Surface系统）
  3. Framework层： 大部分用Java语言编写。是Android平台的基石。（zygote、system server等）
  4. Application层：与用户之间交互。都是用Java开发。（MediaProvider等）

Java世界与Native世界的关系

  1. JAVA通过JNI层调用Linux的系统调用来完成对应的功能
  2. JAVA世界经过JNI层通过IPC方式与Native世界交互。而IPC方法就是是Binder。
  3. JNI是Java Native Interface的是缩写， 即“Java本地调用”。简单来说，java程序中的函数可以调用Native写的函数。Native程序中的函数可以调用Java层的函数。

三、开始第一个程序

  1. 双击Eclipse, 启动Eclipse
  2. 选择File -> New -> Project, 在打开的对话框中，选择Android -> Android Application Project

  1. 程序创建完成，我们来看看效果，首先利用android 提供虚拟设备管理，创建虚拟机，并运行
  2. 右键工程， Debug as -> Android Application, 运行效果如下
  3. （如果工程暂时不要，可以选择工程，右键“Close Porject”,可以提高打开esclipse的速度，当工程多的时候，这个效果特别明显）

    四、程序目录介绍

    总体目录

目录及文件 说明
Src 代码目录，代码编写、功能实现的地方
Assets 存放资源文件，例如歌曲等
Bin 存放编译生成的二进制文件
Libs 库
Res 布局文件
AndroidManifest.xml 关键配置文件，包括组件的声明，版本的定义，权限的声明等

代码文件说明

程序启动的时候，会调用onCreate中setContentView,进行界面的初始化，后面会详细说明activity的生命周期。onCreateOptionMenu和onOptionsItemSelected是选项菜单的实现。

布局文件说明

Android提供了一组View类，用作视图的容器。每个布局实现管理器子布局的大小和位置的特定策略。

布局管理器 说明
LinearLayout 以水平或者垂直的方式组织其子控件
FrameLayout 显示单一帧
TableLayout 以行和列的方式组织其子控件
AbsoluteLayout 绝对布局，兼容性不好，不建议使用
RelativeLayout 相对布局,容器中的控件相

 

Android中，控件通常是在layout目录下定义，但是代码中如何使用呢? 这里先解释下两个定义的不同

“@+”表示新声明， “@”表示引用，例如：

“@+id/tv” 表示新声明一个id， 是id名为tv的组件

“@id/tv” 表示引用id名为tv的组件,比较常用于布局

定义编辑框
<EditText
android:id="@+id/search_bar"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:hint="@string/search_example" />
 
代码中引用：
private EditText text_search;          
text_search = (EditText) findViewById(R.id.search_bar);

AndroidManifest文件说明

<application></application>是进行组件的声明，例如activity, service, brocadcast等注意，如果涉及到网络的交互，要在该文件中加入如下权限：

<uses-permission android:name="android.permission.INTERNET"></uses-permission>

六、 布局管理器

LinearLayout线性布局

线性布局是最常用的一种。此布局会保持组件之间的间隔以及组件之间互相对齐。显示组件的方式有垂直于水平两种，可以通过orientation进行设定。

垂直方式：

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent"
    android:orientation="horizontal"
     >
    <Button
        android:layout_width="fill_parent"
        android:layout_height = "wrap_content"
        android:text = "Button1"></Button>
    <Button
        android:layout_width="fill_parent"
        android:layout_height = "wrap_content"
        android:text = "Button2"></Button>  
    <Button
        android:layout_width="fill_parent"
        android:layout_height = "wrap_content"
        android:text = "Button2"></Button>          
</LinearLayout>

水平方式：

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent"
    android:orientation="horizontal"
     >
    <Button
        android:layout_width="wrap_content"
        android:layout_height = "wrap_content"
        android:text = "Button1"></Button>
    <Button
        android:layout_width="wrap_content"
        android:layout_height = "wrap_content"
        android:text = "Button2"></Button>  
    <Button
        android:layout_width="wrap_content"
        android:layout_height = "wrap_content"
        android:text = "Button2"></Button>          
</LinearLayout>

FrameLayout单帧布局

单帧布局新定义的组件永远放在屏幕的左上角，后一个组件总会将前一个组件覆盖

<FrameLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent"
     >
    <Button
        android:layout_width="fill_parent"
        android:layout_height = "wrap_content"
        android:text = "Button1"></Button>
    <Button
        android:layout_width="wrap_content"
        android:layout_height = "fill_parent"
        android:text = "Button2"></Button>  
    <Button
        android:layout_width="wrap_content"
        android:layout_height = "wrap_content"
        android:text = "Button3"></Button>          
</FrameLayout>

TableLayout表格布局

表格布局就像一个表格。由TableRow组成，每个TableRow代表一行。

<TableLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent"
     >
     <TableRow>
        <Button android:text = "Button1"></Button>
        <Button android:text = "Button2"></Button>
        <Button android:text = "Button3"></Button>             
     </TableRow>
 
     <TableRow>
        <Button android:text = "Button4"></Button>
        <Button android:text = "Button5"></Button>
        <Button android:text = "Button6"></Button>             
     </TableRow>   
 
     <TableRow>
        <Button android:text = "Button7"></Button>
        <Button android:text = "Button8"></Button>
        <Button android:text = "Button9"></Button>             
     </TableRow>            
</TableLayout>

AbsoluteLayout绝对布局

绝对布局，组件的位置可以准确指定在屏幕的x/y坐标。但是这种布局兼容性不好。

<AbsoluteLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:orientation="vertical"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent"
     >
    <Button
        android:layout_width="wrap_content"
        android:layout_height = "fill_parent"
        android:text = "Button1"
        android:layout_x="100dp"></Button>
    <Button
        android:layout_width="fill_parent"
        android:layout_height = "wrap_content"
        android:text = "Button2"
        android:layout_y="100dp"></Button>   
</AbsoluteLayout>

RelativeLayout相对布局

相对布局，是一种比较常用的比较，每个组件都可以指定相对于其他组件或者父组件的位置(通过ID来指定)。一个组件的位置，至少要确定组件“左右”与“上下”两个位置才可以准确确定组件位置

<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent"
    >
    <Button
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text = "Button1"
        android:id="@+id/btn1"></Button>
    <Button
        android:layout_width="fill_parent"
        android:layout_height = "wrap_content"
        android:text = "Button2"
        android:id="@+id/btn2"
        android:layout_below="@id/btn1"></Button>
    <Button
        android:layout_width="wrap_content"
        android:layout_height = "wrap_content"
        android:text = "Button3"
        android:id="@+id/btn3"
        android:layout_below="@id/btn2"
        android:layout_alignRight="@id/btn2"></Button>  
    <Button
        android:layout_width="wrap_content"
        android:layout_height = "wrap_content"
        android:text = "Button4"
        android:id="@+id/btn4"
        android:layout_below="@id/btn3"
        android:layout_alignParentRight="true"></Button>
    <Button
        android:layout_width="wrap_content"
        android:layout_height = "wrap_content"
        android:text = "Button5"
        android:id="@+id/btn5"
        android:layout_below="@id/btn4"
        android:layout_centerHorizontal="true"></Button>
</RelativeLayout>

七、程序组件简介

Activity简介

  • 应用程序中的每个屏幕显示都通过几次和扩展基类Activity来实现
  • Activity利用View来实现应用程序的GUI。应用程序通过GUI向用户显示信息，用户通过GUI向应用程序发出指令和响应

    Service简介

  • Service是具有一段较长生命周期且没有用户界面的程序
  • Service继承自android.app.Service类
  • Service不能自己启动
  • 启动和关闭Service的流程
StartService（）启动service
stopService() 关闭service
stopSelf() service自身调用关闭
bindservice() 将context对象(如activity)绑定到指定的service
这样的话，context对象消亡，service也会停止运行

BroadcastReceiver简介

  • BroadcastReceiver是用户接受广播通知的组件
  • BroadcastReceiver是对发送出来的Broadcast进行过滤接收并响应的一类组件
  • 如果想要接受到广播，首先要注册BroadcastReceiver，注册的方式有两种，一种是静态的在AndroidManifest.xml中用<receiver>标签声明注册，并设置过滤器。另一种方式，动态的设置一个IntentFilter对象，然后在需要注册的地方调用registerReceiver,取消注册的地方调用unregisterReceiver方法。
  • 如何发生广播呢？首次，在要发送信息的地方，封装一个Intent对象，然后调用sendBroadcast方法吧Intetn对象以广播的形式发送出去。这样的话，所有已经注册的BroadcastReceiver会检查注册时的IntentFilter是否与发送的Intent向匹配，如果匹配则调用onRecevie方。

    ContentProvider简介

    ContentProvider能将应用程序特定的数据提供给另一个应用程序使用。

    Intent连接组件的纽带

    Intent是一种运行时绑定机制，它能在程序运行的过程中连接两个不同的组件

    Intent的主要组成部分：

组成 描述
组件名称 Intent目标组件的名称
Action(动作) Intent所触发动作名字的字符串
Data(数据) 描述Intent要操作的数据URI和数据类型
Category(类别) 对被请求组件的额外描述信息
Extra(附加信息) 附加额外信息

八、Activity的生命周期

Activity生命周期的七个函数：

函数 说明
onCreate Activity初次创建时被调用，一般在这里创建view, 初始化布局，设置监听器。如果Activity首次调用，那么其后会调用onStart,

如果Activity是停止后重新刷新，那么其后调用onRestart()
onStart() 当Activity对用户即将可见时被调用，其后调用onResume()
onRestart() 当Activity停止后重新显示被调用，其后调用onStart()
onResume() 当用户能在界面中进行操作的时候调用
onPause() 当系统要启动一个其他的Activity时调用，这个方法被用来停止动画和其他占用CPU资源的事情
onStop() 当另一个Activity恢复并遮盖住当前Activity，导致其对用户不再可见时调用
onDestory() 当前的Activity被销毁前所调用的最后一个方法，或者进程终止时调用

为了详细说明生命周期的变化，创建“MyFirstProject”的项目，添加两个类“MainActivity.java”和“OtherActivity.java”，这两个类都继承了Activity，并实现了上面的七 个函数，在每个生命周期函数中添加了一个Log打印语句，方便观察周期变化。MainActivity添加了一个按钮，用于跳转到OtherActivity。

MainActivity.java关键代码
public class MainActivity extends Activity implements OnClickListener {
    private Button btn;
 
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
        Log.v("MainActivity", "onCreate");
        btn = (Button) findViewById(R.id.Main_btn);
        btn.setOnClickListener(this);
    }
 
    @Override
    public void onClick(View arg0) {
        if (arg0 == btn) {
            Intent intent = new Intent();
            intent.setClass(this, OtherActivity.class);
            this.startActivity(intent);
        }
    }
 
    @Override
    protected void onDestroy() {
        // TODO Auto-generated method stub
        super.onDestroy();
        Log.v("MainActivity", "onDestroy");
    }
 
    @Override
    protected void onPause() {
        // TODO Auto-generated method stub
        super.onPause();
        Log.v("MainActivity", "onPause");
    }
 
    @Override
    protected void onRestart() {
        // TODO Auto-generated method stub
        super.onRestart();
        Log.v("MainActivity", "onRestart");
    }
 
    @Override
    protected void onResume() {
        // TODO Auto-generated method stub
        super.onResume();
        Log.v("MainActivity", "onResume");
    }
 
    @Override
    protected void onStart() {
        // TODO Auto-generated method stub
        super.onStart();
        Log.v("MainActivity", "onStart");
    }
 
    @Override
    protected void onStop() {
        // TODO Auto-generated method stub
        super.onStop();
        Log.v("MainActivity", "onStop");
    }
 
}
OtherActivity.java 关键代码
public class OtherActivity extends Activity implements OnClickListener {
    private Button btn;
 
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.other);
        Log.v("OtherActivity", "onCreate");
        btn = (Button) findViewById(R.id.Other_btn);
        btn.setOnClickListener(this);
    }
 
    @Override
    public void onClick(View arg0) {
        if (arg0 == btn) {
            this.finish();
        }
    }
 
    @Override
    protected void onDestroy() {
        // TODO Auto-generated method stub
        super.onDestroy();
        Log.v("OtherActivity", "onDestroy");
    }
 
    @Override
    protected void onPause() {
        // TODO Auto-generated method stub
        super.onPause();
        Log.v("OtherActivity", "onPause");
    }
 
    @Override
    protected void onRestart() {
        // TODO Auto-generated method stub
        super.onRestart();
        Log.v("OtherActivity", "onRestart");
    }
 
    @Override
    protected void onResume() {
        // TODO Auto-generated method stub
        super.onResume();
        Log.v("OtherActivity", "onResume");
    }
 
    @Override
    protected void onStart() {
        // TODO Auto-generated method stub
        super.onStart();
        Log.v("OtherActivity", "onStart");
    }
 
    @Override
    protected void onStop() {
        // TODO Auto-generated method stub
        super.onStop();
        Log.v("OtherActivity", "onStop");
    }
 
}

 效果图如下所示

（1）首次启动项目，进入MainActivity

02-16 08:35:49.673: V/MainActivity(1303): onCreate
02-16 08:35:49.673: V/MainActivity(1303): onStart
02-16 08:35:49.693: V/MainActivity(1303): onResume

（2）按下手机上的“Back”键

02-16 08:40:21.593: V/MainActivity(1303): onPause
02-16 08:40:24.413: V/MainActivity(1303): onStop
02-16 08:40:24.413: V/MainActivity(1303): onDestroy

（3）重新打开程序，单击手机上的Home键

02-16 08:42:55.133: V/MainActivity(1303): onPause
02-16 08:43:03.983: V/MainActivity(1303): onStop

（4）单击程序图标

02-16 08:44:21.963: V/MainActivity(1303): onRestart
02-16 08:44:21.963: V/MainActivity(1303): onStart
02-16 08:44:21.973: V/MainActivity(1303): onResume

上面的情况是单个Activity的时候，下面讲述两个Activity的情况

（1）打开OtherActivity

02-16 08:47:38.743: V/MainActivity(1303): onPause
02-16 08:47:41.423: V/OtherActivity(1303): onCreate
02-16 08:47:41.473: V/OtherActivity(1303): onStart
02-16 08:47:41.473: V/OtherActivity(1303): onResume
02-16 08:47:43.833: V/MainActivity(1303): onStop

（2）在OtherActivity，按下“Back”按钮或者按下“关闭当前Activity”按钮

02-16 08:51:22.223: V/OtherActivity(1303): onPause
02-16 08:51:22.583: V/MainActivity(1303): onRestart
02-16 08:51:22.583: V/MainActivity(1303): onStart
02-16 08:51:22.593: V/MainActivity(1303): onResume
02-16 08:51:24.493: V/OtherActivity(1303): onStop
02-16 08:51:24.493: V/OtherActivity(1303): onDestroy

将OtherActivity的主题风格，设置成对话框的形式，效果图如下所示

1）打开OtherActivity

02-16 09:04:23.103: V/MainActivity(1390): onPause
02-16 09:04:23.743: V/OtherActivity(1390): onCreate
02-16 09:04:23.743: V/OtherActivity(1390): onStart
02-16 09:04:23.753: V/OtherActivity(1390): onResume

从上面可以看出，如果新打开的Activity不能完全覆盖前面的Activity,  那么前面的Activity就不会调用onStop这个生命周期。

九、Service的生命周期

下面通过创建项目，在service的各个状态回调方法中加入log信息，了解其生命周期

  • 首先创建service类
public class SampleService extends Service {
    final String TAG = "Service";
    
    @Override
    public IBinder onBind(Intent intent) {
        Log.d(TAG, "onBind");
        return null;
    }
    @Override
    public boolean onUnbind (Intent intent) {
        Log.d(TAG, "onUnbind");
        return super.onUnbind(intent);
    }
    @Override
    public void onRebind (Intent intent) {
        super.onRebind(intent);
        Log.d(TAG, "onRebind");
    }
    @Override
    public void onCreate () {
        super.onCreate();
        Log.d(TAG, "onCreate");
    }
    @Override
    public void onDestroy () {
        super.onDestroy();
        Log.d(TAG, "onDestroy");
    }
    @Override
    public void onStart (Intent intent, int startId) {
        super.onStart(intent, startId);
        Log.d(TAG, "onStart");
    }
}
  •   主Activity设置监听按钮
public class MainActivitySampleService extends Activity {
    OnClickListener listener;
    ServiceConnection connection;
    /** Called when the activity is first created. */
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.ch6ex1);
        // 定义ServiceConnection对象，用于绑定Service
        connection = new ServiceConnection(){
            @Override
            public void onServiceConnected(ComponentName arg0, IBinder arg1) {
            }
            @Override
            public void onServiceDisconnected(ComponentName arg0) {
            }
        };
        /*定义Button的点击监听器*/
        listener = new OnClickListener(){
            @Override
            public void onClick(View v) {
                Intent i = new Intent(MainActivitySampleService.this,SampleService.class);
                switch (v.getId()) {
                case R.id.startService:
                    startService(i);
                    break;
                case R.id.stopService:
                    stopService(i);
                    break;
                case R.id.bindService:
                    bindService(i, connection, BIND_AUTO_CREATE);
                    break;
                case R.id.unbindService:
                    unbindService(connection);
                    break;
                default:
                    break;
                }
            }
        };
        /*设置点击监听器*/
     findViewById(R.id.startService).setOnClickListener(listener);
        findViewById(R.id.stopService).setOnClickListener(listener);
        findViewById(R.id.bindService).setOnClickListener(listener);
        findViewById(R.id.unbindService).setOnClickListener(listener);
    } 
}

  • 按下四个按钮的流程信息
StartService:
03-29 14:46:33.801: D/Service(17346): onCreate
03-29 14:46:33.802: D/Service(17346): onStart
 
stopService:
03-29 14:47:31.801: D/Service(17346): onDestroy
 
bindService:
03-29 14:48:13.689: D/Service(17346): onCreate
03-29 14:48:13.713: D/Service(17346): onBind
 
unbindService:
03-29 14:48:41.871: D/Service(17346): onUnbind
03-29 14:48:41.871: D/Service(17346): onDestroy

十、BroadcastRecevier的应用

下面通过一个简单的例子来说明，如何处理广播消息。利用android系统启动完毕时，会发送一个action为ACTION_BOOT_COMPLETED的Intent，来实现开机自启动服务。

  • 首次，为了能够接收广播，需要在AndroidManifest.xml中，加入权限
<uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED"/>
  • 然后创建类MyBootRecevier,  并在onReceiver方法中启动服务
public class MyBootReceiver extends BroadcastReceiver {
    @Override
    public void onReceive(Context context, Intent intent) {
        Intent i = new Intent(context,SampleService.class);
        context.startService(i);
    }
}
  • 最后，采用静态注册的方法注册MyBootReceiver
<receiver android:name=".MyBootReceiver">
    <intent-filter>
        <action android:name="android.intent.action.BOOT_COMPLETED" />
    </intent-filter>
</receiver>

十一、 Intent的应用

1、 利用intent在两个Activity之间传递数据

首先，创建intent, bundle对象，bundle存入数据，并通过intent将数据传递给RoutePlanActivity
        Int iLatitude = 10;
        Int iLongtitude = 20;
        Intent intent = new Intent();
        Bundle bundle = new Bundle();
        bundle.putInt("latitude", iLatitude);
        bundle.putInt("longtitude", iLongtitude);
        intent.putExtras(bundle);      
        intent.setClass(MainContentHuntSheActivity.this, RoutePlanActivity.class);
        startActivity(intent); 
 
RoutePlanActivity接收到消息，进行如下处理
Bundle myBundle = this.getIntent().getExtras();
int iLatitude   = myBundle.getInt("latitude");
int iLongtitude = myBundle.getInt("longtitude");

2、 通过intent，实现信息分享

// 分享短串结果
 Intent it = new Intent(Intent.ACTION_SEND);
   
 String str = "冬日暖曲，一款时尚音乐软件，界面简洁实用哦！";
 it.putExtra(Intent.EXTRA_TEXT, str);
 it.setType("text/plain");
 ((Activity)mainActionView.getContext()).startActivity(Intent.createChooser(it, "将短串分享到"));

十二、分辨率问题

Android资源文件中，各个文件存放的分辨率

目录 说明
drawable-ldpi 240×320
drawable-ldpi 320×480
drawable-hdpi 480×800、480×854
drawable-xhdpi 至少960*720
drawable-xxhdpi 1280×720

长度单位dp、sp和px的区别

  • dp也就是dip，这个和sp基本类似。

如果设置表示长度、高度等属性时可以使用dp或sp。但如果设置字体，需要使用sp。

  • dp是与密度无关，sp除了与密度无关外，还与scale无关。如果屏幕密度为160，这时dp和sp和px是一样的。
1dp=1sp=1px，但如果使用px作单位，如果屏幕大小不变（假设还是3.2寸），而屏幕密度变成了320。那么原来TextView的宽度设成160px，在密度为320的3.2寸屏幕里看要比在密度为160的3.2寸屏幕上看短了一半。
但如果设置成160dp或160sp的话。系统会自动将width属性值设置成320px的。也就是160 * 320 / 160。其中320 / 160可称为密度比例因子。
  • 如果使用dp和sp，系统会根据屏幕密度的变化自动进行转换

十三、应用程序签名

Android应用程序要发布，并被别人使用，需要进行签名，下面将说明如何进行签名

  • 生产私钥，Android的SDK中，有个工具keytool.exe，专门用来生产私钥。打开cmd， 进入工具keytool.exe的所在目录，执行以下命令，那么，在当前目录就会生成文件test.keystore
keytool -genkey -dname "CN=Zijun Li,OU=Zijun Li,O=Zijun Li,L=shenzhen,S=guangdong,C=0086" -storepass 密码 -keystore test.keystore -keyalg RSA -keypass 密码 -validity 15000
  • 然后在eclipse中，选中项目，右击鼠标，选择Android Tools ->Export Unsigned Application Package…，然后，按照提示执行，最后导出的apk，即为签名的apk,可以提供给别人使用或者上传应用商店

十四、推荐学习

  • 通过android SDK中的api demo进行学习
  • 反编译别人的apk，学习别人的代码，目前有两种方法（方法一，dex2jar和jd-gui; 方法二，apktool）

 

解决内存管理问题的最佳利器-valgrind

Valgrind是一个动态分析工具，能够自动检测许多内存管理问题、线程bug,  并且能够分析程序的状况。它内部支持多个工具集，包括内存错误检测器，线程错误检测器，缓存分析器、堆分析器等，默认使用的是内存检测器(memcheck),  它是使用最多的一个内存检测工具。当然，你也可以基于Valgrind自己建立新的工具。

Valgrind支持的平台有：x86/Linux、AMD/64Linux、PPC32/Linux、PPC64LE/Linux、S390X/Linux、ARM/Linux(supported since ARMv7)、ARM64/Linux、MIPS32/Linux、MIPS64/Linux、X86/Solaris、 AMD64/Solaris、 X86/illumos、 AMD64/illumos、X86/Darwin (10.10, 10.11)、 AMD64/Darwin (10.10, 10.11)、ARM/Android、ARM64/Android、 MIPS32/Android、X86/Android

Valgrind是开源免费的软件，基于GNU General Public License, version 2.

一、快速入门

Valgrind工具集中最受欢迎的是memcheck,  它满足大部分的场景。memcheck能够检测内存相关的错误，并且是采用C/C++编译的程序，程序运行过程中奔溃或者不可预料的行为都可以使用Valgrind中的memcheck来进行检测。

使用Valgrind前，采用-g选项编译程序，这样memcheck才能够提取到具体的行号信息，同时可以使用-O0优化选项，但是如果使用-O1选项，那么显示的行号信息可能就不准确；不推荐使用-O2选项，如果使用的话，memcheck偶尔上报不是真的存在的未初始化的错误信息

命令行一般的使用格式如下所示，–leak-check=yes是打开内存泄露的检测器，

valgrind --leak-check=yes myprog arg1 arg2

下面提供一个C++例子，该例子有内存泄露和访问不存在地址的两个错误

#include <string>

void f(void)
{
    int* x = new int[10](); 
    x[10] = 0; // 访问不存在地址       
} // 内存泄露，没有释放内存                   

int main(void)
{
    f();
    return 0;
}

错误信息描述如下，表示访问不存在地址，第一行“Invalid write of size 4”表明什么类型错误，写数据到内存中，而该内存是不应该访问的。1066表示进程id号。如果错误的堆栈信息显示不够显示，那么可以加上选项–num-callers，再加上层级数量，比如–num-callers=20。

==1066== Invalid write of size 4
==1066==    at 0x100000F55: f() (example_02.cpp:6)
==1066==    by 0x100000F83: main (example_02.cpp:11)
==1066==  Address 0x100dea808 is 0 bytes after a block of size 40 alloc'd
==1066==    at 0x1000AC086: malloc (in /usr/local/Cellar/valgrind/3.15.0/lib/valgrind/vgpreload_memcheck-amd64-darwin.so)
==1066==    by 0x100179627: operator new(unsigned long) (in /usr/lib/libc++abi.dylib)
==1066==    by 0x100000F33: f() (example_02.cpp:5)
==1066==    by 0x100000F83: main (example_02.cpp:11)

内存泄露的错误信息提示描述如下, 它会告诉你内存分配的位置，但是它不能告诉你内存为什么泄露。

==1122== 40 bytes in 1 blocks are definitely lost in loss record 14 of 42
==1122==    at 0x1000AC086: malloc (in /usr/local/Cellar/valgrind/3.15.0/lib/valgrind/vgpreload_memcheck-amd64-darwin.so)
==1122==    by 0x100179627: operator new(unsigned long) (in /usr/lib/libc++abi.dylib)
==1122==    by 0x100000F33: f() (example_02.cpp:5)
==1122==    by 0x100000F83: main (example_02.cpp:11)

一般有几种内存泄露的类型，比较重要的两种是definitely lost和possibly lost，definitely lost是确定内存泄露，需要修复它，possibly lost可能存在内存泄露，需要仔细确认。

==1122== LEAK SUMMARY:
==1122==    definitely lost: 40 bytes in 1 blocks
==1122==    indirectly lost: 0 bytes in 0 blocks
==1122==      possibly lost: 72 bytes in 3 blocks
==1122==    still reachable: 200 bytes in 6 blocks
==1122==         suppressed: 18,127 bytes in 153 blocks
==1122== Reachable blocks (those to which a pointer was found) are not shown.
==1122== To see them, rerun with: --leak-check=full --show-leak-kinds=all

另外memcheck比较经常会上报没有初始化值的信息，但是要定位到错误信息的根本原因是比较困难的，对此，可以添加参数–track-origins=yes来获取更多的信息，但是，这样会使得memcheck运行的更慢。

Conditional jump or move depends on uninitialised value(s)

二、memcheck的错误信息

memcheck是内存错误的检测器，他可以检测C/C++常见的下列错误问题

  1. 访问不应该访问的内存，例如堆溢出、栈溢出、访问已经释放的内存
  2. 使用没有定义的值，例如值没有初始化
  3. 不正确的释放堆内存，例如重复释放内存，malloc/new/new[] 和 free/delete/delete[]没有一一对应使用
  4. 使用memcpy函数，源地址和目的地址重叠
  5. 向内存分配函数中，传递一个不正确的参数，例如负数
  6. 内存泄露
  • 非法读写错误，例如读取已经释放内存的地址，为了获取更多的信息，可以加上–read-var-info=yes的选项
==1178== Invalid read of size 16
==1178==    at 0x101321A50: qstricmp(char const*, char const*) (in /Users/lizijun/Qt5.13.0/5.13.0/clang_64/lib/QtCore.framework/Versions/5/QtCore)
==1178==    by 0x101539A81: QTimerInfoList::activateTimers() (in /Users/lizijun/Qt5.13.0/5.13.0/clang_64/lib/QtCore.framework/Versions/5/QtCore)
  • 使用没有定义的值，例如定义了变量，但是没有初始化，如果信息不够详细,可以添加参数–track-origins=yes来获取更多的信息
#include <string>
#include <iostream>

int main(void)
{
    int i_number;
    std::cout << i_number << std::endl;
    return 0;
}

==1189== Conditional jump or move depends on uninitialised value(s)
==1189==    at 0x1003D83C5: __vfprintf (in /usr/lib/system/libsystem_c.dylib)
==1189==    by 0x1003FF058: __v2printf (in /usr/lib/system/libsystem_c.dylib)
==1189==    by 0x1003E434A: _vsnprintf (in /usr/lib/system/libsystem_c.dylib)
==1189==    by 0x1003E43A7: vsnprintf_l (in /usr/lib/system/libsystem_c.dylib)
==1189==    by 0x1003D53B2: snprintf_l (in /usr/lib/system/libsystem_c.dylib)
==1189==    by 0x1000D4D22: std::__1::num_put<char, std::__1::ostreambuf_iterator<char, std::__1::char_traits<char> > >::do_put(std::__1::ostreambuf_iterator<char, std::__1::char_traits<char> >, std::__1::ios_base&, char, long) const (in /usr/lib/libc++.1.dylib)
==1189==    by 0x1000C8F27: std::__1::basic_ostream<char, std::__1::char_traits<char> >::operator<<(int) (in /usr/lib/libc++.1.dylib)
==1189==    by 0x100000D0D: main (example_03.cpp:7)
  • 非法释放地址，例如重复释放内存
#include <string>
#include <iostream>

int main(void)
{
    char *p_data = new char[64]();
    delete []p_data;
    delete []p_data;
    return 0;
}
==1212== Invalid free() / delete / delete[] / realloc()
==1212==    at 0x1000AC463: free (in /usr/local/Cellar/valgrind/3.15.0/lib/valgrind/vgpreload_memcheck-amd64-darwin.so)
==1212==    by 0x100000F7D: main (example_04.cpp:8)
==1212==  Address 0x100dea7e0 is 0 bytes inside a block of size 64 free'd
==1212==    at 0x1000AC463: free (in /usr/local/Cellar/valgrind/3.15.0/lib/valgrind/vgpreload_memcheck-amd64-darwin.so)
==1212==    by 0x100000F62: main (example_04.cpp:7)
==1212==  Block was alloc'd at
==1212==    at 0x1000AC086: malloc (in /usr/local/Cellar/valgrind/3.15.0/lib/valgrind/vgpreload_memcheck-amd64-darwin.so)
==1212==    by 0x100179627: operator new(unsigned long) (in /usr/lib/libc++abi.dylib)
==1212==    by 0x100000F2A: main (example_04.cpp:6)
  • 调用申请和释放内存的方法不匹配，例如malloc申请内存，但是使用delete来释放，对某些系统来说是不允许的，因此，为了保证程序健壮，使用malloc,那么对应使用free; 使用new,那么对应使用delete; 使用new [], 那么对应使用delete []。
Mismatched free() / delete / delete []

三、Valgrind调用QtCreator程序

mac系统通过QtCreator创建程序之后，也可以采用Valgrind在终端上检测QtCreator生成的程序。

首先进入QtCreator编译生成的文件目录

接着选择build开头的目录，右键弹出的列表选择“服务”->”新建位于文件夹位置的终端窗口”来启动终端,  终端输入如下所示的命令来使用Valgrind测试QtCreator编译生成的程序JQtTestStudy.app

四、局限性

  1. Memcheck并不完美，它也会出现误报，但是它有99%的准确性，对于它提示的信息我们应该警惕。
  2. memcheck不能检测每一种内存错误，比如它不能检测到对静态分配或堆栈上的数组的超出范围的读写，但是它还是能够检测出使得你程序奔溃的错误，例如段错误segmentation fault

    五、总结

程序开发过程中，可能会遇到崩溃的问题，如果代码量很多的时候，我们可能会使用gdb来查看coredump信息，但是有时候gdb的信息比较简单，没有更加详细的堆栈信息，那么就可以考虑使用Valgrind进行分析。最近，工作中遇到一个问题，程序运行过程中，会偶发崩溃问题，使用gdb查看coredump信息，显示是重复释放内存，但是堆栈信息很少，一直找不到位置，后来使用Valgrind来查看程序，仔细查看从Valgrind提供的堆栈信息，很快找到问题的位置，原因确实是重复释放内存。

温馨提示：Valgrind经常上报了很多错误提示信息，这个可能是同样一个地方调用了多次，所以，如果解决了一个地方的问题，错误提示信息就会全部消失，需要耐心仔细。

析构函数的妙用, 让你明白流方式输出日志的实现原理

学习面向对象（如C++编程语言），那么肯定了解析构函数，它在对象销毁的时候被调用，通常我们在构造函数中申请资源，在析构函数中释放资源。那么析构函数在实现以流方式输出日志中有什么妙用呢？接下来请让我一步步为你揭开这层迷雾。

C/C++语言日志输出模式一般有两种，一种类似printf的方式，另一种类似std::cout的方式，这里说的流方式输出日志指的就是类似std::cout的方式，并且自定义日志输出的格式，同时既可以将日志输出到终端，也可以将日志输出到文件。

printf("%s  %d \n", "this is my log", 1);
std::cout << "this is my log " << 1 << std::endl;

一、格式化字符串的输出流

C++语言提供了ostringstream模版，它支持格式化字符串输出流。

  • 首先让我们看看ostringstream的简单使用，定义ostringstream变量oss，然后将当前的线程id以十六进制的方式写入ostringstream变量,  再调用ostringstream的函数str()，将其转换为std::string字符串之后，打印输出到终端。
#include <sstream>

std::ostringstream oss;
oss << std::hex << std::this_thread::get_id();
LOG(INFO) << oss.str();

输出的信息如下所示，当前的线程id是以十六进制的格式输出。

[2019-11-30 22:03:50,124554] [bool JDebugCPPAttr::TestOstringstream():277] 0x7fff9e22c380
  • 上面是ostringstream的简单使用方法，那么下面将说明如何构造输出函数名称和行号的字符串。通过利用系统提供的宏定义__func__和__LINE__来构造所需字符串信息。
std::ostringstream oss2;
oss2 << "[" << __func__ << ":" << __LINE__ << "]";
std::cout << oss2.str() << std::endl;

从输出的格式内容看，ostringstream按照预期的效果输出了正确的字符串格式。

[TestOstringstream:281]

二、资源获取即初始化

RAII全称是“Resource Acquisition is Initialization”，资源获取即初始化”，简单来说，就是说在构造函数中申请分配资源，在析构函数中释放资源。经常使用的方式是：构造函数中通过new申请内存，析构函数中通过delete释放内存。

  • 基于RAII的思想，我们实现资源管理的管理类，管理类ResourceManager构造函数接受std::function类型的变量, 将其赋值给类的私有成员变量exit_handle，析构函数内调用exit_handle,  那么如果想要实现满足RAII， 那么只要构建释放资源的std::function类型的变量，然后传递给 ResourceManager。
class ResourceManager
{
public:
    explicit ResourceManager(std::function<void()> fun):exit_handle(fun)
    {
        std::cout << "call constructor" << std::endl;
    }
    
    ~ResourceManager()
    {
        std::cout << "call destructor " << std::endl;
        exit_handle();
    }
    
private:
    std::function<void()> exit_handle;
};

申请创建内存，然后再创建ResourceManager对象，构造函数的入参是一个匿名函数，函数的功能是释放创建的内存。

{
    int *p_data = new int();
    ResourceManager( [&]()
                   {
                       std::cout << "delete p_data" << std::endl;
                       delete p_data;
                   });
}

运行程序之后，输出打印信息

call constructor
call destructor 
delete p_data
  • 同样的方式，我们可以创建文件之后，再创建ResourceManager对象，构造函数的参数功能是释放文件句柄。
{
    std::ofstream ofs("test.txt");
    ResourceManager( [&]
                   {
                       std::cout << "close ofs" << std::endl;
                       ofs.close();
                   });
}

运行程序之后，输出打印信息

call constructor
call destructor 
close ofs
  • 从上面的两个例子中，可以看出都是利用对象在销毁时会调用析构函数的原理来实现，简单来说，申请资源之后，紧接着设置释放资源，等到申请的资源使用完成之后，资源管理对象在退出作用域之后，就会调用析构函数来释放资源，这样做的好处是，我们不必关注资源什么时候进行释放的问题，同时一定程度上也防止忘记释放资源。

三、利用析构函数来实现日志输出

结合std::ostringstream可以格式化输出流的功能和对象销毁时调用析构函数的原理，我们就可以实现自定义格式，并以流方式输出日志的功能。

  • 实现JWriter类来格式化日志信息并输出，这里我们只是简单输出到终端，当然，你也可以将自定义格式的日志信息写入文件或者写入队列，再由线程将队列中的日志信息写入文件。
  • JWriter类的构造函数接受三个参数：日志等级、函数名称、行号；并且重载了operator<<运算符
///类定义
class JWriter
{
public:
    explicit JWriter(const std::string &strLevel, const std::string &strFun, int iLine);
    ~JWriter();

    // 重载operator<<运算符
    template <typename T>
    inline JWriter& operator<<(const T& log) {
        m_log << log;
        return *this;
    }

private:
    std::string GetSysTimeToMs();

private:
    std::ostringstream m_log;
};


///类实现
#include <iostream>
#include <thread>
#include <chrono>
#include <sys/timeb.h>

JWriter::JWriter(const std::string &strLevel, const std::string &strFun, int iLine)
{
    m_log <<"["<< GetSysTimeToMs() << "]" << "[" << strFun << ":" << iLine << "]" << "[" << strLevel << "] ";
}


JWriter::~JWriter()
{
    m_log << std::endl;
    /// 这里可以实现将日志输出到终端或者写入文件
    std::cout << m_log.str();
}

std::string JWriter::GetSysTimeToMs()
{
    time_t timep;
    struct timeb tb;

    time (&timep);
    char tmp[128] ={0};
    strftime(tmp, sizeof(tmp), "%Y-%m-%d %H:%M:%S",localtime(&timep) );

    char tmp2[128] ={0};
    ftime(&tb);
    snprintf(tmp2,sizeof(tmp2),"%d",tb.millitm);

    std::ostringstream buffer;
    buffer << tmp << "." << tmp2 ;

    return buffer.str();
}
  • 那么如何来使用JWriter类，使用效果又是怎样呢？其实很简单，定义如下所示的宏，该宏只接受日志等级的字符串参数。
#define MyLogJ(LEVEL) JWriter(LEVEL, __func__, __LINE__)
  • 调用方式如下所示，它跟我们熟悉使用的std::cout的方式是一样一样的，只是std::cout换成了我们实现的MyLogJ()宏，因此，不存在需要花费时间来学习它的使用的问题。
MyLogJ("INFO") << "hello " << 123;
MyLogJ("INFO") << "hello " << " world";
  • 如下所示输出的效果，它首先输出日期时间，然后是函数名和对应行号以及日志等级，最后才输出用户输入的日志信息。这样的格式，通常是比较美观，并且利于问题的定位，当然，你也可以根据个人的喜好来修改JWriter的构造函数来自定义自己的日志格式。
[2019-12-01 10:26:00.657][TestMyLog:266][INFO] hello 123
[2019-12-01 10:26:00.657][TestMyLog:267][INFO] hello  world

四、总结

自定义日志格式并以流方式输出的功能已经介绍结束，它是利用了std::ostringstream可以格式化输出流的功能，并且在构造函数格式日志信息，析构函数最后处理日志信息，同时重载了operator<<运算符。

析构函数不只是用于释放资源，我们可以利用它的特性来做其他的运用，就如本文介绍的一样，利用了析构函数实现了流方式的日志功能，如果没有，单纯利用构造函数很难实现流方式的日志功能。当然，析构函数可能还有其他妙用，这需要我们不断去发掘。

 

结合生产消费者模式实现异步日志功能

软件程序开发过程中，日志是诊断bug必不可少的功能，日志功能通常是将每条日志信息按照一定的格式写入指定的文件，但是，实时将日志信息写入文件，必定耗费时间，对于性能要求比较高的机器来说，可能是无法接受的，并且由于时间差问题可能会带来无法预料的问题。

基于上面的原因，解决方案是将日志信息临时存储内存，然后启动线程来将内存中的日志写入文件，因此，本文将结合生产消费者模式来实现异步写入日志的功能。

生产者消费者模式，顾名思义，就是生产者生成数据，消费者处理数据。首先，将通过例子来说明生产者消费者的模式，然后再介绍异步写入日志的功能，其功能代码虽然简单，但是对于日志功能要求场景不多的人来说，却是相当实用的。

一、生产者消费者模式

1、实现简单的生产消费者管理类，生产者即函数Product, 它首先加锁，然后将数据写入队列，最后通过条件变量来唤醒消费者来处理数据；消费者即函数Consume,  它首先加锁，调用条件变量的wait等待接受信号，如果接受到信号，那么从队列中取出数据然后处理，这里需要注意的是取出数据之后，可以提前解锁，以便生产者能够尽快处理数据，另外wait函数添加的匿名函数，它判断队列是否为空，如果不为空，才继续往下处理数据，如果为空，那么继续等待,   这样做的原因是wait返回有可能不是因为接受到生产者发送的信号。

#include <iostream>
#include <mutex>
#include <condition_variable>
#include <thread>
#include <queue>

class JDataManager
{
public:
    //生产者
    void Product()
    {
        for(int i = 0; i < 5; i++)
        {
            std::unique_lock<std::mutex> lock(m_mutex);
            m_queue.push(string("hello"));
            m_condition.notify_one();
            std::cout << "Product  i =  " << i << std::endl;
        }
    }
    
    //消费者
    void Consume()
    {
        int i = 0;
        do
        {
            std::unique_lock<std::mutex> lock(m_mutex);
            m_condition.wait(lock, [&]{ return !m_queue.empty(); } );
            std::string str = m_queue.front();
            m_queue.pop();
            std::cout << "Consume i = " << i << std::endl;
            i++;
        }while(true);
    }
private:
    std::mutex m_mutex;
    std::queue<std::string> m_queue;
    std::condition_variable m_condition;
};

2、上面实现了生产消费者管理类，接下来测试下其运行效果，首先启动线程用于执行消费者函数， 休眠两秒，再启动第二个线程用于执行生产者函数

JDataManager data_manager;

std::thread consumer(&JDataManager::Consume, &data_manager);

std::this_thread::sleep_for(std::chrono::seconds(2));

std::thread productor(&JDataManager::Product, &data_manager);


if(productor.joinable())
{
    productor.join();
}
if(consumer.joinable())
{
    consumer.join();
}

3、最后运行打印的信息如下图所示，生产者生成的数据，消费者对应的提取出来。这先启动消费者，再启动生产者后，运行的效果是合理的。

4、上面是先启动消费者，再启动生产者，如果反过来呢，即先启动生产者，再启动消费者

std::thread productor(&JDataManager::Product, &data_manager);

std::this_thread::sleep_for(std::chrono::seconds(2));

std::thread consumer(&JDataManager::Consume, &data_manager);

5、最后运行打印的信息如下图所示，先启动生产者再启动消费者，消费者也能够正常处理生产者生成的数据。

二、异步日志功能

1、日志是程序中每个模块都会使用到的功能，所以，考虑采用单例模式来实现日志的基本框架。

/// 类定义
class JMyLog
{
public:
    ~JMyLog();
    static JMyLog* Instance(void);

private:
    JMyLog();
);

private:
    static JMyLog* m_pMyLog;
};


/// 类实现
JMyLog* JMyLog::m_pMyLog = nullptr;

JMyLog::JMyLog()
{
}


JMyLog::~JMyLog()
{
    if (m_pMyLog)
    {
        delete m_pMyLog;
        m_pMyLog = nullptr;
    }
}

JMyLog* JMyLog::Instance(void)
{
    if (m_pMyLog == nullptr)
    {
        m_pMyLog = new JMyLog();
    }
    return m_pMyLog;
}

2、实现将每条日志信息写入队列的函数接口，这个相当于生产者， 它负责将写入的每条日志写入队列，再通过条件变量通知消费者处理数据。

/// 类定义
class JMyLog
{
public:
    ~JMyLog();
    static JMyLog* Instance(void);
    // 每条日志信息写入队列
    void WriteLog(int iLogLevel, const std::string &strFileName, int iLineNum
                  , const std::string &strFunName, const char *pFmt, ...);
private:
    JMyLog();

    std::string GetSysTimeToMs();
    std::string GetFirstLog();
    std::string GetLevelInfo(int iLevel);
    std::string GetThreadId();

private:
    static JMyLog* m_pMyLog;
    std::mutex  m_mutex;
    std::deque<std::string> m_deque;
    int m_iLogLevel;
    std::condition_variable m_condVariable;
};


/// 函数实现
static const std::string LOG_DEBUG = "DEBUG";

void JMyLog::WriteLog(int iLogLevel, const std::string &strFileName, int iLineNum
              , const std::string &strFunName, const char *pFmt, ...)
{

    std::unique_lock<std::mutex> lock(m_mutex);
    va_list vaa;
    va_start(vaa, pFmt);
    char ac_logbuf[1024];
    std::memset(ac_logbuf, 0x00, sizeof(ac_logbuf));

    snprintf(ac_logbuf, sizeof (ac_logbuf) - 2, "[%s][%s:%d:%s][%s][%s]"
             , GetSysTimeToMs().c_str()
             , strFileName.c_str()
             , iLineNum
             , strFunName.c_str()
             , GetThreadId().c_str()
             , GetLevelInfo(iLogLevel).c_str());

    size_t ilog_len = strlen(ac_logbuf);
    vsnprintf(ac_logbuf + ilog_len, sizeof(ac_logbuf) - ilog_len -2, pFmt, vaa);
    ilog_len = strlen(ac_logbuf);
    ac_logbuf[ilog_len] = '\n';
    m_deque.push_back(ac_logbuf);
    va_end(vaa);
    m_condVariable.notify_one();
    lock.unlock();
}

std::string JMyLog::GetSysTimeToMs()
{
    time_t timep;
    struct timeb tb;

    time (&timep);
    char tmp[128] ={0};
    strftime(tmp, sizeof(tmp), "%Y-%m-%d %H:%M:%S",localtime(&timep) );

    char tmp2[128] ={0};
    ftime(&tb);
    snprintf(tmp2,sizeof(tmp2),"%d",tb.millitm);

    std::ostringstream buffer;
    buffer << tmp << "." << tmp2 ;

    return buffer.str();
}

std::string JMyLog::GetLevelInfo(int iLevel)
{
    std::string str_level_info;
    switch (iLevel)
    {
        case E_LOG_DEBUG:
        {
            str_level_info = LOG_DEBUG;
            break;
        }
        default:
        {
            str_level_info = LOG_DEBUG;
            break;
        }
    }
    return str_level_info;
}

std::string JMyLog::GetThreadId()
{
    std::ostringstream thread_id;
    thread_id << std::hex << std::this_thread::get_id();
    return thread_id.str();
}

std::string JMyLog::GetFirstLog()
{
    std::string str = m_deque.front();
    m_deque.pop_front();
    return str;
}

3、上面实现了生产者的日志生成功能后，接下来就是实现消费者的日志处理功能，由于考虑的是异步的模式，所以，消费者需要在线程中运行。下面实现的消费者是从队列中取出数据，然后将日志信息打印到终端，后面将添加日志写入文件的功能。

/// 类定义
class JMyLog
{
public:
    ~JMyLog();
    static JMyLog* Instance(void);
    // 每条日志信息写入队列
    void WriteLog(int iLogLevel, const std::string &strFileName, int iLineNum
                  , const std::string &strFunName, const char *pFmt, ...);
private:
    JMyLog();

    std::string GetSysTimeToMs();
    std::string GetFirstLog();
    std::string GetLevelInfo(int iLevel);
    std::string GetThreadId();

    // 启动线程
    void StartThread();
    // 线程执行函数
    void ThreadExce();

private:
    static JMyLog* m_pMyLog;
    std::mutex  m_mutex;
    std::deque<std::string> m_deque;
    int m_iLogLevel;
    std::condition_variable m_condVariable;
};

/// 函数实现
void JMyLog::StartThread()
{
    std::thread thread_obj(&JMyLog::ThreadExce, this);
    thread_obj.detach();
}

void JMyLog::ThreadExce()
{
    while(true)
    {
        std::unique_lock<std::mutex> lock_log(m_mutex);
        m_condVariable.wait(lock_log, [&] { return !m_deque.empty();});
        std::string str = GetFirstLog();
        lock_log.unlock();
        if (!str.empty())
        {
            std::cout << str;
        }
        str.clear();
    }
}

4、为了用户更加方便的调用，我们定义了如下所示的宏

enum E_LOG_LEVEL
{
    E_LOG_DEBUG = 1,
};

#define MyLogD(pFmt, ...) \
    JMyLog::Instance()->WriteLog(E_LOG_DEBUG, __FILE__, __LINE__, __func__, pFmt, ##__VA_ARGS__);

5、测试代码如下所示，调用者按照类似printf的格式使用定义好的宏MyLogD

MyLogD("%s", "this is mylog1.");
MyLogD("%s", "this is mylog2.");

6、日志输出的格式如下图所示

[2019-11-24 16:27:28.950][../JQtTestStudy/debbugtest/jdebugcppattr.cpp:259:TestMyLog][0x7fffa4c16380][DEBUG]this is mylog1.
[2019-11-24 16:27:28.951][../JQtTestStudy/debbugtest/jdebugcppattr.cpp:260:TestMyLog][0x7fffa4c16380][DEBUG]this is mylog2.

7、 为了将日志信息写入文件，封装日志文件写入类，该写入类主要实现打开文件、关闭文件，日志写入文件以及刷新文件的四个函数。

#include <string>
#include <fstream>

/// 类定义
class JLogFileHandler
{
public:
    JLogFileHandler(const std::string &strFilePath);
    ~JLogFileHandler();

    void Open();
    void Close();
    void Write(const std::string &strInfo);
    void Flush();

private:
    void InitFilePath();

private:
    std::string m_strFilePath;
    std::ofstream m_outfstream;
};

/// 类实现
JLogFileHandler::JLogFileHandler(const std::string &strFilePath)
    : m_strFilePath(strFilePath)
{
    InitFilePath();
}


JLogFileHandler::~JLogFileHandler()
{

}

void JLogFileHandler::InitFilePath()
{

}

void JLogFileHandler::Open()
{
    if (!m_outfstream.is_open())
    {
        m_outfstream.open(m_strFilePath);
    }
}

void JLogFileHandler::Close()
{
    if (m_outfstream.is_open())
    {
        m_outfstream.close();
    }
}

void JLogFileHandler::Write(const std::string &strInfo)
{
    m_outfstream << strInfo;
}

void JLogFileHandler::Flush()
{
    m_outfstream.flush();
}

8、JMyLog类添加文件处理者对象，然后线程执行函数中将日志信息写入文件，并且执行刷新功能

/// 类定义
class JMyLog
{
public:
    ~JMyLog();
    static JMyLog* Instance(void);
    // 每条日志信息写入队列
    void WriteLog(int iLogLevel, const std::string &strFileName, int iLineNum
                  , const std::string &strFunName, const char *pFmt, ...);
private:
    JMyLog();

    std::string GetSysTimeToMs();
    std::string GetFirstLog();
    std::string GetLevelInfo(int iLevel);
    std::string GetThreadId();

    // 启动线程
    void StartThread();
    // 线程执行函数
    void ThreadExce();

    // 初始化文件
    void InitFile();

private:
    static JMyLog* m_pMyLog;
    std::mutex  m_mutex;
    std::deque<std::string> m_deque;
    int m_iLogLevel;
    std::condition_variable m_condVariable;
    std::shared_ptr<JLogFileHandler> m_FileHandler; // 文件处理者

};

/// 函数实现
JMyLog::JMyLog()
{
    InitFile();
    StartThread();
}

void JMyLog::ThreadExce()
{
    while(true)
    {
        std::unique_lock<std::mutex> lock_log(m_mutex);
        m_condVariable.wait(lock_log, [&] { return !m_deque.empty();});
        std::string str = GetFirstLog();
        lock_log.unlock();
        if (!str.empty())
        {
            std::cout << str;

            m_FileHandler->Write(str);
            m_FileHandler->Flush();
        }
        str.clear();
    }
}

void JMyLog::InitFile()
{
    std::string str_file = "../../../log/test.log";
    m_FileHandler = std::make_shared<JLogFileHandler>(str_file);
    m_FileHandler->Open();
}

9、再次运行测试代码，查看日志目录下生成了日志文件test.log，并且日志信息也成功写入到文件

三、总结

最后再来总结异步日志功能的实现步骤，首先采用单例模式实现日志的基本框架，接着实现日志生产者，即提供写入日志信息接口，然后再实现日志消费者，日志消费者运行在线程中，并且收到信号才开始处理数据，最后实现文件处理者，将日志信息写入文件。至此，结合生产者消费者模式的异步日志功能完成了。

基于future和promise实现的异步收发数据模版类

std::future和std::promise两者结合可以实现异步的功能场景，本文将介绍的异步收发数据模版类是在实践中结合std::future和std::promise而摸索出来的。

工作过程中，我们可能会经常遇到这样的场景，需要从线程中获取运行的结果。现在我们有两种方式可以实现这样的效果。

  • 第一种方式，属于通用用法，通过使用指针在线程间共享数据。传递指针给新建的线程，主线程使用条件变量等待被唤醒；当线程设置完成数据到传递过来的指针之后，发送条件变量信号，主线程被唤醒之后，从指针中提取数据。这种方式采用条件变量、锁、指针结合才实现了异步功能，比较复杂。
  • 第二种方式，采用std::future和std::promise对象，也就是本文接下来要详细说明的一种异步实现方式。
  • std::future是一个类模版，内部存储一个将来用于分配的值，它提供了get()成员函数来访问该值的机制。如果关联值可用之前，调用了get函数，那么get函数将阻塞直到关联值不可用。
  • std::promise也是一个类模版，它用来设置上面的关联值，每一个stb::promise和一个std::future对象关联，一旦stb::promise设置值之后，std::future对象的get()函数就会获取到值，然后返回。std::promise与它关联的std::future共享数据。

一、阻塞等待获取数据

1、实现线程执行函数，入参是一个std::promise指针，函数内调用std::promise指针设置值

void thread_function(std::promise<std::string>* pPromiseObj)
{
    if(nullptr == pPromiseObj)
    {
        return;
    }
    
    pPromiseObj->set_value("this is my name.");
}

2、定义std::promise对象，从该对象获取关联的std::future对象，启动线程并且传入std::promise对象的指针，调用std::future对象的get()函数阻塞等待，如果返回，那么打印输出返回的字符串信息。

// 定义std::promise对象，从该对象获取关联的std::future
std::promise<std::string> promise_obj;
std::future<std::string> future_obj = promise_obj.get_future();

// 启动线程
std::thread thread_obj(&thread_function, &promise_obj);

// 阻塞等待
std::string str = future_obj.get();
std::cout << "std = " << str << std::endl;

// 等待线程退出
thread_obj.join();

3、运行程序，输出的信息如下所示，从这里可以看出，std::promise在线程中设置值之后，std::future对象的get()函数成功获取并返回。

二、通知线程退出

基于std::promise和std::future的机制，我们可以利用std::promise的set_value来通知运行的线程退出。具体如何做呢，我们接下来给出例子进行说明。

1、实现线程的执行函数，入参为与std::promise关联的std::future对象，执行函数内部调用std::future的wait_for循环超时等待，如果std::future的wait_for在超时时间内没有收到std::promise调用set_value发送的信号，那么继续循环等待，如果在超时时间内收到std::promise调用set_value发送的信号，那么退出循环，同时线程页退出了。

void JThreadFunction(std::future<void> FutureObj)
{
    // 调用std::future的wait_for循环超时等待
    while(FutureObj.wait_for(std::chrono::milliseconds(1))
          == std::future_status::timeout)
    {
        std::cout << "do something" << std::endl;
        std::this_thread::sleep_for(std::chrono::milliseconds(1000));
    }
}

2、创建std::promise对象，从std::promise对象提取关联的future对象，启动线程，并且将上面的future对象传递给线程，主线程休眠一段时间之后，调用std::promise对象的set_value函数来发送信号，通知线程退出。

//创建promise对象
std::promise<void> exit_signal;

//提取future对象
std::future<void> future_obj = exit_signal.get_future();

//启动线程
std::thread thread_obj(JThreadFunction, std::move(future_obj));

//休眠
std::this_thread::sleep_for(std::chrono::seconds(3));

//发送信号
std::cout << "send signal" << std::endl;
exit_signal.set_value();

//等待线程退出
thread_obj.join();
std::cout << "exit function" << std::endl;

3、从输出的结果信息看，线程一直在运行，当收到std::promise对象发送信号的信号之后就退出。

三、异步收发数据

经过上面两个例子的讲解，相信大家对std::future和std::promise已经有了一个大概的了解。下面就给出异步收发数据的模版类。

1、类模版JAsyncSender实现两个函数，一个是Send用于发送数据，它可以在线程中执行，另一个是Wait等待接收数据，如果第三个参数没有输入，那么默认一直等待，否则在指定时间内，没有收到信息，那么返回失败。

#ifndef JASYNCSENDER_H
#define JASYNCSENDER_H

#include <future>
#include <chrono>
#include <thread>
#include "log/easylogging++.h"

///
/// 模版类声明
///
template <class RealT>
class JAsyncSender
{
public:
    JAsyncSender();
    ~JAsyncSender();

    // 发送数据
    bool Send(const RealT &data);
    // 等待接收数据，需要先运行
    bool Wait(std::promise<RealT> promiseObj, RealT &data, unsigned int uiTimeMills = 0);
private:
    std::promise<RealT> m_promiseObj;
};


///
/// 类模版实现
///
template  <typename RealT>
JAsyncSender<RealT>::JAsyncSender()
{

}

template  <typename RealT>
JAsyncSender<RealT>::~JAsyncSender()
{

}

template  <typename RealT>
bool JAsyncSender<RealT>::Send(const RealT &data)
{
    try
    {
        m_promiseObj.set_value(data);
    } catch (const std::exception &e)
    {
        LOG(INFO) << "exception: " << e.what();
    }
    return true;
}


template  <typename RealT>
bool JAsyncSender<RealT>::Wait(std::promise<RealT> promiseObj, RealT &data, unsigned int uiTimeMills)
{
    std::future<RealT> future_obj = promiseObj.get_future();
    m_promiseObj = std::move(promiseObj);
    if (uiTimeMills > 0)
    {
        while(future_obj.wait_for(std::chrono::milliseconds(uiTimeMills))
              == std::future_status::timeout)
        {
            return false;

        }
    }
    data = future_obj.get();
    return true;
}

#endif // JASYNCSENDER_H

2、接下来说明类模版JAsyncSender的使用方法

  • 定义成员变量m_AsyncSendInt，它由主线程和子线程共享。JAsyncSender的type为整型，也可以定义为字符串，甚至是自定义对象，根据具体需求场景具体定义。
    JAsyncSender<int> m_AsyncSendInt;
  • 通过lambda方式创建线程，当然你也可以使用其他方式，线程内部先休眠一段时间，然后发送数据。
// 通过lambda方式创建线程
std::thread thread_obj( [&]{
     LOG(INFO) <<  ": lambda thread executing";
     std::this_thread::sleep_for(std::chrono::seconds(3));
     m_AsyncSendInt.Send(20);
 } ) ;


 std::promise<int> promise_obj;
 int i_data = -1;
 // 等待线程返回数据
 m_AsyncSendInt.Wait(std::move(promise_obj), i_data);
 LOG(INFO) <<  "i_data: " << i_data;
 if (thread_obj.joinable())
 {
     thread_obj.join();
 }
  • 从运行结果看，基于future和promise实现的异步收发数据模版类的功能是正常的。
[2019-11-17 19:29:01,539829] [auto JDebugCPPAttr::TestAsyncSender()::(anonymous class)::operator()() const:235] : lambda thread executing
[2019-11-17 19:29:04,542497] [bool JDebugCPPAttr::TestAsyncSender():244] i_data: 20

四、总结

std::promise与std::future的结合使用，可以更加容易处理异步消息事件，另外C++11标准中提供的 std::asych和std::packaged_task也是结合std::future来处理异步的事件流程。std::promise与std::future虽然功能强大，但是std::promise与std::future是一一对应的，目前没有办法处理一对多的问题，比如一个std::promise对应多个std::future。std::promise如果设置过一次，再次设置会报错，如果需要重新使用，需要再创建std::promise对象。

QT私有方法成功消除的经验总结

工作过程中，涉及excel的读取，因此，通过搜索从网络下载开源库QXlsx来读写excel文档， 从实际的验证过程中，QXlsx支持windows、linux平台，不但能够读取excel文档，而且可以格式化excel文档，设置文档的字体类型，字体大小、字体颜色，对齐方式等，但是它有一个不好的地方，就是使用的时候，QtCreator创建的工程中pro文件需要加入gui-private, Qt官方不推荐使用的 gui-private, 并且如果升级Qt版本，gui-private提供的接口就有可能不能使用或者被删除，Qt官方不保证gui-private的稳定。所以，决定消除QXlsx使用QZipReader和QZipWriter这种私有的方法，通过尝试和研究，最终成功解决了这个问题。本文将记录其解决的过程方法，作为经验的积累和以后其他类似问题解决的借鉴。

一、前期准备工作

通过阅读QXlsx中ZipReader和ZipWriter源代码，ZipReader和ZipWriter类内部封装了Qt私有接口QZipReader和QZipWriter，而QZipReader的功能就是解压读取zip文件，QZipWriter写入文件并压缩成zip文件。因此，如果需要消除QZipReader和QZipWriter，那么首先需要找到QZipReader和QZipWriter的代替品，然后实现ZipReader和ZipWriter的功能。

通过网络搜索找到Zip Utils简化版本的zip库，它支持C++，具体下载地址可以参考文末的链接。

1、如果是在linux系统上使用，需要添加ZIP_STD宏，例如我是在QtCreator工具上使用，那么在pro文件添加如下所示的信息

DEFINES += ZIP_STD

2、如果是在window上使用，经验证可能需要添加部分接口，有编译的问题，欢迎留言一起探讨。

3、如果是在mac系统上使用，那么unzip.cpp文件中malloc.h需要修改为stdlib.h, 为了跨平台的使用，可以按照如下所示的方式进行修改

#ifdef __APPLE__
#include <stdlib.h>
#else
#include <malloc.h>
#endif

4、ZipReader的头文件定义

#include "xlsxglobal.h"

#include <QScopedPointer>
#include <QStringList>
#include <QIODevice>

#if QT_VERSION >= 0x050600
 #include <QVector>
#endif

class QZipReader;

QT_BEGIN_NAMESPACE_XLSX

class  ZipReader
{
public:
    explicit ZipReader(const QString &fileName);
    explicit ZipReader(QIODevice *device);
    ~ZipReader();
    bool exists() const;
    QStringList filePaths() const;
    QByteArray fileData(const QString &fileName) const;

private:
    Q_DISABLE_COPY(ZipReader)
    void init();
    QScopedPointer<QZipReader> m_reader;
    QStringList m_filePaths;
};

QT_END_NAMESPACE_XLSX

5、ZipWriter的头文件定义

#include <QString>
#include <QIODevice>

#include "xlsxglobal.h"

class QZipWriter;

QT_BEGIN_NAMESPACE_XLSX

class ZipWriter
{
public:
    explicit ZipWriter(const QString &filePath);
    explicit ZipWriter(QIODevice *device);
    ~ZipWriter();

    void addFile(const QString &filePath, QIODevice *device);
    void addFile(const QString &filePath, const QByteArray &data);
    bool error() const;
    void close();

private:
    QZipWriter *m_writer;
};

QT_END_NAMESPACE_XLSX

二、读取类的消除

1、修改ZipReader头文件,  其中添加USE_LOCAL_ZIP是为了方便开启和关闭我们自己加入zip utils库，如果定义了USE_LOCAL_ZIP，那么使用我们自己加入的zip utils库，否则使用原来的类。另外对比ZipReader前后修改的头文件，可以发现主要的修改就是将QZipReader修改为HZIP。

#include <QScopedPointer>
#include <QStringList>
#include <QIODevice>

#if QT_VERSION >= 0x050600
 #include <QVector>
#endif

if defined(USE_LOCAL_ZIP)

#include "unzip.h"

QT_BEGIN_NAMESPACE_XLSX

class  ZipReader
{
public:
    explicit ZipReader(const QString &fileName);
    explicit ZipReader(QIODevice *device);
    ~ZipReader();
    bool exists() const;
    QStringList filePaths() const;
    QByteArray fileData(const QString &fileName) const;

private:
    Q_DISABLE_COPY(ZipReader)
    void init();
    HZIP m_reader;
    QStringList m_filePaths;
    ZRESULT m_result;
};

QT_END_NAMESPACE_XLSX

#endif

2、实现ZipReader类，其中需要注意的点：1> 传入的QIODevice需要先close, 再调用zip库的接口OpenZip才能打开成功； 2> QString类型的字符串转换为char *类型，需要先调用toUtf8。

#if defined(USE_LOCAL_ZIP)

#include <QFile>

QT_BEGIN_NAMESPACE_XLSX

ZipReader::ZipReader(const QString &filePath) :
#ifdef UNICODE
    m_reader(OpenZip(reinterpret_cast<const wchar_t *>(filePath.utf16()), nullptr))
#else
    m_reader(OpenZip(filePath.toUtf8().constData(), nullptr))
#endif
    , m_result(ZR_OK)
{
    init();
}

ZipReader::ZipReader(QIODevice *device)
{

    QFile *file = dynamic_cast<QFile *>(device);
    if (nullptr != file)
    {
        QString str_filename = file->fileName();
        file->close();
    #ifdef UNICODE
        m_reader = OpenZip(reinterpret_cast<const wchar_t *>(str_filename.utf16()), nullptr);
    #else
        m_reader = OpenZip(str_filename.toUtf8().constData(), nullptr);
    #endif
    }
    else
    {
        // 如果使用下面的方式，那么会读取不到数据，需要解决，目前走的是上面的分支
        m_reader = OpenZip(device->readAll().data(), device->size(), nullptr);
    }

    init();
}

ZipReader::~ZipReader()
{
    CloseZip(m_reader);
}

void ZipReader::init()
{
    ZIPENTRY entry;
    GetZipItem(m_reader, -1, &entry);
    int i_numitems = entry.index;
    for (int zi = 0; zi <i_numitems; zi++)
    {
        GetZipItem(m_reader, zi, &entry);
        m_filePaths.append(QString::fromUtf8(entry.name));
    }
}

bool ZipReader::exists() const
{
    return IsZipHandleU(m_reader);
}

QStringList ZipReader::filePaths() const
{
    return m_filePaths;
}

QByteArray ZipReader::fileData(const QString &fileName) const
{
    ZIPENTRY entry;
    int i = -1;

    // 使用fileName.toUtf8().constData()， 而不是fileName.toStdString().c_str()，否则会读取不到
    FindZipItem(m_reader, fileName.toUtf8().constData(), true, &i, &entry);
    if (entry.unc_size < 0 || i < 0)
    {
        return QByteArray("");
    }

    char *p_buf = new char[entry.unc_size + 1];
    UnzipItem(m_reader,i, p_buf, entry.unc_size);
    QByteArray byte_array("");
    byte_array.append(p_buf, entry.unc_size);
    delete[] p_buf;
    p_buf = nullptr;
    return byte_array;
}
QT_END_NAMESPACE_XLSX

#endif

三、写入类的消除

1、修改ZipWriter头文件, 对比ZipWriter前后修改的头文件，可以发现主要的修改就是将QZipWriter修改为HZIP。

#if defined(USE_LOCAL_ZIP)
#include "zip.h"

QT_BEGIN_NAMESPACE_XLSX

class ZipWriter
{
public:
    explicit ZipWriter(const QString &filePath);
    explicit ZipWriter(QIODevice *device);
    ~ZipWriter();

    void addFile(const QString &filePath, QIODevice *device);
    void addFile(const QString &filePath, const QByteArray &data);
    bool error() const;
    void close();

private:
    HZIP m_writer;
    ZRESULT m_result;

};

QT_END_NAMESPACE_XLSX
#endif

2、实现ZipWriter类，其中需要注意的点：1> 传入的QIODevice需要先close, 再调用zip库的接口CreateZip才能创建成功； 2> QString类型的字符串转换为char *类型，需要先调用toUtf8。

#if defined(USE_LOCAL_ZIP)

#include <QFile>
#include <QDebug>

QT_BEGIN_NAMESPACE_XLSX

ZipWriter::ZipWriter(const QString &filePath)
{
#ifdef UNICODE
    m_writer = CreateZip(reinterpret_cast<const wchar_t *>(filePath.utf16()), nullptr);
#else
    m_writer = CreateZip(filePath.toUtf8().constData(), nullptr);
#endif
}

ZipWriter::ZipWriter(QIODevice *device)
{

    QFile *file = dynamic_cast<QFile *>(device);
    if (nullptr != file)
    {
        QString str_filename = file->fileName();
        // 需要先close，否则Create会失败
        file->close();
    #ifdef UNICODE
        m_writer = CreateZip(reinterpret_cast<const wchar_t *>(str_filename.utf16()), nullptr);
    #else
        m_writer = CreateZip(str_filename.toUtf8().constData(), nullptr);
    #endif
    }
    else
    {
    }

}

ZipWriter::~ZipWriter()
{
    if (m_writer)
    {
        CloseZip(m_writer);
        m_writer =nullptr;
    }
}

bool ZipWriter::error() const
{
    return !IsZipHandleZ(m_writer);
}

void ZipWriter::addFile(const QString &filePath, QIODevice *device)
{
    ZipAdd(m_writer, filePath.toUtf8().constData(),  (void *)device->readAll().data(), device->size());
}

void ZipWriter::addFile(const QString &filePath, const QByteArray &data)
{
    ZipAdd(m_writer, filePath.toUtf8().constData(),  (void *)data.data(), data.size());
}

void ZipWriter::close()
{
    if (m_writer)
    { 
        CloseZip(m_writer);
        m_writer =nullptr;
    }
}

QT_END_NAMESPACE_XLSX

#endif

四、总结

总的来说，消除私有方法，首先需要找到代替的类，如果是简单的功能，可以考虑自己实现，否则试试从网络上查找相关的开源代码。接着就是利用代替类重新实现相同的接口，另外，最好提前写好测试类，方便对比测试前后修改的功能。最后需要注意unicode字符类型和utf8字符类型的转换，否则有可能出现程序崩溃，功能不正常等问题。

五、参考链接

读写excel文档入门讲解一

zip_utils

C++容器中实用的查找功能

C++标准中std提供了几种容器，它们包括顺序容器，比如vector, list, deque, queue, stack等，关联容器 ，比如map, set等，其中使用频率比较高的容器是vecotor向量容器、map键值对容器，我们经常会使用这两个容器来存储数据，然后根据不同的场景来查找获取容器内的值。而本文接下来将说明从这两类容器中快速查找获取数据的方法。

一、vector容器查找功能

vector容器自身没有提供查找函数，这里借助标准模版库algorithm提供的find,  使用的时候需要包含该头文件。

1、首先定义vector容器变量，然后存入数据，接着遍历打印容器内的所有数据，最后调用algorithm提供的函数find从vector向量中查找数据，algorithm提供的函数find需要输入三个入参数，第一个参数是容器开始查找的迭代器变量，第二个变量是容器结束查找的迭代器变量，第三个参数是需要查找的数据。

#include <vector>
#include <algorithm>

// 定义vecotor，然后存入数据
std::vector<std::string> vec_str;
vec_str.push_back("abc");
vec_str.push_back("def");
vec_str.push_back("fhj");
vec_str.push_back("123");
vec_str.push_back("456");

// 遍历打印vector容器内的数据
std::vector<std::string>::iterator iter = vec_str.begin();
for(iter = vec_str.begin(); iter != vec_str.end(); iter++)
{
    LOG(INFO) << *iter;
}
LOG(INFO) << "======";

// 调用find函数查找，内容为“def”的信息
iter = find(vec_str.begin(),vec_str.end(), "def");
if (iter != vec_str.end())
{
    LOG(INFO) << "find info: " << *iter;
}
LOG(INFO) << "======";

2、运行程序，输出的内容如下图所示，容器内存在需要查找的数据，返回迭代器变量，我们根据迭代器变量输出数据内容

二、map容器查找功能

map容器自身提供了查找功能，同时它也支持使用标准模版库algorithm提供的find函数。

1、首先定义map容器变量，写入数据，再遍历输出容器内的数据，接着调用map容器自身提供的find函数来查找key为2的数据，返回迭代器变量，然后根据这个迭代器变量输出键值，接下来调用algorithm提供的find函数，需要注意的是第三个参数输入的是迭代器的取值，最后也是返回迭代器变量。

#include <map>
#include <algorithm> 

// 首先定义map容器变量，写入数据
std::map<int, std::string> map_str;
map_str[1] = "aa";
map_str[2] = "bb";
map_str[3] = "cc";

// 遍历输出容器内的所有内容
std::map<int, std::string>::iterator iter_map;
for(iter_map = map_str.begin(); iter_map != map_str.end(); iter_map++)
{
    LOG(INFO) << "key: " << iter_map->first <<" value "<< iter_map->second;
}
LOG(INFO) << "======";

// 调用map容器自身提供的find函数，查找key为2的数据
iter_map = map_str.find(2);
if (iter_map != map_str.end())
{
    LOG(INFO) << "key: " << iter_map->first <<" value: "<< iter_map->second;
}
LOG(INFO) << "======";

// 调用algorithm提供的find函数来查找数据，注意find的第三个参数输入的是迭代器的取值
std::map<int, std::string>::iterator iter_map_ret;
iter_map_ret = find(map_str.begin(), map_str.end(), *iter_map);
if (iter_map_ret != map_str.end())
{
    LOG(INFO) << "result, key: " << iter_map_ret->first <<" value: "<< iter_map_ret->second;
}

2、运行程序，输出的内容如下图所示

三、键自定义的map容器查找功能

map容器使用过程中，有时候为了程序的可维护性以及降低代码的复杂度，需要自定义类作为map的键，在这种场景下，上面的查找方法是否也能够生效呢？接下来让我们进行验证。

1、首先自定义类JKeyPair来作为map的key,  如果自定义对象要作为map的键，那么需要重载operator<运算符，而如果要使用algorithm中的find,需要重载operator==运算符

#include <iostream>

/// 类的定义
class JKeyPair
{
public:
    JKeyPair(const std::string &strName, int iIndex);
    ~JKeyPair();

    std::string GetName(void);
    int GetIndex(void);

    // 自定义map中的key，需要重载operator<运算符（一定要记得加上const, 否则调用出错）
    bool operator<(const JKeyPair &rhs) const;

    // 自定义map中的key，使用algorithm中的find,需要重载operator==运算符（一定要记得加上const, 否则调用出错）
    bool operator==(const JKeyPair& rhs) const;
private:
    std::string m_strName;
    int m_iIndex;
};


/// 类的实现
JKeyPair::JKeyPair(const std::string &strName, int iIndex)
    :m_strName(strName),m_iIndex(iIndex)
{}

JKeyPair::~JKeyPair()
{}

std::string JKeyPair::GetName(void)
{
    return m_strName;
}

int JKeyPair::GetIndex(void)
{
    return m_iIndex;
}

bool JKeyPair::operator<(const JKeyPair &rhs) const
{
    if (m_iIndex < rhs.m_iIndex)
    {
        return true;
    }
    else if ((m_iIndex ==  rhs.m_iIndex)
             && (m_strName < rhs.m_strName))
    {
        return true;
    }
    return false;
}


bool JKeyPair::operator==(const JKeyPair& rhs) const
{
    if ((m_iIndex ==  rhs.m_iIndex)
            && (m_strName == rhs.m_strName))
    {
        return true;
    }
    return false;
}

2、验证调用map自身提供的find函数，其测试代码如下图所示

// 定义map容器变量，key是自定义类型，然后写入数据
std::map<JKeyPair, std::string> map_info;
JKeyPair key_pair_1("one", 1);
map_info[key_pair_1] = "value_one";
JKeyPair key_pair_2("two", 2);
map_info[key_pair_2] = "value_two";
JKeyPair key_pair_3("three", 2);
map_info[key_pair_3] = "value_three";

// 循环遍历容器内数据
std::map<JKeyPair, std::string>::iterator iter;
for(iter = map_info.begin(); iter != map_info.end(); iter++)
{
    JKeyPair key_pair = iter->first;
    LOG(INFO) << "name : " << key_pair.GetName();
    LOG(INFO) << "index : " << key_pair.GetIndex();
    LOG(INFO) << "value : " << iter->second;
}
LOG(INFO) << "======";

// 通过调用map自身提供的函数find，来查找键为key_pair_2的数据
iter = map_info.find(key_pair_2);
if (iter != map_info.end())
{
    LOG(INFO) << "find, value : " << iter->second;
}

3、从运行的结果看，使用自定义对象作为key值，map容器提供的find函数能够正确运行，并且从实际操作过程中，可以得出，map容器提供的find函数，自定义对象不需要重载operator==运算符。

4、接着再验证algorithm中的find，从实际操作过程中，自定义对象需要重载operator==运算符，测试代码段如下图所示，其中find中第三个参数是上一步骤中调用map自身的find返回的迭代器变量

// 使用alogrithm提供的find来查找map容器的数据
std::map<JKeyPair, std::string>::iterator iter_map_key;
iter_map_key = std::find(map_info.begin(), map_info.end(), *iter);
if (iter_map_key != map_info.end())
{
    JKeyPair key_pair = iter_map_key->first;
    LOG(INFO) << "result, self key: " << key_pair.GetName()  << "/" << key_pair.GetIndex()
              <<" value: "<< iter_map_key->second;
}

5、运行后打印的结果信息看，能够正确调用algorithm中的find来查找map中的数据

四、总结

到这里，我们已经将容器vector,map的查找功能介绍完成。接下来梳理总结。vector容器自身没有提供查找函数，因此，需要调用algorithm中的find来快速查找数据。map容器自身既提供了查找函数，也支持使用algorithm中的find来快速查找数据。而自定义对象作为map容器的键的情况下，如果需要支持上面的场景，那么自定义类需要重载operator<和operator==运算符。