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

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

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

介绍开闭原则之前,首先会结合例子来讲解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 关键配置文件,包括组件的声明,版本的定义,权限的声明等

代码文件说明

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

布局文件说明

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==运算符。