c++ - 检测两个类是否是兄弟

Question

有人可以改进我下面可怕的 are_siblings 实现吗？它只是猜测所有可能的 parent ，然后根据这些 parent 候选者确定这两个类(class)是否是 sibling 。

#include <type_traits>

template <bool...> struct Or;

template <bool First, bool... Rest>
struct Or<First, Rest...> : std::conditional<First,
    std::true_type, Or<Rest...>>::type {};

template <>
struct Or<> : std::false_type {};

template <typename T, typename U, typename... Parents>
struct are_siblings :
    Or<(std::is_base_of<Parents, T>::value && std::is_base_of<Parents, U>::value
    && !std::is_base_of<T,U>::value && !std::is_base_of<U,T>::value)...> {};

// Test
#include <iostream>

struct A {};
struct B : A {};
struct C : A {};
struct D : A, C {};
struct E : B, C {};

int main() {
    std::cout << std::boolalpha << are_siblings<D,E, A,B,C>::value << '\n';  // true
    std::cout << are_siblings<C,D, A,B,E>::value << '\n';  // false
    std::cout << are_siblings<B,E, A,B,E>::value << '\n';  // false
}

如果有一种方法可以在编译时获取类的所有父类，那么我认为这将解决问题。

更新:下面消除了猜测 parent 候选人的需要，但理想情况下是否有一种解决方案不依赖于定义 parents 成员类型的类？

#include <type_traits>
#include <tuple>

template <bool...> struct Or;

template <bool First, bool... Rest>
struct Or<First, Rest...> : std::conditional<First,
    std::true_type, Or<Rest...>>::type {};

template <>
struct Or<> : std::false_type {};

template <typename T, typename U, typename Parents> struct are_siblings_helper;

template <typename T, typename U, template <typename...> class P, typename... Parents>
struct are_siblings_helper<T, U, P<Parents...>> :
    Or<(std::is_base_of<Parents, T>::value && std::is_base_of<Parents, U>::value
    && !std::is_base_of<T,U>::value && !std::is_base_of<U,T>::value)...> {};

template <typename, typename> struct merge;

template <template <typename...> class P, typename... Ts, typename... Us>
struct merge<P<Ts...>, P<Us...>> {
    using type = P<Ts..., Us...>;
};

template <typename T, typename U>
struct are_siblings : are_siblings_helper<T,U,
    typename merge<typename T::parents, typename U::parents>::type> {};

// Test
#include <iostream>

struct A {};

struct B : virtual A {
    using parents = std::tuple<A>;
};

struct C : virtual A {
    using parents = std::tuple<A>;
};

struct D : virtual A, C {
    using parents = std::tuple<A,C>;
};

struct E : virtual B, virtual C {
    using parents = std::tuple<B,C>;
};

int main() {
    std::cout << std::boolalpha << are_siblings<D,E>::value << '\n';  // true
    std::cout << are_siblings<C,D>::value << '\n';  // false
    std::cout << are_siblings<B,E>::value << '\n';  // false
}

进一步更新:如果您有兴趣，可以使用更新后的代码查看该项目的发展方向:
http://ideone.com/UQJ3WZ

std::is_base_of 甚至不再被使用了!这看起来是一个需要完成的重大项目，我将尝试自己完成。

Answer 1

“是否有一种解决方案不依赖于定义 parents 成员类型的类” - 在纯 C++ 中通常没有什么比这更方便的了。 (其他选项相当于记录您的 parents 成员直接添加的相同类型的信息 - 例如，在类型特征中；搜索“C++ introspection library”或“C++ reflection library”如果你想看看人们被黑了)。

有一些工具可以输出抽象语法树表示(例如 clang/llvm)，然后可以由创建 C++ 代码的工具读取/处理，但相对来说很少值得将它们带入您的构建过程....