Java和C++在细节上的差异:泛型程序设计-c++ 泛型

八、泛型程序设计：

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

public class Pair<T,U> { 
public Pair() { first = null; second = null; } 
public Pair(T first,U second) { this.first = first; this.second = second; } 
 
public T getFirst() { return first; } 
public U getSecond() { return second; } 
public void setFirst(T first) { this.first = first; } 
public void setSecond(U second) { this.second = second; } 
 
private T first; 
private U second; 
}

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

template<typename T,typename U> 
class Pair { 
public: 
Pair(T first,U second): _first(first),_second(second) {} 
~Pair() {} 
public: 
T getFirst() { return _first; } 
U getSecond() { return _second; } 
void setFirst(T frist) { _first = first; } 
void setSecond(U second) { _second = second; } 
private: 
T _first; 
U _second; 
}

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

public class MyFirst { 
public static void main(String[] args) throws Exception {  
String[] names = {"john","Q.","Public"}; 
String middle = ArrayAlgo.<String>getMiddle(names); 
System.out.println(middle); 
}  
} 
 
class ArrayAlgo { 
public static <T> T getMiddle(T[] a) { 
return a[a.length/2]; 
} 
}

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

class ArrayAlgo { 
public: 
template<typename T> 
static T getMiddle(T* a,size_t len) { 
return a[len/2]; 
} 
}; 
 
int main() 
{ 
int v[] = {1,2,3}; 
int ret = ArrayAlgo::getMiddle(v,3); 
printf("This value is %d.\n",ret); 
return 0; 
}

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

public static <T> T min(T[] a) { 
if (a == null || a.length == 0) 
return null; 
T smallest = a[0]; 
for (int i = 0; i < a.length; ++i) { 
if (smallest.compareTo(a[i]) > 0) 
smallest = a[i]; 
} 
return smallest; 
}

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

public static <T extends Comparable> T min(T[] a) { 
if (a == null || a.length == 0) 
return null; 
T smallest = a[0]; 
for (int i = 0; i < a.length; ++i) { 
if (smallest.compareTo(a[i]) > 0) 
smallest = a[i]; 
} 
return smallest; 
}

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

template<typename T> 
static T min(T* a,size_t len) { 
T smallest = a[0]; 
for (int i = 0; i < len; ++i) { 
if (smallest.compareTo(a[i]) > 0) 
smallest = a[i]; 
} 
return smallest; 
}

注：C++中的模板是在引用时才编译的，因此如果在模板类型中出现任何语法错误，但此时尚未有任何引用时，编译器是不会报错的。
4. 泛型代码中的类型擦除：记得在我阅读Thinking in Java 4th 的时候，书中给出了一些比较明确的解释，为什么Java会这样实现泛型，其最主要的原因是为了考虑向前兼容，也承认这样的实现方式有着很多的缺陷和弊病，希望Java在今后的版本中予以补足。
简单的说类型擦除，就是几乎所有的泛型相关的行为都是由编译器通过暗插各种各样的代码，或者是暗自修订部分代码的声明，然后再将修订后的代码(基本不再包含泛型信息)生成字节码后交给JVM去执行，因此可以据此判断在JVM中对我们的泛型类型是一无所知的。C++也是同样的道理，只是编译器完成的工作被定义为类型展开或类型实例化，因此，同样的模板类，如果实例化的类型参数不同，那么用他们声明出来的类对象也同样不属于相同类型的对象，其限制主要表现为，不能通过缺省copy constructor或者缺省赋值操作符来完成对象之间的复制，除非其中某个类型实例化后的对象专门针对另外一种类型实例化后的类型进行了copy constructor和赋值等于的重载。

1) 类型擦除：将类型参数替换为限定类型，如果没有限定类型则替换为Object，见如下代码：

public class Pair<T> { 
public Pair(T first,T second) { this.first = first; this.second = second; } 
public T getFirst() { return first; } 
public T getSecond() { return second; } 
public void setFirst(T first) { this.first = first; } 
public void setSecond(T second) { this.second = second; } 
private T first; 
private T second; 
}

由于Pair中的类型参数T没有限定类型，因此类型擦除后将会变成如下代码：

public class Pair { 
public Pair(Object first,Object second) { this.first = first; this.second = second; } 
public Object getFirst() { return first; } 
public Object getSecond() { return second; } 
public void setFirst(Object first) { this.first = first; } 
public void setSecond(Object second) { this.second = second; } 
private Object first; 
private Object second; 
}

