31C++编程提高篇----2、类模板原理

已于 2022-10-13 21:02:06 修改
阅读量467 收藏
点赞数
分类专栏： C++ 文章标签： c++ c# 开发语言 类模板
于 2022-08-28 13:36:15 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45986997/article/details/126568972
版权

文章目录

10.3 类模板

10.3.1 类模板

类模板作用：

  • 建立一个通用类，类中的成员，数据类型可以不具体制定，用一个虚拟的类型来代表。

语法：

template<typename T>
类

解释：

template------------声明创建模板

typename ---------表明其后面的符号是一种数据类型，可以用class 代替

T --------- 通用的数据类型，名称可以替换，通常为大写字母

示例代码：

#include<iostream>
using namespace std;
#include<string>
//类模板
template<class NameType,class AgeType>
class Person
{
public:
	Person(NameType name, AgeType age)
	{
		m_name = name;
		m_age = age;
	}

	void showPerson()
	{
		cout << this->m_name << "      " << this->m_age <<"岁"<< endl;
	}

	NameType m_name;
	AgeType m_age;
};

void test71()
{
	Person<string, int>p1("孙悟空", 99);
	p1.showPerson();
}

int main()
{
	test71();
	system("pause");
	return 0;
}

运行结果：

在这里插入图片描述

**总结：**类模板和函数模板语法相似，在声明模板template后面加类，此类称为类模板。

10.3.2 类模板与函数模板区别

类模糊与函数模板区别主要有两点：

  1. 类模板没有自动类型推导的使用方式
  2. 类模板在模板参数列表中可以有默认参数

示例代码：

#include<iostream>
using namespace std;
#include<string>

//类模板与函数模板区别
//template<class NameType,class AgeType>
template<class NameType,class AgeType=int> //在参数列表中指定参数AgeType默认类型为int
class Person7
{
public:
	Person7(NameType name,AgeType age)
	{
		this->m_Name = name;
		this->m_Age = age;
	}

	void showPerson7()
	{
		cout << this->m_Name << " " << this->m_Age << "岁" << endl;
	}

	NameType m_Name;
	AgeType		m_Age;
};

//1、类模板没有自动类型推导使用方式
void test81()
{
	//Person7 p("孙悟空",100);  错误，无法用自动类型推导
	Person7<string, int>p("孙悟空",100);//正确，只能用显示指定类型方式
	p.showPerson7();
}

//2、类模板在模板参数列表中可以有默认参数
void test82()
{
	Person7<string>p("猪八戒", 999);
	p.showPerson7();
}

int main()
{
	//test81();
	test82();
	system("pause");
	return 0;
}

运行结果：

在这里插入图片描述

总结：

  • 类模板使用只能用显示指定类型方式
  • 类模板中的目标参数列表可以有默认参数
10.3.3 类模板中成员函数创建时机

类模板中成员函数和普通函数中成员函数创建时机是有区别的：

  • 普通类中的成员函数一开始就可以创建
  • 类模板中的成员函数在调用时才开始创建

示例代码：

#include<iostream>
using namespace std;

//类模板中成员函数创建时机
//类模板中成员函数在调用时才去创建

class Person91
{
public:
	void showPerson91()
	{
		cout << "showPerson91()" << endl;
	}
};

class Person92
{
public:
	void showPerson92()
	{
		cout << "showPerson92()" << endl;
	}
};

template<class T>
class MyClass
{
public:
	T obj;
	//类模板中的成员函数，并不是一开始就创建的，而是在模板调用时再生成
	void  func1()
	{
		obj.showPerson91();
	}

	void func2()
	{
		obj.showPerson92();
	}
};

void test91()
{
	MyClass<Person92>m;
	//m.func1();		//编译会出错，什么函数调用才会去创建成员函数
	m.func2();
}

int main()
{
	test91();
	system("pause");
	return 0;
}

运行结果：

在这里插入图片描述

**总结：**类模板中的成员函数并不是一开始就创建的，而是在调用时才会创建。

