template_11实参演绎

1,演绎过程

匹配类型A(来自实参的类型),参数化类型P(行参参数声明)
如果被声明的参数是一个引用声明g(T& )那么P就是所引用类型T;
f(T)中P就是所声明的参数类;
decay指从数组和函数类型隐式转换为指针类型。
如果实参的类型是数组或函数类型,则会发生decay,此时还会忽略高层次的const和volatile限定符。

template <class
T>
T
const& max(T
const& a, T
const& b)


T被要求同时是char[7]和char[4]所以error.
如果去掉参数声明中的引用符号,则可以decay,演绎成char*就能编译通过了。

2,演绎上下文
根据一些基本的类型匹配构造出复杂的类型。

fp中T演绎为int**
fe中E为bool,N为32
fs中T1,T2,T3为int,S,double

复杂的类型声明都是产生自比它基本的构造;匹配过程从最顶层的构造开始,然后不断递归各种组成元素(即构造):大多数的类型声明构造都可以使用这种方式进行匹配,这些构造被称为演绎 的上下文。

某些构造不能作为演绎上下文:
受限制的类型名称,诸如Q<T>::X类型名称不能被用来演绎模板参数T。
除了非类型参数外模板参数还包含其他成份的非类型表达式,诸如S<T+2>,int(&)[sizeof(S<T>)]。

3,特殊的演绎
存在两种特殊情况,其中用于演绎的实参-参数对(A-P)并不是分别来自于函数调用的实参和函数模板的参数。
第1种情况出现在取函数模板地址的时候,此时P是函数模板声明的参数化类型,而A是被赋值或初始化的指针所代表的函数类型:
template<class
T>
void f(T, T);

void(*pf)(char, char) = &f;
上面P就是void(T, T),而A就是void(char, char)
pf被初始化为"特化f<char>"的地址

另一种特殊情况和转型运算符模拟一起出现,
资料说可以吧S转换为int(&)[20],于是P为T[N],A为int[20]
but,我测试却是无法转换,可能是vs不支持。

4,
模板实参演绎只能应用于函数模板和成员函数模拟,不能用于类模板和类模版的构造函数。

依赖于模板参数调用缺省实参

不是依赖型,也不能用于演绎模板实参

5,Barton-NackMan方法:限制的模板扩展
需要定义类模版的operator ==的时候,如果把该运算符声明为模板的成员,则改运算符的第一个实参(this指针)和第二个实参的转型规则可能不一致。而operator==意味着它的两个实参应该是对称的,有了不同转型后就很难保证这种对称性了 。
于是如下图把该运算符声明为一个名字空间作用域的函数供调用。

如果函数模板不能被重载,则在这个作用域中也不能声明其他的operator==模板了。
把这个运算符作为类的普通友元函数定义在类的内部即可。
假设用int类型来实例化模板类,那么作为实例化的结果,这个友元类运算符相应地被具体声明了(即确定了参数类型)。但是这个具体函数本身并不是函数模板实例化的结果,它本身就是一个非模板函数,只是借助于实例化过程的边缘效应它才被声明为一个具体函数,并且插入到全局作用域中。
由于是非模板函数,所以即使在语言不支持函数模板重载的情况下也可以对该运算符"重载",借助该技术可以不使用模板运算符operator==(T, T)却使运算符能应用于所有类型的T(无限扩展机制),因此叫做限制的模板扩展(restricted template expansion)。
由于友元定义在类定义的内部,因此它被隐式的看作是inline的,因此可以把实现委托给一个函数模板,这个函数模板不需要内联也不会和相同名字的其他模板冲突。


模板运算符重载:        Arry<>::operator==
运算符友元:            operator==
命名空间作用域运算符:    operator==<>

-------------------------------------------------
该技术的关键就是在类模板实例化的过程中,伴随生成一个非模板的具体函数。
而且这个函数并不产生自函数模板,因此也不需要去进行模板实参演绎,但该函数却属于重载解析规则。

时间: 2024-12-28 09:47:11

template_11实参演绎的相关文章

C++模板:实参演绎

