mentalmushroom - 11 months ago 91

C++ Question

I've been trying to understand the way C++ selects templates. Namely, consider the following code sample:

`template <typename R>`

class Curious

{

public:

template <typename T, typename std::enable_if<std::is_const<T>::value, int>::type = 33>

void test1() {}

template <typename T, typename std::enable_if<!std::is_const<T>::value, int>::type = 33>

void test1() {}

template <typename T, typename = typename std::enable_if<std::is_const<T>::value>::type>

void test2() {}

template <typename T, typename = typename std::enable_if<!std::is_const<T>::value>::type>

void test2() {}

template <typename std::enable_if<std::is_const<R>::value>::type * = nullptr>

void test3() {}

template <typename std::enable_if<!std::is_const<R>::value>::type * = nullptr>

void test3() {}

// works

template <typename T = void>

typename std::enable_if<std::is_const<R>::value, T>::type test4() {}

template <typename T = void>

typename std::enable_if<!std::is_const<R>::value, T>::type test4() {}

// also works

template <typename T = void, typename std::enable_if<std::is_const<R>::value, T>::type * = nullptr>

void test5() {}

template <typename T = void, typename std::enable_if<!std::is_const<R>::value, T>::type * = nullptr>

void test5() {}

}; // Curious

The first two functions (test1) work fine (

`Curious<int> curious;`

curious.test1<int>();

curious.test1<const int>();

While the rest of them cause compilation errors.

Regarding the function test2 the compiler claims I'm trying to create a duplicate:

error C2535: 'void Curious::test2(void)': member function already defined or declared

Here the documentation says:

A common mistake is to declare two function templates that differ only

in their default template arguments. This is illegal because default

template arguments are not part of function template's signature, and

declaring two different function templates with the same signature is

illegal.

So it seems to be the case. However, I don't see that much difference from the first two functions, which also have the default template argument. Thus we have a default type (test2 - doesn't work) against a default value (test1 - works). Is there any rule about it?

In case of test3:

error C2039: 'type': is not a member of 'std::enable_if'

Like in the first case this time the member function template has a default non-type parameter, but it depends on the class template parameter. Now SFINAE doesn't skip the wrong one (also not sure why).

In the fourth case SFINAE resolves the template by the return type. But don't these test4 functions have identical signature? As they differ only in the return type.

As far as I understand, in the fifth case adding extra parameter makes test5 signature dependent on the function template parameter, therefore SFINAE kicks in and resolution works.

I'm quite confused about how C++ deals with these templates. Could somebody be so kind to clear these things up?

Answer Source

With default value removed, for test1, you have:

`template <typename T, typename std::enable_if<std::is_const<T>::value, int>::type> void test1(); template <typename T, typename std::enable_if<!std::is_const<T>::value, int>::type> void test1();`

Which have clearly different signatures.

For test2:

`template <typename T, typename> void test2(); template <typename T, typename> void test2();`

Which are clearly identical signatures.

For test3, SFINAE doesn't apply as you have hard error as

`R`

is fixed in the class and your`enable_if`

doesn't depend of template parameter of the function.