当前位置:首页 » 《随便一记》 » 正文

C++模板进阶_Booksort的博客

14 人参与  2021年11月06日 13:03  分类 : 《随便一记》  评论

点击全文阅读


  • 非类型模板参数
    • 模板参数”缺省“
  • 模板的特化
    • 显示具体化
      • 实例化与具体化
      • 注意
  • 重载解析
  • 针对类模板的特化
    • 全特化
    • 偏特化
  • 模板分离编译

非类型模板参数

模板参数

  1. 类型模板参数:用typename/class定义的参数类型名称
  2. 非类型模板参数:用一个整形作为模板的一个参数,在模板中可以当常量使用

例如:

template<class T,size_t N>//T就是类型模板参数,N就是非类型模板参数

这个N可以直接当常量用,就是说可以直接去初始化数组的元素个数
举个实际点的例子

#include <iostream>
template <class T ,size_t N>
class arr
{
public:
	size_t size(void)
	{
		return sizeof(_a) / sizeof(_a[0]);
	}
private:
	int _a[N];
};
int main(void)
{
	arr<int,100> arr1;
	std::cout << arr1.size() << std::endl;
	arr<double, 20> arr2;
	std::cout << arr2.size() << std::endl;
	return 0;
}

在这里插入图片描述
我们可以利用这个创建一个可控长度的数组,
非常surprise and comfortable也算是了了我想用可自选长度的数组的心愿了,虽然C语言中有变长数组,但这个还是要用的舒心一些。

还有最重要的一点:非类型模板参数只能是 int 整形常量

模板参数”缺省“

还有一点特别好玩的,可以给模板 ”赋初值“

继续拿刚刚的例子

#include <iostream>
template <class T=int ,size_t N=10>
class arr
{
public:
	size_t size(void)
	{
		return sizeof(_a) / sizeof(_a[0]);
	}
private:
	int _a[N];
};
int main(void)
{

	arr<> arr1;
	std::cout << arr1.size() << std::endl;
	arr<double, 20> arr2;
	std::cout << arr2.size() << std::endl;
	return 0;
}

在这里插入图片描述
就是跟函数的参数列表中的缺省参数类似,如果没有传要实例化的参数,就会自动调用,并实例化初值的类。挺好玩的。

模板的特化

对于类模板去实例化具体的类,是编译器去处理,根据给的类型去推出,自动生成的。

不过,在一些特殊场景下,有时候编辑器自动实例化的模板不能正确处理我们所需要的的逻辑,无法满足我们的需求,需要针对一些情况处理进行特殊化处理

举个经典例子,常量字符串与字符串的例子

#include <iostream>
template <class T1,class T2>
bool compare(const T1& left,const T2& right)
{
	return left == right;
}

int main(void)
{
	char s1[] = "Hello World";
	char s2[] = "Hello World";
	std::cout << compare(s1, s2)<<std::endl;
	const char* s3 = "Hello World";
	const char* s4 = "Hello World";
	std::cout << compare(s3, s4)<<std::endl;
	return 0;
}

看看输出结果:
在这里插入图片描述
而作为一个简单问题,其原因在于:

s1,s2都是数组,储存位置在 栈,且储存在不同的位置。
s3,s4是常量字符串,储存位置在静态区。只有这一份数据。
也就是说,s1,s2作为指针,其实指向的是栈区中不同的位置,
而s3,s4也是指针,指向静态区的同一个位置。

在这里插入图片描述

而,函数传递过去的参数,被编译器推断成指针也就是地址,函数区比较两个地址是否一样。这就远离我们的期望了。

我们的目的是比较两个字符串是否完全相等。

所以,针对一些特殊要求的函数,需要尽心一些特俗化处理,使之满足我们的需求。

#include <iostream>
//函数模板
template <class T>
bool compare(T left,T right)
{
	return left == right;
}


///特化
template<>
bool compare<char*>(char* left, char* right)
{
	return  std::strcmp(left, right)== 0;
}
template<>
bool compare<const char*>(const char* left, const char* right)
{
	return  std::strcmp(left, right) == 0;
}



int main(void)
{
	char s1[] = "Hello World";
	char s2[] = "Hello World";
	std::cout << compare(s1, s2)<<std::endl;
	
	const char* s3 = "Hello World"; 
	const char* s4 = "Hello World";
	std::cout << compare(s3, s4)<<std::endl;
	
	std::cout << compare(1.1, 1.2) << std::endl;
	return 0;
}

在这里插入图片描述

显示具体化

为了满足可以在特定的场景满足特定的需求,C++98提供了第三代具体化标准

  1. 对于给定的函数名,可以有非模板函数模板函数显示具体化模板函数以及他们的重制版本
  2. 显示具体化的原型和定义应以template<>,并通过名称来指出类型
  3. 具体化优先于常规模板实例化,而非模板函数优先于具体化常规模板

