C++中的模板与java中的泛型-yiteyi-C++库

在构建大型项目时，我们需要代码与提供给它的任何类型的数据兼容。这是你编写的代码高于其他代码的地方。在这里，我们的意思是使您编写的代码对提供给程序的任何类型的数据都是通用的，而不管其数据类型如何。这就是java中的泛型和C++中的模板模板的用处。虽然两者功能相似，但在一些地方有所不同。

null

C++中的模板

在C++中编写泛型程序称为模板。

C++中模板的主要特征之一是元编程的使用。它使所提供的代码的模板签名不同，是C++提供了实现它们的能力。
模板参数可以是类，也可以是函数。
C++需要在其标题中添加模板源。
可以实现模板专门化，即可以实现特定类型和方法的模板。

                     // CPP program to illustrate Templates                   
                     #include <iostream>                   
                     #include <string.h>                   
                             
                     using                               namespace                               std;                   
                             
                     template                               <                               class                               T>                   
                     class                               TempClass {                   
                             
                                         T value;                   
                             
                     public                               :                   
                                         TempClass(T item)                   
                                         {                   
                                         value = item;                   
                                         }                   
                             
                                         T getValue()                   
                                         {                   
                                         return                               value;                   
                                         }                   
                     };                   
                             
                     int                               main()                   
                     {                   
                                         class                               TempClass<string>* String =                   
                                         new                               TempClass<string>(                               "Generics vs Templates"                               );                   
                             
                                         cout <<                               "Output Values: "                               << String->getValue()                   
                                         <<                               ""                               ;                   
                             
                                         class                               TempClass<                               int                               >* integer =                               new                               TempClass<                               int                               >(9);                   
                                         cout <<                               "Output Values: "                               << integer->getValue();                   
                     }                   

输出：

Output Values: Generics vs Templates
Output Values: 9

Java中的泛型

Java泛型的一个主要特性是，它在实例化期间处理类型检查，并生成与非泛型代码等效的字节码。 Java编译器在实例化之前检查类型，这反过来使泛型类型的实现是安全的。同时，在C++中，模板对类型一无所知。
如果泛型应用于一个类，那么它就会应用于类中的类和方法。
导致在Java中使用泛型的另一个主要因素是，它允许您消除降级。
实例化泛型类与使用作为特定类的等效类相比，没有运行时开销对象而不是一般类型的 T .

                     // Java program to illustrate                   
                     // Generics                   
                     public                               class                               GenericClass<T> {                   
                     private                               T value;                   
                             
                                         public                               GenericClass(T value)                   
                                         {                   
                                         this                               .value = value;                   
                                         }                   
                             
                                         public                               void                               showType()                   
                                         {                   
                                         System.out.println(                               "Type:"                               +                   
                                         value.getClass().getSimpleName());                   
                                         System.out.println(                               "Value: "                               + value);                   
                                         }                   
                             
                                         public                               static                               void                               main(String[] args)                   
                                         {                   
                                         GenericClass<String> Str =                   
                                         new                               GenericClass<String>(                               "Generics vs Templates"                               );                   
                             
                                         GenericClass<Integer> integer =                   
                                         new                               GenericClass<Integer>(                               9                               );                   
                             
                                         Str.showType();                   
                                         integer.showType();                   
                                         }                   
                     }                   

输出：

Type:String
Value: Generics vs Templates
Type:Integer
Value: 9

java中C++模板与泛型的比较

虽然创建泛型类型的两种方法相似，但它们在某些地方有所不同，而它们所拥有的实现属性是相同的。

类型擦除： 类型擦除确保在编译时进行更严格的类型检查。Java泛型只提供编译时安全性，不需要强制转换。这是直接在Java编译器前端实现的，并确保完成了类型擦除。
在C++中，当使用模板时，编译器将在使用所使用的类型替换泛型参数之后再次发射模板代码。这在几个方面更强大，但可能导致 臃肿的可执行文件 .
包装类： 在爪哇中，即使我们必须使用任何对象来具体指定函数调用的数据类型，我们不需要将其与实际数据类型类似于C++，而是使用包装类来完成所需的数据。
类型检查： java泛型在实例化过程中处理类型检查，并生成等效于非泛型代码的字节代码C++具有“潜类型”和模板元编程，并为每个实例化生成新的类。

Java鼓励软件重用，并为泛型编程添加了一些基本支持。对于Java来说，这是在商业软件开发领域迈出的重要一步。

本文由小妞 .如果你喜欢GeekSforgek，并想贡献自己的力量，你也可以使用写极客。组织或者通过电子邮件查看你的文章-team@geeksforgeeks.org.看到你的文章出现在Geeksforgeks主页上，并帮助其他极客。

如果您发现任何不正确的地方，或者您想分享有关上述主题的更多信息，请写下评论。

文章版权归作者所有，未经允许请勿转载。

THE END

Java