19

In the following code why does the explicit expansion of template function foo fail to compile, yet the expansion of bar compiles successfully ? Live link - https://godbolt.org/z/o8Ea49KEb

template <typename T1, typename T2>
T1 foo(T2) { T2(42); return T1{}; };

template <typename T1, typename T2>
T1 bar(void) { T2(42); return T1{}; };

int main()
{
    foo<int, void>();    // fails

    bar<int, void>();    // works
}

Note that the template parameter T2 is used in the body of both functions and the only difference is that the function parameter to bar has been manually substituted.

This question was inspired after reading std::conditional - Invalid parameter type ‘void’ even when testing for 'void' and trying to simplify the issue.

Richard Critten
  • 2,138
  • 3
  • 13
  • 16
  • 7
    `T1 bar(void)` that's an archaic form for `T1 bar()` and it doesn't really accepts any arguments. `T1 foo(T2)` requires to accept an argument - but there is no such thing as accepting a `void` for an argument. – ALX23z May 26 '22 at 11:58
  • Since there is no **function** partial template specialization (*sad panda*), you could `template T1 foo() { return T1{}; };` and `foo();`, and omit the `void` entirely. As a workaround. – Eljay May 26 '22 at 12:18

2 Answers2

24

The rule saying a parameter list (void) is the same as the empty parameter list () is found in C++ Standard [dcl.fct]/4:

A parameter list consisting of a single unnamed parameter of non-dependent type void is equivalent to an empty parameter list. Except for this special case, a parameter shall not have type cv void.

The important piece for this question is "non-dependent type". The template parameter T is type-dependent, so it doesn't trigger the rule.

I presume the Standard has this rule because it would also be quite confusing (I'd say worse) if a template function which normally takes one parameter could suddenly become a zero-parameter function if an instantiation happens to make that parameter type void. With this rule, we know when a template is declared with a parameter, it really has one parameter.

aschepler
  • 70,891
  • 9
  • 107
  • 161
  • I'd say the only reason why `int foo(void)` is valid at all is to be compatible with some old C-style code. – ALX23z May 26 '22 at 13:05
  • 7
    @ALX23z `int foo(void);` is not an old C style - it's recommended in modern C, since `int foo();` is not a prototype and allows for any number of parameters and/or arguments without consistency checks. But yes, that's the reason it's allowed in C++. – aschepler May 26 '22 at 13:07
5

Consider the following:

template<typename T>
void foo(T) {}

void bar(void) {}

You are assuming foo<void> and bar(void) are equivalent, but they are not. foo<T> always requires an argument. So foo<void> is equivalent to a function baz(void x). This does not compile, as you cannot have a value of type void. That is the same error message you got.

In the function signature void bar(void) the void in brackets signifies something different: a function without arguments. This is a remnant of C and not recommended.

The functions bar<void>(T) and baz(void x) cannot exists, because they both require a value of type void, which cannot exist.

The solution with template functions is to provide overloads or specialisations for cases where a template instantiation would be illegal.

template<typename T>
void foo(T) {} // one argument

void foo() {}  // no arguments -> different signatures -> overload

template<typename T> 
void bar() {}  // no arguments

template<>
void bar<void> {} // still no arguments -> same signature -> specialisation
sudosandwich
  • 59
  • 2