Я строю фреймворк C ++, который можно расширить, добавив новый класс

Я хотел бы найти способ для упрощения расширения новых классов.

Мой текущий код выглядит так:

class Base {
public:
    virtual void doxxx() {...}
};

class X: public Base {
public:
    static bool isMe(int i) { return i == 1; }
};

class Y: public Base {
public:
    static bool isMe(int i) { return i == 2; }
};

class Factory {
public:
    static std::unique_ptr<Base> getObject(int i) {
        if (X::isMe(i)) return std::make_unique<X>();
        if (Y::isMe(i)) return std::make_unique<Y>();

        throw ....
    }
};

Также для каждого нового класса должен быть добавлен новый оператор if.

Теперь я хотел бы найти способ переписать мой класс Factory (с помощью метапрограммирования), чтобы добавление нового класса можно было сделать, вызвав метод add, а класс factory выглядит следующим образом:

class Factory
{
public:
    static std::unique_ptr<Base> getObject(int i) {
        for X in classNames:
            if (X::isMe(i)) return std::make_unique<X>();

        throw ....
    }

    static void add() {...}

    static classNames[];...
};

Factory::add(X);
Factory::add(Y);

, ,

Возможно ли что-то подобное? Спасибо заранее

2
Mauri 22 Фев 2018 в 14:32

5 ответов

Лучший ответ

Вы можете сделать что-то вроде следующего:

template <typename ... Ts>
class Factory {
public:
    static std::unique_ptr<Base> createObject(int i) {
        if (i < sizeof...(Ts)) {
            static const std::function<std::unique_ptr<Base>()> fs[] = {
                [](){ return std::make_unique<Ts>();}...
            };
            return fs[i]();
        }
        throw std::runtime_error("Invalid arg");
    }

};

Использование будет:

using MyFactory = Factory<X, Y /*, ...*/>;

auto x = MyFactory::createObject(0);
auto y = MyFactory::createObject(1);

Если вы хотите зарегистрироваться во время выполнения, вы можете сделать следующее:

class Factory {
public:
    static std::unique_ptr<Base> createObject(int i) {
        auto it = builders.find(i);
        if (it == builders.end()) {
            throw std::runtime_error("Invalid arg");
        }
        return it->second();
    }

template <typename T>
void Register()
{
    builders.emplace(T::Id, [](){ return std::make_unique<T>();});
}

private:
    std::map<int, std::function<std::unique_ptr<Base>()>> builders;
};

Использование будет:

class X: public Base {
public:
    static constexpr int id = 1;
};

class Y: public Base {
public:
    static constexpr int id = 2;
};

И

Factory factory;
factory.register<X>();
factory.register<Y>();

auto x = factory.createObject(1);
auto y = factory.createObject(Y::id);
6
Jarod42 22 Фев 2018 в 12:45

Вы могли бы сделать что-то вроде этого:

#include <type_traits>
#include <utility>
#include <memory>
#include <functional>
#include <stdexcept>

class I {
public:
    virtual ~I(); // Always give a polymorphic class a virtual dtor!
    virtual void doxxx();
};

enum class I_Key {
    X = 1,
    Y
    /*...*/
};

struct I_Key_Order {
    bool operator()(I_Key k1, I_Key k2) const
    {
        using U = std::underlying_type_t<I_Key>;
        return static_cast<U>(k1) < static_cast<U>(k2);
    }
};

class I_Factory {
public:
    using Generator = std::function<std::unique_ptr<I>()>;
    static std::unique_ptr<I> getObject(I_Key key) const;
    static void add(I_Key key, Generator gen);

    template <class T>
    class AutoRegister {
    public:
        AutoRegister() {
            auto generator = []() -> std::unique_ptr<I>
                { return std::make_unique<T>(); };
            add(T::class_key, std::move(generator));
        }

        AutoRegister(const AutoRegister&) = delete;
        AutoRegister& operator=(const AutoRegister&) = delete;
    };

private:
    using GenMapT = std::map<I_Key, Generator, I_Key_Order>;
    static GenMapT& m_generators();
};

inline std::unique_ptr<I> I_Factory::getObject(I_Key key)
{
    auto& gen_map = m_generators();
    auto iter = gen_map.find(key);
    if (iter != gen_map.end())
        return iter->second();
    throw std::invalid_argument("unknown I_Factory key");
}

inline void I_Factory::add(I_Key key, Generator gen)
{
    m_generators().emplace(key, std::move(gen));
}

I_Factory::GenMapT& I_Factory::m_generators()
{
    static GenMapT generators;
    return generators;
}

class X : public I {
public:
    static constexpr I_Key class_key = I_Key::X;
    static const I_Factory::AutoRegister<X> _reg;
};

