What is a Template Class?
Learn what a template class is, how C++ templates differ from Java generics and type erasure, with code examples and interview Q&A.
Expected Interview Answer
A template class is a class defined with one or more type parameters so the compiler can generate a distinct, type-specific version of it for each concrete type used, letting the same code work correctly and efficiently across many data types without duplication.
The term “template” comes from C++, where `template<typename T> class Box { T value; }` produces a fresh compiled class per instantiation (`Box<int>`, `Box<std::string>`), each specialized at compile time with zero runtime overhead. Java's closest equivalent is a generic class (`class Box<T> { T value; }`), but the mechanism differs: Java generics use type erasure, compiling to a single class with type checks enforced only at compile time, whereas C++ templates truly generate separate machine code per type. Both approaches solve the same core problem — writing one algorithm or container once instead of copy-pasting a near-identical version for every data type — while trading off differently between compile-time code bloat (C++) and runtime type information loss (Java). Understanding this distinction matters when candidates are asked to compare C++ and Java generic mechanisms in interviews.
- Eliminates duplicated, type-specific copies of the same class logic
- Gives compile-time type safety instead of runtime casting errors
- C++ templates additionally get zero-overhead, fully specialized machine code per type
- Encourages reusable container and algorithm libraries (e.g. C++ STL, Java Collections)
AI Mentor Explanation
A groundskeeper has one master pitch-marking stencil that can be filled in for "T20 markings" or "Test-match markings" depending on which format is requested, rather than hand-drawing a whole new stencil for every format from scratch. The stencil itself stays generic until you specify which format fills the blank. A template class works the same way: one generic blueprint is written once, and the compiler fills in the blank type parameter to produce a specialized version for each type requested.
Step-by-Step Explanation
Step 1
Declare a type parameter
Write the class with a placeholder type, e.g. class Box<T> in Java or template<typename T> class Box in C++.
Step 2
Use the parameter as a real type
Fields, method parameters and return types inside the class refer to T as if it were a concrete type.
Step 3
Instantiate with a concrete type
Client code supplies an actual type argument, e.g. Box<Integer> or Box<int>.
Step 4
Compiler specializes or erases
C++ generates a distinct compiled class per type; Java erases T to Object with compile-time checks (type erasure).
What Interviewer Expects
- Correct definition of a template/generic class as a type-parameterized blueprint
- Awareness that “template” is the C++ term and “generic” is the closer Java term
- Understanding that C++ templates generate real per-type code while Java uses type erasure
- A working code example showing a parameterized class in use
Common Mistakes
- Using “template” and “generic” interchangeably without acknowledging the underlying mechanism differs
- Claiming Java generics generate separate bytecode per type the way C++ templates generate separate machine code
- Forgetting that primitive types need boxing to be used as Java generic type arguments
- Not mentioning that template misuse in C++ can cause compile-time code bloat
Best Answer (HR Friendly)
“A template class is a class written with a placeholder type instead of a fixed one, so the same code can work with many different data types without being rewritten for each. In C++ this is literally called a template, and the compiler generates a specialized version per type. Java achieves the same reuse goal with generics, though it implements it differently under the hood using type erasure.”
Code Example
class Box<T> {
private T value;
Box(T value) { this.value = value; }
T get() { return value; }
void set(T value) { this.value = value; }
}
Box<String> nameBox = new Box<>("Ada");
Box<Integer> ageBox = new Box<>(37);
System.out.println(nameBox.get()); // Ada
System.out.println(ageBox.get()); // 37template<typename T>
class Box {
public:
Box(T value) : value(value) {}
T get() const { return value; }
private:
T value;
};
Box<int> ageBox(37);
Box<std::string> nameBox("Ada");Follow-up Questions
- What is the difference between a C++ template class and a Java generic class?
- What is type erasure and how does it affect Java generics at runtime?
- Can you have a template class with multiple type parameters?
- Why can C++ templates cause longer compile times and larger binaries?
MCQ Practice
1. What is the primary purpose of a template class?
A template/generic class is parameterized by type so the same definition can be reused for many concrete types.
2. How does C++ implement template classes differently from how Java implements generic classes?
C++ templates are instantiated per type at compile time; Java generics use type erasure, compiling to one class with compile-time-only type checks.
3. In Java, `Box<Integer>` requires Integer instead of the primitive `int` because?
Java generic type parameters must be reference types; primitives are used via their boxed wrapper classes like Integer.
Flash Cards
Template class in one line? — A class parameterized by type so one definition works across many concrete types.
C++ vs Java mechanism? — C++ generates a distinct class per type at compile time; Java erases the type parameter (type erasure).
Java’s equivalent term? — Generic class, e.g. class Box<T>.
Why box primitives in Java generics? — Type parameters must be reference types, so int becomes Integer.