C++_模板_学习笔记

已于 2024-05-08 19:40:04 修改
阅读量386 收藏 8
点赞数 4
分类专栏： C++学习笔记 文章标签： c++ 学习 笔记
于 2024-05-05 13:49:30 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/uncle_tou/article/details/138441886
版权

模板的作用：简历通用的模具，提高复用性。
C++提供两种模板机制：函数模板和类模板

1 函数模板

1.1 函数模板语法

template<typename T>
函数声明或定义

template — 声明创建模板
typename — 表明其后面的符号是一种数据类型，可以用class代替
T — 通用的数据类型，名称可以替换

例如：要实现两个数交换，每种情况都写一遍太麻烦了，使用模板来搞：
template<typename T>
void mySwap(T& a, T& b)
{
	T temp = a;
	a = b;
	b = temp;
}

int main()
{
	int a1 = 10;
	int b1 = 20;
	float a2 = 10;
	float b2 = 20;
	// 调用方法1、自动类型推导
	mySwap(a1, b1);
	// 调用方法2、显式指定类型
	mySwap<float>(a2, b2);
	return 0;
}

注意事项1. 模板的使用可以通过自动类型推导，但必须推导出一致的数据类型T才可以使用。
即

	int a1 = 10;
	float b1 = 20;
	mySwap(a1, b1);

这样做是非法的，推导出来的T不一致。
注意事项2. 模板必须要确定出T的数据类型才可以使用
即

template <typename T>
void func()
{
	cout << "OMG" << endl;
}
int main()
{
	func(); //这样做是非法的，因为没有指出确定的T。
	func<int>(); // 对于这种情况，要指定数据类型才能正常运行。
}

1.2 函数模板和普通函数的区别

  1. 普通函数调用可以发生隐式类型转换
int func(int a, int b){...}
int main()
{
	int a = 10;
	char b = 'd';
	func(a , b);
}

该函数会将b强制转换为int，再执行函数
  1. 函数模板用自动类型推导时，不可以发生隐式类型转换
template<typename T>
T func(T a, T b){...}
int main()
{
	int a = 10;
	char b = 'd';
	func(a , b);
}

这样会报错
  1. 函数模板用显式指定类型时，可以发生隐式类型转换
template<typename T>
T func(T a, T b){...}
int main()
{
	int a = 10;
	char b = 'd';
	func<int>(a , b);
}

这样会将b强制转换为int，再运行函数。

建议使用显式指定类型来调用模板

2 类模板

2.1 类模板基本语法

template<typename T>
类

template<class NameType, class AgeType>
//这里的class和typename一样的，有的人为了方便区分，写类模板时用class
class Person
{
public:
	Person(NameType name, AgeType age)
	{
		this->m_name = name;
		this->m_age = age;
	}
	void showPerson()
	{
		cout << m_name << m_age << endl;
	}
	NameType m_name;
	AgeType m_age;
};

int main()
{
	Person<string, int> p1 ("卢本伟", 25) ;
	p1.showPerson();
	return 0;
}

类模板没有自动类型推导，必须显式指定类型。
类模板中的成员函数只有当程序运行时才会创建；而普通类中的成员函数在编译时就会创建。

2.2 类模板对象做函数参数

目的：类模板实例化出来的对象，作为函数的参数。
有三种传入方式：

  1. 指定传入类型：直接显式对象的数据类型
  2. 参数模板化：将对象中的参数变为模板进行传递
  3. 类模板化：将这个对象类型模板化进行传递
    最常用的是指定传入类型
template<class T1, class T2>
class Person
{
public:
	Person(T1 name, T2 age)
	{
		this->m_name = name;
		this->m_age = age;
	}
	void ShowPerson()
	{
		cout << "姓名：" << this->m_name << "\t年龄：" << this->m_age << endl;
	}
	T1 m_name;
	T2 m_age;

};
//1、指定传入类型
void PrintPerson1(Person<string,int> &p)
{
	p.ShowPerson();
}
//2、参数模板化
template<typename T1, typename T2>
void PrintPerson2(Person< T1, T2 >& p)
{
	p.ShowPerson();
}
//3、类模板化
template<typename T>
void PrintPerson3(T &p)
{
	p.ShowPerson();
}