10.3.4 类模板对象做函数参数

学习目标：

  • 类模板实例化出的对象，向函数传参的方式

一共有三种传入方式：

  1. 指定传入的类型 ---- 直接显示对象的数据类型
  2. 参数模板化 -----将对象中的参数变为模板进行传递
  3. 整个模板 ----将这个对象类型模板化进行传递

示例代码:

#include<iostream>
using namespace std;
#include<string>

//类模板做函数参数
template<class TN,class TA>
class Person10
{
public:
	Person10(TN name, TA age)
	{
		this->m_Name = name;
		this->m_Age = age;
	}

	void showPerson10()
	{
		cout << "姓名：" << this->m_Name << "  " << "年龄：" << this->m_Age << endl;
	}

	TN m_Name;
	TA m_Age;
};

//1、指定传入类型
void printPerson1(Person10 <string, int >&p) //通过引用的方式传入
{
	p.showPerson10();
}

void test101()
{
	Person10 <string, int >p("孙悟空",9);
	printPerson1(p);
}

//2、参数模板化
template<class T1,class T2>
void printPerson2(Person10<T1, T2>&p)
{
	p.showPerson10();
	//打印T1和T2的数据类型
	cout << "T1的类型为：" << typeid(T1).name() << endl;
	cout << "T2的类型为：" << typeid(T2).name() << endl;
}
void test102()
{
	Person10<string, int>p("小猪猪", 8);
	printPerson2(p);
}

//3、整个类模板化
template<class T>
void printPerson3( T &p)
{
	p.showPerson10();
	//打印T所代表的数据类型
	cout << "T的数据类型为：" << typeid(T).name() << endl;
}
void test103()
{
	Person10<string, int>p("唐憎",10);
	printPerson3(p);
}

int main()
{
	//test101();
	//test102();
	test103();
	system("pause");
	return 0;
}

运行结果：

在这里插入图片描述

总结：

  • 通过类模板创建的对象，可以有三种方式向函数中进行传参
  • 使用比较广泛的是第一种：指定传入的类型
10.3.5 类模板与继承

当类模板碰到继承时，需要注意以下几点：

  • 当子类继承的父类是一个类模板时，子类在声明的时候，要指定出父类中T的类型
  • 如果不指定，编译器无法给子类分配内存
  • 如果想灵活指定出父类中T的类型，子类也需变为类模板

示例代码：

#include<iostream>
using namespace std;

//类模板与继承
template<class T>
class Base
{
public:
	T m;
};

//class Son :public Base		//错误，必须知道父类中T的类型，才能继承给子类
class Son:public Base<int>
{

};

void test11()
{
	Son s1;
}

//如果想灵活指定父类中T类型，子类也需要变为类模板
template<class T1, class T2>
class Son2 :public Base<T1>
{
public:
	Son2()
	{
		cout << "T1的类型为：" << typeid(T1).name() << endl;
		cout << "T2的类型为：" << typeid(T2).name() << endl;
	}

	T2 obj;
};

void test112()
{
	Son2 <char, int>s2;
}

int main()
{
	//test11();
	test112();
	system("pause");
	return 0;
}

运行结果：

在这里插入图片描述

**总结：**如果父类是类模板，子类需要指定出父类中T的数据类型

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

学习目标：能够掌握类模板中的成员函数类外实现

示例代码：

#include<iostream>
using namespace std;
#include<string>

//类模板成员函数类外实现
template<class T1,class T2>
class Person12
{
public:
	Person12(T1 name, T2 age);
	//{
	//	m_Name = name;
	//	m_Age = age;
	//}
	void showPerson12();
	//{
	//	cout << "姓名：" << thiis->m_Name << " " << "年龄：" << this->m_Age << endl;
	//}

	T1 m_Name;
	T2 m_Age;
};

//构造函数类外实现
template<class T1, class T2>
Person12<T1,T2>::Person12(T1 name, T2 age)
{
	m_Name = name;
	m_Age = age;
}

