Why are default template arguments only allowed on class templates?

In C++, default template parameters are a very useful feature that allows developers to provide default values for template parameters when defining templates. This mechanism simplifies template usage, enabling developers to instantiate templates without specifying all template parameters. However, default template parameters are not universally supported for all template types; for function templates, they can introduce ambiguity and are generally avoided. Below, I will explain in detail why default template parameters are only allowed on class templates.

1. Ambiguity Resolution and Complexity in Compiler Implementation

First, function templates and class templates differ in parsing. For class templates, template parameters must be fully determined at the time of instantiation, providing the compiler with sufficient information for effective deduction and matching when handling default template parameters.

For example, consider the following class template example using default template parameters:

cpp
template<typename T = int>
class Example {
public:
    T value;
};

Example<> example; // Using default type int
Example<double> example2; // Explicitly specifying type double

In this example, the instantiation of Example<> is straightforward, and the compiler can easily deduce that T is of the default type int.

For function templates, the situation is more complex. Function template parameters can be deduced from arguments at the time of invocation, which increases the compiler's deduction burden. If default values are allowed for function template parameters, it would introduce more ambiguity and complexity during overload resolution and template parameter deduction.

2. Overload Resolution and Template Parameter Deduction for Function Templates

Using default template parameters in function templates can cause call ambiguity, especially when multiple overloaded functions exist. Consider the following example:

cpp
template<typename T>
void func(T);

// First version with default parameter
template<typename T>
void func(T) {
    // Implementation
}

// Second version without default parameter
template<typename T>
void func(T) {
    // Implementation
}

If func(nullptr) is called, the compiler struggles to determine which version of func to select, as nullptr can be deduced as int* (the second template instantiation) or directly use the default parameter int (the first template instantiation).

3. Language Design Philosophy

One of C++'s design philosophies is to keep things simple (despite C++ being a complex language itself). The added complexity and potential for errors from introducing default template parameters in function templates are considered not worth it, especially since other methods (such as function overloads) can achieve similar effects.

Conclusion

In summary, due to the complexity of parsing, potential call ambiguity, and design philosophy, the C++ standard restricts default template parameters to class templates only. This limitation helps maintain language consistency and implementation simplicity, while avoiding potential errors and confusion. In practical development, we can address cases where default parameters might be needed for function templates using other approaches, such as overloads or specializations.

Why Default Template Parameters Are Only Allowed on Class Templates?

First, it's important to clarify a misconception: default template parameters are not only allowed on class templates; they can also be used on function templates, but with certain limitations.

Class Templates and Default Template Parameters

Class templates allow the use of default template parameters, making instantiation more flexible. For example, consider the following class template:

cpp
template<typename T = int>
class MyClass {
    // ...
};

This approach improves code reusability and flexibility. Users can specify only the necessary parameters without always specifying all.

Function Templates and Default Template Parameters

Default template parameters can also be used for function templates. However, parameter deduction for function templates is more complex than for class templates. When a function template is called, the compiler must deduce the specific types of template parameters from the function arguments. If the function template has default template parameters, it may introduce ambiguity or unclear situations during parameter deduction.

For example, consider the following function template:

cpp
template<typename T>
void foo(T) {
    // Implementation
}

The foo function can be called without any arguments, where T defaults to int, or with other types of parameters. However, if multiple function templates or overloads exist, the compiler may encounter difficulties during call resolution because multiple candidate functions satisfy the call conditions.

Summary

Although default template parameters are allowed for both class and function templates, extra care is needed when using them in function templates to avoid potential complexity and ambiguity issues. When designing interfaces, avoiding these issues by simplifying template parameters and clearly defining function overloads can improve code maintainability and stability. In practical applications, flexibly using these features allows for appropriate choices based on specific requirements and scenarios.