C++中的类模板

C++类模板 类模板 1.3.1 类模板语法 类模板作用: 建立一个通用类,类中的成员 数据类型可以不具体制定,用一个虚拟的类型来代表。 语法: template<typename T> 类 解释: template — 声明创建模板 typename — 表面其后面的符号是一种数据类型,可以用class代替 T — 通用的数据类型,名称可以替换,通常为大写字母 示例: #include <string> //类模板 template<class NameType, c 阅读详情

1 C++中的类模板简介

我们知道,有些类主要用于存储和组织数据元素,类中数据组织的方式和数据元素的具体类型无关,如:数组类、链表类、Stack类、Queue类等。C++中将模板的思想应用于类,使得类的实现不关注数据元素的具体类型,而只关注类所需要实现的功能。

C++中的类模板:

  • 以相同的方式处理不同的类型。
  • 在类声明前使用template进行标识。
  • <typename T>用于说明类中使用的泛指类型T。
  • 声明的泛指类型T可以出现在类模板的任意地方。

在这里插入图片描述
类模板的应用:

  • 只能显示指定具体类型,无法自动推导。
  • 使用具体类型<Type>定义对象。

在这里插入图片描述
编译器对类模板的处理方式和函数模板相同:

  • 从类模板通过具体类型产生不同的类。
  • 在声明的地方对类模板代码本身进行编译。
  • 在使用的地方对参数替换后的代码进行编译(成员函数也是分步编译,调用了哪个成员函数就对哪个成员函数进行编译)。

编程实验:类模板初探

#include <iostream>
#include <string>

using namespace std;

template < typename T >
class Operator
{
public:
    T add(T a, T b)
    {
        return a + b;
    }
    T minus(T a, T b)
    {
        return a - b;
    }
    T multiply(T a, T b)
    {
        return a * b;
    }
    T divide(T a, T b)
    {
        return a / b;
    }
};

string operator-(string& l, string& r)
{
    return "Minus";
}

int main()
{
    Operator<int> op1;
    
    cout << op1.add(1, 2) << endl;
    
    Operator<string> op2;
    
    cout << op2.add("D.T.", "Software") << endl;
    cout << op2.minus("D.T", "Software") << endl;
    
    return 0;
}



2 继承中类模板的使用

2.1 父类一般类、子类是模板类

class B
{
public:
	B(int b)
	{
		this->b = b;
	}

private:
	int b;
};

template <typename T>
class A : public B
{
public:
	//函数的参数列表使用虚拟类型
	A(T t) : B (0)
	{
		this->t = t;
	}
	//成员函数返回值使用虚拟类型
	T &getT()
	{
		return t;
	}

private:
	//成员变量使用虚拟类型
	T t;
};

父类一般类,子类是模板类, 和普通继承的玩法类似。

2.2 子类一般类、父类是模板类

template <typename T>
class A
{
public:
	//函数的参数列表使用虚拟类型
	A(T t)
	{
		this->t = t;
	}
	//成员函数返回值使用虚拟类型
	T &getT()
	{
		return t;
	}

private:
	//成员变量使用虚拟类型
	T t;
};

class B : public A<int>
{
public:
	B(int b)
	{
		this->b = b;
	}

private:
	int b;
};

子类是一般类,父类是模板类,继承时必须在子类里实例化父类的类型参数。

2.3 父类和子类均为模板类

template <typename T>
class A
{
public:
	//函数的参数列表使用虚拟类型
	A(T t)
	{
		this->t = t;
	}
	//成员函数返回值使用虚拟类型
	T &getT()
	{
		return t;
	}

private:
	//成员变量使用虚拟类型
	T t;
};

template <typename Tb>
class B: public A<Tb>
{
	public:
	B(Tb b):A<Tb>(b)
	{
		this->b = b;
	}

private:
	Tb b;

};

父类和子类都时模板类时,子类的虚拟的类型可以传递到父类中。


3 类模板的工程应用