//类模板中成员函数类外实现
template<class T1, class T2>
void Person12<T1, T2>::showPerson12()
{
	cout << "姓名：" << this->m_Name << " " << "年龄：" << this->m_Age << endl;
}

void test12()
{
	Person12<string, int>P("Mr.liao", 22);
	P.showPerson12();
}

int main()
{
	test12();
	system("pause");
	return 0;
}

运行结果：

在这里插入图片描述

总结:；类模板中成员函数类外实现时，需要加上模板参数列表

10.3.7 类模板分文件编写

学习目标：

  • 掌握类模板成员函数分文件编写产生的问题以及解决方式

问题：

  • 类模板中成员函数创建时机是在调用阶段，导致分文件编写是连接不到

解决办法：

  • 解决方式1：直接包含.cpp源文件
  • 解决方式2：将声明和实现写到同一个文件中，并更改后缀名为.hpp，hpp是约定的名称，并不是强制。

示例代码：

person13.hpp文件

#pragma once
#include<iostream>
using namespace std;
#include<string>

//类模板分文件编写问题以及解决办法
template<class T1, class T2>
class Person13
{
public:
	Person13(T1 name, T2 age);
	void showPerson13();

	T1 m_Name;
	T2 m_Age;
};

//类模板的构造函数类外实现
template <class T1, class T2>
Person13<T1, T2>::Person13(T1 name, T2 age)
{
	this->m_Name = name;
	this->m_Age = age;
}

//类模板成员函数类外实现
template <class T1, class T2>
void Person13<T1, T2>::showPerson13()
{
	cout << "姓名：" << this->m_Name << " " << "学号：" << this->m_Age << endl;
}

main.cpp文件

#include<iostream>
using namespace std;

//第一种解决方法直接包含源文件
//#include"person13.h"
//#include"person13.cpp"

//第二种解决办法，将.h和.cpp中的内容写到一起，将后缀名改为.hpp文件
#include"person13.hpp"

类模板分文件编写问题以及解决办法
//template<class T1,class T2>
//class Person13
//{
//public:
//	Person13(T1 name, T2 age);
//	void showPerson13();
//
//	T1 m_Name;
//	T2 m_Age;
//};

类模板的构造函数类外实现
//template <class T1,class T2>
//Person13<T1,T2>::Person13(T1 name, T2 age)
//{
//	this->m_Name = name;
//	this->m_Age = age;
//}

//类模板成员函数类外实现
//template <class T1, class T2>
//void Person13<T1, T2>::showPerson13()
//{
//	cout << "姓名：" << this->m_Name << " " << "学号：" << this->m_Age << endl;
//}

void test13()
{
	Person13<string, int>p("Mr.liao",22);
	p.showPerson13();
}

int main()
{
	test13();
	system("pause");
	return 0;
}

运行结果：

在这里插入图片描述

**总结：**主流的解决方式是第二种，将类模板成员函数写到一起，并将后缀名改成.hpp

10.3.8 类模板与友元

学习目标：

  • 掌握类模板配合友元函数的类内和类外实现

全局函数类内实现 - 直接在类内声明友元即可

全局函数类外实现 - 需要提前让编译器知道全局函数的存在

示例代码：

#include<iostream>
using namespace std;

//提前让编译器知道Person类存在
 template<class T1,class T2>
 class Person14;

//2、全局函数类外实现
template<class T1, class T2>
void showPerson2(Person14<T1, T2>p)
{
	cout << "姓名：" << p.m_Name << " " << "年龄：" << p.m_age << endl;
}

//通过全局函数 打印Person信息
template<class T1,class T2>
class Person14
{
	//1、全局函数，类内实现
	friend  void showPerson1(Person14<T1, T2>p)
	{
		cout << "姓名：" << p.m_Name << " " << "年龄：" << p.m_age << endl;
	}

	//2、全局函数类外实现
	//加空模板的参数列表
	//如果全局函数是类外实现，需要让编译器提前知道这个函数的存在
	friend void showPerson2<>(Person14<string, int>p);
public:

