When Does Pointer Decay Override Template Deduction in C Overload Resolution?

Ambiguity in Overload Resolution: Pointer Decay vs. Template Deduction

In C , when overloaded functions are available, determining which one to call can be ambiguous. One such case involves pointer decay taking precedence over a deduced template.

Root of the Ambiguity

Consider a function that prints the length of a string:

template <size_t N>
void foo(const char (&s)[N]) {
    std::cout << "array, size=" << N - 1 << std::endl;
}

foo("hello") // prints array, size=5

To support non-arrays, an additional overload is added:

void foo(const char* s) {
    std::cout << "raw, size=" << strlen(s) << std::endl;
}

Unexpectedly, the first overload no longer gets called:

foo("hello") // now prints raw, size=5

Pointer Decay vs. Template Deduction

The ambiguity arises because an array is essentially a pointer to its first element. Pointer decay automatically converts an array to a pointer when passing it as an argument. However, template deduction would result in an exact match with the first overload.

According to the C standard, overload resolution prioritizes functions that are not specializations of a function template (except in certain cases). In this instance, the array-to-pointer conversion is an Lvalue Transformation with lower priority than template deduction.

Breaking the Ambiguity

One way to resolve the ambiguity is to define the second overload as a function template as well, enabling partial ordering:

template <typename T>
auto foo(T s)
    -> std::enable_if_t<std::is_convertible<T, char const*>{}>
{
    std::cout << "raw, size=" << std::strlen(s) << std::endl;
}

By specifying the type constraint, the compiler can deduce that the first overload should be used for arrays, while the second overload handles non-arrays.

In summary, while pointer decay offers a shortcut for accessing the first element of an array, it can lead to unexpected ambiguity in overload resolution when templates are involved. Careful consideration of function overloads and thoughtful use of type constraints are key to avoiding such pitfalls.

The above is the detailed content of When Does Pointer Decay Override Template Deduction in C Overload Resolution?. For more information, please follow other related articles on the PHP Chinese website!