举个例子:
下面函数分别是常规函数模板函数模板具体化非函数模板函数

//常规模板
template <class T>
bool compare(T left,T right)
{
	return left == right;
}

//具体化的原型
template<>
bool compare<char*>(char* left, char* right)
{
	return  std::strcmp(left, right)== 0;
}

//非函数模板函数
bool compare(char* left, char* right)
{
	return std::strcmp(left, right) == 0;
}

所以说,函数特化,其实就是非模板函数于显示具体化的模板函数

实例化与具体化

为了进一步了解模板,必须理解实例化具体化
模板C++提供的特性之一,模板其本身并不会生成函数定义,它只是一个用于生成函数定义的解决方案。

函数模板就像的图纸,函数的定义就是房子,图纸设计好了,并不代表房子也建好了。

在函数被调用时,模板会根据函数调用时的参数来生成指定的函数定义。得到了模板对指定类型的实例化。这就是隐式实例化

还有显示实例化,需要什么类型,就提前声明,这样可以直接命令编辑器生成特定的函数定义。

template bool compare<int>(int l, int r);

需要用<>来指定类型。

具体化和实例化存在差别,他是为特殊情况下满足特殊需求存在的。

template<> bool compare(char* left, char* right);
template<> bool compare<char*>(char* left, char* right);

这些是显式具体化的声明,但是,提供显示具体化是为了满足特殊需求,所以函数模板的定义有些情况并不能满足时,就可以用具体化来从新定义函数,且必须要有自己的定义,不然为什么要提供这个特性。

注意

嗯,事实上是没有模板函数这个概念的,只有函数模板,而函数模板实例化出来的函数其实就是一个普通的函数。

重载解析

但是,对于编辑器而言,其中的函数,有非函数模板函数,显示具体化,函数模板实例化的常规函数,以及他们的重载,这些不同版本的函数(其函数名一定是一样的)。编辑器该如何选择?

C++为了处理这些问题,定义了一个良好的策略,尤其是处理多个参数时,这个过程是重载解析

  1. 创建候选函数列表,其中包含与被调用函数的名称相同的函数与模板
  2. 使用候选函数列表去创建可行函数列表。这些都是参数数目正确的函数,为此有一个隐式转换序列,其中包括实参类型与形参类型完全匹配的情况(如类型之间的转换,例:float转向double,但是模板也可以生成一个float类型的实例)
  3. 确定是否有最佳的可行函数,如果有就是用,否该函数调用就报错

在创建可行函数列表中有隐式转换序列,有些事不能转换的,如:整形不能转换为指针类型

列出可行函数列表后,再开始确定哪个可行函数是最佳的

  1. 完全匹配(常规函数优先于模板)
  2. 提升转换(小类型可以向大类型提升转换,例:char/short转向int,float转向double)
  3. 标准转换(例:Int转换为char,long转换为double)
  4. 用户定义的转换(在调用时,函数名<>,其中指定或不指定类型,让模板去实例化)

总结一下,重载解析将寻找最佳匹配函数。
如果只存在一个这样的函数,则选择它。

如果存在多个这样的函数,但其中只有一个非模板函数(其实就是一个模板实例化的普通函数的重载函数(参数类型不一样,定义也可能不一样,算是具体化的一种)),则选择该函数。

如果函数的调用是不确定的(编译器不知道调用哪个),那么将报错。

针对类模板的特化

与函数特化类似,在特殊场景下,无法满足特殊需求,就需要自己指定。

template <class T1,class T2>
class Tmp
{
public:
	Tmp()
	{
		cout << "Tmp<T1,T2>" << endl;
	}
private:
	T1 _a;
	T2 _b;
};

这就是类模板,编辑器会根据指定的类型去实例化相应的类。

全特化

类的特化,或者说全特化,我理解为类的具体化(不知道对不对)

这个编辑器会先去匹配已经具体化的类(类型参数要完全符合),就不会去实例化类模板,而是直接调用最佳的类去创建对象。

#include <iostream>
using namespace std;
template <class T1,class T2>
class Tmp
{
public:
	Tmp()
	{
		cout << "Tmp<T1,T2>" << endl;
	}
private:
	T1 _a;
	T2 _b;
};


template <>
class Tmp<int,int>
{
public:
	Tmp()
	{
		cout << "Tmp<int,int>" << endl;
	}
private:
	int _a;
	int _b;
};
int main(void)
{
	Tmp<int ,int> t1;
	Tmp<double, float> t2;
	return 0;
}

在这里插入图片描述
这两个暑促结果足以证明两个对象的创建,不是同一个类。

偏特化

也就是说,类也可以只特化一部分。
比如这样

template <class T>
class Tmp<T,int>
{
public:
	Tmp()
	{
		cout << "Tmp<T,int>" << endl;
	}
private:
	T _a;
	int _b;
};

