A template declaration is a pattern that the compiler matches against a call. Changing a parameter from value to reference changes what can be deduced. A specialization supplies a different implementation for a particular template case, while an overload participates in function selection. A parameter pack lets one declaration accept several types without resorting to an unsafe untyped argument list.
This guide uses C++17, including fold expressions and variable-template type traits. It builds on the introductory templates lesson. You will inspect value-category deduction, specialize a small formatter and implement a variadic output helper. The examples stay within explicit operations instead of implying that every arbitrary type supports every generic algorithm.
Deduction follows the parameter pattern
A by-value parameter normally deduces a value type and does not preserve the caller's reference or top-level const qualification in the same way as a reference parameter. Array and function arguments can also decay under value-style deduction. A reference pattern can preserve more information about the referred type.
A forwarding reference has the relevant form T&& with a deduced type parameter in the appropriate context. When passed an lvalue, T can be deduced as an lvalue reference; reference collapsing then makes the parameter usable as an lvalue reference. An rvalue follows a different deduction path. Do not assume every double-ampersand type is a forwarding reference: a fixed type's rvalue reference is not the same pattern.
Forward only when the destination contract needs it
Std::forward can preserve the deduced argument category when forwarding to another operation. A named parameter is an lvalue expression even when its declared type is an rvalue reference, so simply passing its name does not preserve rvalueness. This is why a carefully designed forwarding wrapper uses the deduced type.
Forwarding is not a general instruction to move everything. Forwarding the same potentially consumable argument twice can cause surprising behavior. Borrowing APIs can use const references when they only inspect input. Owning APIs can take a value or an explicit rvalue-reference contract when transfer is intended. Keep the function's ownership purpose clear before introducing a universal-looking forwarding helper.
Specialization is different from overloading
A full specialization provides a definition for one specific template argument set. Class templates can also have partial specializations that match a family of arguments, such as pointer-shaped types. Function templates do not support partial specialization; function overloads are usually the relevant mechanism for such selection.
Declare a specialization before a use that would cause conflicting implicit instantiation in the applicable program structure. Keep specializations in the intended namespace and under the language's declaration rules. Do not scatter them after unrelated uses and rely on one compiler's diagnostic timing. A specialization can change implementation, but its public contract should remain understandable to generic callers.
Parameter packs expand under a chosen operation
A template parameter pack represents zero or more template arguments. A function parameter pack supplies corresponding function arguments. An expansion applies a pattern to those arguments. C++17 fold expressions provide a compact way to combine the pack with an operator.
The choice of operator determines order, result and empty-pack behavior. A comma fold is useful for sequenced side effects such as output. An arithmetic fold needs an intentional initial value and numeric contract. Adding arbitrary values can overflow or select surprising mixed-type conversions, so a shorter expression does not remove validation. Use sizeof... to inspect pack length when the interface has an empty-input rule.
Avoid accidental generic promises
A generic function should require exactly the operations its body needs. If it only reads a size, do not require copying the entire object unnecessarily. If it returns a borrowed reference, document the owner lifetime. If it creates owned output, make the copy or move boundary visible.
Use static assertions for clear local requirements under C++17, and consider concepts under a C++20 baseline. Constraints improve diagnostics but do not prove semantic rules such as stable ordering or safe arithmetic. Test representative supported types and deliberately verify that an unsupported type is rejected at the intended boundary. Avoid broad fallback overloads that silently accept an invalid call and produce a meaningless default.
Read template failures from the first requirement
Compiler template diagnostics can include a long instantiation chain. Find the first actual unsupported operation or mismatched deduction pattern rather than treating every later line as a separate defect. For a mixed-type call to a single-T template, decide whether both arguments should share one type, be explicitly converted, or use a deliberately designed two-type interface.
Do not make a call compile by weakening every argument to object-like pointers or removing const indiscriminately. That loses useful guarantees. A small example that reproduces the failing deduction is often easier to analyze than the whole application. Keep template definitions visible where their instantiation needs them, consistent with the header and one-definition rules taught earlier.
Official references
C++ Template Deduction, Specialization and Packs Examples
Each example shows the code, the output it produces and what each part does.
Deduction and a full formatter specialization
The complete program prints whether a deduced forwarding type is an lvalue reference, then formats an integer and a Boolean. The Boolean specialization deliberately uses words rather than the default stream representation.
The primary formatter requires stream insertion for its chosen T. That requirement is not satisfied by every possible type. The helper's output fixture does not use implementation-specific type-name strings.
#include <iostream>
#include <sstream>
#include <string>
#include <type_traits>
template<class T>
void describe(T&&) {
std::cout << "Lvalue reference: "
<< std::is_lvalue_reference_v<T> << '\n';
}
template<class T>
struct Formatter {
static std::string text(const T& value) {
std::ostringstream output;
output << value;
return output.str();
}
};
template<>
struct Formatter<bool> {
static std::string text(bool value) {
return value ? "yes" : "no";
}
};
int main() {
int count = 7;
std::cout << std::boolalpha;
describe(count);
describe(9);
std::cout << Formatter<int>::text(7) << '\n';
std::cout << Formatter<bool>::text(true) << '\n';
}Lvalue reference: true
Lvalue reference: false
7
yesC++ Template Deduction, Specialization and Packs in Real Projects
Worked exercise: print a bounded field group
The task is to print a small group of streamable fields separated by a vertical bar, without a leading separator. An empty group prints a clear marker. The helper accepts const references because it only observes its arguments. The comma fold sequences each output action.
#include <cstddef>
#include <iostream>
#include <string>
template<class... Ts>
void write_fields(std::ostream& output, const Ts&... values) {
static_assert(sizeof...(Ts) <= 8,
"At most eight fields are supported.");
if constexpr (sizeof...(Ts) == 0) {
output << "(no fields)";
} else {
std::size_t written = 0;
((output << (written++ == 0 ? "" : " | ") << values), ...);
}
output << '\n';
}
int main() {
write_fields(std::cout, 7, std::string("ready"), 3);
write_fields(std::cout);
}7 | ready | 3
(no fields)The compile-time count limit is a deliberate interface rule for this teaching helper. Field text length still needs a policy if values are untrusted. Streamability is checked when the relevant template is instantiated, and a production generic library can express it with a suitable C++20 constraint.
C++ Template Deduction, Specialization and Packs FAQ
Is every T&& parameter a forwarding reference?
No. The forwarding rule depends on a suitable deduced type-parameter pattern. A fixed type such as Widget&& is an rvalue reference with a different contract. A const T&& pattern also does not have the same forwarding behavior. Identify deduction first, then apply reference-collapsing and forwarding rules. The main example deliberately uses a plain deduced T&& pattern.
Can a function template be partially specialized?
Function templates do not support partial specialization. Use overloads or an appropriate class-template helper when selecting a family of cases. Full specialization is a different mechanism and must follow its declaration rules. Keep the call-selection design clear, because overload resolution and specialization placement can interact in ways that are less obvious than a simple class specialization.
Why handle an empty pack explicitly?
Zero arguments can be a valid use of a variadic helper, but not every fold operator has a suitable empty result. An explicit branch makes the interface's behavior clear. The output helper prints a marker rather than relying on incidental stream state. For arithmetic, choose a meaningful identity and type contract, and reject empty input if the operation has no defined domain result.
Does a template remove runtime validation?
No. It can verify type-level requirements and compile-time counts, but runtime values still need range, size and domain checks. A valid streamable string can be too long, and an integral arithmetic operation can overflow. Keep those checks in the operation's contract. Genericity changes how code is generated and selected, not whether external input is trustworthy.
C++ Template Deduction, Specialization and Packs Exercises
Answer each one and check it instantly. If you get stuck, open the hint before the answer.
The field writer only observes arguments. Which parameter contract is appropriate?
C++ Template Deduction, Specialization and Packs Quiz
2 questions to check what you learned.
What is deduced for T in describe(T&&) when called with an int lvalue?
- Plain int, followed by an automatic move from the caller's lvalue.
- Always plain int regardless of argument category.
- An applicable lvalue-reference type.
- int&&, because the parameter spelling contains two ampersands.
Which template facility permits partial specialization?
- A function-template overload, treated as a partial specialization of another function.
- An ordinary non-template function.
- A function template through any arbitrary partial argument list.
- A class template under its specialization rules.