【C++20】类型与对象

类型与对象

值类别

左值、右值、将亡值
左值引用、右值引用
拷贝构造、移动构造
转发引用、完美转发

引用参考
forward

类型推导

auto

auto v = expr

note:

1. 若expr为引用类型，则会丢失引用属性，同样也会丢失对应的CV属性
2. auto语义下表现为值语义，即通过移动、拷贝构造，丢失了CV属性，想保留了引用语义与CV属性，需要显式指定auto&
3. auto&& 其实是一个转发引用，既能绑定左值也能绑定右值

decltype

由值获得相应的类型

decltype(exp) varName;
decltype(exp) varName=value;
using varName = decltype(exp);

推导规则:

1. 带括号版本获取表达式的值类别
   若表达式的值类别为将亡值，则decltype将产生T&&
   若表达式的值类别为左值，则decltype将产生T&
   若表达式的值类别为右值，则decltype将产生T
2. 不带括号版本用于获取标识符类型（标识符定义时的类型）

note:

sizeof(x++)和decltype(x++)不会使x的值自增

decltype(auto)

decltype(auto) v1 = ptr

例:

struct Point{
    int x = 0;
    int y = 0;
}
Point pt;

decltype(pt)v1 = pt; //Point
decltype((pt))v2 = pt //Point&
decltype(1+2+3+4)v3 = 1+2+3+4; //int
            |
            |
            |
decltype(auto)v1 = pt; //Point
decltype(auto)v2 = (pt) //Point&
decltype(auto)v3 = 1+2+3+4; //int

std::decval

返回某个类型T的右值引用,令在 decltype 表达式中不必经过构造函数就能使用成员函数,不管该类型是否有默认构造函数或者该类型是否可以创建对象,返回某个类型T的右值引用，这个动作是在编译时完成的，所以很多人把std::declval也称为编译时工具

inline T &&std::declval<T>()

// declval example
#include <utility>      // std::declval
#include <iostream>     // std::cout

struct A {              // abstract class
    virtual int value() = 0;
};

class B : public A {    // class with specific constructor
    int val_;
public:
    B(int i,int j):val_(i*j){}
    int value() {return val_;}
};

int main() {
    decltype(std::declval<A>().value()) a;  // int a
    decltype(std::declval<B>().value()) b;  // int b
    decltype(B(0,0).value()) c;   // same as above (known constructor)
    a = b = B(10,2).value();
    std::cout << a << '\n';
    return 0;
}

函数对象

bind

通用的函数适配器，它接受一个可调用对象，生成一个新的可调用对象来“适应”原对象的参数列表

auto newCallable = bind(callable,arg_list)

newCallable本身是一个可调用对象，arg_list是一个逗号分隔的参数列表，对应给定的callable的参数。即，当我们调用newCallable时，newCallable会调用callable,并传给它arg_list中的参数

1.绑定普通函数

#include<iostream>
#include<functional>
using namespace std;

int plus(int a,int b)
{
   return a+b;
}
int main()
{
  //表示绑定函数plus 参数分别由调用 func1 的第一，二个参数指定
   function<int(int,int)> func1 = std::bind(plus, placeholders::_1, placeholders::_2);
   
  //func2的类型为 function<void(int, int, int)> 与func1类型一样
   auto  func2 = std::bind(plus,1,2);   //表示绑定函数 plus 的第一，二为： 1， 2 
   cout<<func1(1,2)<<endl; //3
   cout<<func2()<<endl; //3
   retunrn 0;
}

占位符_1,_2这是一个来自于std::placeholder名称空间的占位符

2.绑定类的成员函数

#include<iostream>
#include<functional>
using namespace std;

int plus(int a,int b)
{
   return a+b;
}
int main()
{
  //表示绑定函数plus 参数分别由调用 func1 的第一，二个参数指定
   function<int(int,int)> func1 = std::bind(plus, placeholders::_1, placeholders::_2);
   
  //func2的类型为 function<void(int, int, int)> 与func1类型一样
   auto  func2 = std::bind(plus,1,2);   //表示绑定函数 plus 的第一，二为： 1， 2 
   cout<<func1(1,2)<<endl; //3
   cout<<func2()<<endl; //3
   retunrn 0;
}

3.绑定类静态成员函数

#include<iostream>
#include<functional>
using namespace std;
class Plus
{
    public:
        static int plus(int a,int b)
        {
            return a+b;
        }
}
int main()
{
    function<int(int,int)> func1 = std::bind(&Plus::plus, placeholders::_1, placeholders::_2);
    cout<<func1(1,2)<<endl; //3
    retunrn 0;
}

函数对象和普通对象一样，可以赋值给一个对象进行传递下列代码将所有大于4的数打印出来

std::vector<int> nums = {5,3,2,5,6,1,4,7};
std::copy_if(nums.begin() , nums.end() , std::ostream_iterator<int>(std::cout , " , ") , std::bind(std::greater<int>{} , _1 , 4));

copy_if接受一个输入迭代器区间和一个输出迭代器,接受一个单参的谓词函数（返回类型为bool的函数），对输入迭代器的每个区间进行谓词调用，若为真则把这个元素复制到输出迭代器上
greater<int>函数对象接受两个参数，判断这两个参数是否满足大于关系，通过bind将第二个参数绑定为4得到一个只接受一个参数的谓词函数

lambda表达式

[capture-list] (parameters) mutable -> return-type {statement}

lambda表达式参考

---

参考资料:
1.《C++20高级编程》罗能
2.链接
3.链接