因此尽管在调用Pair时，传递的类型参数有所不同，如String、Date，但是在类型擦除之后，他们将成为相同的类型。如果类型参数存在多个限定类型，则取***个限定类型作为擦除后的类型参数，见如下代码：

public class Interval<T extends Comparable & Serializable> implements Serializable { 
public Interval(T first, T second) { 
if (first.compareTo(second) <= 0) { 
lower = first; 
upper = second; 
} else { 
lower = second; 
uppper = first; 
} 
} 
private T lower; 
private T upper; 
}

擦除类型信息后的原始类型如下：

public class Interval implements Serializable { 
public Interval(Comparable first, Comparable second) { 
if (first.compareTo(second) <= 0) { 
lower = first; 
upper = second; 
} else { 
lower = second; 
uppper = first; 
} 
} 
private Comparable lower; 
private Comparable upper; 
}

5. 泛型类向遗留代码的兼容：由于编译器自动完成了类型信息的擦除，因此在原有调用原始类型的地方，可以直接传入等价的泛型类，只要保证该泛型类在类型擦除后可以符合被调用函数参数的语法要求即可，见如下代码：

public class TestMain { 
public static void test(MyClass t) { 
System.out.println(t.getValue()); 
} 
 
public static void main(String[] args) { 
MyClass<Integer> v = new MyClass<Integer>(5); 
test(v); 
} 
} 
class MyClass<T> { 
public MyClass(T t) { 
this.t = t; 
} 
public T getValue() { return t;} 
private T t; 
}

6. 约束与局限性：

1) 不能使用原始类型作为类型参数，如int、double等，因为他们和Object之间没有直接的继承关系，因此在需要时只能使用包装类，如Integer、Double分别予以替换，不能这样的替换确实也带来了效率上的折损，C++中没有这样的限制，因此模板类的增多只会影响编译的效率和不会影响运行时的效率。

2) 运行时的类型查询只适用于原始类型，即if (a instanceof Pair<String>) 等价于 if (a instanceof Pair)。

3) 泛型类对象调用getClass()方法返回的Class对象都是擦除类型信息的原始Class类型，因此在做比较时，他们将为真，见如下代码：

public class TestMain { 
public static void main(String[] args) { 
MyClass<Integer> i = new MyClass<Integer>(5); 
MyClass<Double> d = new MyClass<Double>(5.0); 
//返回的均为MyClass.Class 
if (d.getClass() == i.getClass())  
System.out.println("Type info will be ignored here"); 
} 
} 
class MyClass<T> { 
public MyClass(T t) { 
this.t = t; 
} 
public T getValue() { return t;} 
private T t; 
} 
/* 输入结果： 
Type info will be ignored here 
*/

4) 泛型类不能实现Throwable接口，换言之泛型类不能成为异常类，否则会导致编译错误。

5) 不能声明参数化类型的数组，如Pair<String>[] table = new Pair<String>[10]; 在擦除类型后将会变为Pair[] table = new Pair[10]; 因此可以执行该转换：Objec[] objarray = table; 由于数组可以记住元素的类型，如果此时试图插入错误的类型元素，将会导致异常ArrayStoreException的抛出。C++中没有该限制。

6) 不能实例化泛型类型的变量，如public Pair() { first = new T(); second = new T();}，C++中不存在这样的限制，针对以上写法，类型T只要存在缺省的构造函数即可。如果确实需要实例化类型参数的对象，见如下代码：

public static <T> Pair<T> makePair(Class<T> c1) { 
return new Pair<T>(c1.newInstance(),c1.newInstance()); 
} 
public static void main(String[] args) { 
//String.class的类型为Class<String> 
Pair<String> p = Pair.makePair(String.class); 
}

这里主要是利用Class类型本身也是泛型类型，可以利用Class<T>的类型参数推演出Pair<T>中T的类型。同样的道理带有类型参数的数组对象也不能直接创建，需要利用Array的反射机制来辅助完成，见如下代码：

public static <T extends Comparable> T[] minmax(T[] a) { 
T[] mm = (T[])Array.newInstance(a.getClass().getComponentType(),a.length); 
//do something here based on mm 
return mm; 
}

7) 泛型类不能应用于静态上下文中，见如下代码：

public class Singleton<T> { 
public static T getInstance() { //Compilation ERROR 
return singleInstance; 
} 
private T singleInstance; //Compilation ERROR 
}

因为这样的写法在定义Singleton<String>和Singleton<Date>之后，由于类型擦除，将会生成唯一一个Singleton原始共享对象，事实上这并不是我们所期望的结果，在C++中没有这样的限制，甚至有的时候还可以利用这样的机制针对不同类型的对象作声明计数器用，见如下代码：

