设计模式（6）：C++工厂+注册

目录

实现动机

实现方法

一个单例的对象工厂代码

Factory最终的实现

用法示例：

实现动机

最近项目中需要用到工厂模式，但是普通的工厂模式面临一个问题，每新增一个派生类，都需要在工厂中加一个case分支，这样就会频繁地修改工厂的代码，而且随着派生类越来越多，case分支也逐渐增多，代码越来越臃肿，对于后期的维护也不友好。下面是一个工厂方法的伪代码：

Message* create(int type)
{
    switch (type) 
    {
    case MSG_PGSTATS:
        m = new MPGStats;
        break;
    case MSG_PGSTATSACK:
        m = new MPGStatsAck;
        break;
    case CEPH_MSG_STATFS:
        m = new MStatfs;
        break;
    case CEPH_MSG_STATFS_REPLY:
        m = new MStatfsReply;
        break;
    case MSG_GETPOOLSTATS:
        m = new MGetPoolStats;
        break;
    default:
        break;
    }
}

最近在博客上看到了一个比较优雅的解决方案：自动注册的工厂方法模式。自己也动手实现了一把，解决了项目中遇到的问题。

实现方法

自动注册的对象工厂的实现思路如下：

• 提供一个单例工厂对象。
• 工厂注册对象（保存创建对象的key和构造器）。
• 利用辅助类，在辅助类对象的构造过程中实现目标对象地注册。
• 利用一个宏来生成辅助对象。
• 在派生类文件中调用这个宏实现自动注册。

其中，需要注意的是，对象工厂并不直接保存对象，而是对象的构造器，因为对象工厂不是对象池，是对象的生产者，允许不断地创建实例，另外，这样做还实现了延迟创建。另外一个要注意的地方是借助宏来实现自动注册，本质上是通过宏来定义了很多全局的静态变量，而这些静态变量仅仅是为了实现自动注册，并没有实际的意义。

下面来看看如何用C++11来实现这个自动注册的对象工厂。

一个单例的对象工厂代码

对象工厂的辅助类的代码

struct factory
{
    template<typename T>
    struct register_t
    {
        register_t(const std::string& key)
        {
            factory::get().map_.emplace(key, []{ return new T; });
        }
    };
private:
    inline static factory& get()
    {
        static factory instance;
        return instance;
    }
    
    static std::map<std::string, FunPtr> map_;
};

对象工厂的辅助类register_t是工厂类的一个内部模版类，非常简单，只有一个构造函数，这个构造函数中调用了factory的私有变量map_，并往map_中插入了key和泛型对象的构造器。这里用到了C++11的一个新特性：内部类可以通过外部类的实例访问外部类的私有成员，所以register_t可以直接访问factory的私有变量map_。

自动注册的代码

#define REGISTER_MESSAGE_VNAME(T) reg_msg_##T##_
#define REGISTER_MESSAGE(T, key, ...) static factory::register_t<T> REGISTER_MESSAGE_VNAME(T)(key, __VA_ARGS__);

在派生类中调用宏注册自己：

class Message1 : public Message
{
    //……
};

REGISTER_MESSAGE(Message1, "message1");

自动注册的关键是通过一个宏来生成静态全局的register_t的实例，因为register_t的实例是用来向工厂注册目标对象的构造器。所以仅仅需要在派生类中调用这个宏就可以实现自动至注册了，而无需修改原有代码。

我们还可以添加智能指针接口，无需让用户管理原始指针，甚至让工厂能创建带任意参数的对象。

Factory最终的实现

//factory
#pragma once

#include <unordered_map>
#include <iostream>
#include <functional>
#include <memory>

#include "message.h"

struct factory {
    template<typename T>
    struct register_t
    {
        register_t(const std::string& key)
        {
            factory::get().map_.emplace(key, [] { return std::make_shared<T>(); });
        }

        template<typename... Args>
        register_t(const std::string& key, Args... args)
        {
            factory::get().map_.emplace(key, [=] { return std::make_shared<T>(args...); });
        }
    };

    static std::shared_ptr<Message> produce(const std::string& key)
    {
        if (map_.find(key) == map_.end())
            throw std::invalid_argument("the message key is not exist!");

        return map_[key]();
    }
private:
    factory() = default;
    factory(const factory&) = delete;
    factory(factory&&) = delete;

    static factory& get()
    {
        static factory instance;
        return instance;
    }

    static std::unordered_map<std::string, std::function<std::shared_ptr<Message>()>> map_;
};

std::unordered_map<std::string, std::function<std::shared_ptr<Message>()>> factory::map_;

#define REGISTER_MESSAGE_VNAME(T) reg_msg_##T##_
#define REGISTER_MESSAGE(T, key, ...) static factory::register_t<T> REGISTER_MESSAGE_VNAME(T)(key, ##__VA_ARGS__);

用法示例：

//message.h
#pragma once

#include"factory.h"

class Message {
public:
    virtual ~Message() = default;

    virtual void foo() = 0;
};

class Message1 : public Message {
public:
    Message1() {
        std::cout << "message1 Construct" << std::endl;
    }

    Message1(int a) {
        std::cout << "message1 value: " << a << std::endl;
    }

    void foo() {
        std::cout << "message1 foo" << std::endl;
    }
};

class Message2 : public Message {
public:
    Message2() {
        std::cout << "message2" << std::endl;
    }

    Message2(int a) {
        std::cout << "message2 value: " << a << std::endl;
    }

    void foo(){
        std::cout << "message2" << std::endl;
    }
};

//main.cpp
#include"factory.h"
using namespace std;

REGISTER_MESSAGE(Message1, "message1", 5);

int main() {

    std::shared_ptr<Message> p = factory::produce("message1");
    p->foo();

    return 0;
}