class Y : public I {
public:
    static constexpr I_Key class_key = I_Key::Y;
    static const I_Factory::AutoRegister<Y> _reg;
};

Обратите внимание, что в дополнение к функции I_Factory::add() я установил второй, часто более простой, способ добавления генератора для класса C: определить объект типа I_Factory::AutoRegister<C>, если { {X3}} является допустимым перечислителем. Если объект является статическим членом класса, добавление произойдет по существу в начале программы. Это будет работать только в том случае, если у класса есть открытый конструктор по умолчанию, поэтому функция add может по-прежнему использоваться, если необходимо что-то другое.

1
aschepler 22 Фев 2018 в 12:14

Вот одна версия с функцией add и map для хранения разных типов.

class Base {
public:
    virtual void doxxx() {...}
};

class X: public Base {
public:
    static int isMe = 1;
};

class Y: public Base {
public:
    static int isMe = 2;
};

class Factory {
public:
    static std::unique_ptr<Base> getObject(int i) {
        if (classID.find(i) != classID.end())
            return classID[i]();

        throw ....
    }

    template <typename C>
    static void add() {
        classID[C::isMe] = [](){ return std::make_unique<C>(); };
    }

    static std::map<int, std::function<std::unique_ptr<Base>()>> classID;
};

// Called like this
Factory::add<X>();
Factory::add<Y>();
0
super 22 Фев 2018 в 12:07

Решение C ++ 14.

Требуемые заголовки:

#include <memory>
#include <iostream>

Класс, который выдается, когда индекс не может быть найден

class ClassNotIndexed{};

Вспомогательный класс, помогающий создать связь между индексом и запрошенным типом:

template< typename ClassType, typename IndexType, IndexType idx >
class ClassIndexer
{};

Основной шаблон для нашего фабричного класса

template <typename... >
class ClassSelector;

Базовый корпус для заводского класса. Когда индекс найден, создайте unique_pointer, иначе выведите исключение:

template<typename BaseClass,
            typename ClassType, typename IndexType, IndexType idx,  
            template<typename,typename,IndexType> typename T>
class ClassSelector<BaseClass, T<ClassType,IndexType, idx>>
{
public:
    constexpr static
    std::unique_ptr<BaseClass> getObject(IndexType i)
    {
        if (i == idx)
            return std::make_unique<ClassType>();
        else
            throw ClassNotIndexed();
    }
};

Шаблон Variadic, который принимает много проиндексированных классов. Если индекс первого класса совпадает, то make_unique_pointer в противном случае проверяет следующий индексированный класс:

template<   typename BaseClass,
            typename ClassType, typename IndexType, IndexType idx,  
            template< typename , typename, IndexType > typename T,
            typename... Ts >
class ClassSelector<BaseClass, T<ClassType,IndexType, idx>, Ts... > : ClassSelector< BaseClass, Ts ... >
{
    using Base = ClassSelector< BaseClass, Ts ... >;

public:
    constexpr static
    std::unique_ptr<BaseClass> getObject(IndexType i)
    {
        if (i == idx)
            return std::make_unique<ClassType>();
        else
            return Base::getObject( i );
    }
};

Примере:

class Base
{
public:
    virtual void doxxx() {}
};

class X : public Base
{
public:
    //static bool isMe( int i ) { return i == 1; }
    void doxxx() override {std::cout << "I'm X !!\n";}
};

class Y : public Base
{
public:
    //static bool isMe( int i ) { return i == 2; }
    void doxxx() override {std::cout << "I'm Y !!\n";}
};


int main()
{
    using Factory = ClassSelector< 
                        Base,
                        ClassIndexer< X, int, 1 >, 
                        ClassIndexer< Y, int, 2 > 
                    >;


    Factory::getObject( 1 )->doxxx();
    Factory::getObject( 2 )->doxxx();

    int choose;

    std::cin >> choose;

    Factory::getObject( choose )->doxxx();

    return 0;
}
0
Robert Andrzejuk 22 Фев 2018 в 15:05

Вы можете просто иметь функцию шаблона:

#include <memory>

class Base {
public:
    virtual void doxxx() { /* ... */ };
};

template<int i>
std::unique_ptr<Base> getObject();
#define REGISTER_CLASS(CLS, ID) \
template<> \
std::unique_ptr<Base> getObject<ID>() { return std::unique_ptr<Base>(new CLS()); }

class X1: public Base {
public:
   // ...
};
REGISTER_CLASS(X1, 1)

class X2: public Base {
public:
    // ...
};
REGISTER_CLASS(X2, 2)

int main()
{
  auto obj1 = getObject<1>();  // Makes X1
  auto obj2 = getObject<2>();  // Makes X2
  return 0;
}

Однако это допускает только значения идентификатора класса, известные во время компиляции.

1
jdehesa 22 Фев 2018 в 12:09