C++ 泛型编程详解

泛型编程与面向对象编程的目标相同,即使重用代码和抽象通用概念的技术更加简单。但是面向对象编程强调编程的数据方面,泛型编程强调的是独立于特定数据类型。

这一篇介绍一下 C++ 编程中与面向对象并列的另一大分支——泛型编程,这一篇主要介绍函数模板、类模板和成员模板三大部分

如有侵权,请联系删除,如有错误,欢迎大家指正,谢谢

泛型编程

模板是泛型编程的一种重要思想,STL(Standard Template Library,标准模板库)是采用模板实现的一个实例
函数模板

对比函数重载(同一作用域内函数名相同,参数列表不同的函数),函数模板只需要一个函数就实现了函数重载的部分功能(参数个数相同类型不同,函数重载需要定义多个同名参数列表不同的函数)

template<typename T, typename Y> // 这也可以写 template<class T, class Y> 此处的 class 和 typename 作用相同
void tfunc(T& t, Y& y) {
 cout << t << " " << y << endl;
}
int n = 2;
double d = 2.1;
tfunc(n, d);

// 运行结果:2 2.1

函数模板具体化,函数模板具体化就是将某一(某几)个要处理的类型单独处理,需要单独写一个实现,形式是 template<> void fun(type& t);,函数模板的具体化和普通函数可以同时存在,调用顺序是 普通函数 > 函数模板具体化 > 模板函数

// ====== 测试一:函数模板针对特殊数据类型具体化 ======
struct Node {
 int val;
 Node* next;
};
// 函数模板
template<typename T>
void tfunc(const T& t) {
 cout << "template: " << t << endl;
}
// 函数模板具体化(用于处理Node类型数据)
template<>
void tfunc<Node>(const Node& node) {
 cout << "template<Node>: " << node.val << endl;
}
// 函数模板具体化(用于处理int类型数据)
template<>
void tfunc<int>(const int& n) {
 cout << "template<int>: " << n << endl;
}
// 普通函数
void tfunc(const int& n) {
 cout << "tfunc(): " << n << endl;
}
double d = 2.1;
tfunc(d); // 函数模板未具体化double类型函数,调用模板
Node node{ 2, nullptr };
tfunc(node); // 函数模板具体化Node类型函数,调用函数模板的具体化
int n = 2;
tfunc(n); // 函数模板具体化int类型函数,也存在普通函数,调用普通函数
// ====== 测试二:函数模板部分具体化 ======
template<typename T1, typename T2>
void tfunc(T1 t1, T2 t2) {
 cout << typeid(T1).name() << " and " << typeid(T2).name() <<": " << t1 << " " << t2 << endl;
}
template<typename T1>
void tfunc(T1 t1, int i) {
 cout << typeid(T1).name() << " and " << "int: " << t1 << " " << i << endl;
}
template<typename T2>
void tfunc(long l, T2 t2) {
 cout << "long and " << typeid(T2).name() << ": " << l << " " << t2 << endl;
}
template<>
void tfunc(short l, int i) {
 cout << "long and int: " << l << " " << i << endl;
}
// 分别调用以上四个模板函数
tfunc(char('c'), char('c'));
tfunc(char('c'), int(10));
tfunc(long(10), char('c'));
tfunc(short(10), int(10));

函数模板实例化,让编译器生成指定类型的函数定义,不用写函数的实现,形式是 template void fun(type& t);

// 函数模板
template<typename T>
void tfunc(const T& t) {
 cout << "template: " << t << endl;
}

// 函数模板实例化,不用写函数的实现,编译器会生成该类型的模板具体化函数
template void tfunc<char>(const char& c);

类模板

类模板可以指定默认模板参数(函数模板不可以),跟函数参数的默认值一样,必须从右向左连续赋值默认类型,如果实例化对象时又传递了类型,默认类型会被覆盖掉,跟函数参数是一样的
创建对象时需要传递模板参数列表,模板参数列表加在类名后面 ClassName< typename T > classN; 如果类的模板参数列

表有默认值,可以不传模板参数,但一定要加 <> 如 ClassName< > classN; 创建堆区对象的时候,所有的类名称后面都要加模板参数列表,如 ClassName< typename T >* classN = new ClassName< typename T>; 除了类内,其他地方出现 ClassName 的地方一般都要加模板参数列表

template<typename T = int, typename Y = char> // 此处指定了模板默认参数,部分指定必须从右到左指定
class Test {
public:
 Test(T t, Y y) : t(t), y(y) {
 }
 void tfunc();
private:
 T t;
 Y y;
};
template<typename T, typename Y> // 类模板的函数在类外实现,需要加上模板参数列表,但不需要加指定的默认模板参数
void Test<T, Y>::tfunc() { // 类外使用Test需要加模板参数
 cout << t << " " << y << endl;
}
int n = 2;
double d = 2.1;
Test<int, double> test(n, d); // 此处如果使用默认模板参数可定义为 Test<> test(int(2), char('a'));
test.tfunc();
// 运行结果:2 2.1