类模板的工程应用:

  • 类模板必须在头文件中定义。
  • 类模板不能分开实现在不同的文件中。
  • 类模板外部定义的成员函数需要加上模板<>声明,成员函数的内部加不加都是可以的。

编程实验:模板类的工程应用
operator.h:

#ifndef _OPERATOR_H_
#define _OPERATOR_H_

template < typename T >
class Operator
{
public:
    T add(T a, T b);
    T minus(T a, T b);
    T multiply(T a, T b);
    T divide(T a, T b);
};

template < typename T >
T Operator<T>::add(T a, T b)
{
    return a + b;
}


template < typename T >
T Operator<T>::minus(T a, T b)
{
    return a - b;
}


template < typename T >
T Operator<T>::multiply(T a, T b)
{
    return a * b;
}


template < typename T >
T Operator<T>::divide(T a, T b)
{
    return a / b;
}

#endif

main.cpp:

#include <iostream>
#include <string>
#include "Operator.h"

using namespace std;


int main()
{
    Operator<int> op1;
    
    cout << op1.add(1, 2) << endl;
    cout << op1.multiply(4, 5) << endl;
    cout << op1.minus(5, 6) << endl;
    cout << op1.divide(10, 5) << endl;
    
    return 0;
}


我们在有些地方也会看到类模板的声明和实现是放在两个不同的文件中,但是因为类模板的特殊实现,我们应在使用类模板时使用#include 包含 实现部分的.cpp 或.hpp文件(如果一个文件是hpp结尾,那么代表当前文件是类模板的实现)。这样的作法显然有点过于繁琐,因此还是定义在同一个文件中比较合适!


4 多参数类模板和类模板的特化

4.1 多参数类模板

类模板可以定义任意多个不同的类型参数。

在这里插入图片描述

4.2 类模板的特化

类模板可以被特化:

  • 指定类模板的特化实现。
  • 部分类型参数必须显示指定。
  • 根据类型参数分开实现类模板。

类模板的特化类型:

  • 部分特化:用特定规则约束类型参数。
  • 完全特化:完全显示指定类型参数。

部分特化:
在这里插入图片描述
完全特化:
在这里插入图片描述
类模板特化注意事项:

  • 特化只是模板的分开实现,本质上是同一个类模板。
  • 特化模板的使用方式是统一的,必须显示指定每一个类型参数。

编程实验:类模板的特化

#include <iostream>
#include <string>

using namespace std;

template
< typename T1, typename T2 >
class Test
{
public:
    void add(T1 a, T2 b)
    {
        cout << "void add(T1 a, T2 b)" << endl;
        cout << a + b << endl;
    }
};

template
< typename T1, typename T2 >
class Test < T1*, T2* >      // 关于指针的特化实现
{
public:
    void add(T1* a, T2* b)
    {
        cout << "void add(T1* a, T2* b)" << endl;
        cout << *a + *b << endl;
    }
};

template
< typename T >
class Test < T, T >    // 当 Test 类模板的两个类型参数完全相同时,使用这个实现
{
public:
    void add(T a, T b)
    {
        cout << "void add(T a, T b)" << endl;
        cout << a + b << endl;
    }
    void print()
    {
        cout << "class Test < T, T >" << endl;
    }
};

template
<  >
class Test < void*, void* >    // 当 T1 == void* 并且 T2 == void* 时
{
public:
    void add(void* a, void* b)
    {
        cout << "void add(void* a, void* b)" << endl;
        cout << "Error to add void* param..." << endl;
    }
};

int main()
{  
    Test<int, float> t1;
    Test<long, long> t2;
    Test<void*, void*> t3;
    
    t1.add(1, 2.5);
    
    t2.add(5, 5);
    t2.print();
    
    t3.add(NULL, NULL);
    
    Test<int*, double*> t4;
    int a = 1;
    double b = 0.1;
    
    t4.add(&a, &b);
    
    return 0;
}


4.3 重定义和特化的不同

