C++模板参数列表中参数名称可选性及无名称模板参数合法性咨询

Great question! This is a common point of confusion, but the rules are actually straightforward once you break them down. Let's walk through exactly how unnamed template parameters work, and how they align with the function parameter analogy you noticed.

1. Unnamed Type Template Parameters #

For type template parameters (declared with typename or class), the parameter name is completely optional. The syntax is:

template<typename /* optional name here */>
// or
template<class /* optional name here */>

You’d omit the name when you don’t need to reference the type in the generic template definition—usually because you only plan to use specialized versions of the template.

For example:

// Generic template with unnamed type parameter (no implementation needed)
template<typename>
struct TypeNamePrinter;

// Specialization for int
template<>
struct TypeNamePrinter<int> {
    static void print() { std::cout << "This is an int!\n"; }
};

// Specialization for std::string
template<>
struct TypeNamePrinter<std::string> {
    static void print() { std::cout << "This is a string!\n"; }
};

Here, the generic template doesn’t need to know the type’s name because we only use the specialized versions. The unnamed parameter just acts as a placeholder to define the template’s signature.

2. Unnamed Non-Type Template Parameters #

For non-type template parameters, the rule is similar: after specifying the type (like int, bool, or a pointer type), the parameter name is optional. The syntax looks like:

template<int /* optional name here */>
// or
template<bool /* optional name here */>

Again, you’d skip the name when the generic template doesn’t need to use the parameter’s value. This is useful when you want to create distinct template instances based on a value, but don’t need that value in the generic code.

Example:

// Generic template with unnamed int parameter
template<int>
struct SizeMarker;

// Specialization for size 4
template<>
struct SizeMarker<4> {
    using ValueType = std::int32_t;
};

// Specialization for size 8
template<>
struct SizeMarker<8> {
    using ValueType = std::int64_t;
};

The generic SizeMarker doesn’t need to know the int value—we only care about the specialized versions that map specific sizes to types.

3. Analogy to Unnamed Function Parameters #

You’re exactly right to draw a parallel to function parameters! Just like you can write:

// Unnamed int parameter—we accept it but don't use it in the function body
void logMessage(int) {
    std::cout << "A message was logged!\n";
}

Unnamed template parameters serve the same purpose: they declare that the template expects a parameter at that position, but the generic definition doesn’t need to reference it directly. It’s all about defining the correct signature for specialization or template matching.

C++ Standard Context #

To confirm, the C++ standard explicitly permits omitting names for both type and non-type template parameters. As long as the parameter’s type (for non-type) or the typename/class keyword (for type) is present, the syntax is valid.

内容的提问来源于stack exchange，提问作者Li Chen