类模板的继承,类模板被继承后参数的传递方式主要有两种,一种是直接在子类继承父类的时候,为父类指定固定的类型,二是通过子类模板参数列表传递

// ====== 测试一 ======
template<typename T, typename Y>
class A {
public:
 A(T t, Y y) {
 }
};
class Test : public A<int, double> { // 父类是类模板,子类是普通类
public:
 Test() : A<int, double>(2, 2.1) {
 }
};
Test();
// ====== 测试二 ======
template<typename T, typename Y>
class A {
public:
 A(T t) {
 }
};
template<typename X, typename Z, typename P>
class Test : public A<X, P> {
public:
 Test(X x, Z z, P p) : A<X, P>(x) {
 }
};
Test<int, double, char>(int(2), double(2.1), char('a'));

类模板的多态,在创建对象时,分为子类没有模板(CFather<short, char>*cf = new CSon;)和子类有模板(CFather<short, char> *cf = new CSon<short, int, char>)两种,子类和父类的模板参数列表可以不一样,但一定要对应好

// ====== 测试一 ======
template<typename T, typename Y>
class A {
public:
 virtual void tfunc(T t, Y y) = 0;
};
class Test : public A<int, double> {
public:
 virtual void tfunc(int n, double d) {
 cout << n << " " << d << endl;
 }
};
// 父类是类模板,子类是普通类,在多态情况下父类需要指定模板参数,子类就不用了
A<int, double>* a = new Test;
a->tfunc(2, 2.1);
// 运行结果:2 2.1
// ====== 测试二 ======
template<typename T, typename Y>
class A {
public:
 virtual void tfunc(T t, Y y) = 0;
};
template<typename X, typename Z, typename P>
class Test : public A<X, P> {
public:
 virtual void tfunc(X x, P p) {
 cout << x << " " << p << endl;
 }
};

// 父类是类模板,子类是类模板,在多态情况下父类和子类都需要指定模板参数
A<int, double>* a = new Test<int, char, double>;
a->tfunc(2, 2.1);
// 运行结果:2 2.1

类模板具体化,类模板的具体化分为部分具体化和全部具体化两种

template<typename T1, typename T2>
class Test {
public:
 Test() {
 cout << "T1 and T2" << endl;
 }
};
// 部分具体化
template<typename T1>
class Test<T1, int> {
public:
 Test() {
 cout << "T1 and int" << endl;
 }
};
// 部分具体化
template<typename T2>
class Test<long, T2> {
public:
 Test() {
 cout << "long and T2" << endl;
 }
};
// 全部具体化
template<>
class Test<long, int> {
public:
 Test() {
 cout << "long and int" << endl;
 }
};
// 分别创建上面四个类
Test<char, char>();
Test<char, int>();
Test<long, char>();
Test<long, int>();

成员模板

成员模板简单说就是模板中的模板

class Base1 { };
class Base2 { };
class Test1 : public Base1 { };
class Test2 : public Base2 { };
template<typename T1, typename T2>
class Pair {
public:
 T1 t1;
 T2 t2;
 Pair(T1 t1, T2 t2) : t1(t1), t2(t2) {
 }
 // 类模板中的成员模板
 template<typename U1, typename U2>
 Pair(const Pair<U1, U2>& pair) : t1(pair.t1), t2(pair.t2){
 }
};
Pair<Base1*, Base2*>(Pair<Test1*, Test2*>(new Test1, new Test2));

如果未特殊说明,以上测试均是在win10 vs2017 64bit编译器下进行的

总结

以上所述是小编给大家介绍的C++ 泛型编程,希望对大家有所帮助!

(0)

