Partial template specialization

Example

Suppose there exists a KeyValuePair class with two template parameters, as follows.

template <typename K, typename V>
class KeyValuePair {};

The following is an example of a class that defines an explicit full template specialization of KeyValuePair by pairing integers with strings. The class type retains the same name as the original version.

using std::string;

template <>
class KeyValuePair<int, string> {};

The next is an example of partial specialization of KeyValuePair with the same name as the original version and one specialized template parameter.

template <typename K>
class KeyValuePair<K, string> {};

The next example class KeyStringPair is derived from the original KeyValuePair with a new name, and defines a partial template specialization. In contrast to the explicit specialization above, only the V template parameter of the superclass is specialized, while the K template parameter remains generic.

template <typename K>
class KeyStringPair : public KeyValuePair<K, string> {};

It does not matter which template parameters are specialized and which remain generic. For instance, the following is also a valid example of a partial specialization of the original KeyValuePair class.

template <typename V>
class IntegerValuePair : public KeyValuePair<int, V> {};

Caveats

C++ templates are not limited to classes - they can also be used to define function templates. Although function templates can be fully specialized, they cannot be partially specialized, irrespective of whether they are member function templates or non-member function templates. This can be beneficial to compiler writers, but affects the flexibility and granularity of what developers can do.^[1] But, function templates can be overloaded, which gives nearly the same effect as what partial function template specialization would have.^[2] The following examples are provided to illustrate these points.

import std;

using std::string;

// legal: base function template
template <typename Ret, typename Arg>
Ret Foo(Arg arg);

// legal: explicit/full function template specialization
template <>
string Foo<string, char>(char arg) {
    return "Full";
}

// illegal: partial function template specialization of the return type
//          function template partial specialization is not allowed
// template <typename Arg>
// void Foo<void, Arg>(Arg arg);

// legal: overloads the base template for a pointer argument type
template <typename Ret, typename Arg>
Ret Foo(Arg* argPtr) {
    return "PtrOverload";
}

// legal: base function name reused. Not considered an overload. ill-formed: non-overloadable declaration (see below)
template <typename Arg>
string Foo(Arg arg) {
    return "Return1";
}

// legal: base function name reused. Not considered an overload. ill-formed: non-overloadable declaration (see below)
template <typename Ret>
Ret Foo(char arg) {
    return "Return2";
}

In the example listed above, note that while the last two definitions of the function Foo are legal C++, they are considered ill-formed according to the standard because they are non-overloadable declarations.^[3] This is because the definition of function overloading only accounts for the function name, parameter type list and the enclosing namespace (if any). It does not account for the return type.^[4] However, these functions can still be called by explicitly indicating the signature to the compiler, as demonstrated by the following program.

import std;

using std::string;

int main(int argc, char* argv[]) {
    char c = 'c';
    // let the compiler resolve the call
    string r0 = Foo(c);
    // explicitly specify which function to call
    string r1 = Foo<string>(c);
    string r2 = Foo<string, char>(c);
    string r3 = Foo<string, char>(&c);

    // generate output:
    // Return1, Return2, Full, PtrOverload
    std::println("{}, {}, {}, {}", r0, r1, r2, r3);
}