如何在C++中简化这个"变量作为模板参数"？

Question

我该如何简化此代码？

mfer::i_value* make_empty_value(mfer::tag tag_)
{
    if (tag_ == mfer::tag::mwf_ble) {
        return memory_manager::instance().add(new mfer::t_value<mfer::tag::mwf_ble>());
    } else if (tag_ == mfer::tag::mwf_chn) {
        return memory_manager::instance().add(new mfer::t_value<mfer::tag::mwf_chn>());
    } else if (tag_ == mfer::tag::mwf_blk) {
        return memory_manager::instance().add(new mfer::t_value<mfer::tag::mwf_blk>());
    } else if (tag_ == mfer::tag::mwf_seq) {
        return memory_manager::instance().add(new mfer::t_value<mfer::tag::mwf_seq>());
    } else if (tag_ == mfer::tag::mwf_man) {
        return memory_manager::instance().add(new mfer::t_value<mfer::tag::mwf_man>());
    } else if (tag_ == mfer::tag::mwf_ivl) {
        return memory_manager::instance().add(new mfer::t_value<mfer::tag::mwf_ivl>());
    } else if (tag_ == mfer::tag::mwf_sen) {
        return memory_manager::instance().add(new mfer::t_value<mfer::tag::mwf_sen>());
    } else if (tag_ == mfer::tag::mwf_wfm) {
        return memory_manager::instance().add(new mfer::t_value<mfer::tag::mwf_wfm>());
    } else if (tag_ == mfer::tag::mwf_pre) {
        return memory_manager::instance().add(new mfer::t_value<mfer::tag::mwf_pre>());
    } else if (tag_ == mfer::tag::mwf_off) {
        return memory_manager::instance().add(new mfer::t_value<mfer::tag::mwf_off>());
    } else if (tag_ == mfer::tag::mwf_nul) {
        return memory_manager::instance().add(new mfer::t_value<mfer::tag::mwf_nul>());
    } else if (tag_ == mfer::tag::mwf_pnt) {
        return memory_manager::instance().add(new mfer::t_value<mfer::tag::mwf_pnt>());
    } else if (tag_ == mfer::tag::mwf_nte) {
        return memory_manager::instance().add(new mfer::t_value<mfer::tag::mwf_nte>());
    } else if (tag_ == mfer::tag::mwf_txc) {
        return memory_manager::instance().add(new mfer::t_value<mfer::tag::mwf_txc>());
    } else if (tag_ == mfer::tag::mwf_flt) {
        return memory_manager::instance().add(new mfer::t_value<mfer::tag::mwf_flt>());
    } else if (tag_ == mfer::tag::mwf_skw) {
        return memory_manager::instance().add(new mfer::t_value<mfer::tag::mwf_skw>());
    } else if (tag_ == mfer::tag::mwf_mss) {
        return memory_manager::instance().add(new mfer::t_value<mfer::tag::mwf_mss>());
    } else if (tag_ == mfer::tag::mwf_pnm) {
        return memory_manager::instance().add(new mfer::t_value<mfer::tag::mwf_pnm>());
    } else if (tag_ == mfer::tag::mwf_pid) {
        return memory_manager::instance().add(new mfer::t_value<mfer::tag::mwf_pid>());
    }

    return nullptr;
}

简要说明,

• mfer :: tag是枚举,enum tag {};在名称空间mfer中定义.

• mfer :: i_value是抽象类.

  class i_value {};
  

• mfer :: t_value是模板类,

  template <mfer::tag tag_type>
  class t_value : public i_value {};
  

此刻,我不知道如何简化this make_empty_value().

理想情况下,我想这样做:

mfer::i_value* make_empty_value(mfer::tag tag_)
{
    return memory_manager::instance().add(new mfer::t_value<tag_>());
}

但我知道它是模板,所以上面没有意义.

有没有想法简化这段代码？(一些现代C++特性,Boost库等)

Answer 1

通过一些模板工作，我们可以将工厂函数简化为：

i_value* make_empty_value(tag tag_type)
{
    static constexpr auto factory = make_factory(all_tags());

    auto index = std::size_t(tag_type - tag::first);
    if (index < tag::ntags) {
        return memory_manager::instance().add(factory[index]());
    }
    else {
        return nullptr;
    }
}

完整代码如下。

i_value 生成器映射是在编译时构建的，允许常量时间查找。

限制：

• 枚举中的值必须是连续的，但它们不必从零开始。

• 该演示需要 c++14。它可以轻松地适应 c++11。对于 c++03，我们希望联系 boost mpl 或 boost_pp。

完整的工作示例：

#include <array>
#include <utility>
#include <deque>
#include <iostream>

// minimal implementation of virtual base
class i_value {
public:
    virtual void prove() const = 0;
    virtual ~i_value() = default;
};

// tag enum - note that we have supplied some extra introspection information
// these could just as well be constexpr integers outside the enum
enum tag
{
    ble,
    chn,
    blk,
    seq,

    first = ble,                // first available tag
    last = seq,             // last available tag
    ntags = last-first      // number of tags
};

/// Function to offset an index sequence by the distance from
/// zero to the first available tag - in case the first tag is not zero
template<std::size_t...tags>
constexpr auto tag_offset(std::index_sequence<tags...>)
{
    return std::index_sequence<(tags + tag::first)...>();
}

/// Function to compute an index sequence of all valid tags
constexpr auto all_tags()
{
    return tag_offset(std::make_index_sequence<std::size_t(ntags)>());
}

/// Factory function to generate a derived class for a given tag
template <tag tag_type>
class t_value : public i_value {
    void prove() const override { void(std::cout << "I have tag " << tag_type << std::endl); }
    ~t_value() { void(std::cout << "tag " << tag_type << " destroyed" << std::endl); }
};

template<tag tag_type>
i_value* make_instance()
{
    return new t_value<tag_type>();
}


/// Function to generate a 'factory' - an array of factory functions, one for
/// each tag in the variadic template argument tags...
/// Note that the array is zero-based, the tags may not be. All we care about
/// here is the size of the list of tags (and their values)
///
template<std::size_t...tags>
constexpr auto make_factory(std::index_sequence<tags...>)
{
    return std::array<i_value* (*)(), sizeof...(tags)>
    {
        &make_instance<static_cast<tag>(tags)>...
    };
}

// minimal memory manager
struct memory_manager {
    struct impl {
        i_value* add(i_value* item) {
            _ivalues.push_back(item);
            return item;
        };
        ~impl() {
            for (auto i = _ivalues.rbegin() ; i != _ivalues.rend() ; ++i) {
                delete *i;
            }
        }
        std::deque<i_value*> _ivalues;
    };
    static impl& instance()
    {
        static impl _instance = {};
        return _instance;
    }
};

// here is resulting factory function.
i_value* make_empty_value(tag tag_type)
{
    static constexpr auto factory = make_factory(all_tags());

    auto index = std::size_t(tag_type - tag::first);
    if (index < tag::ntags) {
        return memory_manager::instance().add(factory[index]());
    }
    else {
        return nullptr;
    }
}

// test
int main()
{
    for(auto tag_type : { tag::ble, tag::chn })
    {
        auto pvalue = make_empty_value(tag_type);
        pvalue->prove();
    }
}

预期输出：

I have tag 0
I have tag 1
tag 1 destroyed
tag 0 destroyed