相关推荐

  • C++ 泛型编程详解

    泛型编程与面向对象编程的目标相同,即使重用代码和抽象通用概念的技术更加简单.但是面向对象编程强调编程的数据方面,泛型编程强调的是独立于特定数据类型. 这一篇介绍一下 C++ 编程中与面向对象并列的另一大分支--泛型编程,这一篇主要介绍函数模板.类模板和成员模板三大部分 如有侵权,请联系删除,如有错误,欢迎大家指正,谢谢 泛型编程 模板是泛型编程的一种重要思想,STL(Standard Template Library,标准模板库)是采用模板实现的一个实例 函数模板 对比函数重载(同一作用域内函数

  • C++ 中函数重载、覆盖与隐藏详解

    C++ 中函数重载.覆盖与隐藏详解 在C++语言中,函数扮演着很重要的角色,不管面向过程设计,还是基于对象设计:不管是面向对象编程,还是基于泛型编程,函数都可以随处而见.在谈论C++中的函数重载.覆盖和隐藏之前,先回顾下函数的基础知识. 函数的声明包括函数的返回值类型,函数名称,参数列表(参数的类型.参数的个数.参数的顺序).例如,声明一个两个整数之和的函数,int iAdd(int iNum1,int iNum2);而函数的定义可以理解为对函数功能的详尽而准确的解说,通俗点,就是实现函数"ho

  • 详解C++ 多态的两种形式(静态、动态)

    1.多态的概念与分类 多态(Polymorphisn)是面向对象程序设计(OOP)的一个重要特征.多态字面意思为多种状态.在面向对象语言中,一个接口,多种实现即为多态.C++中的多态性具体体现在编译和运行两个阶段.编译时多态是静态多态,在编译时就可以确定使用的接口.运行时多态是动态多态,具体引用的接口在运行时才能确定. 静态多态和动态多态的区别其实只是在什么时候将函数实现和函数调用关联起来,是在编译时期还是运行时期,即函数地址是早绑定还是晚绑定的.静态多态是指在编译期间就可以确定函数的调用地址,

  • 详解为什么指针被誉为C语言灵魂

    目录 一.内存本质 1.1.内存编址 1.2.内存地址空间 1.3.变量的本质 二.指针是什么东西? 2.1.变量放在哪? 2.2.指针本质 2.3.解引用 2.4.活学活用 2.5.看个小问题 三. 结构体和指针 四.多级指针 五.指针与数组 5.1.一维数组 5.2.二维数组 六.神奇的 void 指针 七.花式秀技 一.内存本质 编程的本质其实就是更好的操控数据,而我们的数据是存放在内存中. 因此,如果能更好地理解内存的模型,以及 C 如何管理内存,就能对程序的工作原理洞若观火,从而使编程

  • 详解C++11中模板的优化问题

    1. 模板的右尖括号 在泛型编程中,模板实例化有一个非常繁琐的地方,那就是连续的两个右尖括号(>>)会被编译器解析成右移操作符,而不是模板参数表的结束.我们先来看一段关于容器遍历的代码,在创建的类模板 Base 中提供了遍历容器的操作函数 traversal(): // test.cpp #include <iostream> #include <vector> using namespace std; template <typename T> class

  • C++元编程语言初步入门详解

    目录 模板 泛型初步 函数模板 友元 模板参数 元编程的基本概念 可变参数模板 模板 由于模板元编程需要以面向对象为基础,所以如有疑问之处可以先补充一点C++面向对象的知识: C++面向对象这一篇就够了 泛型初步 由于C++是静态强类型语言,所以变量一经创建,则类型不得更改.如果我们希望创建一种应用广泛地复数类型,那么相应地需要基于int.float.double这些基础类型逐一创建,十分麻烦.泛型编程便是为了简化这一过程而生. 能够容纳不同数据类型作为成员的类被成为模板类,其基本方法为在类声明

  • Java 中泛型 T 和 ? 的区别详解

    目录 泛型中 T 类型变量 和 ? 通配符 区别 Generic Types 类型变量 用法 2.声明通用的方法 – 泛型方法: 有界类型参数 Wildcards 通配符 1.上界通配符:? extend 上界类型 2.无界通配符:? 3.下界通配符:? super 子类 类型擦除 泛型中 T 类型变量 和 ? 通配符 区别 定义不同 :T 是类型变量,? 是通配符 使用范围不同: ? 通配符用作 参数类型.字段类型.局部变量类型,有时作为返回类型(但请避免这样做) T 用作 声明类的类型参数.

  • C++模板Template详解及其作用介绍

    目录 1. 模板 2. 函数模板 2.1 函数模板概念 2.2 函数模板格式 2.3 函数模板原理 2.4 函数模板的实例化 2.5 模板参数的匹配原则 2.6声明定义分离 3. 类模板 3.1 类模板格式 3.2 类模板的实例化 3.3 类模板中函数放在类外进行定义时 4. 模板分离编译 4.1 什么是分离编译 4.2 模板的分离编译 5. 缺省值与返回值 6. 总结 1. 模板 首先模板分为函数模板和类模板 想到模板,就会联想到泛型编程 泛型编程:编写与类型无关的通用代码,是代码复用的一种手

  • C++详解如何通过模板实现元素的反序

    目录 所涉知识点 模板概念 示例代码 开发环境 运行结果 注意 所涉知识点 阅读此文需要掌握的知识点:回调函数,模板类,类模板,栈. 模板概念 首先模板分为函数模板和类模板 想到模板,就会联想到泛型编程 泛型编程:编写与类型无关的通用代码,是代码复用的一种手段.模板是泛型编程的基础. 网图: 在之前,我们已经知道了函数重载 还是那一个例子 Swap函数交换 int double char 哪怕是函数重载,我们也要写三个,但是如果有了模板,我们只需要: 告诉编译器一个模板,让编译器根据不同的类型利

  • Java使用通配符实现增强泛型详解

    目录 使用通配符增强泛型 1.题目 2.解题思路 3.代码详解 知识点补充 使用通配符增强泛型 1.题目 泛型是JAVA重要的特性,使用泛型编程,可以使代码复用率提高. 实现:在泛型方法中使用通配符 2.解题思路 创建一个类:WildcardsTest. 创建一个方法getMiddle()用于获得给定列表的中间值. 在泛型中,使用“?”作为通配符,通配符的使用与普通的类型参数类似,如通配符可以利用extends关键字来设置取值的上限.如 <? extends Number> 表示Byte,Do

随机推荐