Generics vs Templates: Java vs C++
Java generics vs C++ templates compared — type erasure vs instantiation, tradeoffs and capabilities, with examples.
Expected Interview Answer
Java generics and C++ templates both let you write type-parameterized code, but they resolve that parameterization completely differently: Java erases generic type information at compile time into a single shared runtime representation, while C++ instantiates a fully separate, concrete copy of the code for every distinct type used.
Because Java uses type erasure, `List<String>` and `List<Integer>` share one compiled `List` class at runtime with no way to reflectively distinguish them, which is why you cannot do `new T()`, `new T[]`, or `instanceof T` in Java generics. Because C++ uses template instantiation (monomorphization), `Stack<int>` and `Stack<std::string>` become two entirely separate compiled classes, so C++ templates can do things Java generics cannot — like use `T` with primitive types directly, take non-type parameters, or specialize behavior per type — at the cost of larger binaries and slower compiles. Java’s approach trades some flexibility for smaller binaries, backward compatibility with pre-generics bytecode, and simpler compiler diagnostics; C++'s approach trades compile time and binary size for zero-overhead abstraction and greater expressive power. Neither approach is objectively better — they reflect different design priorities: JVM binary compatibility versus C++'s zero-cost abstraction philosophy.
- Clarifies why Java generics cannot create arrays of T or use T with primitives directly
- Explains why C++ templates can be more expressive but bloat binaries
- Highlights the erasure vs instantiation distinction interviewers commonly probe
- Frames each language's generics as a deliberate design tradeoff, not a limitation alone
AI Mentor Explanation
A club that issues one shared "Player" badge to everyone regardless of role, checking their actual specialty only when needed, is like Java’s erasure — one runtime badge, role details resolved by policy rather than the badge itself. A club that instead prints a fully distinct badge design per specialty — Batter badge, Bowler badge, each visually and structurally different — is like C++'s instantiation, where each type gets its own separate, complete artifact. Both let the club handle many specialties generically at selection time, but only the second keeps the distinction visible afterward.
Step-by-Step Explanation
Step 1
Java: erase at compile time
Generic type parameters are checked by the compiler, then stripped to raw types/bounds in the bytecode.
Step 2
Java: one shared runtime class
All `List<T>` instantiations share the same `.class`, with no way to inspect T at runtime.
Step 3
C++: instantiate per type
The compiler generates a fully separate, concrete class or function for each distinct type argument used.
Step 4
C++: pay compile/binary cost
More instantiations mean longer compiles and larger binaries, in exchange for zero runtime overhead and more capability (e.g. non-type params).
What Interviewer Expects
- Precise articulation of erasure (Java) vs instantiation/monomorphization (C++)
- Concrete examples of what each approach cannot/can do (new T[], primitives, non-type params)
- Understanding of the underlying tradeoffs (binary size, compile time, expressiveness)
- No claim that one approach is strictly superior — recognition of differing design goals
Common Mistakes
- Treating Java generics and C++ templates as interchangeable concepts
- Not knowing why Java forbids `new T()`/`new T[]` while C++ allows the template equivalent
- Assuming C++ templates have runtime overhead like a virtual dispatch
- Forgetting that C++ templates support non-type parameters, unlike Java generics
Best Answer (HR Friendly)
“Both Java generics and C++ templates let you write one version of code that works with multiple types, but they do it very differently under the hood. Java strips out the specific type information after compiling, so there’s just one shared version at runtime, which is simpler but more limited. C++ actually builds a separate, fully compiled version of the code for every type you use, which gives you more power and zero runtime overhead, but can make your compiled program larger and slower to build.”
Code Example
class Box<T> {
private T value;
Box(T value) { this.value = value; }
T get() { return value; }
}
Box<String> a = new Box<>("hello");
Box<Integer> b = new Box<>(42);
System.out.println(a.getClass() == b.getClass()); // true: same erased Box class
// C++'s equivalent Box<std::string> and Box<int> would be two DIFFERENT compiled types.Follow-up Questions
- Why can C++ templates use `T` with primitive types like `int` directly while Java generics cannot?
- What compile artifacts differ between a Java generic class and a C++ template class?
- How does erasure affect method overloading in Java generics?
- Which approach has better runtime performance, and why?
MCQ Practice
1. What does Java use to implement generics?
Java generics use type erasure — generic type info exists only at compile time.
2. What does C++ use to implement templates?
C++ templates are instantiated into fully separate, concrete compiled versions per type.
3. Which capability do C++ templates have that Java generics do not?
C++ templates can take non-type parameters like fixed integers; Java generics cannot.
Flash Cards
Java generics mechanism? — Type erasure — one shared runtime representation.
C++ templates mechanism? — Instantiation (monomorphization) — a separate compiled copy per type.
Why can't Java do `new T[]`? — Because T is erased at runtime, there is no concrete type to allocate.
C++ template unique capability? — Non-type template parameters, e.g. fixed-size arrays via `template<int N>`.