How Can CRTP in C Handle Typedefs from Derived Classes for Static Polymorphism?

C Static Polymorphism (CRTP) with Typedefs from Derived Classes

In static polymorphism, also known as compile-time polymorphism, the types of derived classes are known to the base class at compile time. This can be achieved using the curiously recurring template pattern (CRTP). However, you may want to customize the return types of functions based on the derived type.

Consider the following code:

template <typename derived_t>
class base {
public:
    typedef typename derived_t::value_type value_type;
    value_type foo() {
        return static_cast<derived_t*>(this)->foo();
    }
};

template <typename T>
class derived : public base<derived<T>> {
public:
    typedef T value_type;
    value_type foo() {
        return T(); //return some T object (assumes T is default constructable)
    }
};

However, this code may not compile due to the use of the type alias value_type from the derived class within the base class template. The error is that derived is incomplete when used as a template argument to base.

One solution is to employ a traits class template. Here's a modified example:

// Declare a base_traits traits class template:
template <typename derived_t> 
struct base_traits;

// Define the base class that uses the traits:
template <typename derived_t> 
struct base { 
    typedef typename base_traits<derived_t>::value_type value_type;
    value_type base_foo() {
        return base_traits<derived_t>::call_foo(static_cast<derived_t*>(this));
    }
};

// Define the derived class; it can use the traits too:
template <typename T>
struct derived : base<derived<T>> { 
    typedef typename base_traits<derived>::value_type value_type;

    value_type derived_foo() { 
        return value_type(); 
    }
};

// Declare and define a base_traits specialization for derived:
template <typename T> 
struct base_traits<derived<T>> {
    typedef T value_type;

    static value_type call_foo(derived<T>* x) { 
        return x->derived_foo(); 
    }
};

By specializing base_traits for each derived type, you can provide the necessary members (value_type and call_foo) required by the base class template. This allows you to access typedefs and functions from the derived class within the base class template, achieving static polymorphism with customized return types.

The above is the detailed content of How Can CRTP in C Handle Typedefs from Derived Classes for Static Polymorphism?. For more information, please follow other related articles on the PHP Chinese website!