模板参数类型推导和完美转发及move、引用折叠

最新推荐文章于 2023-09-19 00:15:00 发布

liuge

最新推荐文章于 2023-09-19 00:15:00 发布

阅读量395

点赞数

分类专栏： c++学习

本文链接：https://blog.csdn.net/weixin_44537992/article/details/104668314

版权

c++学习专栏收录该内容

30 篇文章 2 订阅

订阅专栏

模板实参推断（Template Argument Deduction）的规则比较复杂，首先要知道参数类型和模板参数类型是不同的概念。
注意点;
模板参数T是由PT和模板实参共同决定的


template<typename T> // 尖括号里的T叫模板参数
void f(T x); // 圆括号里的T叫调用参数

// 参数类型（即x的类型）和模板参数类型（即T的类型）是不同的概念

// 推断时用来替换模板参数的叫模板实参，比如
int i;
f(i); // 模板实参是int

1、推断规则

调用参数不是引用或指针（即T）：

如果表达式不是指针，T和x的类型都是非引用类型，cv限定符去除。比如表达式是int、int&、int&&、const int、const int&，只要不是指针，T和x最终都是int；如果是指针，T和x都是对应的指针类型，cv限定符保留；

template<typename T> 
void f(T x);
// 为了方便，只指明类型不做初始化

int i;
int* p;
const int* q;
f(i); // T和x都是int
f(p); // T和x都是int*
f(q); // T和x都是const int*

调用参数是引用或指针（即T&或T*）：

对于T&，不管表达式是什么，x一定是左值引用类型（表达式是指针则x是指针的引用），cv限定符保留；对于T*，和T&类似，x一定是指针类型，cv限定符保留；知道x类型则可以很容易知道T类型；通过下面的例子可以发现，T一定是非引用类型；


template< typename T> 
void f(T& x);

int i;
int& r;
int&& rr;
const int& cr;
int* p;
const int* const q;
f(i); // x是int& => T&是int& => T是int
f(r); // x是int& => T&是int& => T是int
f(rr); // x是int& => T&是int& => T是int
f(cr); // x是const int& => T&是const int& => T是const int
f(p); // x是int* & => T&是int* & => T是int*
f(q); // x是const int* const & => T&是const int* const & => T是const int* const


template<typename T>
void f2(T* x);

f2(&i); // x是int* => T*是int* => T是int
f2(&cr); // x是const int* => T*是const int* => T是const int
f2(p); // x是int* => T*是int* => T是int
f2(q); // x是const int* => T*是const int* => T是const int

了解第三种情况的规则之前先要理解左值和右值的区别，简单来说，可以取地址的就是左值，即将销毁的就是右值，再简单粗暴一点，变量都是左值，字面值都是右值。右值和右值引用不是一个概念，右值引用是一个变量，可以是左值。int&& r = 42; // r是右值引用，但不是右值而是左值
int&& r2 = r; // 错误：不能将右值引用绑定到左值

调用参数是转发引用（即T&&）：

不管表达式是什么，x都是引用类型：如果表达式是左值，则x是左值引用，cv限定符保留，即采用和T&相同的规则，只不过因为T&&多了个&，为了转为左值引用需要引入引用折叠的概念。通过下面的例子可以发现，T一定是左值引用类型，这是T被推断为引用类型的唯一情况；如果表达式是右值，则x是右值引用类型；
在这里插入图片描述
引用折叠规则


template< typename T>
void f(T&& x);

int i;
int& r;
int&& rr;
const int& cr;
int* p;
const int* const q;
// 都是左值，采用的规则和T&的相同
f(i); // x是int& => T&&是int&，int& + && = int& => T是int&
f(r); // x是int& => T&&是int&，int& + && = int& => T是int&
f(rr); // x是int& => T&&是int&，int& + && = int& => T是int&
f(cr); // x是const int& => T&&是const int& => T是const int&
f(p); // x是int* & => T&&是int* & => T是int* &
f(q); // x是const int* const & => T&&是const int* const & => T是const int* const &

// 表达式是右值
f(42); // x是int&& => T&&是int&& => T是int
再来解释题目中的情况就很容易了。template <typename T> void f4(T t) {t += 10;};
template <typename T> void f5(T& t) { t += 10; };
template <typename T> void f6(T&& t) { t += 10; };

int test_val=0;              //变量
int& test_val_ref = test_val;//左值引用
int&& test_val_rref = test_val*1;//右值引用

