C++工程，C++设计模式-策略模式

c++设计模式
策略模式是指定义一系列的算法，把它们单独封装起来，并且使它们可以互相替换，使得算法可以独立于使用它的客户端而变化，也是说这些算法所完成的功能类型是一样的，对外接口也是一样的，只是不同的策略为引起环境角色环境角色表现出不同的行为。

相比于使用大量的if…else，使用策略模式可以降低复杂度，使得代码更容易维护。

缺点：可能需要定义大量的策略类，并且这些策略类都要提供给客户端。

1,data_queue.h

#ifndef __DATA_QUEUE_H__
#define __DATA_QUEUE_H__

#include <map>

enum class QueueType : int {
    QUEUE = 1,
    ZMQ = 2,
};

//此处结构体参数要兼容不同队列的创建
//此处只做示意，需要酌情修改
struct QueueParam {
    QueueType queue_type = QueueType::QUEUE;
    int queue_size; 
    std::string queue_name;
};

class AbstractQueue {
public:
    virtual int pullData(int &number, std::vector<std::shared_ptr<int>> &record_list) = 0;
    virtual int pushData(int &number, std::vector<std::shared_ptr<int>> &record_list) = 0;
    virtual int getQueueSize(int &size) = 0;
    virtual ~AbstractQueue(){};
};

class DataQueue {
private:
    QueueType m_type;
public:
    AbstractQueue *m_queue;
public:
    DataQueue();
    DataQueue(const QueueParam &queue_param);
    ~DataQueue();
};

#endif

2,my_queue.h

#ifndef __MY_QUEUE_H__
#define __MY_QUEUE_H__

#include <queue>
#include "data_queue.h"

class MyQueue : public AbstractQueue {
private:
    std::queue<std::shared_ptr<int>> m_queue;
    int m_size;
    std::mutex m_queue_mutex;
public:
    MyQueue();
    MyQueue(int queue_size);
    ~BdavsQueue();
    int pullData(int &number, std::vector<std::shared_ptr<int>> &record_list);
    int pushData(int &number, std::vector<std::shared_ptr<int>> &record_list);
    int getQueueSize(int &size);
};
#endif

2,my_zmq.h

#ifndef __MY_ZMQ_H__
#define __MY_ZMQ_H__

#include <zmq.h>
#include "data_queue.h"

class MyZmq : public AbstractQueue {
private:
	//zmq的具体实现方式和相应的成员变量

    std::mutex m_queue_mutex;
public:
    MyZmq();
    MyZmq(int queue_size, string queue_name);
    ~MyZmq();
    int pullData(int &number, std::vector<std::shared_ptr<int>> &record_list);
    int pushData(int &number, std::vector<std::shared_ptr<int>> &record_list);
    int getQueueSize(int &size);
};
#endif

3,data_queue.cpp

#include "data_queue.h"
#include "my_queue.h"
#include "my_zmq.h"

namespace bdavs {
    namespace eyeofgod {

        DataQueue::DataQueue() {
        }

        DataQueue::DataQueue(const QueueParam &queue_param) {
            m_type = queue_param.queue_type;
            if(m_type == QueueType::QUEUE) {
                m_queue = (AbstractQueue *)new MyQueue(queue_param.queue_size);
                LOG(INFO) << "DataQueue struct successful. typr: queue   name:" << queue_param.queue_name;
            }
            else if(m_type == QueueType::ZMQ) {
                m_queue = (AbstractQueue *)new MyZmq(queue_param.queue_size, queue_param.queue_name);
                LOG(INFO) << "DataQueue struct successful. typr: zmq   name:" << queue_param.queue_name;
            }
            else {
                LOG(ERROR) << "error queue type!";
            }
        }

        DataQueue::~DataQueue() {
            delete m_queue;
        }
    }
}

4,main.cpp

#include "data_queue.h"

int main()
{
    QueueParam queue_param;
    queue_param.queue_type = QueueType::QUEUE;
    queue_param.queue_size = 30;
    queue_param.queue_name = "first_queue";
    
    DataQueue data_queue(queue_param);
    std::vector<int> int_in = {1, 2, 3, 4};
    data_queue->m_queue.pushData(4, int_in);
    
    std::vector<int> int_out;
    int out_num;
    data_queue->m_queue.pullhData(out_num, int_out);
    return 0;
}