还可以特化为指针或者引用

template <class T1, class T2>
class Tmp<T1*,T2*>
{
public:
	Tmp()
	{
		cout << "Tmp<T1*,T2*>" << endl;
	}
private:
	T1 _a;
	T2 _b;
};

所有实验例子

#include <iostream>
using namespace std;
template <class T1,class T2>
class Tmp
{
public:
	Tmp()
	{
		cout << "Tmp<T1,T2>" << endl;
	}
private:
	T1 _a;
	T2 _b;
};
template <>
class Tmp<int,int>
{
public:
	Tmp()
	{
		cout << "Tmp<int,int>" << endl;
	}
private:
	int _a;
	int _b;
};

template <class T1, class T2>
class Tmp<T1*,T2*>
{
public:
	Tmp()
	{
		cout << "Tmp<T1*,T2*>" << endl;
	}
private:
	T1 _a;
	T2 _b;
};
template <class T>
class Tmp<T,int>
{
public:
	Tmp()
	{
		cout << "Tmp<T,int>" << endl;
	}
private:
	T _a;
	int _b;
};
int main(void)
{
	Tmp<int ,int> t1;
	Tmp<double, float> t2;
	Tmp<double , int> t3;
	Tmp<double*, int*> t4;


	return 0;
}

输出结果
在这里插入图片描述
这样可以更方便的符合使用者的需求,减少限制。

模板分离编译

在我模拟实现一些简单STL类模板时,如:string/vector/list/priority_queue,我对类模板的成员函数的定义与声明都是放在同一个.h文件中,本来大型工程中的声明.h文件与定义.cpp文件都是分开为声明与定义。但是这里却无法运行,报错原因是找不到链接。 但也就是说,在编译之前的过程,这个工程是可以跑过的。那么我就要从工程执行的过程开始寻找问题。
我们都知道C/C++的编译过程:

预处理->编译->汇编->链接
test.cpp -> test.s- > test.i -> test.o -> a.out(可执行文件)

这个过程不清楚的可以去看C/C++编译过程

main.cpp

#include <iostream>
using namespace std;
#include "test.h"
int main(void)
{
	Data d;
}

test.h

#pragma once

class Data
{
public:
	Data();
	~Data();

private:

};

test.cpp

#include "test.h"
Data::Data()
{

}
Data::~Data()
{

}

这个是可以跑过的,因为这是一个类,而不是模板。

但是,对于类模板而言,这就无法通过编译。
首先程序要进行 预处理
预处理要

删除注释
#include等头文件内容拷贝到文件中,
宏替换
条件编译

.h文件会被拷贝到main.c文件的开头。

再进行 编译
编译

把cpp代码翻译成汇编代码
语法分析(判断代码的语法是否正确)
词法分析
语义分析(翻译每段代码的意思)
符号汇总

编译时,代码编译器检查到使用类模板创建对象后者调用函数模板的函数,由于预处理时,已经包含了类模板或者函数模板的声明,编译器就会认为这个函数已经声明了,就相当于一个通行证,只要这些自定义的东西声明了,就都能通过编译,不管有没有定义,或者找不找得到定义。

能通过编译,语法也没什么问题,语义还是那个也没有什么二义性,编译器就会把cpp代码翻译成汇编。

汇编会把各个文件中的函数汇总,形成符号表。
在编译器中处理的过程:预处理、编译、汇编,都没什么问题

但是在最后的链接器中,出问题了,由于在编译的时候,根据命名修饰规则 ,函数被修饰,但是在汇编中并没有其定义的地址,其地址一直处于未知状态。在最后的链接中,虽然,对于函数模板的定义所处的文件,也会被编译预处理,汇编之列的步骤,但是,这还是处于模板的状态,也就是说,模板并没有针对调用的类型参数进行实例化,所以,根本就没有相关的函数形成符号表,当然也就找不到来链接了。只要有声明就能通过编译,但是最后的链接,是不可找到其相关的函数的定义。所以不可能让模板进行分离编译。

最后就总结,
定义的地方美没有实例化
实例化的地方没有定义,只有声明

所以模板不能分离编译

解决方案

  1. 显式实例化:在定义的地方指定实例化的类型 template void fuc<int>(int a,int b)(这样就能让定义的位置进行实例化,就能形成相应都符号表,能找到地址,可以进行链接)
  2. 不要分离编译(朴实无华)

点击全文阅读


本文链接:http://zhangshiyu.com/post/30545.html

函数  模板  具体化  
<< 上一篇 下一篇 >>

  • 评论(0)
  • 赞助本站

◎欢迎参与讨论,请在这里发表您的看法、交流您的观点。

关于我们 | 我要投稿 | 免责申明

Copyright © 2020-2022 ZhangShiYu.com Rights Reserved.豫ICP备2022013469号-1