重定义:

  • 一个类模板和一个新类(或者两个类模板)。
  • 使用的时候需要考虑如何选择的问题。

特化:

  • 以统一的方式使用类模板和特化类。
  • 编译器自动优先选择特化类。

5 模板类的特殊用法

5.1 模板类遇到友元函数

#include <iostream>

using namespace std;

template <typename T>
class A
{
public:
	A(T t=0);

	//声明一个友元函数,实现对两个A类对象进行加法操作
	template <typename T>
	friend A<T> addA(const A<T> &a, const A<T> &b);

	/* 也可以写成如下形式:
	friend A<T> addA <T>(const A<T> &a, const A<T> &b);
	*/

	T &getT();

	A operator +(const A &other);

	void print();

private:
	T t;
};



template <typename T>
A<T>::A(T t)
{
		this->t = t;
}

template <typename T>
T &A<T>::getT()
	{
		return t;
	}

template <typename T>
A<T> A<T>::operator+(const A<T> &other){
		A tmp; //类的内部类型可以显示声明也可以不显示
		tmp.t =this->t + other.t;
		return tmp;
	}

template <typename T>
void A<T>::print(){
	cout<<this->t<<endl;
}


//A 类的友元函数,就是它的好朋友
template <typename T>
A<T> addA(const A<T> &a, const A<T> &b){
	A<T> tmp;
	cout<<"call addA()..."<<endl;
	tmp.t = a.t + b.t;
	return tmp;
}

int main(void){
	
	A<int>  a(666), b(888);
	//cout<<a.getT()<<endl;

	A<int> tmp = a + b;
	A<int> tmp1 = addA<int>(a, b);
	
	tmp.print();
	tmp1.print();

	system("pause");
	return 0;
}

结论:
(1) 类内部声明友元函数,必须写成一下形式

template<typename T>
friend A<T> addA (A<T> &a, A<T> &b);

(2) 友元函数实现 必须写成

template<typename T>
 A<T> add(A<T> &a, A<T> &b)
{
					//......
}

(3)友元函数调用 必须写成A<int> c4 = addA<int>(c1, c2);。

5.2 类模板遇上静态成员

#include <iostream>

using namespace std;

template <typename T>
class A
{
public:
	A(T t=0);

	T &getT();

	A operator +(const A &other);

	void print();

public:
	static int count;
private:
	T t;
};

template <typename T> int A<T>::count = 666;

template <typename T>
A<T>::A(T t)
{
	this->t = t;
}

template <typename T>
T &A<T>::getT()
{
	return t;
}

template <typename T>
A<T> A<T>::operator+(const A<T> &other){
	A tmp; //类的内部类型可以显示声明也可以不显示
	tmp.t =this->t + other.t;
	return tmp;
}

template <typename T>
void A<T>::print(){
	cout<<this->t<<endl;
}

/*
//当我们的虚拟的类型T被 int 实例化以后,模板类如下:
class A
{
public:
A(int t=0);

int &getT();

A operator +(const A &other);

void print();

public:
static int count;
private:
int t;
};

int A::count = 666;


A::A(int t)
{
this->t = t;
}


int &A::getT()
{
return t;
}

A A::operator+(const A &other){
A tmp; //类的内部类型可以显示声明也可以不显示
tmp.t =this->t + other.t;
return tmp;
}


void A::print(){
cout<<this->t<<endl;
}
*/

/*
//当我们的虚拟的类型T被 float 实例化以后,模板类如下:
class A
{
public:
A(float t=0);

float &getT();

A operator +(const A &other);

void print();

public:
static int count;
private:
float t;
};

int A::count = 666;


A::A(float t)
{
this->t = t;
}


float &A::getT()
{
return t;
}

A A::operator+(const A &other){
A tmp; //类的内部类型可以显示声明也可以不显示
tmp.t =this->t + other.t;
return tmp;
}

void A::print(){
cout<<this->t<<endl;
}
*/

