模板类型推导 T

最新推荐文章于 2024-11-19 09:10:01 发布

原创最新推荐文章于 2024-11-19 09:10:01 发布 · 1k 阅读

1 ·

CC 4.0 BY-SA版权

文章标签：

#cpp

Effectivve Modern Cpp 专栏收录该内容

25 篇文章

订阅专栏

本文详细介绍了C++从C++98到C++14中类型推导的发展，包括template、auto和decltype的使用。通过实例分析了不同类型推导的规则和优劣，强调了类型推导在C++新特性中的重要地位，并探讨了引用、指针、右值引用和万能引用的推导机制。

                    
类型推导

c++98

只有template一种.

c++11

auto template并做了一点改良.

c++14

在c++11的基础上做了加强auto和decltype的组合.

推导优劣

好处

少打代码.
可以声明不确定类型的变量类型.
必须初始化.
在修改某返回类型时,不用改太多.

劣势

阅读性不强.
甚至可能得不到预期的.

地位

C++的新特性基本都是基于类型推导,所以需要好好的学习掌握类型推导的原理.

主要内容

类型推导如何实现的,怎么看类型推导出来的结果.

核心

都是编译器需要支持对应语法.

类型推导

关系

template支持类型推导。
auto使用了template的规则进行类型推导,也有部分的差异。
decltype则是全新的逻辑.

总纲

变量本身强相关. &,*都是.
变量本身不想管. 值传递.

原则

类型规则说明
T&T = valuetype - argtypeargtype中包含&
T*T = valuetype - argtypeargtype中包含*
T&&T = valuetype - argtypeargtype中包含&&
T非指针T = valuetype - argtypeargtype最终的变量是*类型.

T&

说明

argtype中包含&,即左值右值和const,volatile,*,none之类的修饰进行分析.
这里仅仅部分的案例.

分析

引用就是指针,指针则会关注指针指向的类型.
即对于指针指向内容的约束,只能扩大,不能缩小.

概括

引用取对象的完整类型.
T = valuetype - argtype

案例一分析

template<typename T>
void show(const T& a) {
   // error code
   a.nice();
}
int main() {
   show(1);
}

T = valuetype - argtype = int&& - const &,利用集合运算. 则T = int.
最终的argtype = const int&
因为有const所以&&等价于&.

案例二分析

template<typename T>
void show(const T& a) {
   // error code
   a.nice();
}
int main() {
   int a = 1;
   show(a);
}

T = valuetype - argtype = int & - const & = int.则T = int.
最终的是valuetype = const int &

案例三分析

template<typename T>
void show(T& a) {
   // error code
   a.nice();
}
int main() {
   int a = 1;
   show(a);
}

T = valuetype - argtype = int & - & = int,则T = int.
最终的valuetype = int &.

案例三分析

template<typename T>
void show(T& a) {
   // error code
   a.nice();
}
int main() {
   const int a = 1;
   show(a);
}

T = valutype - argtype = const int & - & = const int, 则T = const int
最终 valuetype = const int &

案例四

template<typename T>
void show(T&& a) {
   // error code
   a.nice();
}
int main() {
   const int a = 1;
   show(&a);
}

这里加入了指针类型,因为指针类型和变量类型是两个独立的存在。
T = valuetype - argtype = const int * && - && = const int *.

总结

引用,不论是&,&&都可以按照这个表达式进行计算. 但是需要区分右值&&和万能引用的场景.
T&&是万能,其他格式都是右值引用.

T*

说明

argtype中的值传递是指针类型。

指针类型和指向类型

指针类型: 是指针这个变量本身的类型.有对应的修饰。
指向类型: 是地址对应的变量是某个类型.

概括

指针取指向类型,而不是变量本身.
T = valtype - argtype.
注意: 变量的引用和指向类型可能会有歧义.

案例分析

比较好理解的就是typedef int *int_ptr;
即*int_ptr = int.
同理typedef const int *c_intptr;,*c_intptr = const int.
变量本身的所有的类型修饰一般在对应*之后.
typedef的可阅读性变差,C++11之后就变成使用using了.

核心

T&实际就是*类型.

案例一

template<typename T>
void show(T* a) {
   // error code
   a.nice();
}
int main() {
   const int a = 1;
   show(&a);
}

