165

Java 有泛型，C++ 提供了一个非常强大的编程模型template。那么，C++ 和 Java 泛型有什么区别呢？

4

13 回答 13

160

他们之间有很大的不同。在 C++ 中，您不必为泛型类型指定类或接口。这就是为什么您可以创建真正通用的函数和类，但需要注意的是更宽松的类型。

template <typename T> T sum(T a, T b) { return a + b; }

上面的方法添加了两个相同类型的对象，并且可以用于任何具有“+”运算符的类型 T。

在 Java 中，如果要对传递的对象调用方法，则必须指定类型，例如：

<T extends Something> T sum(T a, T b) { return a.add ( b ); }

在 C++ 中，泛型函数/类只能在标头中定义，因为编译器会为不同的类型（调用它的）生成不同的函数。所以编译比较慢。在 Java 中，编译没有重大损失，但 Java 使用一种称为“擦除”的技术，其中泛型类型在运行时被擦除，所以在运行时 Java 实际上是调用...

Something sum(Something a, Something b) { return a.add ( b ); }

因此，Java 中的泛型编程并不是真正有用，它只是帮助新的 foreach 构造的一点语法糖。

编辑：上面关于有用性的意见是由一个年轻的自己写的。Java 的泛型当然有助于类型安全。

于 2008-08-30T21:34:05.967 回答
132

Java 泛型与 C++ 模板有很大不同。

基本上在 C++ 中，模板基本上是一个美化的预处理器/宏集（注意：由于有些人似乎无法理解类比，我并不是说模板处理是一个宏）。在 Java 中，它们基本上是语法糖，以最大限度地减少对象的样板转换。这是对 C++ 模板与 Java 泛型的相当不错的介绍。

详细说明这一点：当您使用 C++ 模板时，您基本上是在创建代码的另一个副本，就像您使用#define宏一样。这允许你做一些事情，比如int在模板定义中有参数来确定数组的大小等等。

Java 不是那样工作的。在 Java 中，所有对象都来自java.lang.Object，因此，在泛型之前，您可以编写如下代码：

public class PhoneNumbers {
    private Map phoneNumbers = new HashMap();
    
    public String getPhoneNumber(String name) {
      return (String) phoneNumbers.get(name);
    }
}

因为所有的 Java 集合类型都使用 Object 作为它们的基本类型，所以你可以在其中放入任何东西。Java 5 滚动并添加了泛型，因此您可以执行以下操作：

public class PhoneNumbers {
    private Map<String, String> phoneNumbers = new HashMap<String, String>();
    
    public String getPhoneNumber(String name) {
        return phoneNumbers.get(name);
    }
}

这就是 Java 泛型的全部内容：用于转换对象的包装器。那是因为 Java 泛型没有被细化。他们使用类型擦除。做出这个决定是因为 Java 泛型在这篇文章中出现得太晚了，以至于他们不想破坏向后兼容性（Map<String, String>只要需要 a，a 就可以使用Map）。将此与不使用类型擦除的 .Net/C# 进行比较，这会导致各种差异（例如，您可以使用原始类型并且IEnumerable彼此IEnumerable<T>之间没有关系）。

使用 Java 5+ 编译器编译的泛型类在 JDK 1.4 上可用（假设它不使用任何其他需要 Java 5+ 的特性或类）。

这就是为什么 Java 泛型被称为语法糖的原因。

但是这个关于如何做泛型的决定具有如此深远的影响，以至于（极好的）Java 泛型常见问题解答如雨后春笋般涌现，以回答人们对 Java 泛型的许多问题。

C++ 模板有许多 Java 泛型没有的特性：

  • 使用原始类型参数。

    例如：

    template<class T, int i>
class Matrix {
    int T[i][i];
    ...
}

    Java 不允许在泛型中使用原始类型参数。

  • 使用默认类型参数，这是我在 Java 中错过的一个特性，但有向后兼容性的原因；

  • Java 允许对参数进行限制。

    例如：

    public class ObservableList<T extends List> {
    ...
}

确实需要强调的是，具有不同参数的模板调用确实是不同的类型。他们甚至不共享静态成员。在 Java 中，情况并非如此。

除了与泛型的差异之外，为了完整起见，这里是C++ 和 Java（以及另一个）的基本比较。

我也可以建议Thinking in Java。作为 C++ 程序员，许多概念（如对象）已经成为第二天性，但存在细微差别，因此即使您略读部分内容，也值得拥有介绍性文本。