	Person14(T1 name, T2 age)
	{
		this->m_Name = name;
		this->m_age = age;
	}


private:
	T1 m_Name;
	T2 m_age;
};



void test141()
{
	Person14<string, int>p("Mr.liao",22);
	showPerson1(p);
}

//2、全局函数在类外实现
void test142()
{
	Person14<string, int>p2("Mr.xiong", 20);
	showPerson2(p2);
}

int main()
{
	//test141();
	test142();
	system("pause");
	return 0;
}

运行结果:

在这里插入图片描述

**总结：**建议全局函数类内实现，用法简单，而编译器可以直接识别

10.3.9 类模板案例

案例描述：实现一个通用的数组类，要求如下：

  • 可以对内置数组类型以及自定义数据类型进行存储
  • 将数组中的数据存储到堆区
  • 构造函数中可以传入数组的容量
  • 提高对应的拷贝函数以及operator=防止浅拷贝问题
  • 可以通过下标的方式访问数组中的元素
  • 可以获取数组中当前元素个数和数组的容量

示例代码–第一阶段：

MyArry.hpp文件：

#pragma once
#include<iostream>
using namespace std;

//数组模板
template<class T>
class MyArry
{
public:
	//有参构造	参数	容量
	MyArry(int capacity)
	{
		cout << "MyArry有参构造调用" << endl;
		this->m_Capacity = capacity;		
		this->m_Size = 0;
		this->pAddress = new T[this->m_Capacity];
	}



	//拷贝构造
	MyArry(const MyArry& arr)
	{
		cout << "MyArry拷贝构造调用" << endl;

		this->m_Capacity = arr.m_Capacity;
		this->m_Size = arr.m_Size;
		//this->pAddress=arr.pAddress;

		//深拷贝
		this->pAddress = new T[arr.m_Capacity];

		//将arr中的数据都拷贝过来
		for (int i = 0; i < this->m_Size; i++)
		{
			this->pAddress[i] = arr.pAddress[i];
		}
	}

	//operator = 防止浅拷贝问题
	MyArry& operator=(const MyArry& arr)
	{
		cout << "MyArry的operator=调用" << endl;

		//先判断原理堆区是否有数据，如果有先释放
		if (this->pAddress != NULL)
		{
			delete[] this->pAddress;
			this->pAddress = NULL;
			this->m_Capacity = 0;
			this->m_Size = 0;
		}

		//深拷贝,把数组中的所有数据多copy过来
		this->m_Capacity = arr.m_Capacity;
		this->m_Size = arr.m_Size;
		for (int i = 0; i < this->m_Size; i++)
		{
			this->pAddress = new T[arr.pAddress[i]];
		}
		return *this;

	}

	//析构函数
	~MyArry()
	{
		cout << "MyArry析构函数调用" << endl;

		if (this->pAddress != NULL)
		{
			delete[] this->pAddress;		//释放堆区数组的内存
			this->pAddress = NULL;		//将指针置空，防止野指针出现
		}
	}

private:
	T* pAddress;		//	指针指向堆区开辟的真实数组
	int m_Capacity;		///数组的容量
	int m_Size;			//数组大小
};

main.c文件：

#include<iostream>
using namespace std;
#include"MyArry.hpp"

void test15()
{
	MyArry<int>arr1(5);
	MyArry<int>arr2(arr1);//测试拷贝构造
	MyArry<int>arr3(100);
	arr3 = arr1;
}

int main()
{
   test15();

	system("pause");
	return 0;
}

在这里插入图片描述

大成篇：

MyArry.hpp

#pragma once
#include<iostream>
using namespace std;

//数组模板
template<class T>
class MyArry
{
public:
	//有参构造	参数	容量
	MyArry(int capacity)
	{
		cout << "MyArry有参构造调用" << endl;
		this->m_Capacity = capacity;		
		this->m_Size = 0;
		this->pAddress = new T[this->m_Capacity];
	}