// 下面三种都是传值，实际没有做任何改变
f4(test_val); // f4<int>(int t)，传值，实际没改变test_val
f4(test_val_ref); // f4<int>(int t)，传值，实际没改变test_val_ref
f4(test_val_rref); // f4<int>(int t)，传值，实际没改变test_val_rref
// 下面三种是传引用，所以会改变值
f5(test_val); // f5<int>(int& t)，传引用，test_val = 10，test_val_ref = 10
f5(test_val_ref); // f5<int>(int& t)，传引用，test_val = 20，test_val_ref = 20
f5(test_val_rref); // f5<int>(int& t)，传引用，test_val_rref = 10
// 下面三种传递的表达式都是左值，因此情况同上三种，最终结果就是40，40，20
f6(test_val); f6(test_val_ref); f6(test_val_rref);

2、完美转发

完美转发的使用是有场景限制的，得在模板中使用，输入T，并根据输入的实参类型，选择相应的函数重载的模板，最后再调用万能引用，通过引用堆叠，来完成强制类型转换！！！
先用remove_reference<_ Tp >来移除传入的参数的引用，使得只能传入左值T&或者右值T&&。

  template< typename _Tp>
    constexpr _Tp&&
    forward(typename std::remove_reference<_Tp>::type& __t) noexcept
    { return static_cast<_Tp&&>(__t); }

  /**
   *  @brief  Forward an rvalue.
   *  @return The parameter cast to the specified type.
   *
   *  This function is used to implement "perfect forwarding".
   */
  template<typename _Tp>
    constexpr _Tp&&
    forward(typename std::remove_reference<_Tp>::type&& __t) noexcept
    {
      static_assert(!std::is_lvalue_reference<_Tp>::value, "template argument"
		    " substituting _Tp is an lvalue reference type");
      return static_cast<_Tp&&>(__t);
    }

  /// remove_reference
  template<typename _Tp>
    struct remove_reference
    { typedef _Tp   type; };

  template<typename _Tp>
    struct remove_reference<_Tp&>
    { typedef _Tp   type; };

  template<typename _Tp>
    struct remove_reference<_Tp&&>
    { typedef _Tp   type; };

完美转发典型使用场景

template <class _Tp>
inline
_Tp&&
forward(typename remove_reference<_Tp>::type& __t)
{
    return static_cast<_Tp&&>(__t);
}

template<class TYPE, class ARG>
TYPE* get_instance(ARG&& arg)
{
     TYPE* ret;
     ret = new TYPE(std::forward<ARG>(arg));
     return ret;
}

由上栗子可以看出，当调用get_instance()时步骤：
1、函数模板参数推导，如果int&& i=1； get_instance(i)，arg为int&，ARG&&为int&，则ARG为int&，则调用左值的forward，并且forward<int &>,实现完美转发

3.MOVE

将左值强行转换为右值，主要用于转移构造或者转移赋值中，作为输入的前处理

  template<typename _Tp>
    constexpr typename std::remove_reference<_Tp>::type&&
    move(_Tp&& __t) noexcept
    { return static_cast<typename std::remove_reference<_Tp>::type&&>(__t); }

3.1 Move_if_noexcept

如果move带有noexcept，则表示保证不会出现意外，则move_if_noexcept调用时，会用move，否则走拷贝构造！！！

struct Bad
{
    Bad() {}
    Bad(Bad&&)  // 可能抛出
    {
        std::cout << "Throwing move constructor called\n";
    }
    Bad(const Bad&) // 亦可能抛出
    {
        std::cout << "Throwing copy constructor called\n";
    }
};
 
struct Good
{
    Good() {}
    Good(Good&&) noexcept // 将不抛出
    {
        std::cout << "Non-throwing move constructor called\n";
    }
    Good(const Good&) noexcept // 将不抛出
    {
        std::cout << "Non-throwing copy constructor called\n";
    }
};
int main() {
    Bad bad1;
    Good good;
    Bad bad2 = move_if_noexcept(bad1);
    Good good1 = move_if_noexcept(good);

4.引用折叠

一共四种类型
1、模板实例化
T&-&\ T&-&& \ T&&-& \T&&-&&
2、auto
Widget w; auto w1=w; w为左值T&，auto为T& &&，折叠
3、生成和使用typedef

template<class T>
class Widget
{
public:
	typedef T&& RvalueRefToT;//并不是万能引用，不需要类别推导，只有类别堆叠
}
Widget<int&> w;
RvalueRefToT 为int&

4、decltype

liuge

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
模板参数类型推导和完美转发及move、引用折叠

模板实参推断（Template Argument Deduction）的规则比较复杂，首先要知道参数类型和模板参数类型是不同的概念。注意点;模板参数T是由PT和模板实参共同决定的template<typename T> // 尖括号里的T叫模板参数void f(T x); // 圆括号里的T叫调用参数// 参数类型（即x的类型）和模板参数类型（即T的类型）是不同的概念...
复制链接

扫一扫