学习 Java 时您将学到的很多东西都是所有库（包括标准库——JDK 中的库——和非标准库，包括 Spring 等常用的东西）。Java 语法比 C++ 语法更冗长，并且没有很多 C++ 特性（例如，运算符重载、多重继承、析构函数机制等），但这也不能严格地使其成为 C++ 的子集。

于 2009-01-31T05:22:50.087 回答
94

C++ 有模板。Java 有泛型，看起来有点像 C++ 模板，但它们非常非常不同。

顾名思义，模板的工作原理是为编译器提供一个（等待它...）模板，它可以通过填写模板参数来生成类型安全的代码。

据我了解，泛型反过来工作：编译器使用类型参数来验证使用它们的代码是类型安全的，但生成的代码根本没有类型。

将 C++ 模板视为一个非常好的宏系统，将 Java 泛型视为自动生成类型转换的工具。

 

于 2008-08-30T21:30:13.637 回答
17

C++ 模板具有 Java 泛型所没有的另一个特性是特化。这允许您对特定类型有不同的实现。因此，例如，您可以为int提供高度优化的版本，同时为其余类型提供通用版本。或者您可以为指针和非指针类型提供不同的版本。如果您想在传递指针时对取消引用的对象进行操作，这会派上用场。

于 2009-01-31T18:23:25.673 回答
13

Maurice Naftalin 和 Philip Wadler在Java 泛型和集合中对这个主题有很好的解释。我强烈推荐这本书。去引用：

Java 中的泛型类似于 C++ 中的模板。...语法故意相似，语义故意不同。... 从语义上讲，Java 泛型是通过擦除定义的，而 C++ 模板是通过扩展定义的。

请在此处阅读完整说明。

替代文字
（来源：oreilly.com）

于 2009-01-31T18:16:23.427 回答
5
于 2009-01-31T05:18:15.323 回答
4

Java（和 C#）泛型似乎是一种简单的运行时类型替换机制。
C++ 模板是一种编译时构造，它为您提供了一种修改语言以满足您的需要的方法。它们实际上是编译器在编译期间执行的纯函数式语言。

于 2008-09-03T12:00:04.380 回答
3

C++ 模板的另一个优点是专业化。 

template <typename T> T sum(T a, T b) { return a + b; }
template <typename T> T sum(T* a, T* b) { return (*a) + (*b); }
Special sum(const Special& a, const Special& b) { return a.plus(b); }

现在，如果你用指针调用 sum，第二个方法将被调用，如果你用非指针对象调用 sum，第一个方法将被调用，如果你sum用Special对象调用，第三个方法将被调用。我认为Java不可能做到这一点。

于 2008-09-03T15:23:38.633 回答
2

我会用一句话来概括：模板创建新类型，泛型限制现有类型。

于 2016-01-31T02:43:28.593 回答
2

下面的答案来自Cracking The Coding Interview Solutions to Chapter 13这本书，我觉得很好。

Java泛型的实现植根于“类型擦除”的思想：这种技术在将源代码转换为Java虚拟机（JVM）字节码时消除了参数化类型。例如，假设您有以下Java代码：

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

在编译过程中，这段代码被重写为：

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

Java 泛型的使用并没有真正改变我们的能力。它只是让事情变得更漂亮了。由于这个原因，Java 泛型有时被称为“语法糖：”。

这与 C++ 完全不同。在 C++ 中，模板本质上是一个美化的宏集，编译器为每种类型创建一个模板代码的新副本。证明这一点的事实是 MyClass 的实例不会与 MyClass 共享静态变量。然而，MyClass 的两个实例将共享一个静态变量。

/*** MyClass.h ***/
 template<class T> class MyClass {
 public:
 static int val;
 MyClass(int v) { val v;}
 };
 /*** MyClass.cpp ***/
 template<typename T>
 int MyClass<T>::bar;

 template class MyClass<Foo>;
 template class MyClass<Bar>;

 /*** main.cpp ***/
 MyClass<Foo> * fool
 MyClass<Foo> * foo2
 MyClass<Bar> * barl
 MyClass<Bar> * bar2

 new MyClass<Foo>(10);
 new MyClass<Foo>(15);
 new MyClass<Bar>(20);
 new MyClass<Bar>(35);
 int fl fool->val; // will equal 15
 int f2 foo2->val; // will equal 15
 int bl barl->val; // will equal 35
 int b2 bar2->val; // will equal 35