	//拷贝构造
	MyArry(const MyArry& arr)
	{
		cout << "MyArry拷贝构造调用" << endl;

		this->m_Capacity = arr.m_Capacity;
		this->m_Size = arr.m_Size;
		//this->pAddress=arr.pAddress;

		//深拷贝
		this->pAddress = new T[arr.m_Capacity];

		//将arr中的数据都拷贝过来
		for (int i = 0; i < this->m_Size; i++)
		{
			this->pAddress[i] = arr.pAddress[i];
		}
	}

	//operator = 防止浅拷贝问题
	MyArry& operator=(const MyArry& arr)
	{
		cout << "MyArry的operator=调用" << endl;

		//先判断原理堆区是否有数据，如果有先释放
		if (this->pAddress != NULL)
		{
			delete[] this->pAddress;
			this->pAddress = NULL;
			this->m_Capacity = 0;
			this->m_Size = 0;
		}

		//深拷贝,把数组中的所有数据多copy过来
		this->m_Capacity = arr.m_Capacity;
		this->m_Size = arr.m_Size;
		for (int i = 0; i < this->m_Size; i++)
		{
			this->pAddress = new T[arr.pAddress[i]];
		}
		return *this;

	}

	//尾插法
	void Push_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;
		}
		//delete this->pAddress[this->m_Size];
		//this->pAddress[this->m_Size] = NULL;
		this->m_Size--;
	}

	//通过下标访问数组中的数据,要赋左值要返回引用而不是数值
	T& operator[] (int index)
	{
		return this->pAddress[index];
	}

	//返回数组的大小
	int getSize()
	{
		return this->m_Size;
	}

	//返回数组的容量
	int getCapacity()
	{
		return this->m_Capacity;
	}

	//析构函数
	~MyArry()
	{
		cout << "MyArry析构函数调用" << endl;

		if (this->pAddress != NULL)
		{
			delete[] this->pAddress;		//释放堆区数组的内存
			this->pAddress = NULL;		//将指针置空，防止野指针出现
		}
	}

private:
	T* pAddress;		//	指针指向堆区开辟的真实数组
	int m_Capacity;		///数组的容量
	int m_Size;			//数组大小
};

main.c

#include<iostream>
using namespace std;
#include"MyArry.hpp"

//打印数组
void printIntArray(MyArry <int>& arr)
{
	for (int i = 0; i < arr.getSize(); i++)
	{
		cout << arr[i] << endl;
	}
}

void test15()
{
	MyArry<int>arr1(5);
	//MyArry<int>arr2(arr1);//测试拷贝构造
	//MyArry<int>arr3(100);
	//arr3 = arr1;
	for (int i = 0; i < 5; i++)
	{
		arr1.Push_Back(i);
	}
	cout << "数组中的元素打印输出为：" << endl;
	printIntArray(arr1);
	cout << "arr1容量为：" <<arr1.getCapacity() <<endl;
	cout << "arr1目前大小为：" <<arr1.getSize()<< endl;

	MyArry<int>arr2(arr1);//测试拷贝构造
	cout << "数组中的元素打印输出为：" << endl;
	printIntArray(arr2);

	//尾删
	arr2.Pop_Back();
	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;
};

//打印Person类
void PrintArray(MyArry <Person>& arr)
{
	for (int i = 0; i < arr.getSize(); i++)
	{
		cout << "姓名：" << arr[i].m_name << " " << "年龄：" << arr[i].m_age << endl;
	}
}

void test151()
{
	MyArry<Person>arr(10);
	Person p1("张三",16);
	Person p2("李四", 18);
	Person p3("王五", 169);
	Person p4("赵六", 11);
	Person p5("周七", 13);

	//将数据插入到数组中
	arr.Push_Back(p1);
	arr.Push_Back(p2);
	arr.Push_Back(p3);
	arr.Push_Back(p4);
	arr.Push_Back(p5);

	//打印数组
	PrintArray(arr);

	//输出数组的容量
	cout << "arr的容量：" << arr.getCapacity()<<endl;

	//输出数组的大小
	cout << "arr的大小：" << arr.getSize()<<endl;

}

