C++基础梳理 2019.1.16（函数模板写法，选择排序复习，普通函数和函数模板的区别和调用机制，模板内部实现原理，模板的局限性，自定义类型如何使用函数模板，区分类模板的和函数模板，类模板做函数的）

最新推荐文章于 2022-10-21 14:24:50 发布
最新推荐文章于 2022-10-21 14:24:50 发布
阅读量213 收藏
点赞数 1
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_29996285/article/details/86503103
版权

函数模板

核心思想——类型参数化（把类作为参数）

 

一种函数模板的写法

// 告诉编译器 下面如果出现T不要报错，T是一个通用的类型
template<class T> 
void mySwap(T &a, T &b)
{
	T tmp = a;
	a = b; 
	b = tmp;
}

1 自动类型推导,必须有参数类型才可以推导

mySwap(a, c1); 推导不出来T，所以不能运行

2 模板必须要指定出T才可以使用

mySwap<int>(a, b);

 

另一种函数模板的写法

template<typename T>
void mySwap2(T &a, T &b)
{
	T tmp = a;
	a = b;
	b = tmp;
}

使用方法

//模板必须要指定出T才可以使用
mySwap2<int>(a,b);

typename和class没有区别，class常用语类模板

 

 

 

练习——使用模板，实现char和int类型数组的排序（选择排序）

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;

//对char和int数组进行排序  排序规则 从大到小  利用选择排序

template <class T>
void mySwap( T &a, T &b)
{
	T tmp = a;
	a = b;
	b = tmp;
}

//选择排序——每轮确定一个元素的位置
template<class T>
void mySort( T arr[], int len )
{
	for (int i = 0; i < len;i++)
	{
		int max = i;
		//找到i位置之后元素的最大值
		for (int j = i + 1; j < len;j++)
		{
			if (arr[max] < arr[j])
			{
				//交换 下标
				max = j;
			}
		}
		if (max != i)
		{
			//交换数据
			mySwap(arr[max], arr[i]);
		}
	}
}

//输出数组元素的模板
template<class T>
void printArray( T arr[], int len)
{
	for (int i = 0; i < len;i++)
	{

		cout << arr[i] << " ";
	}
	cout << endl;
}

void test01()
{
	char charArr[] = "helloworld";
	int num = sizeof(charArr) / sizeof(char);
	mySort(charArr, num);
	printArray(charArr, num);


	int intArr[] = { 1, 4, 100, 34, 55 };
	int num2 = sizeof(intArr) / sizeof (int);
	mySort(intArr, num2);
	printArray(intArr, num2);

}


int main(){

	test01();

	system("pause");
	return EXIT_SUCCESS;
}

 

 

 

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

 1、普通函数可以进行隐式类型转换  ，模板不可以

实例：

template<class T>
T myPlus(T a, T b)
{
	return a + b;
}

int myPlus2(int a, int b)
{
	return a + b;
}

void test01()
{
	int a = 10;
	int b = 20;
	char c = 'c'; // a = 97 
//	myPlus(a, c); //类型推导不出来 ,函数模板不可以进行隐式类型转换
	cout << myPlus2(a, c) <<endl; // 10 + 99  普通函数 可以进行隐式类型转换
}

 

调用规则：

  • c++编译器优先考虑普通函数
  • 可以通过空模板实参列表的语法限定编译器只能通过模板匹配
  • 函数模板可以像普通函数那样可以被重载
  • 如果函数模板可以产生一个更好的匹配，那么选择模板

 

1 、如果出现重载 ，优先使用普通函数调用（把普通函数注释掉，发现myPrient(a,b)也可以调用函数模板）

template<class T>
void myPrint(T a, T b)
{
	cout << "模板调用的myPrint" << endl;
}

void myPrint(int a, int  b)
{
	cout << "普通函数调用 myPrint" << endl;
}

//调用
void test(){
    int a = 10;
    int b = 20;

    myPrint(a, b);

}

 

2、 如果想强制调用模板 ，那么可以使用空参数列表

myPrint<>(a, b);

 