int main()
{
	Person<string, int> p1 ("卢本伟", 25) ;
	PrintPerson1(p1);
	PrintPerson2(p1);
	PrintPerson3(p1);

	return 0;
}

typeid(变量名).name()	
可以查看变量的数据类型

2.3 类模板继承

注意事项：

  1. 当父类是类模板时，子类声明时要指定父类中T的类型，否则编译器无法给子类分配内存
template <class T>
class Base
{
	T m;
};

class Son:public Base<int>//需要知道父类中T的类型
{...};
  1. 如果想要灵活指出父类T的类型，子类也需要变为类模板
template <class T>
class Base
{
	T m;
};

template <class T>
class Son :public Base<T>
{
	T obj;
};

如果要更灵活的话：

template <class T>
class Base
{
	T m;
};
template <class T1, class T2>
class Son :public Base<T2>
{
	T1 obj;
};

2.4 类模板成员函数类外实现

template <class T1, class T2>
class Person
{
public:
	Person(T1 name, T2 age);
	/*{
		this->m_name = name;
		this->m_age = age;
	}*/
	void showPerson();
	/*{
		cout << this->m_name << this->m_age << endl;
	}*/
	T1 m_name;
	T2 m_age;
};
//构造函数的类外实现
template <class T1, class T2>
Person<T1 , T2>::Person(T1 name, T2 age)
{
	this->m_name = name;
	this->m_age = age;
}
//成员函数的类外实现
template <class T1, class T2>
void Person<T1,T2>::showPerson()
{
	cout << this->m_name << this->m_age << endl;
}


int main()
{s

	Person<string, int> p("卢本伟", 25);
	p.showPerson();
	return 0;
}

2.5 类模板友元

全局函数类内实现：直接在类内声明友元即可
全局函数类外实现：需要提前让编译器知道全局函数的存在

//2、全局函数类外实现
//由于需要让编译器提前知道这个函数，需要将函数定义放在最前面
//又由于函数定义中有Person，又要把Person的声明放前面
template<class T1, class T2>
class Person;
template<class T1, class T2>
void printPerson2(Person<T1, T2> p)
{
	cout << "类外实现：" << p.m_name << p.m_age << endl;
}



template<class T1 , class T2>
class Person
{
	//1、全局函数类内实现
	friend void printPerson1(Person<T1, T2> p)
	{
		cout << "类内实现：" << p.m_name << p.m_age << endl;
	}

	//2、全局函数类外实现
	//由于类外实现时定义其为模板，所以需要添加空模板参数列表<>
	friend void printPerson2<>(Person<T1, T2> p);
	

public:
	Person(T1 name, T2 age)
	{
		this->m_name = name;
		this->m_age = age;
	}
private:
	T1 m_name;
	T2 m_age;
};



int main()
{
	Person<string, int> p("卢本伟", 25);
	printPerson1(p);
	printPerson2(p);

	return 0;
}

2.6 数组类封装例程

功能：

  1. 可以对内置数据类型以及自定义数据类型的数据进行存储
  2. 将数组中的数据存储到堆区
  3. 构造函数中可以传入数组的容量
  4. 提供对应的拷贝构造函数以及operator-防止浅拷贝问题
  5. 提供尾插法和尾删法对数组中的数据进行增加和删除
  6. 可以通过下标的方式访问数组中的元素
  7. 可以获取数组中当前元素个数和数组的容量

文件1、myarray.hpp，存放自定义的通用数组类

//myarray.hpp
//自定义的通用数组类
#pragma once
#include <iostream>
#include <string>
using namespace std;

