C++ Template Specialization
In this page:
What is Template Specialization?
Template specialization lets you provide a custom, hand-optimized implementation for one particular data type, overriding what the generic template would otherwise generate for that type specifically.
Example: What is Template Specialization?
#include <iostream>
template <typename T>
void show(T value) {
std::cout << "Generic: " << value << std::endl;
}
int main() {
show(5);
show(3.14);
return 0;
}Login to try C/C++/Java/PHP code in the editor
Explicit Function Specialization
To specialize a function template explicitly, you write 'template <>' immediately before the function signature and specify the target type after the function name in angle brackets, telling the compiler this version replaces the generic one only for that exact type.
Example: Explicit Function Specialization
#include <iostream>
template <typename T>
void show(T value) {
std::cout << "Generic: " << value << std::endl;
}
template <>
void show<char>(char value) {
std::cout << "Character: " << value << std::endl;
}
int main() {
show(5);
show('A');
return 0;
}Login to try C/C++/Java/PHP code in the editor
Explicit Class Specialization
You can specialize an entire class template as well, which lets you design completely different member variables and functions tailored to one specific type — useful when the generic implementation would be correct but inefficient for that particular case.
Example: Explicit Class Specialization
#include <iostream>
template <typename T>
class Printer {
public:
void print(T value) { std::cout << "Value: " << value << std::endl; }
};
template <>
class Printer<bool> {
public:
void print(bool value) { std::cout << (value ? "true" : "false") << std::endl; }
};
int main() {
Printer<int> p1;
p1.print(5);
Printer<bool> p2;
p2.print(true);
return 0;
}Login to try C/C++/Java/PHP code in the editor
Scoping Template Definitions
Keep specialized template definitions grouped near their general template counterparts in your source files, since this makes it much easier for the compiler — and for future readers — to see exactly which specialized versions exist and when each one applies.
Example: Scoping Template Definitions
#include <iostream>
template <typename T>
void show(T value) {
std::cout << "Generic: " << value << std::endl;
}
template <>
void show<int>(int value) {
std::cout << "Int: " << value << std::endl;
}
int main() {
show(5);
show(3.14);
return 0;
}Login to try C/C++/Java/PHP code in the editor
Preventing Code Bloat
Because a template generates separate compiled code for every distinct type it's used with, heavy template use can bloat binary size; specialization can actually help here by letting several similar types share one hand-written, more compact implementation.
Example: Preventing Code Bloat
#include <iostream>
template <typename T>
void process(T value) {
std::cout << value << std::endl;
}
int main() {
// Each distinct type used (int, double, ...) generates its own compiled
// copy; specialization can share logic across similar types instead.
process(5);
process(3.14);
return 0;
}Login to try C/C++/Java/PHP code in the editor
Chapter Quiz — Complete all 5 topics to unlock
0/5 topics done
Complete these topics first: