C++工厂模式简易实现
引言：动态绑定是面向对象编程的重要功能，但C++目前还没有纳入标准库的反射机制，所以为了更方便的动态构造对象，使得通过配置文件的方式改变派生类对象，而不需要去修改代码，所以可以使用工厂这一常见的设计模式，来完成类对象的动态构造。
基于C++11的新特性和模板，实现一个简易的类对象构造工厂，本文实现的工厂产生的类对象都是独立的。（即非单例工厂）
首先，考虑到在一个程序中，始终应该只有一个工厂对象，故我们采用单例模式来实现工厂，其代码如下
#pragma once
#include <unordered_map>
#include <memory>
#include <functional>
#include <string>
// 第一个参数是基类名称 可变参数是构造器的参数列表
template<class Base, class... Args>
class Factory {
public:
// 禁止外部拷贝和赋值
Factory(const Factory&) = delete;
const Factory& operator = (const Factory&) = delete;
// 获取工厂实例
static Factory& Instance() {
// C++11 保证static对象在构造的时候是线程安全的
static Factory<Base, Args...>* instance = new Factory<Base, Args...>();
return *instance;
}
// 向工厂注册类及其构造器
void Register(const std::string& name, std::function<std::shared_ptr<Base>(Args...)> constructor) {
_factory[name] = constructor;
return;
}
// 通过名字构造对象
std::shared_ptr<Base> Construction(const std::string& name, Args... args) {
return _factory.find(name) == _factory.end() ? nullptr :
_factory[name](std::forward<Args>(args)...);
}
private:
Factory() = default;
~Factory() = default; // 禁止外部析构
// 类名->构造器
std::unordered_map<std::string, std::function<std::shared_ptr<Base>(Args...)>> _factory;
};
然后为了减少向工厂注册类对象的重复工作量，将该操作进行封装，封装后的类对象如下：
#pragma once
#include "Factory.h"
// 辅助注册类 第一个参数是基类 第二个参数是 派生类
// 可变参数是派生类构造函数所需要的参数
template<class Base, class Impl, class... Args>
class Register {
public:
// name是对象的名字，也是工厂中用于映射的key
explicit Register(const std::string& name) {
Factory<Base, Args...>& factory = Factory<Base, Args...>::Instance();
factory.Register(name, [](Args... args) {
return std::make_shared<Impl>(std::forward<Args>(args)...);
});
}
};
以上就是C++工厂的实现，下面来进行测试。
假设基类为Animal，其有两个派生类Cat和Dog。其定义分别如下：
Animal.h内容：
#pragma once
#include <iostream>
#include <string>
#include "Factory.h"
// 基类 声明为纯虚函数
class Animal {
public:
Animal() = default;
virtual ~Animal() = default;
virtual std::string getName() = 0;
private:
};
Dog.h内容：
#pragma once
#include "Animal.h"
#include "Register.h"
class Dog : public Animal {
public:
Dog() = default;
Dog(const std::string& _name) : name(_name) {}
std::string getName() override;
~Dog() = default;
private:
std::string name;
};
Dog.cpp内容:
#include "Dog.h"
std::string Dog::getName() {
return name;
}
namespace {
// 注册语句建议不要放在.h文件中，可能会导致在编译的时候出现重名
// 放在.cpp文件并放入匿名namespace中可以将作用域限定在该cpp文件
// 不会与其他文件产生冲突
// 本质是定义了一个名字为 _ 的Register对象 因为在cpp文件中
// 且放入匿名namespace，所以Cat.cpp中同样可以定义一个名字为 _ 的
// Register对象
Register<Animal, Dog, std::string> _("Dog");
}
Cat.h内容：
#pragma once
#include "Animal.h"
#include "Register.h"
class Cat : public Animal {
public:
Cat() = default;
Cat(const std::string& _name) : name(_name) {}
std::string getName() override;
~Cat() = default;
private:
std::string name;
};
Cat.cpp内容
#include "Cat.h"
std::string Cat::getName() {
return name;
}
namespace {
// 同Dog注释
Register<Animal, Cat, std::string> _("Cat");
}
最后，进行测试，main.cpp文件内容如下：
#include <iostream>
#include <string>
#include "Factory.h"
#include "Cat.h"
#include "Dog.h"
namespace {
using std::cout;
using std::endl;
using std::string;
}
int main() {
std::shared_ptr<Animal> animal1 = Factory<Animal, std::string>::Instance().Construction("Cat", "I am cat");
std::shared_ptr<Animal> animal2 = Factory<Animal, std::string>::Instance().Construction("Dog", "I am dog");
if (animal1 != nullptr && animal1.get() != nullptr) {
std::cout << animal1->getName() << std::endl;
}
if (animal1 != nullptr && animal2.get() != nullptr) {
std::cout << animal2->getName() << std::endl;
}
return 0;
}
输出如下：
I am cat
I am dog