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

软件程序开发过程中,日志是诊断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==运算符。