Defining inheritance relationships between types of erasable classes

Question

I have a typical erase setting:

struct TEBase { virtual ~TEBase() {} // ... }; template <typename T> struct TEImpl : TEBase { // ... }; 

Now the question is: given such a hierarchy of the second class,

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

is it possible, if a TEBase * p , to determine whether the dynamic type *p form TEImpl<X> , where X comes from Foo ? In other words, I want a function:

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

such that:

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

In particular, I am looking for a solution that is general, non-intrusive and effective. I found two solutions to this problem (posted below as answers), but none of them solves all three criteria.

Answer 1

This solution involves comparing typeid s. TEImpl knows its own type, so it can check the passed typeid on its own.

The problem is that this method does not work when you add inheritance, so I also use template metaprogramming to check if typedef super exists, in which case it will recursively check its parent class.

 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 )); } 

For this, Bar must be redefined as:

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

This should be efficient enough, but it’s obvious that it’s not intrusive, since typedef super is required in the target class whenever inheritance is used. typedef super should also be publicly available, which contradicts what many consider the recommended practice of placing your typedef super in your private section.

It also has nothing to do with multiple inheritance at all.

Update: This decision can be made to make it general and non-intrusive.

Make it shared

typedef super excellent because it is idiomatic and already used in many classes, but does not allow multiple inheritance. To do this, we will need to replace it with a type that can store several types, for example, a tuple.

If Bar was rewritten as:

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

we could support this form of declaration by adding the following code to 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; } }; 

Make it non-intrusive

Now we have a solution, effective and general, but it is still intrusive, so it will not support classes that cannot be changed.

To support this, we need a way to declare the inheritance of objects from outside the class. For Foo we could do something like this:

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

To maintain this style, we first need a non-specialized form of ClassHierarchy, which we define as follows:

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

We will use the presence of undefined to determine if this class was specialized.

Now we need to add some more functions to TEImpl. We will continue to use most of the code before, but now we will also support reading type data from 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; } 

And now we have a solution that is effective, general and non-intrusive.

Future decision

This solution satisfies the criteria, but still a little annoying to need to document the class hierarchy explicitly. The compiler already knows everything about the class hierarchy, so it’s a shame that we should do this work.

Proposed solution to this problem: N2965: Type and base classes that were implemented in GCC . This document defines the direct_bases class, which is almost identical to our ClassHierarchy class, except that its only type element is guaranteed to be a tuple, such as supers , and the class is fully generated by the compiler.

So, now we need to write a small template to make it work, but if N2965 is accepted, we can get rid of the template and make TEImpl much shorter.

Special thanks to S. Kerrek and Jan Herrmann. This answer inspired their comments.

Answer 2

Something like that:

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

This is not 100% universal, as you cannot, for example, say DoPred<int> . A more universal solution would be to add a function virtual std::type_info type() const { return typeid(...); } virtual std::type_info type() const { return typeid(...); } member into the hierarchy and would use this to determine if the type matches (the idiom of erasing the standard type). However, both approaches use the same type of RTTI.

---

After clarification:

Right now, I don’t think it can be solved. All you have is a TEBase subobject. It can be part of TEImpl<Bar> or part of TEImpl<Unrelated> , but none of these types are associated with TEImpl<Foo> , and this is what you need.

Essentially, you ask that TEImpl<Bar> comes from TEImpl<Foo> . To do this, you would like TEImpl<T> inherit from all TEImpl<std::direct_bases<T>::type>... if you understand what I mean. This is not possible in C ++ 11, but it is possible in TR2. GCC already supports it. Here is an example implementation. (This causes a warning due to ambiguous reasons, which can be avoided when working, but nonetheless it works.)

 #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 3

I would suggest reading the article General Programming: Lists and Applications . There, Andrei Alexandrescu describes the implementation of a special visitor who should solve your problem. Another good resource would be his book Moder C ++ Design , where he describes a multi-dispatcher in Brute Force mode, which uses the same approach (pages 265 ...).

In my opinion, these 2 resources are better for understanding than any code that can be printed here.

Answer 4

This decision involves several abuses. If the TEImpl type just throws its data, is_derived_from can catch the type it is looking for.

 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; } 

This solution works great. It works great with any inheritance structure, and it is completely not intrusive.

The only problem is that it is ineffective at all. Exceptions are not intended to be used in this way, and I suspect that this solution is thousands of times slower than other solutions.