Статический хеш или switch-case/if-else для выбора

void parseByType(const QString &data, const QString &type)
{
    if(type == "integer")
    {
        IntegerHandler handler(data);
        handler->parse();
    }
    else if(type == "boolean")
    {
        BooleanHandler handler(data);
        handler->parse();
    }
    else if(type == "string")
    {
        StringHandler handler(data);
        handler->parse();
    }
    else
    {
        // ошибка
    }
}

template<typename T>
BaseHandler* createHandler(const QString &data)
{
    return new T(data);
}
 
static const QHash<QString, BaseHandler* (*)(const QString&)> handlers = {
    {"integer", createHandler<IntegerHandler>},
    {"boolean", createHandler<BooleanHandler>},
    {"string", createHandler<StringHandler>},
};
 
void parseByType(const QString &data, const QString &type)
{
    BaseHandler *handler = handlers.at(type, nullptr);
    if(handler == nullptr)
    {
        // ошибка
    }
    else 
    {
        handler(data);
        handler->parse(); // виртуальный метод
    }
}

#include <iostream>
#include <map>
#include <memory>
#include <stdexcept>
 
struct Parser
{
    virtual ~Parser() = default;
    virtual void parse(const char *) const = 0;
};
 
struct IntParser : Parser
{
    void parse(const char *) const override { std::cout << "int\n"; }
};
 
struct BoolParser : Parser
{
    void parse(const char *) const override { std::cout << "bool\n"; }
};
 
struct StrParser : Parser
{
    void parse(const char *) const override { std::cout << "string\n"; }
};
 
class Processor
{
public:
    Processor() : m_parserMapping()
    {
        // there's no way to init unique_ptr in map from initializer list
        m_parserMapping["int"]      = std::make_unique<IntParser>();
        m_parserMapping["bool"]     = std::make_unique<BoolParser>();
        m_parserMapping["string"]   = std::make_unique<StrParser>();
    }
    void process(const std::string &str) const
    {
        auto cit = m_parserMapping.find(str);
        if (cit == m_parserMapping.end())
            throw std::logic_error("Unknown type");
        cit->second->parse(str.c_str());
    }
protected:
    std::map<std::string, std::unique_ptr<Parser>> m_parserMapping;
};
 
int main()
{
    Processor p;
    for (const auto &str : {"int", "bool", "string"})
        p.process(str);
}