&a是const int * &&类型.但是argtype中没有引用所以忽略&&.
则T = valtype - argtype = const int* - * = const int

案例二

template<typename T>
void show(T* &a) {
   // error code
   a.nice();
}
int main() {
   const int a = 1;
   show(&a);
}

编译错误,因为&a是右值,对变量本身有限制。
将T*&a改成T*&&a即可.

案例三

template<typename T>
void show(const T* a) {
   // error code
   a.nice();
}
int main() {
   const int a = 1;
   show(&a);
}

&a是const int * &&类型.但是argtype中没有引用所以忽略&&.
则T = valtype - argtype = const int* - const* = int.

T&&

说明

万能引用,可以匹配任意类型.

核心

唯一可以推导出T是引用类型的机制.前面的T都是基本类型。
即T =里面不存在&类型.
比如上面的都是int,const int之类,没有&,万能引用可以.

简要

右值引用仅仅用来匹配右值，太大材小用了，毕竟右值的描述性字段很少，就基础的。
用来扩展功能挺好的。

概括

万能引用形式像右值引用,但是也有右值匹配的功能.
T = valuetype - argtype.,注意,这里的& - && = &

注意

因为右值一般是消亡值,所以可以回收利用资源.

案例一

template<typename T>
void show(T&& a) {
   // error code
   a.nice();
}
int main() {
   const int a = 1;
   show(&a);
}

&a是const int *&&.
T = valuetype - argtype = const int *&& - && = const int *.

案例二

template<typename T>
void show(T&& a) {
   // error code
   a.nice();
}
int main() {
   const int a = 1;
   show(a);
}

a是一个const int &类型。
T = valuetype - argtype = const int & - && = const int &.

案例三

template<typename T>
void show(T&& a) {
   // error code
   a.nice();
}
int main() {
   show(7);
}

7是int &&类型.即普通右值.最终有int&&.
T = valuetype - argtype = int && - && = int.

T

说明

就是一个值传递,形参.

核心

形参就是和原本的参数无关,拷贝值,可以随意操作.

概要

值传递,valuetype仅仅保留基础类型.
不将const,volatile之类的修饰用于推测.
T = valuetype - valuetype - const volatile XXX

案例一

template<typename T>
void show(T a) {
   // error code
   a.nice();
}
int main() {
   show(7);
}

T = valuetype - argtype = int.

案例二

template<typename T>
void show(T a) {
   // error code
   a.nice();
}
int main() {
   const int a = 1;
   show(a);
}

T = valuetype - argtype = int.
去掉了const之列的.

案例三

template<typename T>
void show(T a) {
   // error code
   a.nice();
}
int main() {
   const int *a = nullptr;
   show(a);
}

a是指针,指向的类型是const int *.
T = argtype - valuetype = const int *
本身无任何修饰.

案例四

template<typename T>
void show(const T a) {
   // error code
   a.nice();
}
int main() {
   const int *a = nullptr;
   show(a);
}

同案例三.只是对入参加了修饰.

案例五

template<typename T>
void show(T a) {
   // error code
   a.nice();
}
int main() {
   const int *const a = nullptr;
   show(a);
}

同上,这里加了a变量的类型修饰.

案例六

template<typename T>
void show(T& a) {
   // error code
   a.nice();
}
int main() {
   const int *const a = nullptr;
   show(a);
}

a是const int *const类型.const int *是指向的类型,后面的是const类型是自身的类型.
因为这里加了T&.
T = valuetype - argtype = const int * const& - & = const int * const.

案例七

template<typename T>
void show(T& a) {
   // error code
   a.nice();
}
int main() {
   const int *volatile a = nullptr;
   show(a);
}

和上面略有差异.
a指向类型还是const int *,但是本身是一个volatile修饰的.
所以T = valutype - argtype = const int * volatile & - & = const int * volatile.

总结

引用,完整类型,减法.

指针,完整类型,减法.

右值,完整类型,减法.

万能,完整类型,减法.

形参,普通类型,多减.

类型	规则	说明
`T&`	`T = valuetype - argtype`	`argtype`中包含`&`
`T*`	`T = valuetype - argtype`	`argtype`中包含`*`
`T&&`	`T = valuetype - argtype`	`argtype`中包含`&&`
`T`非指针	`T = valuetype - argtype`	`argtype`最终的变量是`*`类型.