3、函数模板可以发生重载

template<class T>
void myPrint(T a, T b, T c)
{
	cout << "模板调用的myPrint(a,b,c)" << endl;
}

void test(){
    
int a = 10;
	int b = 20;
	int c = 30;
	myPrint(a, b, c);
}

 

4、 如果函数模板可以产生更好的匹配，那么优先调用函数模板

template<class T>
void myPrint(T a, T b)
{
	cout << "模板调用的myPrint" << endl;
}


void myPrint(int a, int  b)
{
	cout << "普通函数调用 myPrint" << endl;
}

void test(){
    char c1 = 'c';
    char d = 'd';
    myPrint(c1, d);
}

 

 

 

模板内部实现原理

hello.cpp程序是高级c语言程序，这种程序易于被人读懂。为了在系统上运行hello.c程序，每一条c语句都必须转化为低级的机器指令。然后将这些机器指令打包成可执行目标文件格式，并以二进制形式存储于磁盘中。

预处理(Pre-processing) -> 编译(Compiling) ->汇编(Assembling) -> 链接(Linking)

 

  • 编译器并不是把函数模板处理成能够处理任何类型的函数
  • 函数模板通过具体类型产生不同的函数
  • 编译器会对函数模板进行两次编译，在声明的地方对模板代码本身进行编译，在调用的地方对参数替换后的代码进行编译。

 

 

 

自定义类型如何使用函数模板

 

模板的局限性

  1. 模板不能解决所有的类型，
  2. 如果出现不能解决的类型，可以通过第三地具体化来解决问题
  3. template<> 返回值 函数名<具体类型>（参数）

 

自定义类型使用模板的例子

通过具体化自定义的方式使用模板（感觉有点那啥，就死活要用模板的皮呗？这种自定义和自己写一个有什么区别。。。）

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

class Person
{
public:
	Person(string name, int age)
	{
		this->m_Name = name;
		this->m_Age = age;
	}
	string m_Name;
	int m_Age;
};



template<> 
bool myCompare<Person>(Person &a, Person &b)
{
	if (a.m_Age == b.m_Age)
	{
		return true;
	}
	return false;
}

void test01()
{
	
	Person p1("Tom", 20);
	Person p2("Jerry", 10);

	int ret2 = myCompare(p1, p2);

	cout << "ret2 = " << ret2 << endl;

}


int main() {

	test01();

	system("pause");
	return EXIT_SUCCESS;
}

 

 

 

类模板

  1. 写法template <T…> 紧跟着是类
  2. 与函数模板区别，可以有默认类型参数
  3. 函数模板可以进行自动类型推导，而类模板不可以自动类型推导
  4. 类模板中的成员函数 一开始不会创建出来，而是在运行时才去创建

 

类模板的实例

//类模板
template <class NameType, class AgeType = int> //类模板可以有默认类型
class Person
{
public:
	Person(NameType name, AgeType age)
	{
		this->m_Name = name;
		this->m_Age = age;
	}

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

	NameType m_Name;
	AgeType m_Age;
};

 

区分类模板的和函数模板

  • 类模板不支持自动类型推导，可以有默认类型参数。
  • 函数模板可以进行自动类型推导，不可以有默认类型参数。

 

 

成员函数的创建时机

类模板中的成员函数 一开始不会创建出来，而是在运行时才去创建

 

 

类模板做函数的参数

 

三种方式

  1. 显示指定类型
  2. 参数模板化
  3. 整体模板化

如何查看类型
 

cout << typeid(T1).name() << endl;
#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include <string>
using namespace std;

//类模板
template <class NameType, class AgeType = int> //类模板可以有默认类型
class Person
{
public:
	Person(NameType name, AgeType age)
	{
		this->m_Name = name;
		this->m_Age = age;
	}

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

	NameType m_Name;
	AgeType m_Age;
};

//1  指定传入类型
void doWork( Person<string ,int> & p ) 
{
	p.showPerson();
}

void test01()
{
	Person <string, int> p("MT",10);
	doWork(p);
}