template<class T>
class myArray
{
public:
	myArray(int capacity)//构造函数
	{
		cout << "myarray构造函数调用" << endl;
		this->m_capacity = capacity;
		this->m_size = 0;
		this->pAddress = new T[this->m_capacity]; // 按照容量在堆区开辟存放数组的空间
	}
	myArray(const myArray& arr)//拷贝构造函数。防止浅拷贝，浅拷贝会导致析构时堆区数据重复释放
	{
		cout << "myarray拷贝构造函数调用" << endl;
		this->m_capacity = arr.m_capacity;
		this->m_size = arr.m_size;

		this->pAddress = new T[arr.m_capacity];//深拷贝
		for (int i = 0; i < this->m_capacity; i++)//将原始数组中的元素一个个拷贝到新开辟的空间------------------m_capacity?课件写的是m_size
		{
			this->pAddress[i] = arr.pAddress[i];
		}
	}
	//operator= 赋值运算符重载，为了实现数组的a=b
	myArray& operator=(const myArray& arr)
	{
		cout << "myarray赋值运算符重载调用" << endl;
		//先判断堆区原来是否有数据，有就释放
		if (this->pAddress != NULL)
		{
			delete[] this->pAddress;
		}
		//基本同拷贝构造
		this->m_capacity = arr.m_capacity;
		this->m_size = arr.m_size;
		this->pAddress = new T[arr.m_capacity];//深拷贝
		for (int i = 0; i < this->m_capacity; i++)
		{
			this->pAddress[i] = arr.pAddress[i];
		}
	}

	// 尾插法实现数据添加
	void Puch_Back(const T& val)
	{
		//判断满了没
		if (this->m_capacity == this->m_size) 
		{
			cout << "塞满了" << endl;
			return;
		}
		this->pAddress[this->m_size] = val;
		this->m_size++;
	}
	// 尾删法实现数据删除。让用户访问不到最后一个元素
	void Pop_Back()
	{
		if (this->m_size == 0)
		{
			cout << "没东西可删" << endl;
			return;
		}
		this->m_size--;
	}
	//通过下标方式访问数组元素
	//因为现在myArray是模板，需要重载中括号。又由于想要通过arr[0] = 100赋值，所以返回的不是T而是T&
	T& operator[](int index)
	{
		return this->pAddress[index];
	}
	//返回容量
	int getCapacity()
	{
		return this->m_capacity;
	}
	//返回大小
	int getSize()
	{
		return this->m_size;
	}


	~myArray()//析构函数
	{
		cout << "myarray析构函数调用" << endl;
		if (this->pAddress != NULL)
		{
			delete[] this->pAddress; // 因为是释放数组所以要加[]
			this->pAddress = NULL; //置空防止野指针
		}
	}
private:
	T* pAddress;//指针指向堆区开辟的真实数组
	int m_capacity; // 数组容量
	int m_size; // 数组所占空间大小
};

文件2、test.cpp，用于存放测试代码

#include <iostream>
#include <string>
#include <fstream>
#include "myarray.hpp"
using namespace std;

void printIntArray(myArray <int>&arr)
{
	for (int i = 0; i < arr.getSize(); i++)
	{
		cout << arr[i] << endl;
	}
}
void test1() //测试内置数据类型
{
	myArray <int>arr1(15);
	//测试尾插法插入数据
	for (int i = 0; i < 5; i++)
	{
		arr1.Puch_Back(i);
	}
	cout << "arr1的打印输出为：" << endl;
	printIntArray(arr1);

	cout << "arr1的容量为：" << arr1.getCapacity() << endl;
	cout << "arr1的大小为：" << arr1.getSize() << endl;

	myArray <int>arr2(arr1);
	//测试尾删法删除数据
	arr2.Pop_Back();
	cout << "arr2的打印输出为：" << endl;
	printIntArray(arr2);
	cout << "arr2的容量为：" << arr2.getCapacity() << endl;
	cout << "arr2的大小为：" << arr2.getSize() << endl;


}


