How does `is_base_of` work?

by

If they are related

Let’s for a moment assume that B is actually a base of D. Then for the call to check, both versions are viable because Host can be converted to D* and B*. It’s a user defined conversion sequence as described by 13.3.3.1.2 from Host<B, D> to D* and B* respectively. For finding conversion functions that can convert the class, the following candidate functions are synthesized for the first check function according to 13.3.1.5/1

D* (Host<B, D>&)

The first conversion function isn’t a candidate, because B* can’t be converted to D*.

For the second function, the following candidates exist:

B* (Host<B, D> const&)
D* (Host<B, D>&)

Those are the two conversion function candidates that take the host object. The first takes it by const reference, and the second doesn’t. Thus the second is a better match for the non-const *this object (the implied object argument) by 13.3.3.2/3b1sb4 and is used to convert to B* for the second check function.

If you would remove the const, we would have the following candidates

B* (Host<B, D>&)
D* (Host<B, D>&)

This would mean that we can’t select by constness anymore. In an ordinary overload resolution scenario, the call would now be ambiguous because normally the return type won’t participate in overload resolution. For conversion functions, however, there is a backdoor. If two conversion functions are equally good, then the return type of them decides who is best according to 13.3.3/1. Thus, if you would remove the const, then the first would be taken, because B* converts better to B* than D* to B*.

Now what user defined conversion sequence is better? The one for the second or the first check function? The rule is that user defined conversion sequences can only be compared if they use the same conversion function or constructor according to 13.3.3.2/3b2. This is exactly the case here: Both use the second conversion function. Notice that thus the const is important because it forces the compiler to take the second conversion function.

Since we can compare them – which one is better? The rule is that the better conversion from the return type of the conversion function to the destination type wins (again by 13.3.3.2/3b2). In this case, D* converts better to D* than to B*. Thus the first function is selected and we recognize the inheritance!

Notice that since we never needed to actually convert to a base class, we can thereby recognize private inheritance because whether we can convert from a D* to a B* isn’t dependent on the form of inheritance according to 4.10/3

If they are not related

Now let’s assume they are not related by inheritance. Thus for the first function we have the following candidates

D* (Host<B, D>&)

And for the second we now have another set

B* (Host<B, D> const&)

Since we cannot convert D* to B* if we haven’t got a inheritance relationship, we now have no common conversion function among the two user defined conversion sequences! Thus, we would be ambiguous if not for the fact that the first function is a template. Templates are second choice when there is a non-template function that is equally good according to 13.3.3/1. Thus, we select the non-template function (second one) and we recognize that there is no inheritance between B and D!

More Related Contents:

  1. What do compilers do with compile-time branching?
  2. Check if a variable type is iterable?
  3. SFINAE works differently in cases of type and non-type template parameters
  4. Disambiguate overloaded member function pointer being passed as template parameter
  5. C++ template functions overload resolution
  6. Why is it not possible to overload class templates?
  7. C++ overloaded function as template argument
  8. How to write `is_complete` template?
  9. C++11 is_same type trait for templates
  10. Implicit conversion when overloading operators for template classes
  11. How to tell if template type is an instance of a template class?
  12. Why does overload of template and non-template function with the “same signature” call the non-template function?
  13. Check if a type is passed in variadic template parameter pack
  14. How to test whether class B is derived from template family of classes
  15. How to tell if a type is an instance of a specific template class?
  16. Why do i have a random result on this template?
  17. Why do I get “unresolved external symbol” errors when using templates? [duplicate]
  18. What does it mean to “ODR-use” something?
  19. Passing a string literal as a type argument to a class template
  20. C++ Virtual template method
  21. constexpr overloading
  22. Doing a static_assert that a template type is another template
  23. String literals not allowed as non type template parameters
  24. Forwarding all constructors in C++0x
  25. How to check for the type of a template parameter?
  26. mixing templates with polymorphism
  27. Why is the STL so heavily based on templates instead of inheritance?
  28. calculating factorial using template meta-programming
  29. Templates: template function not playing well with class’s template member function [duplicate]
  30. Can I use the result of a C++17 captureless lambda constexpr conversion operator as a function pointer template non-type argument?

Leave a Comment