在C++函数模板中,实参演绎是一非常种灵活的机制,实参演绎的字面意思就是:通过实参的类型来推断函数模板的类型参数,举个简单的函数模板的例子: template<typename T> T& func1(T &a, T &b) { cout<<typeid(T).name()<<endl; } 因为有了实参演绎,我们可以像使用普通函数一样来使用模板函数,如下: int a,b; func1(a,b); 也就是说,虽然我们没有为func指定T,编译器

C++ template —— 实例化和模板实参演绎(四)

本篇讲解实例化和模板实参演绎------------------------------------------------------------------------------------------------------------第10章 实例化------------------------------------------------------------------------------------------------------------模板实例化是一个过程,它

模板实参演绎

一.什么是实参演绎 如果我们每次都必须显式的指明模板替换参数类型,例如concat<std::string, int>(s, 3),那么过程将会显得非常繁琐. 如果我们可以concat(s, 3)//之前必须声明s是std::string类型,那么将会向普通的函数调用一样简单, 事实上,C++是允许这样的写法,然后C++编译器会根据实参(s和3)的类型推算出合适的替换类型. 如何演绎? 1 template<typename T> 2 T const& max(T cons

字符串作为函数模版实参的意外情况

有时,当把c风格的不同字符串去实例化函数模版的同一个模版参数时,在实参演绎的过程中经常会发生 意想不到的事情,那就是编译失败,并报错类型不匹配. 正如下面的例子一样: #include<iostream> using namespace std; /* *匹配测试 */ template<typename T> int ref_fun(T & t1,T & t2) { return strlen(t1) - strlen(t2); } template<typ

C++ template技巧性基础知识总结

1.如果要访问依赖于模板参数的类型名称,你应该在类型名称前添加关键字typename. 2.嵌套类和成员函数也可以是模板. 3.赋值运算符的模板版本并没有取代缺省赋值运算符. 4.类模板也可以作为模板参数,我们称之为模板的模板参数. 5.模板的模板实参必须精确地匹配.匹配时并不会考虑"模板的模板实参"的缺省模板实参(如std::deque的allocator) 6.通过显示调用缺省构造函数,可以确保模板的变量和成员都已经用一个缺省值完成初始化,这种方法对内建类型的变量和成员也适用. 7

C++ 静态多态和动态多态 浅析

今天的C++已经是个多重泛型编程语言(multiparadigm programming lauguage),一个同时支持过程形式(procedural).面向对象形式(object-oriented).函数形式(functional).泛型形式(generic).元编程形式(metaprogramming)的语言. 这些能力和弹性使C++成为一个无可匹敌的工具,但也可能引发使用者的某些迷惑,比如多态.在这几种编程泛型中,面向对象编程.泛型编程以及很新的元编程形式都支持多态的概念,但又有所不同.

类模板和函数模板

函数模板: 函数模板全特化:所谓特化,是指相对普通模板的特化,是另外一个模板.但不是实例,只是模板 template <class T>                                      //普通函数模板,泛型T mymax(const T t1, const T t2){   return t1 < t2 ? t2 : t1;} template <>const char* mymax(const char* t1,const char* t2)  

C++多态(静多态和动多态)

如今的C++已经是个多重泛型编程语言(multiparadigm programming lauguage),一个同时支持过程形式(procedural).面向对象形式(object-oriented).函数形式(functional).泛型形式(generic).元编程形式(metaprogramming)的语言. 这些能力和弹性使C++成为一个无可匹敌的工具,但也可能引发使用者的某些迷惑,比如多态.在这几种编程泛型中,面向对象编程.泛型编程以及很新的元编程形式都支持多态的概念,但又有所不同.

【C++】泛型编程基础:模板通识

测试环境: Target: x86_64-linux-gnu gcc version 5.3.1 20160413 (Ubuntu 5.3.1-14ubuntu2.1) 什么是泛型编程?为什么C++会有模板?这一切的一切都要从如何编写一个通用的加法函数说起. 很久很久以前 有一个人要编写一个通用的加法函数,他想到了这么几种方法: 使用函数重载,针对每个所需相同行为的不同类型重新实现它 int Add(const int &_iLeft, const int &_iRight) { retu