How Does This C `is_base_of` Implementation Using CRTP Work?

How does this implementation of the is_base_of trait work?

The snippet of code you provided implements the is_base_of trait in C , which checks if one class inherits from another. It uses a technique called "Curiously Recurring Template Pattern" (CRTP).

How it works

Host is a template class that wraps the derived class and provides a way to access its operator B* function. When we want to check if B is the base class of D, we call is_base_of::value.

1. The check function overloads two functions:

   • static yes check(D*, T)
   • static no check(B*, int)
2. Host can be converted to both D* and B* thanks to user-defined conversion sequences.
3. If B is the base of D, the first check function is called with Host converted to D* and an arbitrary T. The check function returns a yes if the conversion is successful (i.e., D inherits from B).
4. If B is not the base of D, the second check function is called with Host converted to B* and the value of int specified. The check function returns a no if the conversion to B* is successful (i.e., B and D are not related).
5. is_base_of::value is set to true if the check function returns a yes and false otherwise.

Importance of the const keyword in operator B*

The operator B* must be const because otherwise, it would be ambiguous when selecting which check function to call. With the const keyword, the compiler knows to use the check function that takes B* const&.

Why is the first check function better?

The first check function is better because it uses a user-defined conversion sequence that converts from D* to B*. This is more specific than the second check function, which uses a user-defined conversion sequence that converts from B* to int.

The above is the detailed content of How Does This C `is_base_of` Implementation Using CRTP Work?. For more information, please follow other related articles on the PHP Chinese website!