Explain the difference between templates in C ++ and generics in Java

Many programmers believe that C ++ templates and generic drugs (such as Java) - this is the same thing, because the syntax is similar: in both cases, you can write something likeList <T>. To find the differences, let's see what templates and generics, and how they are implemented in each of the languages.

Java Generics are associated with the idea of "erasure types» (type erasure). This technique eliminates the type parameters when the source code is converted to bytecode JVM.

Suppose that you have a Java-code:

1 2 3

Vector vector = new Vector(); vector.add(new String("hello")); String str = vector.get(0);

At compile time, it will be converted:

1 2 3

Vector vector = new Vector(); vector.add(new String("hello")); String str = (String) vector.get(0);

Using generalizations Java does not impact on our ability, but to make the code more beautiful. Therefore, generics in Java are often called "syntactic sugar".

Generics are very different from the patterns C ++. Patterns in C ++ is a set of macros, create a new copy of the boilerplate code for each type. This is particularly evident in the following example: an instance of MyClass <Foo> not be able, together with MyClass <Bar> to use a static variable. A two copies of MyClass <Foo> will share the static variable.

To illustrate this example, consider the following code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25

/*** MyClass.h ***/ template<typename T> class MyClass { public:   static int val;   MyClass(int v){ val = v; } };   /*** MyClass.cpp ***/ template<typename T> int MyClass<T>::val;   template class MyClass<Foo>; template class MyClass<Bar>;   /*** main.cpp ***/ MyClass * foo1 = new MyClass<Foo>(10); MyClass * foo2 = new MyClass<Foo>(15); MyClass * bar1 = new MyClass<Bar>(20); MyClass * bar2 = new MyClass<Bar>(35);   int f1 = foo1->val; //будет равно 15 int f2 = foo2->val; //будет равно 15 int b1 = bar1->val; //будет равно 35 int b2 = bar2->val; //будет равно 35

In Java, the various instances of MyClass can share static variables, regardless of the type parameters.

Because of differences in the architecture of generic Java and C ++ templates have many differences:

• C ++ templates can use primitive types, such as,int, a generic Java - no, they have to use Integer.
• Java allows to specify restrictions on the type passed as a parameter. For example, you can use generics to implement CardDeck and indicate that the type parameter must inherit from CardGame.
• In C ++, you can create an instance of a type, pass parameters, and Java - no.
• Java does not allow classes, pass parameters (eg, Foo in MyClass <Foo>) for static methods and variables, as they can be shared in MyClass <Foo> and MyClass <Bar>. In C ++ - classes are different, so the type of the parameter can be used for static methods and variables.
• In all instances of Java MyClass <T>, regardless of their parameters are the same type.Parameters types are destroyed after compilation. In C ++, instances with different parameter types - different types.

Remember that although generic Java and C ++ templates look similar, they are different things.