Templates in C++ vs Generics in Java

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>.
#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.
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).
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.
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.
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).
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).
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);
      }
      System.out.println();
   }
   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:
H E L L O
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.
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 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.
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.
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.