文章/答案/技术大牛

发布

为什么T &&实例化为int&？

T &&实例化为int&的原因是因为T &&是一个右值引用类型，而int&是一个左值引用类型。在C++中，右值引用可以绑定到将要销毁的临时对象，而左值引用只能绑定到具有标识符的对象。

当使用T &&实例化为int&时，意味着我们将右值引用绑定到一个左值上，这是不允许的，因为右值引用的主要目的是为了支持移动语义和完美转发。

在这种情况下，编译器会发出错误，因为int&是一个左值引用类型，而T &&是一个右值引用类型，它们之间存在类型不匹配。

需要注意的是，T &&实例化为int&这种情况是不合法的，正确的实例化应该是T &&实例化为int。

相关·内容

企业移动化为什么要调研先行？

常言道，“兵马未动，粮草先行”，前期调研是企业移动信息化项目成功的保障，而往往企业会忽略这一点，甚至有些企业在不清楚需求的情况下，就盲目启动移动信息化项目，这样...

87711 0

C++11新特性大揭秘：优化性能与简化代码的利器

>(0); // 编译报错，0是右值 // 引用折叠时 -> f1实例化为 void f1(int& x) f1int&>(n); // 正常编译 f1int&>(0);...); // 正常编译 // 折叠->实例化为 f1int&>(n); f1int&>(0); // 折叠->实例化为 f1(n);...); // 正常编译，0 是右值 // 折叠时，实例化为 void f2(int& x) f2int&>(n); // 正常编译，n 是左值 f2int&>(0);...，推导出T为int&，引用折叠，实例化为 void Function(int& t) Function(a); // 左值传递，实例化为 void Function(int& t)...int&，引用折叠，实例化为 void Function(const int& t) Function(b); // 左值传递，实例化为 void Function(const int& t

851 0

右值引⽤与移动语义

如下所示： f1(T& x) 总是实例化为左值引用，因为无论传入的是左值还是右值，T& 都不发生变化。 f2(T&& x) 根据传入的参数类型，实例化为左值引用或右值引用。...例如，传入 int& 时，f2 实例化为 void f2(int& x)；传入 int 时，实例化为 void f2(int&& x)。...报错 // 折叠，实例化为 void f1(const int& x) // n 是左值，T 推导为 const int&，故实例化成功 f1int&>(n); // 报错：0 是右值...T 为 int&，引用折叠，模板实例化为 void Function(int& t) Function(a); // 左值 // std::move(a) 是右值，推导出 T 为 int...// b 是 const 左值，推导出 T 为 const int&，引用折叠，模板实例化为 void Function(const int& t) // 因为 t 是 const 引用

1371 0

【深度剖析 C++11】第二弹：现代C++ 的关键版本和核心驱动

n = 10; func1(n); //没有引用折叠实例化为 void func1(int& x) func1int&>(n); //int& & 折叠为int& 实例化为...&& & 折叠为 const int& 实例化为 void func1(const int& x) } 无论如何实例化 func1只能折叠为左值引用或者const 左值引用 3.2.1、func2的折叠...= 10; func2(10); //没有引用折叠实例化为 void func1(int&& x) func2int&>(n); //int&& & 折叠为int& 实例化为...func(x); } void Test() { int a = 10; //实例化为左值引用传左值 Functionint&>(a); //实例化为右值引用传右值 Function...，就可以使其匹配到对应的func版本 func(forwardT>(x)); } void Test() { int a = 10; //实例化为左值引用传左值 Functionint&>

921 0

C++11特性：初始化列表、右值引用、可变模板

& x) f1(n); //f1(0);//报错:没有与参数列表匹配的函数模板 "f1" 实例 // 折叠->实例化为void f1(int& x) f1int&>(n...实例化为void f1(const int& x) f1int&>(n); f1int&>(0); // 没有折叠->实例化为void f2(int&& x) //...Function(int&& t) Function(10);//右值 int a; // a是左值，推导出T为int&，引用折叠，模板实例化为void Function(int& t) Function...(int&& t) Function(10); int a; // a是左值，推导出T为int&，引用折叠，模板实例化为void Function(int& t) Function(a); /...b = 8; // b是左值，推导出T为const int&，引用折叠，模板实例化为void Function(const int& t) // 所以Function内部会编译报错，x不能++ Function

910 0

【C++11】{}右值引用移动语义类型分类引用折叠完美转发--C++

= 1; // r4 的类型是 int&& // 没有折叠->实例化为void f1(int& x) f1(n); f1(0); // 报错 // 折叠->实例化为void...(0); // 报错 // 折叠->实例化为void f1(const int& x) f1int&>(n); f1int&>(0); // 折叠->实例化为...为int&，引⽤折叠，模板实例化为void Function(int& t) Function(a); // 左值 // std::move(a)是右值，推导出T为int，模板实例化为void...& t) Function(10); // 右值 int a; // a是左值，推导出T为int&，引⽤折叠，模板实例化为void Function(int& t) Function(...右值 const int b = 8; // a是左值，推导出T为const int&，引⽤折叠，模板实例化为void Function(const int& t) Function(b);

540 0

C++ —— 剑斩旧我破茧成蝶—C++11

// 没有折叠->实例化为void f1(int& x) f1(n); f1(0); // 报错 // 折叠->实例化为void f1(int& x) f1int&...>(n); f1int&>(0); // 报错 // 折叠->实例化为void f1(int& x) f1(n); f1(0); // 报错 // 折叠->实例化为...; // 折叠->实例化为void f2(int& x) f2int&>(n); f2int&>(0); // 报错 // 折叠->实例化为void f2(int&& x) f2t) Function(10);// 右值 int a; // a是左值，推导出T为int&，引⽤折叠，模板实例化为void Function(int&...推导出T为int&，引⽤折叠，模板实例化为void Function(int& t) Function(a);// 左值 // std::move(a)是右值，推导出T为int，模板实例化为void

580 0

Effective Modern C++翻译(2)-条款1：明白模板类型推导

，当他们向一个引用类型的参数传递一个const对象时，他们期待这个对象依旧是无法被修改的，比如，这个参数的类型被推导为一个指向const的引用，这就是为什么向带有一个T&参数的模板传递一个const对象是安全的...int& f(cx); // cx是一个左值, 所以T是const int&, // param的类型也是const int...int& f(27); // 27是一个rvalue, 所以T是int, // param类型是int&& 条款26精确的介绍了为什么这些例子会是这样...，函数类型也可以退化为指针，我们讨论的任何一个关于类型推导的规则和对数组相关的事情对于函数的类型推导也适用，函数类型会退化为函数的指针，因此 void someFunc(int, double); //...模板的参数是按值传递的时候，实例化的表达式的引用性和常量性将被忽略。在类型推导期间，数组和函数将退化为指针类型，除非他们是被实例化为相应的引用。

79110 0

GO小知识之实例演示 json 如何转化为 map 和 struct

json 转化为 map 最先想到的方式就是通过 json.Unmarshal 将 JSON 转化 map[string]interface{}。...如果能把 JSON 转化为struct 就好了。 json 转化为 struct 在 GO 中，json 转化为 struct 也非常方便，只需提前定义好转化的 struct 即可。...能不能把 map 转化为 struct ? map 转化为 struct 据我所知，map 转为转化为 struct，GO 是没有内置的。如果要实现，需要依赖于 GO 的反射机制。

1.2K2 0

C++11(2)

实例: int main() { 左值(左值是可以取地址的,一般是变量) int a = 2; int* b = new int(0); const int c = 20; //左值引用实例...,取的别名就是一个变量; const int& n = a + 3; //右值引用左值 int&& f = a; //会报错,无法直接引用左值,因为int 无法转化为int&& ; //但是可以强制转化类型...& 并不是右值引用,而是万能引用;这里的T可以是T&或T&&,如果是T是T&(左值)那么t的类型就是T&,如果T是T&&(右值)那么t的类型就是T&&; 右值引用退化问题右值被引用后是可以修改的,这种情况其实就是右值退化为了左值...;如果函数里面还需要传递右值那么就需要使用强制转化类型将这个左值转化为右值; templateT> void PerfectForward(T&& t) { Fun(t);//这里的...t需要转化为右值 } 1.使用move转化为右值; templateT> void PerfectForward(T&& t) { Fun(move(t));//这里的t需要转化为右值

531 0

模板进阶：特化与编译链接全解析

// 两个参数偏特化为引用类型 template T1, typename T2> class DataT1&, T2&> { public: Data(const T1&...Dataint&, int&> d4(1, 2);：调用了特化的引用版本，因为两个参数是引用类型（注意，这里初始化引用类型参数时传递的是常量1和2，这些字面量会被隐式转换为合适的引用类型）。...模板匹配顺序：编译器在选择模板实例化时，会按照以下优先顺序进行匹配：完全匹配的全特化（优先级最高）最匹配的偏特化最通用的模板指针特化时const的修饰问题为什么在参数列表使用const...已经特化的类中T表示为什么？...为什么不能分离定义？ **原因：**模板实例化的代码并不是编译的时候在模板位置直接生成的，而是在需要实例化的时候才会生成特定的具体代码。实例化时机：模板的实例化发生在编译器遇到模板函数或类的使用时。

1811 0

C++打怪升级（八）- 泛型编程初见

； **也就是说，编译器选择优先考虑是匹配问题； ** int Add(const int& t1, const int& t2) { return t1 + t2; } template，中写实例化的类型，注意类模板名字不是真正的类，而实例化的结果才是真正的类（也就是类模板名加上具体的类型是真正的类名）；这里有个问题，类模板实例化为什么必须在其后加上呢？...或者说为什么我们需要指定类模板实例化的类型而不是像函数模板实例化那样由编译器推导类型再实例化呢？...，那么为什么找不到呢？...；为什么在类模板没有实例化出具体的函数呢？

8172 0

【C++】C++11

// 折叠 -> 实例化为 void f1(int& x) f1 (n); f1 ( 0 ); // 报错 // 折叠 -> 实例化为...// a 是左值，推导出 T 为 int& ，引⽤折叠，模板实例化为 void Function(int& t) 18 Function (a); // 左值 19 20...右值 22 23 const int b = 8 ; 24 // a 是左值，推导出 T 为 const int& ，引⽤折叠，模板实例化为 void Function...// a 是左值，推导出 T 为 int& ，引⽤折叠，模板实例化为 void Function(int& t) Function (a); // 左值 // std::move...b = 8 ; // a 是左值，推导出 T 为 const int& ，引⽤折叠，模板实例化为 void Function(const int& t) Function

921 0

Python基础 | 为什么经常会将list()转化为numpy.array()类型

在平时用python做开发或者阅读流行的开源框架的源码的时候，经常会看到一些代码将普通的列表list()类型转化为numpy的array()，如下所示： import numpy as np a = [...1,2,3,4,5] b = np.array(a) type(b) #numpy.ndarray 变量a是一个常见的Python列表类型，通过numpy.array()方法将该列表转化为了一个ndarray...为什么很多代码都会出现这样的操作？转化之后的numpy.array类型又会带来哪些好处呢？...下面代码是将列表转化为numpy.ndarray后支持的一些常用操作，根据方法名即可快速了解其含义。...从上面的案例分析讲解，大家可以看到为什么会将普通的列表类型转换为numpy.ndarray类型了，很重要的原因在于这种转化后，numpy.ndarray提供了很多常见的方法，使得我们不必自己编写代码就可以实现常见操作

3.6K3 0

A800_1.6T RDMA实例测试指导文档

CPU Intel IceLake*2 (124c 2.7GHz/3.3GHz) GPU 8 * A800 NVSwitch 80G 网卡 CX6 100G * 2 * 8 存储 NVMeSSD-6.4T*

2901 0

T-SQL应用实例

实验一：实验案例一（附加“练习用的可以附加的数据库--class”） 1、在products表中查询出厂日期晚于2014年4月的水果信息。 select * ...

9874 0

【C++】C++模板基础知识篇

泛型编程实现一个通用的交换函数： void Swap(int& left, int& right) { int temp = left; left = right; right = temp;...隐式实例化：让编译器根据实参推演模板参数的实际类型 templateT> T Add(const T& left, const T& right) { return left + right...2.5 模板参数的匹配原则一个非模板函数可以和一个同名的函数模板同时存在，而且该函数模板还可以被实例化为这个非模板函数 templateT> T Add(const T& left, const...T& right) { return left + right; } int Add(const int& left, const int& right) { return left + right...如果typedef能够解决像栈队列这些数据结构的问题，C语言为什么不供，就是语法不好用。真正解决不了的是给栈里面数据类型不同的时候该怎么做？

1121 0

1t固态硬盘为什么不建议分区

随着技术的发展，1T固态硬盘已经成为许多用户升级电脑存储时的首选。由于其快速的读写速度和耐用性，固态硬盘正在逐渐替代传统的机械硬盘。...本文将详细探讨这个问题，分析为什么不建议将1TB固态硬盘进行分区，并提供一些实用的建议和注意事项。

3021 0

【C++】模版+STL简介

1.4函数模版实例化用不同类型的参数使用函数模板时，称为函数模板的实例化。模板参数实例化分为：隐式实例化和显式实例化。...，而且该函数模版还可以被实例化为这个非模版函数 #include using namespace std; //专门处理int的加法函数 int Add(const int& x..._d1; T2 _d2; }; //部分特化 // 将第二个参数特化为int template T1> class DataT1, int> { public: Data()...{coutT1, int>" <<endl;} private: T1 _d1; int _d2; }; //两个参数偏特化为指针类型 template T1,..._d1; T2 _d2; }; //两个参数偏特化为引用类型 template T1, typename T2> class Data T1&, T2&> { public:

701 0

C++ 左值和右值

; //1.当T&& t接收的实参为左值时，T被推导为T&，t的类型为T&，t为左值，此时forward实例化为forwardT&>(T&) //2.1 //mytest2(10); /.../当T&& t接收的实参为右值时，T被推导为T，t的类型为T&&，t为左值，此时forward实例化为forwardT>(T&) //2.2 //mytest2(static_cast...(30)); //当T被显示指定为T&&时（此时形参T&& t只能接收右值实参），t的类型为T&&，t为左值，此时forward实例化为forwardT&&>(T&) func...，T被推导为T&，t的类型为T&，std::move(t)为右值，此时forward实例化为forwardT&>(T&&) //此时因为T被推导为T&，为左值，static_assert断言失败，会报错...//2.1 //mytest2(10); //当T&& t接收的实参为右值时，T被推导为T，t的类型为T&&，std::move(t)为右值，此时forward实例化为forwardT>(

1.2K18 1

点击加载更多

扫码

添加站长进交流群

领取专属 10元无门槛券

手把手带您无忧上云