泛型编程是一种专注于对算法及其数据结构进行设计的编程方式，它使得这些算法即数据结构能够在不损失效率的前提下，运用到最为通用的环境中。
泛型编程是一种编程风格，其中算法以尽可能抽象的方式编写，而不依赖于将在其上执行这些算法的数据形式。这个概念在1989年首次由David Musser和Alexander A. Stepanov提出[1.参考]。
泛型这个词并不是通用的，在不同的语言实现中，具有不同的命名。在Java/Kotlin/C#中称为泛型（Generics），在ML/Scala/Haskell中称为Parametric Polymorphism，而在C++中被叫做模板（Template），比如最负盛名的C++中的STL。任何编程方法的发展一定是有其目的，泛型也不例外。泛型的主要目的是加强类型安全和减少强制转换的次数。
下面来比较java和c++的泛型编程特性
一、基于class的泛型指定
java：
public class Demo<A, B, C> {
public A get(B a) {
System.out.println("this is git(B)");
return null;
}
}
c++
template <typename A, typename B, typename C>
class Demo
{
public:
A get(B b)
{
std::cout << "this is git(B)" << std::endl;
}
private:
};
两种语言很类似，在class申明之初就指定了能够接收几类泛型，其中A、B、C不必申明demo就可以编译通过。（如果Demo被实例化则需要定义A、B、C的实现）
是否支持泛型重载？
java：
public class Demo<A, B, C> {
public A get(B a) {
System.out.println("this is git(B)");
return null;
}
public A get(C a) {
System.out.println("this is git(C)");
return null;
}
}
编译错误：'get(B)' clashes with 'get(C)'; both methods have same erasure
c++
#include <iostream>
template <typename A, typename B, typename C>
class Demo
{
public:
A get(B b)
{
std::cout << "this is git(B)" << std::endl;
}
A get(C c)
{
std::cout << "this is git(C)" << std::endl;
}
private:
};
struct A{};
struct B{};
struct C{};
int main(int argc, char const *argv[])
{
Demo<A,B,C> demo;
B b;
demo.get(b);
C c;
demo.get(c);
std::cout << "======================" << std::endl;
return 0;
}
结果:正常运行
this is git(B)
this is git(C)
二、基于函数的泛型指定
java：
public <A, B> A get(B a) {
System.out.println("this is git(B)");
return null;
}
结果：
this is git(B)
c++
#include <iostream>
template <typename A, typename B>
A get(B)
{
std::cout << "this is git(B)" << std::endl;
}
template <typename A, typename B>
A get(B *)
{
std::cout << "this is git(B*)" << std::endl;
}
struct A{};
struct B{};
int main(int argc, char const *argv[])
{
A a;
B b;
get<A, B>(b);
get<A, B>(&b);
std::cout << "======================" << std::endl;
return 0;
}
结果：
this is git(B)
this is git(B*)
三、c++的traits技术
与java不同，c++中无直接api来判断两个类型的父子关系（一般采用dynamic_cast判空的方法），traits技术登上舞台。traits对于初学者不够友好，但确是一种优雅的类型判断技巧，在STL中大量使用。
#include <iostream>
using namespace std;
/*先定义一些tag*/
struct A {};
struct B {}; // 继承的好处就是，当函数需要参数为A，
// 而你传入的参数为B的时候，可以往上一直找到适合的对象
/*假设有一个未知类*/
template <class AorB>
struct unknown_class {
typedef AorB return_type;
};
/*特性萃取器*/
template <class unknown_class>
struct unknown_class_traits {
typedef typename unknown_class::return_type return_type;
};
/*特性萃取器 —— 针对原生指针*/
template <class T>
struct unknown_class_traits<T*> {
typedef T return_type;
};
template <class unknown_class>
inline typename unknown_class_traits<unknown_class>::return_type
__func(unknown_class, A) {
cout << "use A flag" << endl;
return A();
}
template <class unknown_class>
inline typename unknown_class_traits<unknown_class>::return_type
__func(unknown_class, B) {
cout << "use B flag" << endl;
return B();
}
template <class unknown_class, class T>
T
__func(unknown_class, T) {
cout << "use origin ptr" << endl;
return T();
}
template <class unknown_class>
inline typename unknown_class_traits<unknown_class>::return_type
func(unknown_class u) {
typedef typename unknown_class_traits<unknown_class>::return_type return_type;
return __func(u, return_type());
}
int main() {
unknown_class<B> b;
unknown_class<A> a;
int value = 1;
int *p = &value;
A v1 = func(a);
B v2 = func(b);
int v3 = func(p);
}
四、使用通配符
java特性
使用通配符 ？
import java.util.ArrayList;
import java.util.List;
class Demo {
public void show(List<?> list) {
list.add(null);
//list.add(123); 编译错误
for (Object object:list) {
System.out.println(object);
}
}
}
public class Test {
public static void main (String[] args) throws java.lang.Exception
{
Demo demo = new Demo();
List<String> listStr = new ArrayList<String>();
listStr.add("abc");
demo.show(listStr);
List<Long> listLong = new ArrayList<Long>();
listLong.add(123L);
demo.show(listLong);
}
}
1、只能往集合中add null。
2、因为集合中的类型不确定。因此，为了安全，转换为Object。
使用上界通配符 <? extends Fruit>
import java.util.ArrayList;
import java.util.List;
class Food {}
class Fruit extends Food {}
class Apple extends Fruit {}
public class Test {
public static void main (String[] args) throws java.lang.Exception
{
List<? extends Fruit> list = new ArrayList<Fruit>();
// List<? extends Fruit> listA = new ArrayList<Food>(); 编译错误。不能为父类。
List<? extends Fruit> listN = new ArrayList<Apple>();
listN.add(null);
//listN.add(123); 不能add
Fruit fruit = listN.get(0);
Food food = listN.get(0);
//Apple apple = listN.get(0); 编译错误。get获取的值，只能给父类
listN.remove(0);
}
}
上界通配符，一般用于读取的场景。
1、为泛型指定的类型只能是Fruit类型或者其子类。
2、只能为其列表添加null。
3、get方法获取的值只能赋值给Fruit类或者其超类。
使用下界通配符 <? super Fruit>
import java.util.ArrayList;
import java.util.List;
class Food {}
class Fruit extends Food {}
class Apple extends Fruit {}
public class Test {
public static void main (String[] args) throws java.lang.Exception
{
List<? super Fruit> list = new ArrayList<Fruit>();
List<? super Fruit> listA = new ArrayList<Food>();
//List<? super Fruit> listN = new ArrayList<Apple>(); 编译错误，不能为子类
listA.add(new Fruit());
//listA.add(new Food()); 编译错误，不能为父类。
listA.add(new Apple());
Object object = listA.get(0);
//Fruit fruit = listA.get(0);编译错误。
//Food food = listA.get(0);编译错误。
//Apple apple = listA.get(0); 编译错误。
}
}
下界通配符，一般用于写入的场景。
1、为泛型指定的类型必须为Fruit，或者其超类。
2、可以为其列表添加任意Fruit类型，或者其子类。
3、get方法获取的类型，只能赋值给Object类型。