//2 参数模板化
template<class T1 ,class T2>
void doWork2(Person<T1, T2> & p)
{
	//如何查看类型
	cout << typeid(T1).name() << endl;
	cout << typeid(T2).name() << endl;
	p.showPerson();
}
void test02()
{
	Person <string, int> p("呆贼", 18);

	doWork2(p);
}


//3 整体模板化
template<class T>
void doWork3(T&p)
{
	cout << typeid(T).name() << endl;
	p.showPerson();
}

void test03()
{
	Person <string, int> p("劣人", 18);
	doWork3(p);
}

int main(){
        test01();
	test02();	
	test03();
	system("pause");
	return EXIT_SUCCESS;
}

 

 

 

类模板遇到继承问题

1、child继承与 base必须告诉base中的T的类型，否则T无法分配内存

template <class T>
class Base
{
public:
	T m_A; //double类型
};

//child继承与 base必须告诉base中的T的类型，否则T无法分配内存
class Child :public Base<int>
{

};

但是base类型不能写死，因此可以这么写

template<class T1, class T2>
class Child2 :public Base<T2>
{
public:
	Child2()
	{
		cout << typeid(T1).name() << endl;
		cout << typeid(T2).name() << endl;
	}
public:
	T1 m_B;
};

 

 

 

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

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

template<class T1 ,class T2>
class Person
{
public:
	Person(T1 name, T2  age);
	void showPerson();

private:
	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;
}

void test01()
{
	Person <string ,int> p1("Mt", 100);
	p1.showPerson();

}

int main(){

	test01();	
	system("pause");
	return EXIT_SUCCESS;
}

 

 

 

类模板的分文件编写问题以及解决

测试代码：

Person.h

#pragma once

template<class T1,class T2>
class Person{
public:
	Person(T1 name,T2 age);
	void ShowPerson();
public:
	T1 mName;
	T2 mAge;
};

Person.cpp

#include"Person.h"

template<class T1, class T2>
Person<T1, T2>::Person(T1 name, T2 age){
	this->mName = name;
	this->mAge = age;
}

template<class T1, class T2>
void Person<T1, T2>::ShowPerson(){
	cout << "Name:" << this->mName << " Age:" << this->mAge << endl;
}

main.cpp

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;
#include<string>
#include"Person.hpp"

//模板二次编译
//编译器编译源码 逐个编译单元编译的

int main(){

	Person<string, int> p("eee", 20);
	p.ShowPerson();


	system("pause");
	return EXIT_SUCCESS;
}

案例代码在qt编译器顺利通过编译并执行，但是在Linux和vs编辑器下如果只包含头文件，那么会报错链接错误，需要包含cpp文件，但是如果类模板中有友元类，那么编译失败！

原因：

  1. 类模板需要二次编译，在出现模板的地方编译一次，在调用模板的地方再次编译。
  2. 类模板的成员函数运行阶段才去创建，因此链接不到，会出现问题。
  3. C++编译规则为单元编译，一个一个的检测。

解决方案: 类模板的声明和实现放到一个文件中，我们把这个文件命名为.hpp

 

Person.hpp

#pragma once

template<class T1,class T2>
class Person{
public:
	Person(T1 name,T2 age);
	void ShowPerson();
public:
	T1 mName;
	T2 mAge;
};

template<class T1, class T2>
Person<T1, T2>::Person(T1 name, T2 age){
	this->mName = name;
	this->mAge = age;
}

template<class T1, class T2>
void Person<T1, T2>::ShowPerson(){
	cout << "Name:" << this->mName << " Age:" << this->mAge << endl;
}

 

 

 

 

类模板碰到友元函数

 

友元函数类内实现

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

template<class T1, class T2>
class Person
{
	//友元函数类内实现
	friend void printPerson(Person<T1, T2> & p)//普通函数 声明
	{
		cout << "姓名：" << p.m_Name << "  年龄： " << p.m_Age << endl;
	}
public:
	Person(T1 name, T2 age)
	{
		this->m_Name = name;
		this->m_Age = age;
	}

private:
	T1 m_Name;
	T2 m_Age;
};

