Question

我在项目中开发了某种元对象机制，以便将类型名称和任何类型的属性关联到对象（请参阅结果here）。我有一个脏代码工作，我试图让它更清洁。鉴于以下虚拟结构：

struct A
{
    using Self = A;
    using Base = void;

    static std::string get_type_name(){ return { "A" }; }

    static std::vector<int> get_properties(){ return { 0 }; }
};

#define SELF(class_name)\
    using Base = Self;\
    using Self = class_name;

struct AA : A
{
    SELF(AA)

    static std::string get_type_name() { return { "AA" }; }
};

struct AAA : AA
{
    SELF(AAA)

    static std::string get_type_name(){ return { "AAA" }; }

    static std::vector<int> get_properties(){ return { 2, 1 }; }
};

我最终得到了这个代码来获取整个层次结构中对象的类型名称：

// when the type has no Base member:
template<
    typename T,
    typename std::enable_if<std::is_same<typename T::Base, void>::value>::type* = nullptr
>
typename std::vector<decltype(T::Self::get_type_name())> get_type_names()
{
    return { T::Self::get_type_name() };
}

// when the type has a Base member:
template<
    typename T,
    typename std::enable_if<!std::is_same<typename T::Base, void>::value>::type* = nullptr
>
typename std::vector<decltype(T::Self::get_type_name())> get_type_names()
{
    auto data = get_type_names<typename T::Base>();
    data.insert(data.begin(), T::Self::get_type_name());
    return data;
}

属性类似：

template<
    typename T,
    typename std::enable_if<std::is_same<typename T::Base, void>::value>::type* = nullptr
>
decltype(T::Self::get_properties()) get_properties()
{
    return { T::Self::get_properties() };
}

template<
    typename T,
    typename std::enable_if<!std::is_same<typename T::Base, void>::value>::type* = nullptr
>
decltype(T::Self::get_properties()) get_properties()
{
    auto data = get_properties<typename T::Base>();
    auto self_data = T::Self::get_properties();
    data.insert(data.begin(), self_data.begin(), self_data.end());
    return data;
}

使用此代码段测试代码时：

template<typename T>
void print()
{
    std::cout << T::get_type_name() << std::endl << "\thas types:" << std::endl;
    for(auto type_name : get_type_names<T>())
    {
        std::cout << "\t\t" << type_name << std::endl;
    }
    std::cout << "\thas properties:" << std::endl;
    for(auto property : get_properties<T>())
    {
        std::cout << "\t\t" << property << std::endl;
    }
}

int main()
{
    print<A>();
    print<AA>();
    print<AAA>();

    return 0;
}

我得到以下输出：

A
    has types:
        A
    has properties:
        0
AA
    has types:
        AA
        A
    has properties:
        0
        0
AAA
    has types:
        AAA
        AA
        A
    has properties:
        2
        1
        0
        0

第一个原型适用于名称，但只要声明一个没有属性的对象，就会复制其基础的对象。有人看到了解决问题的简单方法吗？

奖金问题：元函数的实现非常相似，是否有人提示我如何分解代码？

可以使用完整的实时示例here

Answer 1

这是一个不完整的解决方案，可以帮助您走上正轨。首先，一切都依赖于走基地列表。因此，让它成为它自己的元函数：

template <class... > struct typelist { };

template <class T, class... Bases>
struct get_bases
    : get_bases<typename T::Base, Bases..., T>
{ };

template <class... Bases>
struct get_bases<void, Bases...>
{
    using type = typelist<Bases...>;
};

template <class T>
using get_bases_t = typename get_bases<T>::type;

现在，get_bases_t<A>为typelist<A>，get_bases_t<AAA>为typelist<AAA, AA, A>。现在，你所有的其他功能都只是基于走下那个类型列表并为它做些什么。因此，让我们添加一种简单的方法：

template <class T> struct tag { using type = T; };

template <class... Ts>
auto for_each(typelist<Ts...>) {
    return [](auto&& f){
        using swallow = int[];
        (void)swallow{0,
            (void(f(tag<Ts>{})), 0)...
        };
    };
}

现在，获取所有属性是将所有基础转换为相应的get_properties()函数，然后调用所有唯一函数。您可以在编译时挑选出独特的函数，但这也有效：

template <class T>
std::vector<int> get_properties() {
    using bases = get_bases_t<T>;

    using F = std::vector<int>(*)();
    F last = nullptr;
    std::vector<int> props;

    for_each(bases{})([&](auto t){
        using B = typename decltype(t)::type;
        F cur = B::get_properties;
        if (cur != last) {
            auto next = cur();
            props.insert(props.end(), next.begin(), next.end());
            last = cur;
        }
    });

    return props;
}

这种方法对于获取类型名称非常简单：

template <class T>
std::vector<std::string> get_type_names()
{
    using bases = get_bases_t<T>;

    std::vector<std::string> names;
    names.reserve(len_v<bases>); // TODO

    for_each(bases{})([&](auto t){
        names.push_back(decltype(t)::get_type_name());
    });

    return names;
}

或者，在这种情况下，简单地说：

template <class... Bs>
std::vector<std::string> get_type_names_impl(typelist<Bs...>) {
    return {Bs::get_type_name()...};
}


template <class T>
std::vector<std::string> get_type_names()
{
    return get_type_names_impl(get_bases_t<T>);
}

元对象使用＆＃34;静态虚拟＆＃34;函数

1 个答案: