Abstract Factory, переделка примера из книги Александреску с variadic templetes - C++ - Ответ 9540603

#ifndef ABSTRACTFACTORY_ENEMYHIERARCHYFACTORY_H
#define ABSTRACTFACTORY_ENEMYHIERARCHYFACTORY_H
 
#include <memory>
#include <tuple>
 
template <typename T>
struct Type2Type
{
    using type = T;
};
 
template <typename T>
class AbstractFactoryUnit
{
public:
    virtual std::unique_ptr<T> DoCreate(Type2Type<T>) = 0;
 
    virtual ~AbstractFactoryUnit() = default;
};
 
template <template <typename> class Unit, typename ... AbstractProducts>
class AbstractFactory : public Unit<AbstractProducts>...
{
protected:
    using ProductList = std::tuple<AbstractProducts...>;
public:
    template <typename T>
    std::unique_ptr<T> Create()
    {
        Unit<T>& unit = *this;
        return unit.DoCreate(Type2Type<T>());
    }
};
 
template <typename ConcreteProduct, typename Base, std::size_t Index>
class ConcreteFactoryUnit : public Base
{
    using BaseProductList = typename Base::ProductList;
    static constexpr std::size_t ProductSize = std::tuple_size<BaseProductList>::value;
public:
 
    using AbstractProduct = std::tuple_element_t<ProductSize - Index - 1, BaseProductList>;
 
    std::unique_ptr<AbstractProduct>
    DoCreate(Type2Type<AbstractProduct>) override
    {
        return std::make_unique<ConcreteProduct>();
    }
};
 
template <typename AbstractFact, template <typename, typename, std::size_t> class Unit,
          typename ... ConcreteProducts>
class ConcreteFactory;
 
template <typename AbstractFact, template <typename, typename, std::size_t> class Unit,
          typename T, typename ... ConcreteProducts>
class ConcreteFactory<AbstractFact, Unit, T, ConcreteProducts...>
        : public Unit<T, ConcreteFactory<AbstractFact, Unit, ConcreteProducts...>, sizeof...(ConcreteProducts)>
{
};
 
template <typename AbstractFact, template <typename, typename, std::size_t> class Unit,
          typename ConcreteProduct>
class ConcreteFactory<AbstractFact, Unit, ConcreteProduct>
        : public Unit<ConcreteProduct, AbstractFact, 0>
{
 
};
 
#endif //ABSTRACTFACTORY_ENEMYHIERARCHYFACTORY_H

#include <iostream>
#include <memory>
#include "enemy.h"
#include "enemyfactory.h"
 
int main()
{
    using AbstractEnemyFactory =
    AbstractFactory<AbstractFactoryUnit,
    Soldier,
    Monster,
    SuperMonster>;
 
    using EasyFactory =
    ConcreteFactory<AbstractEnemyFactory, ConcreteFactoryUnit,
    SillySoldier,
    SillyMonster,
    SillySuperMonster>;
 
    std::unique_ptr<AbstractEnemyFactory> pFactory{new EasyFactory};
    std::unique_ptr<Enemy> pEnemy = pFactory->Create<Monster>();
    pEnemy->info();
 
    pEnemy = pFactory->Create<Soldier>();
    pEnemy->info();
 
    using HardFactory =
    ConcreteFactory<AbstractEnemyFactory, ConcreteFactoryUnit,
    BadSoldier,
    BadMonster,
    BadSuperMonster>;
 
    pFactory.reset(new HardFactory);
    pEnemy = pFactory->Create<Monster>();
    pEnemy->info();
 
    pEnemy = pFactory->Create<Soldier>();
    pEnemy->info();
}