void test01()
{
	Person<string, int> p("Tom", 10);
	printPerson(p);
}


int main() {
	test01();
	system("pause");
	return EXIT_SUCCESS;
}

 

 

友元函数类外实现

类外声明友元函数，那么友元函数的声明要改写成模板函数的那种，而不能再用普通函数声明了，原因如下：

因为在类外实现要写成：

//类外实现
template<class T1, class T2>
void printPerson(Person<T1, T2> & p)
{
	cout << "姓名：" << p.m_Name << "  年龄： " << p.m_Age << endl;
}

这是一个模板函数的实现，而下侧的函数声明是普通函数的声明。

friend void printPerson(Person<T1, T2> & p);

之前有讲过，如果普通函数和模板函数都匹配某一调用的时候，优先调用普通函数，而这个普通函数我们并没有写出他的实现，因此函数声明要改成模板函数，而不能继续使用普通函数。改成如下版本：

//友元函数类内实现  利用空参数列表 告诉编译器 模板函数的声明
friend void printPerson<>(Person<T1, T2> & p);

但是编译还是会报错，因为这是类内声明，编译器看不到他，会发生编译报错。所以要在类外进行声明：

template<class T1, class T2>void printPerson(Person<T1, T2> & p);

但是编译依然会报错，因为这个声明里用到了Person类，因此需要在声明printPerson之前要声明一下Person。

//让编译器看到Person类声明
template<class T1, class T2> class Person;
//让编译器提前看到printPerson声明
template<class T1, class T2>void printPerson(Person<T1, T2> & p);

 

完整实现代码如下：

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

//让编译器提前看到printPerson声明
//让编译器看到Person类声明
template<class T1, class T2> class Person;
template<class T1, class T2>void printPerson(Person<T1, T2> & p);

template<class T1, class T2>
class Person{
	//友元函数类内实现  利用空参数列表 告诉编译器 模板函数的声明
	friend void printPerson<>(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;
};

//类外实现
template<class T1, class T2>
void printPerson(Person<T1, T2> & p){
	cout << "姓名：" << p.m_Name << "  年龄： " << p.m_Age << endl;
}

void test01(){
	Person<string, int> p("Tom", 10);
	printPerson(p);
}

int main() {
	test01();
	system("pause");
	return EXIT_SUCCESS;
}

 

 

 

自己实现一个数组——类模板应用

下面例子的数组也存储了自定义类型的元素。

注意：每往数组中扔进去一个自定义类型的元素时，自定义类的的默认构造函数都会调用一遍，因此自定义类型如果想用数组，就一定要确保存在默认构造函数，否则会报错。

 

MyArray.hpp

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

template< class T>
class MyArray{
public:
        //构造，开辟内存空间
	//防止隐式类型转换 防止MyArray arr = 10; 写法
	explicit MyArray(int capacity){
		this->m_Capacity = capacity;
		this->m_Size = 0;
		this->pAddress = new T[this->m_Capacity];
	}

        //拷贝构造
	MyArray(const MyArray & array){
		this->m_Capacity = array.m_Capacity;
		this->m_Size = array.m_Size;
		this->pAddress = new T[this->m_Capacity];
		for (int i = 0; i < m_Size;i++){
			this->pAddress[i] = array[i];
		}
	}

	~MyArray(){
		if (this->pAddress != NULL){
			delete[] this->pAddress;
			this->pAddress = NULL;
		}
	}

	//拷贝赋值（防止浅拷贝问题）
	MyArray& operator=(MyArray & array){
		//先判断原始数据，有就清空
		if (this->pAddress != NULL){
			delete[] this->pAddress;
			this->pAddress = NULL;
		}
		
		this->m_Capacity = array.m_Capacity;
		this->m_Size = array.m_Size;
		this->pAddress = new T[this->m_Capacity];
		for (int i = 0; i < m_Size; i++){
			this->pAddress[i] = array[i];
		}
	}

	//[]重载
	T & operator[]( int index){
		return this->pAddress[index];
	}

