1.新增不需要赋值即可初始化
//C++98
int a = 1;
int* p1 = new int[3];
Date d1(2022, 9, 26);
//C++11
Date d2{ 2022,9,27 };
int* p2 = new int[3]{ 1,2,3 };
int b{ 1 };
Date* p4 = new Date[3]{ {2022,9,28},{2022,9,29},{2022,9,30} };
2.右值引用
1.左值引用 只能引用左值，不能引用右值
const 左值 可以引用左值，也可以引用右值
//左值引用
int c = 1;
int& rc = c;
//int& rv = 20; × 左值不允许引用右值
const int& rv = 20;//因为20是常量 关乎到权限的问题 所以可以引用
const int& rb = c;
2.右值引用
//右值引用
int&& r1 = 10;
//int&& r2 = c; 右值引用不允许引用左值
int&& rb = move(c);//move能把左值该为右值 但是他的数据会被转移 所以谨慎使用
string s1("111");
string s2 = (move(s1));
//s1 的111被move转移到了s2 所以现在s1为空
两者的差别在与 坐值引用可以取地址 右值引用不可以取地址
3.可变模版参数
// Args是一个模板参数包，args是一个函数形参参数包
// 声明一个参数包Args...args，这个参数包中可以包含0到任意个模板参数。
template <class ...Args>
void ShowList(Args... args)
{}
4.lambda表达式
//lambda表达式
int d = 1;
int e = 2;
auto add1 = [](int a, int b)->int {return a + b; };
add1(1, 2);
auto add2=[](int a, int b){return a + b; };
add2(1, 2);
auto add3 = [=] {return d + e; };//全部传值
//auto add3=[=]{return d=e;};
//传值 不允许被修改
add3();
auto add4 = [&] {return d = e + 2; };//全部传引用
add4();
auto add5 = [&, d] {return e = d + 2; };//d用传值 其他全部传引用
add5();
auto add6 = [=, &d] {return d = e + 2; };//d用传引用 其他全部传值
add6();
5.包装器
//包装器
function<int(int, int)> fun1 = f;
fun1(1, 2);
function<int(int, int)> fun2 = person::a;//调用静态成员函数
fun2(1, 2);
function<int(person,int, int)> fun3 = &person::b;//调用普通成员函数
fun3(person(), 1, 2);
class Solution {
public:
int evalRPN(vector<string>& tokens) {
stack<long long> s;
map<string,function<long long(long long,long long)>> func=
{
{"+",[](long long a,long long b){return a+b;}},
{"-",[](long long a,long long b){return a-b;}},
{"*",[](long long a,long long b){return a*b;}},
{"/",[](long long a,long long b){return a/b;}}
};
for(auto& e:tokens)
{
if(func.count(e))//判断e是否存在map中 存在就是操作符
{
long long right=s.top();
s.pop();
long long left=s.top();
s.pop();
s.push(func[e](left,right));
}
else//不存在就是操作数
{
s.push(stoll(e));
}
}
return s.top();
}
};
6.bind
//bind
function<int(int, int)> fun1 = bind(f,placeholders::_2,placeholders::_1);
fun1(1, 2);//bind调整顺序
function<int(int, int)> fun2 = person::a;//调用静态成员函数
fun2(1, 2);
function<int(person, int, int)> fun3 = &person::b;//调用普通成员函数 //不用bind时 function参数要加person
fun3(person(), 1, 2);
function<int(int, int)> fun4 = std::bind(&person::b,person(),placeholders::_1, placeholders::_2); //调用普通成员函数 用bind时 function参数不用加person
fun4(1, 2);//bind调整参数个数
7.整体代码
#include<iostream>
#include<functional>
using namespace std;
class Date
{
public:
Date(int y, int m, int d)
{
year = y;
month = m;
day = d;
}
private:
int year;
int month;
int day;
};
template<class T>
void a(T&& t)//传左值变左值 传右值变左值
{
func(t);//这时候的t已经是左值了
//因为被模版折叠
//但可以move改变为右值
func(move(t));//但t的资源会被转移
func(forward<T>(t));//完美转发 转为右值 并且t的资源不会被转移
}
class person
{
//person() = default;
//强制生存默认构造或者其他的拷贝赋值等...
//person() = delete;
//不让调用并且不让生存默认构造或者其他的拷贝赋值等...
public:
static int a(int a, int b)
{
return a + b;
}
int b(int a, int b)
{
return a + b;
}
};
// Args是一个模板参数包，args是一个函数形参参数包
// 声明一个参数包Args...args，这个参数包中可以包含0到任意个模板参数。
template <class ...Args>
void ShowList(Args... args)
{}
int f(int a,int b)
{
return a + b;
}
int main()
{
//C++98
int a = 1;
int* p1 = new int[3];
Date d1(2022, 9, 26);
//C++11
Date d2{ 2022,9,27 };
int* p2 = new int[3]{ 1,2,3 };
int b{ 1 };
Date* p4 = new Date[3]{ {2022,9,28},{2022,9,29},{2022,9,30} };
//左值引用
int c = 1;
int& rc = c;
//int& rv = 20; × 左值不允许引用右值
const int& rv = 20;//因为20是常量 关乎到权限的问题 所以可以引用
const int& rb = c;
//右值引用
int&& r1 = 10;
//int&& r2 = c; 右值引用不允许引用左值
int&& rb = move(c);//move能把左值该为右值 但是他的数据会被转移 所以谨慎使用
string s1("111");
string s2 = (move(s1));
//s1 的111被move转移到了s2 所以现在s1为空
//lambda表达式
int d = 1;
int e = 2;
auto add1 = [](int a, int b)->int {return a + b; };
add1(1, 2);
auto add2=[](int a, int b){return a + b; };
add2(1, 2);
auto add3 = [=] {return d + e; };//全部传值
//auto add3=[=]{return d=e;};
//传值 不允许被修改
add3();
auto add4 = [&] {return d = e + 2; };//全部传引用
add4();
auto add5 = [&, d] {return e = d + 2; };//d用传值 其他全部传引用
add5();
auto add6 = [=, &d] {return d = e + 2; };//d用传引用 其他全部传值
add6();
//包装器
function<int(int, int)> fun1 = f;
fun1(1, 2);
function<int(int, int)> fun2 = person::a;//调用静态成员函数
fun2(1, 2);
function<int(person,int, int)> fun3 = &person::b;//调用普通成员函数
fun3(person(), 1, 2);
//bind
function<int(int, int)> fun1 = bind(f,placeholders::_2,placeholders::_1);
fun1(1, 2);//bind调整顺序
function<int(int, int)> fun2 = person::a;//调用静态成员函数
fun2(1, 2);
function<int(person, int, int)> fun3 = &person::b;//调用普通成员函数 //不用bind时 function参数要加person
fun3(person(), 1, 2);
function<int(int, int)> fun4 = std::bind(&person::b,person(),placeholders::_1, placeholders::_2); //调用普通成员函数 用bind时 function参数不用加person
fun4(1, 2);//bind调整参数个数
return 0;
}
标签：11,function,return,int,long,person,C++,引用
From： https://www.cnblogs.com/LonelyMoNan/p/16732360.html