Question

我有一个典型的类型擦除设置：

struct TEBase
{
    virtual ~TEBase() {}
    // ...
};

template <typename T>
struct TEImpl : TEBase
{
    // ...
};

现在的问题是：给定第二个类层次结构，

struct Foo { };
struct Bar : Foo { };

struct Unrelated { };

是否有可能在给定TEBase * p的情况下确定*p的动态类型是否为TEImpl<X>形式，其中，X来自Foo }？换句话说，我想要功能：

template <typename T> bool is_derived_from(TEBase * p);

这样：

is_derived_from<Foo>(new TEImpl<Foo>) == true
is_derived_from<Foo>(new TEImpl<Bar>) == true

is_derived_from<Foo>(new TEImpl<Unrelated>) == false

特别是，我正在寻找一般，非侵入性和高效的解决方案。我找到了两个解决这个问题的方法（下面作为答案发布），但它们都没有解决所有三个标准。

Answer 1

这样的事情：

template <typename Type, typename UnaryPredicate>
void DoPred(UnaryPredicate pred)
{
    if (T * p = dynamic_cast<Derived<T> *>(this))
    { 
        return pred(p->type);
    }
    return false;
}

这不是100％普遍的，因为你不能，例如，说DoPred<int>。更通用的解决方案是将virtual std::type_info type() const { return typeid(...); }成员函数添加到层次结构中，并使用来确定类型是否匹配（标准类型擦除习惯用法）。但是，这两种方法都使用相同类型的RTTI。

澄清之后：

现在，我不认为这可以解决。你所拥有的只是一个TEBase子对象。它可以是TEImpl<Bar>的一部分，也可以是TEImpl<Unrelated>的一部分，但这两种类型都不属于TEImpl<Foo>，这就是您所追求的。

您基本上要求TEImpl<Bar> 从TEImpl<Foo>派生。要做到这一点，如果你明白我的意思，你实际上希望TEImpl<T>从所有TEImpl<std::direct_bases<T>::type>... 继承。这在C ++ 11中是不可能的，但在TR2中是可能的。 GCC已经支持它。这是一个示例实现。（它由于模糊的基础而引起警告，这可以通过更多的工作来避免，但它仍然有用。）

#include <tr2/type_traits>

struct TEBase { virtual ~TEBase() {} };

template <typename T> struct TEImpl;

template <typename TL> struct Derivator;

template <typename TL, bool EmptyTL>
struct DerivatorImpl;

template <typename TL>
struct DerivatorImpl<TL, true>
: TEBase
{ };

template <typename TL>
struct DerivatorImpl<TL, false>
: TEImpl<typename TL::first::type>
, Derivator<typename TL::rest::type>
{ };

template <typename TL>
struct Derivator
: DerivatorImpl<TL, TL::empty::value>
{ };

template <typename T>
struct TEImpl
: Derivator<typename std::tr2::direct_bases<T>::type>
{
};

template <typename T>
bool is(TEBase const * b)
{
  return nullptr != dynamic_cast<TEImpl<T> const *>(b);
}


struct Foo {};
struct Bar : Foo {};
struct Unrelated {};

#include <iostream>
#include <iomanip>

int main()
{
  TEImpl<int> x;
  TEImpl<Unrelated> y;
  TEImpl<Bar> z;
  TEImpl<Foo> c;

  std::cout << std::boolalpha << "int ?< Foo: " << is<Foo>(&x) << "\n";
  std::cout << std::boolalpha << "Unr ?< Foo: " << is<Foo>(&y) << "\n";
  std::cout << std::boolalpha << "Bar ?< Foo: " << is<Foo>(&z) << "\n";
  std::cout << std::boolalpha << "Foo ?< Foo: " << is<Foo>(&c) << "\n";
}

Answer 2

我建议阅读文章Generic Programming:Typelists and Applications。那里安德烈亚历山大夫斯库（Andrei Alexandrescu）设计了一个临时访客的实施，这应该可以解决你的问题。另一个很好的资源是他的书Moder C++ Design，他用蛮力的方式描述了一个使用相同approuch的多分配器（第265页......）。

在我看来，这两个资源比任何可以在这里打印的代码更能理解。

Answer 3

此解决方案涉及滥用异常。如果TEImpl类型只是抛出其数据，is_derived_from可以捕获它正在寻找的类型。

struct TEBase
{
        virtual ~TEBase() {}

        virtual void throw_data() = 0;
};

template <typename T>
struct TEImpl : public TEBase
{
        void throw_data() {
                throw &data;
        }

        T data;
};

template <typename T>
bool is_derived_from(TEBase* p)
{
        try {
                p->throw_data();
        } catch (T*) {
                return true;
        } catch (...) {
                // Do nothing
        }
        return false;
}

此解决方案效果很好。它与任何继承结构完美配合，并且它完全不具有侵入性。

唯一的问题是它根本没有效率。例外并不打算以这种方式使用，我怀疑这个解决方案比其他解决方案慢了几千倍。

Answer 4

此解决方案涉及比较typeid s。 TEImpl知道自己的类型，因此它可以检查传递的typeid与自己的类型。

麻烦的是，这种技术在你添加继承时不起作用，所以我也使用模板元编程来检查类型是否定义了typedef super，在这种情况下它会以递归方式检查其父类类。