int main(void){

	A<int>  a(666), b(888);
	A<int> tmp = a + b;
	//A  a(666), b(888);
	//A tmp = a + b;

	A<float> c(777), d(999);

	a.count = 888;

	cout<<"b.count:"<<b.count<<endl;

	cout<<"c.count:"<<c.count<<endl;
	cout<<"d.count:"<<d.count<<endl;
	c.count = 1000;
	cout<<"修改后, d.count:"<<d.count<<endl;

	//tmp.print();

	system("pause");
	return 0;
}

总结:

  • 从类模板实例化的每个模板类有自己的类模板数据成员,该模板类的所有对象共享一个static数据成员。
  • 和非模板类的static数据成员一样,模板类的static数据成员也应该在文件范围定义和初始化。
  • static 数据成员也可以使用虚拟类型参数T。

参考资料:

  1. C++深度解析教程
  2. C/C++从入门到精通-高级程序员之路【奇牛学院】
STM32C8T6HAL库实战:MAX30102心率血氧检测与OLED多级菜单一体化方案 本文详细介绍了基于STM32C8T6和HAL库的MAX30102心率血氧检测与OLED多级菜单一体化方案。内容涵盖硬件连接、CubeMX工程配置、传感器驱动移植、数据滤波算法、OLED显示驱动以及高效的多级菜单系统设计,旨在提供一个稳定、实用且易于移植的嵌入式健康监测项目参考。 阅读详情

相关推荐

第4课 SiC MOSFET的动态特性——关断过程

本文分析了SiC MOSFET的关断过程,将其划分为四个阶段:栅源电容放电阶段(t6-t7)、米勒平台阶段(t7-t8)、电压过冲阶段(t8-t9)和换流结束阶段(t9-t10)。通过等效电路详细描述了各阶段的电压电流变化特点。同时探讨了MOSFET的极间电容特性,包括输入电容Ciss、输出电容Coss和反向转移电容Crss,分析了它们对器件开关速度、损耗及电压变化速率的影响。研究指出这些非线性电容会显著影响器件的动态性能。

嵌入式老牛的博客 1053

入门指南:C++ 模板类详解

入门指南:C++ 模板类详解

qq_46017342的博客 6333

SRAM ECC原理与应用:从汉明码到高可靠嵌入式系统设计

在嵌入式系统与高可靠性计算领域,内存数据完整性是系统稳定运行的基石。软错误(Soft Error)由宇宙射线或芯片内部粒子引发,可能导致存储单元发生位翻转,进而引发程序跑飞或数据损坏。为应对这一物理层挑战,错误校验与纠正(ECC)技术应运而生,其核心原理基于扩展汉明码,通过增加校验位实现单错误纠正、双错误检测(SECDED)能力。这项技术通过硬件透明纠错,在提升系统可靠性的同时,几乎不影响访问性能。在汽车电子、工业控制及航空航天等对安全性要求极高的场景中,ECC已成为保障长期稳定运行的关键硬件机制。本文聚焦

weixin_28728265的博客 535

C++中的模板类

什么是模板类:C++发展到一定层次后,必然有部分代码存在仅传参的数据类型不同而内容一致的情况。因此,C++为解决此类场景,特推出模板类的使用。模板类是一种泛型技术,即与数据类型无关的通用程序设计技术。可以使我们设计出独立于数据类型的程序。模板类本身不占空间,当编译器执行到模板参数的调用时,当在程序中赋予具体的数据类型后并调用时则占用空间。常见的模板包含函数模板与类模板。模板的声明中class含义同typenamec,class并不是表明后续的类型名是一个类,而表示后续是一个通用的类型说明符。一、函数模板函数

qq_39645539的博客 1万+

PotPlayer终极画质调校:深入MadVR渲染器设置,让你的显示器发挥100%潜力

本文深入探讨了如何通过MadVR渲染器优化PotPlayer的画质设置,充分发挥高端显卡和显示器的潜力。从色彩空间匹配、色深优化到HDR元数据处理,提供了一套完整的配置指南,帮助用户实现影院级视觉体验。特别适合拥有NVIDIA RTX或AMD RX系列显卡的用户进行精细调校。

