How Can I Restrict Template Types in C Like Java's `extends` Keyword?

Constraining Template Types in C

In Java, you can restrict a generic class to only accept types that extend a specified base class using the extends keyword. Is there a similar keyword in C for this purpose?

C Equivalent

C does not have a direct equivalent to Java's extends keyword for template constraints. However, C 11 provides alternative mechanisms to achieve a similar effect.

C 11 Approach Using Type Traits

In C 11, you can use the std::is_base_of trait from the header to check if a type is derived from another type. Here's an example:

#include <type_traits>

template<typename T>
class observable_list {
    static_assert(std::is_base_of<list, T>::value, "T must inherit from list");

    // ...
};

This example defines an observable_list template class that only accepts types that inherit from the list class. However, it's important to note that excessively constraining templates can limit their flexibility and may not be ideal in C .

Alternative Approach: Traits-Based Constraints

An alternative approach involves creating custom traits to constrain types based on specific requirements. For instance, you might define a trait for types with specific member functions or typedefs:

struct has_const_iterator {
    template<typename T>
    static bool test(...) { return false; }
};

template<typename T>
struct has_const_iterator<T, Void<typename T::const_iterator>> {
    static bool test(...) { return true; }
};

struct has_begin_end {
    template<typename T>
    static bool test(...) { return false; }

    template<typename T, typename Begin, typename End>
    static auto test(int) -> decltype(std::declval<const T&>().begin(), std::declval<const T&>().end()) { return true; }
};

Using these traits, you can constrain observable_list as follows:

class observable_list {
    static_assert(has_const_iterator<T>::value, "Must have a const_iterator typedef");
    static_assert(has_begin_end<T>::value, "Must have begin and end member functions");

    // ...
};

This approach provides greater flexibility and error feedback by allowing you to define specific constraints based on your requirements.

The above is the detailed content of How Can I Restrict Template Types in C Like Java's `extends` Keyword?. For more information, please follow other related articles on the PHP Chinese website!