Templates in C++ vs Generics in Java

C++Server Side ProgrammingProgrammingJava 8

Templates are the foundation of generic programming, which involves writing code in a way that is independent of any particular type.

A template is a blueprint or formula for creating a generic class or a function. The library containers like iterators and algorithms are examples of generic programming and have been developed using template concept.

There is a single definition of each container, such as vector, but we can define many different kinds of vectors for example, vector <int> or vector <string>.

Example Code

#include <iostream>
#include <string>
using namespace std;
template <typename T>
inline T const& Max (T const& a, T const& b) {
   return a < b ? b:a;
int main () {
   int i = 39;
   int j = 20;
   cout << "Max(i, j): " << Max(i, j) << endl;
   double f1 = 13.5;
   double f2 = 20.7;
   cout << "Max(f1, f2): " << Max(f1, f2) << endl;
   string s1 = "Hello";
   string s2 = "World";
   cout << "Max(s1, s2): " << Max(s1, s2) << endl;
   return 0;


Max(i, j): 39
Max(f1, f2): 20.7
Max(s1, s2): World

On The other hand, the Java as Generics.

Java Generic methods and generic classes enable programmers to specify, with a single method declaration, a set of related methods, or with a single class declaration, a set of related types, respectively.

Generics also provide compile-time type safety that allows programmers to catch invalid types at compile time.

Using Java Generic concept, we might write a generic method for sorting an array of objects, then invoke the generic method with Integer arrays, Double arrays, String arrays and so on, to sort the array elements.

Generic Methods

You can write a single generic method declaration that can be called with arguments of different types. Based on the types of the arguments passed to the generic method, the compiler handles each method call appropriately. Following are the rules to define Generic Methods −

  • All generic method declarations have a type parameter section delimited by angle brackets (< and >) that precedes the method's return type ( < E > in the next example).

  • Each type parameter section contains one or more type parameters separated by commas. A type parameter, also known as a type variable, is an identifier that specifies a generic type name.

  • The type parameters can be used to declare the return type and act as placeholders for the types of the arguments passed to the generic method, which are known as actual type arguments.

  • A generic method's body is declared like that of any other method. Note that type parameters can represent only reference types, not primitive types (like int, double and char).

Example Code

public class GenericMethodTest {
   // generic method printArray
   public static < E > void printArray( E[] inputArray ) {
      // Display array elements
      for(E element : inputArray) {
         System.out.printf("%s ", element);
   public static void main(String args[]) {
      // Create arrays of Integer, Double and Character
      Integer[] intArray = { 1, 2, 3, 4, 5 };
      Double[] doubleArray = { 1.1, 2.2, 3.3, 4.4 };
      Character[] charArray = { 'H', 'E', 'L', 'L', 'O' };
      System.out.println("Array integerArray contains:");
      printArray(intArray); // pass an Integer array
      System.out.println("\nArray doubleArray contains:");
      printArray(doubleArray); // pass a Double array
      System.out.println("\nArray characterArray contains:");
      printArray(charArray); // pass a Character array


Array integerArray contains:
1 2 3 4 5
Array doubleArray contains:
1.1 2.2 3.3 4.4
Array characterArray contains:

Now let us see the differences between Templates and the generics. The differences are like below -

  • It uses Type-Erasure; this ensures the tighter type check in the compile time. Generics in Java provides compile time safety and eliminates the need of typecasting. This is directly present in the java compiler front end to ensure this type of erasure is done.

  • In C++, if the templates are used the compiler emits the template code again after replacing generic parameters in it with the given type.

  • In Java even if we have to specify the datatype, within which the function call using any object, we do not need to typecast it similar to that of C++ with actual datatypes, rather than wrapper classes to do the required.

  • Java generics uses type checking in the initialization time, and generate byte-code equivalent to non-generic code C++ has “latern typing” and template meta-programming, and generate new class for each instantiation.

Published on 28-May-2019 11:57:54