Default Values for Non-Type Template Parameters

Yes, it is indeed possible to have default values for non-type template parameters in C++. This feature allows you to provide a default value that will be used if the user doesn't specify a value when instantiating the template. It works similarly to default function arguments.

Here's an example demonstrating how to use default values for non-type template parameters:

1#include <array>
2#include <iostream>
3
4// Template with a non-type parameter
5// with a default value
6template <typename T, std::size_t Size = 5>
7class FixedVector {
8 private:
9  std::array<T, Size> data;
10  std::size_t count{0};
11
12 public:
13  void Add(const T& value) {
14    if (count < Size) {
15      data[count++] = value;
16    }
17  }
18
19  void Print() const {
20    for (std::size_t i = 0; i < count; ++i) {
21      std::cout << data[i] << ' ';
22    }
23    std::cout << '\n';
24  }
25
26  std::size_t Capacity() const { return Size; }
27};
28
29int main() {
30  // Using default size
31  FixedVector<int> vec1;
32  vec1.Add(1);
33  vec1.Add(2);
34  vec1.Add(3);
35  std::cout << "Vec1 (default size): ";
36  vec1.Print();
37  std::cout << "Capacity: "
38    << vec1.Capacity() << '\n';
39
40  // Specifying a custom size
41  FixedVector<double, 3> vec2;
42  vec2.Add(1.1);
43  vec2.Add(2.2);
44  vec2.Add(3.3);
45  // This won't be added as it exceeds capacity
46  vec2.Add(4.4);
47  std::cout << "Vec2 (custom size): ";
48  vec2.Print();
49  std::cout << "Capacity: "
50    << vec2.Capacity() << '\n';
51}

1Vec1 (default size): 1 2 3
2Capacity: 5
3Vec2 (custom size): 1.1 2.2 3.3
4Capacity: 3

In this example, we've created a FixedVector class template that uses a non-type template parameter Size to determine the capacity of the vector. We've given Size a default value of 5.

Key points to note:

1. The syntax for providing a default value is similar to function default arguments: std::size_t Size = 5.
2. When instantiating the template, you can omit the non-type argument if you're happy with the default value: FixedVector<int> will use the default size of 5.
3. You can still specify a custom value if needed: FixedVector<double, 3> creates a vector with a capacity of 3.
4. Default values for template parameters must be constant expressions that can be evaluated at compile-time.
5. You can have multiple non-type template parameters with default values, just like function arguments.

Default values for non-type template parameters can make your templates more flexible and easier to use, as they allow users to opt for a sensible default behavior while still providing the option to customize when needed.

Remember that once you provide a default value for a template parameter, all subsequent parameters must also have default values. This is similar to the rule for function default arguments.