在 Java 中，静态变量在 MyClass 的实例之间共享，而不管不同的类型参数。

Java 泛型和 C++ 模板还有许多其他区别。这些包括：

  • C++ 模板可以使用原始类型，例如 int。Java 不能而且必须改为使用 Integer。
  • 在 Java 中，您可以将模板的类型参数限制为某种类型。例如，您可以使用泛型来实现 CardDeck 并指定类型参数必须从 CardGame 扩展。
  • 在 C++ 中，类型参数可以被实例化，而 Java 不支持这一点。
  • 在Java 中，类型参数（即MyClass 中的Foo）不能用于静态方法和变量，因为它们将在MyClass 和MyClass 之间共享。在 C++ 中，这些类是不同的，因此类型参数可以用于静态方法和变量。
  • 在 Java 中，MyClass 的所有实例，无论它们的类型参数如何，都是相同的类型。类型参数在运行时被擦除。在 C++ 中，具有不同类型参数的实例是不同的类型。
于 2018-07-01T15:59:08.937 回答
1

@基思：

该代码实际上是错误的，除了较小的故障（template省略，专业化语法看起来不同）之外，部分专业化不适用于函数模板，仅适用于类模板。然而，代码可以在没有部分模板特化的情况下工作，而是使用普通的旧重载：

template <typename T> T sum(T a, T b) { return a + b; }
template <typename T> T sum(T* a, T* b) { return (*a) + (*b); }
于 2008-09-03T15:50:35.603 回答
0

模板只不过是一个宏系统。语法糖。它们在实际编译之前被完全扩展（或者，至少编译器表现得好像是这样）。

例子：

假设我们想要两个函数。一个函数接受两个数字序列（列表、数组、向量等），并返回它们的内积。另一个函数接受一个长度，生成两个该长度的序列，将它们传递给第一个函数，并返回它的结果。问题是我们可能在第二个函数中犯了一个错误，因此这两个函数的长度实际上并不相同。在这种情况下，我们需要编译器来警告我们。不是在程序运行时，而是在编译时。

在 Java 中，您可以执行以下操作：

import java.io.*;
interface ScalarProduct<A> {
    public Integer scalarProduct(A second);
}
class Nil implements ScalarProduct<Nil>{
    Nil(){}
    public Integer scalarProduct(Nil second) {
        return 0;
    }
}
class Cons<A implements ScalarProduct<A>> implements ScalarProduct<Cons<A>>{
    public Integer value;
    public A tail;
    Cons(Integer _value, A _tail) {
        value = _value;
        tail = _tail;
    }
    public Integer scalarProduct(Cons<A> second){
        return value * second.value + tail.scalarProduct(second.tail);
    }
}
class _Test{
    public static Integer main(Integer n){
        return _main(n, 0, new Nil(), new Nil());
    }
    public static <A implements ScalarProduct<A>> 
      Integer _main(Integer n, Integer i, A first, A second){
        if (n == 0) {
            return first.scalarProduct(second);
        } else {
            return _main(n-1, i+1, 
                         new Cons<A>(2*i+1,first), new Cons<A>(i*i, second));
            //the following line won't compile, it produces an error:
            //return _main(n-1, i+1, first, new Cons<A>(i*i, second));
        }
    }
}
public class Test{
    public static void main(String [] args){
        System.out.print("Enter a number: ");
        try {
            BufferedReader is = 
              new BufferedReader(new InputStreamReader(System.in));
            String line = is.readLine();
            Integer val = Integer.parseInt(line);
            System.out.println(_Test.main(val));
        } catch (NumberFormatException ex) {
            System.err.println("Not a valid number");
        } catch (IOException e) {
            System.err.println("Unexpected IO ERROR");
        }
    }
}

在 C# 中，您可以编写几乎相同的东西。尝试用C++重写，编译不了，抱怨模板无限扩展。

于 2013-08-24T16:12:37.553 回答
0

我想在这里引用askanydifference：

C++ 和 Java 之间的主要区别在于它们对平台的依赖性。而 C++ 是平台相关语言，Java 是平台无关语言。

上述陈述是 C++ 能够提供真正的泛型类型的原因。虽然 Java 确实有严格的检查，因此它们不允许像 C++ 允许的那样使用泛型。

于 2020-07-12T15:19:34.003 回答