class Person
{
public:
	Person() {};//因为在堆区创建，需要弄一个无参空实现
	Person(string name, int age)
	{
		this->m_name = name;
		this->m_age = age;
	}
	string m_name;
	int m_age;
};
void printPersonArray(myArray<Person>& arr)
{
	for (int i = 0; i < arr.getSize(); i++)
	{
		cout << arr[i].m_name << arr[i].m_age << endl;
	}
}
void test2() //测试自定义数据类型
{
	myArray<Person> arr(10);
	Person p1("卢本伟", 25);
	Person p2("刀哥", 35);
	Person p3("孙笑川", 30);
	arr.Puch_Back(p1);
	arr.Puch_Back(p2);
	arr.Puch_Back(p3);
	printPersonArray(arr);
}
int main()
{
	test1();
	test2();
	return 0;
}
UNCLE-TOU?
关注
  • 4
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++学习笔记_C++_
10-03
总结，C++学习笔记涵盖了从基础到高级的各种主题，包括面向对象编程的精髓、模板和标准库的使用、异常处理和命名空间的管理，以及C++11及后续标准的新特性。通过深入理解和实践这些知识点，开发者能够熟练掌握C++，...
C语言和C++Builder学习笔记.rar_C++笔记_c++学习笔记_c/C++_学习笔记_编程语言
09-20
【C语言和C++Builder学习笔记】 C语言和C++是两种广泛使用的编程语言，它们在软件开发领域占据着重要地位。C语言以其简洁、高效和底层操作能力著称，而C++则在C的基础上引入了面向对象编程，极大地扩展了其应用范围...
C++笔记.zip_C++_笔记
07-13
本资料"**C++笔记.zip**"提供了全面的C++学习资料，特别是针对C++初学者和进阶者的一份宝贵的资源集合。 **C++基础** C++的基础部分包括语法、变量、数据类型、运算符、流程控制等。C++支持基本的数据类型如int、...
C++笔记_C++_
10-01
这份"C++笔记"涵盖了C++的核心概念和技术，旨在帮助学习者掌握这一强大的编程工具。 C++起源于C语言，由Bjarne Stroustrup在1983年为了增加面向对象编程功能而设计。C++不仅保留了C语言的效率和灵活性，还引入了类...
C++基础语法学习笔记_C++初学者学习笔记_
09-30
以上只是C++基础语法的一部分，实际学习中还需要理解并掌握更多内容，如模板、STL（标准模板库）、文件I/O、多态、继承和封装等。持续学习和实践是掌握C++的关键。随着你对C++的理解加深，你将能够编写更复杂、功能...
C语言：刷题笔记
weixin_45930573的博客
09-04 409
c语言刷题记录
【C++】STL—vector的使用
2301_77112794的博客
09-04 705
本文介绍了vector重点函数接口的使用
【C++】vector的简单模拟实现
2303_80828380的博客
09-05 1222
vector的简单模拟实现！！！
C语言 | Leetcode C语言题解之第389题找不同
m0_59237910的博客
09-07 494
C语言 | Leetcode C语言题解之第389题找不同
C语言 ——— #define 定义宏
weixin_55341642的博客
09-04 830
a + b 的和 于 b - a 的差 做乘法，a + b = 8 ，b - a = 2。#define 机制包括了一个规定，允许把参数替换到文本中，这种实现通常称宏。在宏中的每个变量都加上了括号，加上括号的意义在哪，是否能去掉括号呢？所以在声明宏的时候，最好加上必要的括号，以免出现优先级问题。可以从代码验证中看出，不加括号的结果和预期的结果大相径庭。预期结果：8 * 2 = 16。
QWidget(c++)嵌入window环境的exe
sunflower_2020的博客
09-05 278
QWidget(c++)嵌入window环境的exe
C语言——strcpy、sprintf与memcpy
鲸落博客
09-09 709
该函数和printf()函数有很多相似之处，例如printf()将不同类型的数据格式化到终端，而sprintf()函数是将不同类型的数据格式化到字符串中。另外，和strcpy()函数一样，该函数也不会对目标缓冲区进行检查，容易造成溢出。它是一种非常通用的内存复制函数，不仅限于复制字符串，还可以复制任何类型的内存块。3. 未定义行为：程序可能会继续运行，但结果不可预测，可能会输出错误的结果或导致其他未预料的行为。如果memcpy复制字符串，要复制的字节数超过原内存块本身的内存数，会怎么样？
[ C++ ] 一文复习（基础语法，语言特性，STL回顾）
2301_79175236的博客
09-04 1059
C++复习参考文，待完善
c++ 类的继承详解
HJQD777的博客
09-07 466
继承允许类之间建立层次关系，促进代码重用和扩展。继承有不同的访问控制方式（publicprotectedprivate），影响派生类对基类成员的访问权限。基类的构造函数和析构函数不会被继承，派生类需要自行定义。使用虚函数和多态可以实现灵活的接口设计和动态方法调用。理解继承机制对于设计高效、灵活和可维护的面向对象系统至关重要。
【启明智显技术分享】探讨CAN总线相关知识以及Model3C 2路CAN的应用
ami82的博客
09-05 654
通信错误：由于CAN总线上的节点之间存在不同的优先级，可能导致数据冲突。总线阻塞：在某些情况下，CAN总线上的节点可能会长时间保持发送状态，从而导致其他节点无法发送数据，这种现象被称为总线阻塞。总线干扰：CAN总线可能会受到外部电磁干扰，如电源干扰、射频干扰等，这些干扰可能导致总线上的数据传输出错。总线过载：当CAN总线上的节点数量过多或者通信数据量过大时，可能导致总线过载，从而影响通信性能和稳定性。总线错误：CAN总线上的节点可能会发生硬件故障，例如控制器损坏、接口损坏等，这些情况都可能导致总线错误。
C/C++内存详解
2301_79181030的博客
09-03 1484
注意，对于数组，不会调用构造函数来初始化每个元素（除非元素类型是类类型且该类提供了默认构造函数），而是进行默认初始化（对于类类型，调用默认构造函数；，new在底层调用operator new全局函数来申请空间，delete在底层通过operator delete全局函数来释放空间。对于自定义类型的对象，例如类对象，new对象的同时会调用构造函数对对象进行构造，delete对象的同时会调用析构函数对对象进行析构。操作符用于在堆（heap）上动态分配内存，并调用对象的构造函数（如果有的话）。
C 标准库 - `＜float.h＞`
wjs2024的博客
09-08 246
float.h>是 C 标准库中的一个头文件，它定义了与浮点数类型相关的宏。这些宏提供了关于浮点数的属性信息，如精度、最小和最大值、以及舍入误差等。这个头文件对于需要精确控制浮点数行为的程序非常有用，尤其是在数值计算和科学计算领域。<float.h>是 C 标准库中一个重要的头文件，它提供了关于浮点数的属性信息，对于需要精确控制浮点数行为的程序非常有用。掌握<float.h>中的宏，可以帮助开发者更好地理解和处理浮点数。
【项目二】C++高性能服务器开发——日志系统(日志器，日志级别，日志事件)
weixin_45962681的博客
09-06 184
其实也没啥。
C++ 标准库的典型内容
最新发布
qq_68194402的博客
09-10 559
C++ 标准库提供了一系列强大且灵活的工具和组件，用于简化程序设计和提高开发效率。它包含多种功能模块，涵盖了内存管理、数据结构、算法、输入输出操作以及类型特征等多个方面
C++模板入门与学习概览
"C++学习笔记，模板的引入，C++概述，C与C++的关系，面向对象程序设计，C++的行业地位" 在C++学习过程中，模板的引入是为了更高效地处理不同类型的数据，减少代码的冗余。当我们需要编写如`max`这样的函数来找出两...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值