struct TEBase
{
        virtual ~TEBase() {}

        virtual bool is_type(const type_info& ti) = 0;
};

template <typename T>
struct TEImpl : public TEBase
{
        bool is_type(const type_info& ti) {
                return is_type_impl<T>(ti);
        }

        template <typename Haystack>
        static bool is_type_impl(const type_info& ti) {
                return is_type_super<Haystack>(ti, nullptr);
        }

        template <typename Haystack>
        static bool is_type_super(const type_info& ti, typename Haystack::super*) {
                if(typeid( Haystack ) == ti) return true;
                return is_type_impl<typename Haystack::super>(ti);
        }

        template <typename Haystack>
        static bool is_type_super(const type_info& ti, ...) {
                return typeid(Haystack) == ti;
        }
};

template <typename T>
bool is_derived_from(TEBase* p)
{
        return p->is_type(typeid( T ));
}

要使用此功能，Bar需要重新定义为：

struct Bar : public Foo
{
        typedef Foo super;
};

这应该是相当有效的，但它显然不是非侵入性的，因为每当使用继承时它在目标类中都需要typedef super。 typedef super也必须是公开访问的，这与许多人认为将typedef super放入您的私人部分的推荐做法背道而驰。

它根本不涉及多重继承。

更新：可以进一步采用此解决方案，使其具有通用性和非侵入性。

使其成为一般

typedef super很棒，因为它是惯用的并且已经在许多类中使用，但它不允许多重继承。为此，我们需要将其替换为可以存储多种类型的类型，例如元组。

如果Bar被重写为：

struct Bar : public Foo, public Baz
{
        typedef tuple<Foo, Baz> supers;
};

我们可以通过向TEImpl添加以下代码来支持这种形式的声明：

template <typename Haystack>
static bool is_type_impl(const type_info& ti) {
        // Redefined to call is_type_supers instead of is_type_super
        return is_type_supers<Haystack>(ti, nullptr);
}

template <typename Haystack>
static bool is_type_supers(const type_info& ti, typename Haystack::supers*) {
        return IsTypeTuple<typename Haystack::supers, tuple_size<typename Haystack::supers>::value>::match(ti);
}

template <typename Haystack>
static bool is_type_supers(const type_info& ti, ...) {
        return is_type_super<Haystack>(ti, nullptr);
}

template <typename Haystack, size_t N>
struct IsTypeTuple
{
        static bool match(const type_info& ti) {
                if(is_type_impl<typename tuple_element< N-1, Haystack >::type>( ti )) return true;
                return IsTypeTuple<Haystack, N-1>::match(ti);
        }
};

template <typename Haystack>
struct IsTypeTuple<Haystack, 0>
{
        static bool match(const type_info& ti) { return false; }
};

使其成为非侵入性的

现在我们有一个高效且通用的解决方案，但它仍然具有侵入性，因此它不支持无法修改的类。

为了支持这一点，我们需要一种方法来从类外部声明对象继承。对于Foo，我们可以这样做：

template <>
struct ClassHierarchy<Bar>
{
        typedef tuple<Foo, Baz> supers;
};

为了支持这种风格，首先我们需要非专业形式的ClassHierarchy，我们将这样定义：

template <typename T> struct ClassHierarchy { typedef bool undefined; };

我们将使用undefined的存在来判断该类是否已被专门化。

现在我们需要为TEImpl添加更多功能。我们仍然会重复使用之前的大部分代码，但现在我们也支持从ClassHierarchy读取类型数据。

template <typename Haystack>
static bool is_type_impl(const type_info& ti) {
        // Redefined to call is_type_external instead of is_type_supers.
        return is_type_external<Haystack>(ti, nullptr);
}

template <typename Haystack>
static bool is_type_external(const type_info& ti, typename ClassHierarchy<Haystack>::undefined*) {
        return is_type_supers<Haystack>(ti, nullptr);
}

template <typename Haystack>
static bool is_type_external(const type_info& ti, ...) {
        return is_type_supers<ClassHierarchy< Haystack >>(ti, nullptr);
}

template <typename Haystack>
struct ActualType
{
        typedef Haystack type;
};

template <typename Haystack>
struct ActualType<ClassHierarchy< Haystack >>
{
        typedef Haystack type;
};

template <typename Haystack>
static bool is_type_super(const type_info& ti, ...) {
        // Redefined to reference ActualType
        return typeid(typename ActualType<Haystack>::type) == ti;
}

现在我们有一个高效，一般和非侵入性的解决方案。

未来的解决方案

此解决方案符合标准，但是必须明确记录类层次结构仍然有点烦人。编译器已经知道关于类层次结构的所有内容，所以我们必须做这项繁重的工作是一种遗憾。

此问题的建议解决方案是N2965: Type traits and base classes，has been implemented in GCC。本文定义了一个direct_bases类，它几乎与我们的ClassHierarchy类相同，除了它唯一的元素type，保证是一个元组，如supers，和该类完全由编译器生成。

所以现在我们必须编写一些样板来实现它，但是如果N2965被接受，我们可以摆脱样板并使TEImpl更短。

特别感谢Kerrek SB和Jan Herrmann。这个答案从他们的评论中吸取了很多灵感。

确定类型擦除类之间的继承关系

4 个答案:

使其成为一般

使其成为非侵入性的

未来的解决方案