weixin_42530458的博客 610

Lumerical-定向耦合器1

概述:本文章使用FDE求解器对定向耦合器进行了数值仿真,讨论了耦合器的间距相关性,耦合长度相关性,波长相关性。讨论了脊形波导和条形波导两种情况。

m0_61776728的博客 4620

c++中的类模板

目录类模板模板类 类模板 同函数模板,大部分性质相同,类模板也用于代码的重用性体现,性质可见“函数模板” 定义格式: template <class NAME1,class NAME2,...> class class_name{ ///... }; 或 template <typename NAME1,typename NAME2,...> class class_name { //... }; (在模板中class 与 typename关键字的作

来,骗!来,偷袭! 2966

有源滤波电路设计

目录一、低通滤波器1、同相输入低通滤波器(1)一阶低通滤波电路(2)二阶低通滤波电路(压控电压源;Sallen-Key)2、反相输入低通滤波器(1)一阶低通滤波电路(2)二阶低通滤波电路(无限增益多路反馈)二、高通滤波器1、同相输入高通滤波器(1)一阶高通滤波电路(2)二阶高通滤波电路(压控电压源;Sallen-Key)2、反相输入高通滤波电路(1)二阶高通滤波电路(无限增益多路反馈) 一、低通滤波器 1、同相输入低通滤波器 (1)一阶低通滤波电路 即在一阶无源低通滤波器的基础上,加了一个集成运放。 它的

qq_41873236的博客 3万+

C++ 模板基础知识——类模板中的友元

在C++中,类模板中的友元关系可以是相当复杂的主题,因为它涉及到模板参数化和类型依赖的处理。友元在类模板中的使用可以帮助你在保持类封装的同时,允许特定的其他类或函数访问其私有或保护成员。

慢慢记录,慢慢更新。 2762

核回归(Kernel Regression)

本文讲解了核函数,并且实战通过核函数进行了预测,并附python代码

a2333333_的博客 6960

毕设助力!从0到1构建基于YOLO的家居安防异常活动监测系统,让你的毕设守护家庭安全

做完这个项目,你会发现自己完整走过了“数据采集→标注→模型训练→功能集成→界面开发”的毕设全流程,这不仅是技术能力的证明,更是对“技术守护生活”这一理念的实践。答辩时,你可以重点讲这几点:系统解决了家居安防的哪些痛点、对比了不同YOLO模型的性能差异、系统未来能怎么优化(比如对接智能门锁/报警器、实现语音交互)。未来,这个系统还能往“更智能”的方向发展:比如结合行为分析判断异常意图、开发移动端APP实现全屋设备联动、在智慧社区中实现多家庭联防……想象空间很大。

LXY_LOVE36的博客 125

C++中的类模板详细讲述

当使用包含编译模式时,类模板成员的定义被包含在使用其实例的所有程序文本文件中,何时何地编译器实例化类模板成员的定义,我们并不能精确地知晓,为解决这个问题,标准C++提供了显式实例声明:关键字template后面跟着关键字class以及类模板实例的名字。这种编译模式下,类模板的成员函数和静态成员的定义必须被包含在“要将它们实例化”的所有文件中,如果一个成员函数被定义在类模板定义之外,那么这些定义应该被放在含有该类模板定义的头文件中。当一个类模板名被用作另一个模板定义中的类型指示符时,必须指定完整的实参表。

开往春天的地铁 854

TMS_WebGMaps_1.9.8.0_Full_Source

TMS_WebGMaps_1.9.8.0_Full_Source 全源码 delphi cbuilder

【C++】C++中的类模板

基础的类模板 模板类的继承 内部声明定义普通模板函数和友元模板函数 内部声明友元模板函数+外部定义友元模板函数 声明和定义分别在不同的文件(模板函数、模板友元) C++中有一个重要特性,那就是模板类型。类似于Objective-C中的泛型。C++通过类模板来实现泛型支持。 1 基础的类模板 类模板,可以定义相同的操作,拥有不同数据类型的成员属性。通常使用templa...

weixin_30876945的博客 191

怀旧版电脑GBC模拟器

再现原版GBC掌机的界面,电脑运行连游戏界面都一样大小,很怀旧,很真实,(英文版)强烈推荐,很小的文件,很难才找到的。

贝叶斯统计 [韦来生编]

贝叶斯(Bayes)统计是近几十年来迅速发展起来的数理统计的一个重要分支。贝叶斯方法与经典统计方法的主要不同之处是进行统计推断时除了利用样本信息外,还要利用参数的先验信息,因此可以提高统计推断或统计决策的效果。它在经济、金融、生物、医学、自然科学和社会科学等许多领域具有广泛的应用。贝叶斯方法的研究已渗透到了统计学的几乎所有领域。作者在给中国科学技术大学概率论与数理统计专业本科生开设的“数理统计”课程中有一章专门讲授“贝叶斯方法和统计决策理论”,近十年来也给中国科学技术大学概率统计专业研究生开设过几次“贝叶斯分析”课。本书是在对过去讲稿的内容作了适当的增减和调整的基础上完成的。  本书共分六章。第1章是绪论,介绍了贝叶斯统计的若干基本概念,同时对必要的数理统计的基础知识有重点地作了回顾。第二章介绍了确定先验分布的若干可供选择的方法。第三章介绍了几类常见统计模型参数的后验分布的主要结果和计算方法。第四章和第五章分别介绍了“贝叶斯统计推断”和“贝叶斯统计决策”的内容。第六章介绍了贝叶斯统计计算的若干方法,包括蒙特卡洛方法和马尔可夫链蒙特卡洛(MCMC)方法以及相关统计软件的简介。本书的每一章附右大量的例题和习题,书末附有常用的几个表格和部分习题解答供读者查用。  大约可在54学时内讲授本书的第1章至第六章的主要内容,教师可根据学时需要选讲本书第1章至第六章的部分内容。书中标“*”号的章节可略去不讲,留给读者作为阅读材料。第六章例题中的R代码和部分例题的数据文件等可从作者个人主页下载。  作者在编写本书的过程中参考了J.O.Berger教授的《统计决策论及贝叶斯分析》和茆诗松教授编写的《贝叶斯统计》等书中的一些内容,以及《贝叶斯分析》一书中由张伟平博士编写的有关贝叶斯统计计算的一些内容。在此表示衷心感谢。  本书编写准备过程中,中国科学技术大学统计与金融系的几个研究生帮助完成了本书部分中文的录入和排版,作者对他们的辛勤工作表示真诚的感谢。高等教育出版社为本书的出版给予了大力支持。在此一并致谢。

c++中类模板中的函数第二种情形:所有函数都在类的外部,但是都在一个cpp文件中

针对于所有的函数都在类的外部,但是都在一个cpp文件中的这种情形,只有友元函数的存在是比较特殊和难处理的。 (1) 类中只有成员函数的情况 代码如下,注意代码的书写规则: #include <iostream> using namespace std; template <typename T> class Complex { ...

一路向北 398

文档:亲测可用解决vnc灰屏,黑屏,鼠标大黑叉情况

主要解决vnc-viewer灰屏,黑屏,鼠标大黑叉等现象,详细见文档。

C++中的类模板(黑马程序员)

类模板

Bruce 2175

c++中类模板中的函数第三种情形:声明和实现分来,分别在不同的.h和.cpp文件中

关于类模板的解释在“c++中类模板中的函数第二种情形”中已经做了说明,本节内容具体看代码即可。 .h文件: #pragma once #include <iostream> using namespace std; template <typename T> class Complex; //类的前置声明 template <typename T> ...

一路向北 1111
上一篇: C++中的函数模板
下一篇: 单例类模板
SlowIsFastLemon
博客等级 码龄8年 265粉丝 790原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值