int main()
{
   //test15();
	test151();
	system("pause");
	return 0;
}

运行结果：
在这里插入图片描述

总结：

能够利用所学的知识点实现通用的数组。

在这里插入图片描述

谢谢你的点赞，评论和转发 ( ^ o ^)/~。

上一篇：30C++编程提高篇-----1、函数模板原理

下一篇：【32C++提高编程----3、STL入门篇】

GUET_一路向前
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C和C++编程语言学习 - 2015级.zip
06-13
在IT领域，C和C++编程语言是两个基础且至关重要的工具，尤其对于系统级编程、游戏开发以及高性能计算等领域。"C和C++编程语言学习 - 2015级.zip"这个压缩包文件很可能是针对初学者或2015级学生的教学资料集合，旨在...
C++ - SGI 版本 STL源码
10-25
STL（Standard Template Library，标准模板库）是C++编程语言中的一个重要组成部分，它提供了高效且灵活的数据结构和算法。SGI（Silicon Graphics, Inc.）公司在90年代为C++社区贡献了一个广受欢迎的STL实现，因其易...
函数模板、类模板（含模板特化）
challenglistic的博客
04-15 1946
函数模板、类模板(模板特化)
C++ 模板的原理、应用
m0_60010936的博客
10-31 877
1
C++函数模板和类模板
最新发布
Gefangenes的博客
06-25 1216
和其他类模板一样，派生类模板Derived在定义对象时需要明确给出派生类模板中类型参数所指代的实际数据类型。编译器在编译到使用类模板定义对象语句时，将首先按照所给定的实际数据类型对类模板进行实例化，生成一个实例类。在编译到派生类Derived的定义代码时，编译器将按照所给定的实际数据类型double对类模板Base进行实例化，生成一个double型的实例类，最终派生类Derived继承的是该实例类。使用类模板定义对象时，需要明确给出类模板中类型参数所指代的实际数据类型。o1(10.5,6);
【C++】初识模板
m0_62179366的博客
08-10 747
模板（Template）在C++程序设计语言中，是指函数模板与类模板[1]，是一种参数化类型机制。Java和C＃中的泛型与C++的模板大体对应，但也有一些功能上的显著差异（C++模板支持两者没有明确对应的模板模板参数和模板非类型参数，但不支持Java的通配符以及C#的泛型类型约束）。模板是C++的泛型编程中不可缺少的一部分。模板是C++程序员绝佳的武器，特别是结合了多重继承与运算符重载之后。C++的标准函数库提供的许多有用的函数大多结合了模板的概念，如STL以及iostream。——摘自维基百科。.....
C++ 泛型编程（一）：模板基础：函数模板，类模板，模板原理，模板匹配规则
凌桓丶的博客
05-01 1190
类模板 函数模板 泛型编程 泛型编程，泛型即是指具有在多种数据类型上皆可操作的含义，其实就是能够帮助开发者编写完全一般化并可重复使用的算法，同样的工作不需要做多次，同样的算法针对不同的类型也不应该写多次，所以需要通过某种途径，来使一个容器或者算法，能够兼容所有的类型，这就是泛型编程。 void Swap(int& left, int& right) { int t...
商业编程-源码-WTL写的调试输出辅助工具.zip
06-22
【标题】：“商业编程-源码-WTL写的调试输出辅助工具.zip”是一个包含源代码的压缩包，专门设计用于在商业编程环境中辅助调试输出...同时，通过研究源代码，开发者还能学习到WTL库的应用技巧，提升自己的C++编程技能。
LiveSource_C-C++_
10-01
通过这种方式，我们可以逐步揭示LiveSource.c背后的逻辑，即使没有编译和运行，也能从中学到很多关于C/C++编程的知识。在实际工程中，这种能力对于理解和调试他人代码，或者阅读开源项目源码都是极其宝贵的。 总结...
Assignment1_C-C++_
10-03
标题 "Assignment1_C-C++_" 暗示这是一个关于C或C++编程语言的作业，主要涉及全局对齐（global alignment）的概念。全局对齐在计算机科学，特别是生物信息学中是一个重要的概念，用于比较两个序列（如DNA或蛋白质...
C++函数模板及实现原理
12-27
描述C++的模板类，介绍使用方式，对于初学者来说是比不可少的学习资源
一篇文章带你了解C++模板编程详解
转载和创作优秀的博客
09-21 644
一篇文章带你了解C++模板编程详解
C++核心编程-类模板
HYAIWYH的博客
09-28 206
typename--表明其后面的符号是一种数据类型，可以用class代替。建立一个通用类，类中成员 数据类型可以不具体制定，用一个虚拟的类型来代替。T--通用的数据类型，名称可以替换，通常为大写字母。3.如果想灵活指定出父类中T的类型，子类也需变为类模板。2.参数模板化 --将对象中的参数变为模板进行传递。3.整个类模板化 --将这个对象类型 模板化进行传递。1.指定传入的类型--直接显示对象的数据类型。2.如果不指定，编译器无法给子类分配内存。：template--声明创建模板。
模板1.0 -- 模板基本原理
NeilZhy
01-05 700
为什么需要模板 我们经常有这样的一种使用的情形，就是我们可能需要设计一个函数，然后函数的参数可能是整形的，也可能是浮点型的，还有可能是其他的类型的，这个时候如果对于每一个类型都写一个函数，未免有点太复杂了 我们有以下几个方法来实现一个函数针对不同的类型都能够实现 法一：通过函数重载实现 比如我们想要写一个相加的函数，我们需要实现函数的重载 int Add(const int
C++ 编译器处理模板的原理
林彬的专栏
10-26 5954
编译器遇到模板方法定义时，会进行语法检查，但是并不编译模板。编译器无法编译模板定义，因为它不知道使用什么类型。不知道x和y的类型，编译器就无法为x=y这样的语句生成代码。 编译器遇到一个实例化的模板时，例如GridmyIntGrid，就会将模板定义中的每一个T替换为int，从而生成Grid模板的int版本代码。当编译器遇到这个模板另一个实例时，例如，Grid mySpreadsheet，就为Sp
C++重要知识清单：泛型编程（函数模板和类模板机制）包含模板机制的底层实现原理
weixin_39568744的博客
05-06 1349
1.泛型编程相关概念 模板机制 C++提供两种模板机制：函数模板、类模板 类属----类型参数化，又称参数模板：使得程序或算法可以从逻辑功能上抽象，把被处理的对象类型或数据类型作为参数进行传递 模板把函数或类要处理的数据类型参数化，表现为参数的多态性，称为类属。 模板用于表达逻辑结构相同，但具体数据元素类型不同的数据对象的通用行为 2.函数模板 2.1为什么要有函数模板呢？ 首先看下...
C++~模板-泛型编程（函数模板，类模板，模板特化的使用和原理）
Zebra的博客
10-09 673
函数模板和类模板不支持声明和定义放到两个文件中，会出现链接错误普通的函数和类的话是可以的模板不支持声明和定义分别放到xxx.h和xxx.cpp中，一般是要放到一个文件中。有些地方就会命名成xxx.hpp，寓意就是头文件和定义实现内容合并—起但是并不是必须是.hpp，.h也是可以的，最好是.hpp。
C++中类模板的深入理解
05-24 162
1，多参数类模板： 　1，类模板可以定义任意多个不同的类型参数； 　　1，代码示例： 1 template <typename T1, typename T2> 2 class Test 3 { 4 public: 5 void add(T1 a, T2 a); 6 }; 7 8 Test<int, float&g...
07-C++ Templates The Complete Guide(2nd)-p2606
06-04
2. **模板实例化**：详细解释了模板实例化的过程，即当一个模板被用于特定类型时，编译器如何根据传入的类型参数创建实际的函数或类定义。 3. **模板特例化**：区分了模板实例化与特例化，前者是生成针对具体类型的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值