	//尾插法
	void push_Back( T  val){
		this->pAddress[this->m_Size] = val;
		this->m_Size++;
	}

	//获取大小
	int getSize(){
		return m_Size;
	}
	//获取容量
	int getCapacity(){
		return  this->m_Capacity;
	}	

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

main.cpp

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include <string>

#include "MyArray.hpp"

using namespace std;


//输出int类型数组
void printIntArray(  MyArray<int>& array){
	for (int i = 0; i < array.getSize();i++){
		cout << array[i] << 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 printPersonArray( MyArray<Person> & array ){
	for (int  i = 0; i < array.getSize(); i++){
		cout << "姓名： " << array[i].m_Name << " 年龄： " << array[i].m_Age << endl;
	}
}

int main(){

	MyArray <int >arr(10);
	for (int i = 0; i < 10;i++){
		arr.push_Back(i + 100);
	}

	printIntArray(arr);

	Person p1("MT", 10);
	Person p2("呆贼", 12);
	Person p3("傻馒", 14);
	Person p4("劣人", 15);

	MyArray<Person>arr2(10);//开辟十个内存空间
        //每扔进去一个自定义类型的元素的时候，自定义类的的默认构造函数都会调用一遍
	arr2.push_Back(p1);
	arr2.push_Back(p2);
	arr2.push_Back(p3);
	arr2.push_Back(p4);

	printPersonArray(arr2);

	system("pause");
	return EXIT_SUCCESS;
}

 

王小闹儿
关注
专栏目录
函数模板
swillry的博客
07-15 323
1.声明一个函数模板的格式如下： template <模板形参表声明> 返回类型 函数名（函数形参表） { …… //函数体 } 其中，<模板形参表声明>是由一个或多个“模板形参”组成的，如果是多个，则要用逗号隔开。“模板形参”具有下面3种形式：  typename 参数名  class 参数名  类型修饰 参数名 2. 函数模板中声明的函数称为模板函数。 调...
C++函数模板与类模板的区别
热门推荐
ultimate1212的博客
07-18 2万+
类模板： C++ 除了支持函数模板，还支持类模板（Class Template）。函数模板中定义的类型参数可以用在函数声明和函数定义中，类模板中定义的类型参数可以用在类声明和类实现中。类模板的目的同样是将数据的类型参数化。 声明类模板的语法为： template&lt;typename 类型参数1 , typename 类型参数2 , …&gt; class 类名{     //TODO: }...
模板函数与函数模板 类模板和模板的说明
rufeng18的专栏
12-01 3549
一，模板的概念。引入模板的原因：我们已经学过重载，对重载函数而言,C++的检查机制能通过函数参数的不同及所属类的不同。正确的调用重载函数。例如，为求两个数的最大值，我们定义MAX（）函数需要对不同的数据类型分别定义不同重载版本。Int max(int x,int y);{return(x>y)?x:y ;}float max( float x,float y){return (x>y)? x:y
模板类与类模板、函数模板与模板函数等的区别
qq_35608277的博客
05-11 332
C++中概念区分： 函数指针——指针函数 数组指针——指针数组 类模板——模板类 函数模板——模板函数 1.函数指针——指针函数 函数指针的重点是指针。表示的是一个指针，它指向的是一个函数，例子： int (*pf)(); 指针函数的重点是函数。表示的是一个函数，它的返回值是指针。例子： int* fun(); 2.数组指针——指针数组 ...
6、 函数模板和类模板
小强博客
07-15 2405
函数模板和类模板前言C++提供了函数模板(functiontemplate)。所谓函数模板，实际上是建立一个通用函数，其函数类型和形参类型不具体指定，用一个虚拟的类型来代表。这个通用函数就称为函数模板。凡是函数体相同的函数都可以用这个模板来代替，不必定义多个函数，只需在模板中定义一次即可。在调用函数时系统会根据实参的类型来取代模板中的虚拟类型，从而实现了不同函数的功能。1）C++提供两种模板机制...
C++中用函数模板实现和优化抽象操作
07-26
C++函数模板是C++语言中一种用于生成通用函数的机制，它的核心思想在于允许程序员编写与数据类型无关的代码。使用函数模板可以避免针对每一种数据类型编写相似的代码，从而提高代码的可重用性和简洁性。在C++中，...
详解C++函数模板与分离编译模式
08-18
"详解C++函数模板与分离编译模式" C++函数模板是一种非常强大的功能，它允许开发者编写通用的代码，使得程序更加灵活和可重用。然而，在使用函数模板时，需要注意分离编译模式下的问题。在此文章中，我们将详解C++...
用C++_模板实现的基础排序函数_Sort_Arithmetic.zip
最新发布
09-23
用C++_模板实现的基础排序函数_Sort_Arithmetic
C++函数模板声明与定义相分离
12-22
在C++编程中，函数模板是一种强大的工具，它允许我们编写通用的代码，适用于不同数据类型。然而，处理函数模板的声明与定义时，我们经常会遇到一些特定的问题，尤其是在尝试模仿STL（标准模板库）的实现时。STL源码...
C++函数模板
希望我的博客，能帮上你解决学习中工作中所遇到的问题
11-09 682
函数模板 C++另一种编程思想称为 泛型编程 ，主要利用的技术就是模板 C++提供两种模板机制:函数模板和类模板 1.2.1 函数模板语法 函数模板作用： 建立一个通用函数，其函数返回值类型和形参类型可以不具体制定，用一个虚拟的类型来代表。 语法： template<typename T> 函数声明或定义 解释： template — 声明创建模板 typename — 表面其后面的符号是一种数据类型，可以用class代替 T — 通用的数据类型，名称可以替换，通常
函数模板和类模板的区别
m0_60274660的博客
10-21 1190
无
【c++】类模版
StudyWinter的博客
03-15 537
1、类模板语法 类模板作用： 建立一个通用类，类中的成员 数据类型可以不具体制定，用一个虚拟的类型来代表。 语法： template<typename T> 类 解释： template --- 声明创建模板 typename --- 表面其后面的符号是一种数据类型，可以用class代替 T --- 通用的数据类型，名称可以替换，通常为大写字母 #include <iostream> #include <string> using namesp
C++之函数模板
程序员的规则
11-28 6975
函数模板
函数模板与类模板的区别
csw_100的专栏
08-27 1万+
<br />函数模板与类模板有什么区别？答：函数模板的实例化是由编译程序在处理函数调用时自动完成的，而类模板的实例化 <br /> 必 须由程序员在程序中显式地指定。<br /> <br />即函数模板允许隐式调用和显式调用而类模板只能显示调用<br /> <br />这期间有涉及到函数模板与模板函数，类模板与模板类的概念（类似于类与类对象的区 别）<br />请看下面例子<br /> <br />注意：模板类的函数声明和实现必须都在头文件中完成，不能像普通类那样声明在.h文件中实现在.cpp文件中，
函数模板（Function Template）
一直努力
02-06 552
函数模板（Function Template） 所谓函数模板，实际上就是建立一个通用函数 1、函数定义时不指定具体的数据类型（使用虚拟类型代替） 2、函数被调用时编译器根据实参反推数据类型-类型的参数化 //模板头与函数声明/定义永远是不可分割的整体！ template<typename 类型参数1，typename 类型参数2，...>//typename老版C++用class 返回...
深入浅出理解：函数模板与类模板、存在的实际意义以及使用方法，
好儿郎~志在四方
11-17 4008
（1）在讲模板之前，先闲扯一下吧： C++最重要的特性之一就是代码重用，为了实现代码重用，代码必须具有通用性。 通用代码不受数据类型的影响，并且可以自动适应数据类型的变化，这种程序设计类型称为参数化程序设计。 模板是C++支持参数化程序设计的工具，通过它可以实现参数化多态性。 所谓参数化多态性是指：将程序所处理的对象的类型参数化，使得一段程序可以处理多种不同类型的对象。 简单的理解，模板
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值