CODEWITHSUNDEEP
c++templatestype-deductiondefault-arguments
Maestro
Maestro

Reputation: 2552

Why c++ allows default template argument that can never be used?

If I have a function template that has default argument for its template parameter and that function takes a non-default parameter of the type parameter then what's the point in the language to allow that default argument that'll never be used? :

template <class T = int>
void foo(T x){cout << x << endl;}

int main()
{

    foo("hi"); // T is char const *
    foo(); // error
}

As you can see T=int can never be used because the function doesn't have a default parameter thus the compiler in this context always deduces the type of T from the argument passed to foo.

Upvotes: 2

Views: 1627

Answers (4)

JaMiT
JaMiT

Reputation: 16869

what's the point in the language to allow [X]?

Better: what would be the point in prohibiting [X]?

There is value in simplicity. I would give the burden of proof to the side that wants to make the language more complicated. The language allows a template parameter to have a default value. The language allows a template parameter to be deduced when the function is directly invoked. It is simpler to allow these to co-exist than to add a prohibition against using both. Hence I would ask why prohibit, rather than ask why allow. If there is no compelling reason for the complication, then stick to simple. Being allowed to do something does not force one to do it. And maybe someone (like StoryTeller and Dani) will find a use for that something.

Of course, simplicity is not the ultimate criterion. If harm would come from [X], then that would likely outweigh simplicity concerns. Complications can be justified. However, complications should not be introduced just because something seems useless.

On the other hand, one could reasonably ask if [X] can be put to use. And maybe that was the real question, even if the OP did not realize it. Still, I thought I would put up one answer addressing the question-as-phrased.

Upvotes: 0

Lily
Lily

Reputation: 1397

Another example:

#include <typeinfo>
#include <iostream>
using namespace std;

template <class T = int>
void coutType() {
    cout << typeid(T).name() << endl;
}

int main() {
    // default
    coutType();
    // non-default
    coutType<double>();
}

Output with Clang++

int
double

Upvotes: 2

Daniel
Daniel

Reputation: 31579

Although default parameters are usually used for non deduced parameters, taking the address of the function (&foo) uses them too.

Upvotes: 3

StoryTeller - Unslander Monica
StoryTeller - Unslander Monica

Reputation: 170065

But it can be used. Here's an example.

auto* foo_ptr = &foo<>; // The default template argument is used.

A function call expression is not the only context where a function template's arguments need to be figured out.

Upvotes: 7

Related Questions