Итерация через список типов

Question

Как я могу перебирать список типов без создания экземпляра каждого типа?

В моем примере у меня есть родительский класс с методом getByName, который возвращает экземпляр дочернего класса. Метод getByName полностью разрушен, так как вы не можете создать массив typedefs. Каков наилучший способ сделать эту работу?

Одним из решений является создание массива указателей name, но это будет беспорядочно, если есть несколько переменных (больше, чем просто name), с которыми я хочу проверить.

Я в основном хочу чистое решение, которое использует цикл, а не ряд утверждений if.

#include <string> 

struct Number { 
    Number(const std::string &name) :name(name) {} 

    // fix me! 
    static Number* getByName(const std::string &name) { 
     typedef types[] = { 
      One, 
      Two, 
      Three, 
     } 
     for (int i = 0; i < 3; ++i) { 
      if (name == types[i]::name) 
       return new types[i](); 
     } 
     return nullptr; 
    } 
    const std::string name; 
}; 

struct One :Number { 
    One() :Number(name) {} 
    const static std::string name; 
}; 

struct Two :Number { 
    Two() :Number(name) {} 
    const static std::string name; 
}; 

struct Three :Number { 
    Three() :Number(name) {} 
    const static std::string name; 
}; 

const std::string One::name = "one"; 
const std::string Two::name = "two"; 
const std::string Three::name = "three"; 

Answer 1

Вы не можете хранить типы непосредственно осмысленным образом; Однако, вы можете хранить указатели на заводские функции, которые должны быть одинаково полезны:

#include <iostream> 
#include <string> 
#include <map> 

using namespace std; 

struct Number; 

Number* oneCreator(); 
Number* twoCreator(); 
Number* threeCreator(); 

struct Number { 
    typedef Number* (*creatorFP)(); 
    typedef map<string, creatorFP> CreatorMap; 

    static Number* getByName(const string &name) { 
     // maybe initialise this map somewhere else 
     CreatorMap creators; 
     creators.insert(make_pair(string("one"), &oneCreator)); 
     creators.insert(make_pair(string("two"), &twoCreator)); 
     creators.insert(make_pair(string("three"), &threeCreator)); 

     CreatorMap::iterator creator = creators.find(name); 
     if (creator != creators.end()) { 
      return (*(creator->second))(); 
     } 
     return NULL; 
    } 

    virtual void f() { cout << "NUMBER" << endl; } 
}; 

struct One : Number { 
    virtual void f() { cout << "ONE" << endl; } 
}; 

struct Two : Number { 
    virtual void f() { cout << "TWO" << endl; } 
}; 

struct Three : Number { 
    virtual void f() { cout << "THREE" << endl; } 
}; 

Number* oneCreator() { return new One(); } 
Number* twoCreator() { return new Two(); } 
Number* threeCreator() { return new Three(); } 

int main() { 
    Number *two = Number::getByName(string("two")); 
    two->f(); 
    return 0; 
} 

Answer 2

Вы можете реализовать свой завод, как следовать

template <typename T> 
static std::pair<std::string, std::function<Number*()>> register_helper() 
{ 
    return { T::name, []() { return new T{}; }}; 
} 

static Number* getByName(const std::string &name) { 
    static const std::map<std::string, std::function<Number*()>> factories = { 
     register_helper<One>(), 
     register_helper<Two>(), 
     register_helper<Three>() 
    }; 

    auto it = factories.find(name); 
    if (it == factories.end()) { 
     return nullptr; 
    } else { 
     return it->second(); 
    } 
} 

Live Demo

Answer 3

Пытаясь что-то немного проще, чем предыдущая смол и предполагая, что getByName не вызывается с неподдерживаемым значением, что часто.

template <typename TYPE> 
Number * factory() 
{ 
    return new TYPE(); 
} 

static const std::map<std::string, Number*(*)()> factories = 
{ 
    {One::name, factory<One>}, 
    {Two::name, factory<Two>}, 
    {Three::name, factory<Three>} 
}; 

static Number* getByName(const std::string &name) 
{ 
    try 
    { 
     return factories.at(name)(); 
    } 
    catch (std::out_of_range &e) 
    { 
     // Log factory called with bad name as a hint that the programmer 
     // should check calling code. 
     return nullptr; 
    } 
} 

Но если звонки с плохими именами являются ожидаемым прецедентом, сложный путь намного дешевле, чем обработка исключения.

static Number* getByName(const std::string &name) 
{ 
    auto factory = factories.find(name); 
    if (factory != factories.end()) 
    { 
     return factory->second(); 
    } 
    return nullptr; 
}