template<typename T> 
class MyClassCounter { 
public: 
MyClassCounter(T t) { 
_t = t; 
_counter++; 
} 
 
operator T() { 
return _t; 
} 
 
T* operator->() { 
return &_t; 
} 
int getCount() const { return _counter; } 
private: 
T _t; 
static int _counter; 
}

8) 泛型类不能同时继承或实现只是拥有不同参数类型的同一泛型类，如 public class MyClass implements Comparable<String>, Comparable<Date> {}

7. 泛型类型的继承规则：

1) 如果 public class Manager extends Employee {}，那么Pair<Employee> pe = new Pair<Manager>()将会是非常的赋值操作，会导致编译错误。试想如下代码引发的运行时问题。在C++中这种赋值方式同样会导致编译错误，因为他们在类型实例化之后就被视为完全无关的两个类型。

public void test() { 
Pair<Manager> manager = new Pair<Manager>(); 
Pair<Employee> employee = manager; //compilation error 
employee.setFirst(otherEmployeeButNotManager); //employee的另外一个子类，但不是Manager。 
}

2) 数组由于在运行时会记住元素的类型，因此数组可以完成这样的赋值，如Manager[] manager = {}; Employee[] employee = manager;如果赋值之后出现错误的元素赋值将会引发ArrayStoreException异常。

3) 泛型类型可以直接赋值给擦除类型后的原始类型，但是同样也会出现2)中数组赋值的问题，只是触发的异常改为ClassCastException，见如下代码：

public void test() { 
Pair<Manager> manager = new Pair<Manager>(); 
Pair rawType = manager; 
rawType.setFirst("Hello"); //only compilation warning, but will encounter runtime error. 
}

4) 如果 public class ArrayList<Manager> extends List<Manager> {}, 那么从ArrayList<Manager>到List<Manager>的赋值是允许的，这一点和普通类型是一致的，该规则同样适用于C++。

8. 泛型类型的通配符类型：该泛型特征在标准C++中完全不被支持，C#中存在类似的特征。见以下代码：

1) 子类型限定：

public class Manager extends Employee {} 
 
public static void printBuddies(Pair<Employee> p) { 
} 
 
public static void main(String[] args) { 
printBuddies(new Pair<Employee>()); //legal 
printBuddies(new Pair<Manager>()); //illegal; 
}

但是如果将printBuddies改为：void printBuddies(Pair<? extends Employee> p)，上例中main函数将可以通过编译。<? extends Employee>的语义为所有Employee的子类都可以做printBuddies函数参数的类型参数。对于7-1)中的示例代码，如果改为通配符类型将可以通过编译并正常运行，但是仍然存在一定的限制，见如下代码：

public void test() { 
Pair<Manager> manager = new Pair<Manager>(); 
Pair<? extends Employee> employee = manager; //legal here. 
//由于otherEmployeeButNotManager虽为Employee子类，但可能并非Manager类， 
//由于setFirst的参数将会声明为void setFirst(? extends Employee),由于 
//编译器无法确定setFirst参数的实际类型，因此将会直接报告编译错误。 
employee.setFirst(otherEmployeeButNotManager); //compilation error 
}

和setFirst相比，getFirst将会正常编译并运行，因为返回值无论是什么子类型，都不会带来影响和破坏。

2) 超类型限定：Pair<? super Manager>表示参数类型一定是Manager的超类。因此和子类型限定刚好相反，setFirst将是合法的，而getFirst将会产生编译错误。

3) 无限定通配符，如Pair<?>，该泛型类型的setFirst(?)方法不能被调用，即便传入的参数是Object，这样是Pair<?>和Pair之间***的差异。该方法还有一个比较重要的作用就是用于提示泛型函数的调用者，该泛型函数更期望参数是带有类型参数的泛型类型，而不是原始类型，即便原始类型也可能正常的工作，见如下代码：

public class TestMain {  
@SuppressWarnings("unchecked") 
//public static <T> T print(MyClass myclass),同样可以正常的工作， 
//但是会有编译警告产生。 
public static <T> T print(MyClass<?> myclass) { 
myclass.print(); 
return (T)myclass.get(); 
} 
 
public static void main(String[] args) { 
Integer ii = new Integer(5); 
print(new MyClass<Integer>(ii)); 
} 
} 
 
class MyClass<T> { 
public MyClass(T t) { 
_t = t; 
} 
T get() { return _t;} 
 
public void print() { 
System.out.println(_t); 
} 
private T _t; 
}

原文链接：http://www.cnblogs.com/stephen-liu74/archive/2011/08/15/2136859.html

【系列文章】