How does Expression SFINAE (Substitution Failure Is Not An Error) work in C and how can it be used to define traits and conditionally apply function overloads?

Understanding Expression SFINAE

In the context of C programming, Expression SFINAE (Substitution Failure Is Not An Error) allows you to conditionally apply function overloads based on the validity of an expression within the function declaration.

Expression SFINAE in Action

Consider the following code examples:

Example 1:

template <int I> struct A {};

char xxx(int);
char xxx(float);

template <class T> A<sizeof(xxx((T)0))> f(T) {}

The f() function returns a struct A with a parameter I set to the size of the result of calling xxx() with the casted value of the template parameter T to (T)0.

Example 2:

struct X {};
struct Y { Y(X) {} };

template <class T> auto f(T t1, T t2) -> decltype(t1 + t2); // #1
X f(Y, Y); // #2

X x1, x2;
X x3 = f(x1, x2); // deduction fails on #1 (cannot add X+X), calls #2

In example 2, the f() function overloads allow for both addition of numerical types (#1) and construction of Y from X (#2). When the f() function is called with x1 and x2 (which are X objects), the overload that constructs Y is selected because the first overload is invalid for X objects.

Common Use Case: Trait Definition

Expression SFINAE is commonly used in trait definition, where it allows you to define traits based on the existence of specific member functions in a class. For example:

struct has_member_begin_test {
  template <class U> static auto test(U* p) -> decltype(p->begin(), std::true_type());
  template <class> static auto test(...) -> std::false_type;
};

template <class T> struct has_member_begin
  : decltype(has_member_begin_test::test<T>(0)) {};

The has_member_begin struct template can be used to check if a class has a begin() member function. It uses Expression SFINAE to determine if the begin() expression returns a valid type or expression, and returns std::true_type if valid, otherwise std::false_type.

Important Note:

Expression SFINAE is a relatively recent addition to the C language, and not all compilers fully support it. If you encounter any issues with Expression SFINAE in your code, it is important to verify that your compiler version supports it.

The above is the detailed content of How does Expression SFINAE (Substitution Failure Is Not An Error) work in C and how can it be used to define traits and conditionally apply function overloads?. For more information, please follow other related articles on the PHP Chinese website!