Java和C++在细节上的差异(四)

八、泛型程序设计：

1. 泛型类的定义，见如下代码：

1    publicclassPair<T,U> {
2        publicPair() { first = null; second = null; }
3        publicPair(T first,U second) { this.first = first; this.second = second; }
4
5        publicT getFirst() { returnfirst; }
6        publicU getSecond() { returnsecond; }
7        publicvoidsetFirst(T first) { this.first = first; }
8        publicvoidsetSecond(U second) { this.second = second; }
9
10        privateT first;
11        privateU second;
12    }

以上代码中的T,U都是泛型类Pair的类型参数。以下为C++中模板类的定义方式：

1    template<typename T,typename U>
2    classPair {
3    public:
4        Pair(T first,U second): _first(first),_second(second) {}
5        ~Pair() {}
6    public:
7        T getFirst() { return_first; }
8        U getSecond() { return_second; }
9        voidsetFirst(T frist) { _first = first; }
10        voidsetSecond(U second) { _second = second; }
11    private:
12        T _first;
13        U _second;
14    }

2. 泛型方法的定义，在Java中泛型方法不一定声明在泛型类中，可以声明在普通类中，见如下代码：

1    publicclassMyFirst {
2        publicstaticvoidmain(String[] args) throwsException {
3            String[] names = {"john","Q.","Public"};
4            String middle = ArrayAlgo.<String>getMiddle(names);
5            System.out.println(middle);
6        }
7    }
8
9    classArrayAlgo {
10        publicstatic<T> T getMiddle(T[] a) {
11            returna[a.length/2];
12        }
13    }

在以上代码中可以看出getMiddle方法为静态泛型方法，类型变量位于修饰符"public static" 的后面，返回值的前面。调用的时候在方法名的前面给出了参数类型。由于Java的编译器提供类型推演的功能，既类型参数可以通过函数参数的类型进行推演，因此也可以直接调用泛型函数，如String middle = ArrayAlgo.getMiddle(names)。如果编译器无法通过函数参数的类型推演出类型参数的实际类型，这样将会导致编译错误。在C++中同样存在模板函数，也同样存在模板函数的类型推演，在这一点上主要的差异来自于函数声明的语法，见如下C++代码：

1    classArrayAlgo {
2    public:
3        template<typename T>
4        staticT getMiddle(T* a,size_t len) {
5            returna[len/2];
6        }
7    };
8
9    intmain()
10    {
11        intv[] = {1,2,3};
12        intret = ArrayAlgo::getMiddle(v,3);
13        printf("This value is %d.\n",ret);
14        return0;
15    }

3. 类型参数的限定：有些泛型函数在使用类型参数变量时，经常会用到该类型的特殊方法，如在进行数组元素比较时，要求数组中的元素必须是Comparable接口的实现类，见如下代码：

1    publicstatic<T> T min(T[] a) {
2        if(a == null|| a.length == 0)
3            returnnull;
4        T smallest = a[0];
5        for(inti = 0; i < a.length; ++i) {
6            if(smallest.compareTo(a[i]) > 0)
7                smallest = a[i];
8        }
9        returnsmallest;
10    }

在以上代码中，数组元素的类型为T，如果该类型并未提供compareTo域方法，将会导致编译错误，如何确保类型参数确实提供了compareTo方法呢？如果T是Comparable接口的实现类，那么该方法一定会被提供，因此可以通过Java语法中提供的类型参数限定的方式来确保这一点。见如下修订代码：

1    publicstatic<T extendsComparable> T min(T[] a) {
2        if(a == null|| a.length == 0)
3            returnnull;
4        T smallest = a[0];
5        for(inti = 0; i < a.length; ++i) {
6            if(smallest.compareTo(a[i]) > 0)
7                smallest = a[i];
8        }
9        returnsmallest;
10    }

其中的<T extends Comparable>语法保证了类型参数必须是Comparable接口的实现类，否则将会导致编译错误。Java中可以支持多接口的限定，之间用&分隔，如<T extends Comparable & Serializable>和之前的例子一样，尽管同样都会导致编译错误，但是后者不仅会产生更为明确的编译错误信息，同样也使使用者能够更加清晰的看到该方法的使用规则。在标准C++中并未提供这样的限定，但是在C++中对该种方式有另外一种称谓，叫做"类型绑定"，在Boost等开源库中通过更复杂的模板技巧模仿了该功能的实现。然而，就泛型的

补充：软件开发 , Java ,