五、constexpr说明符
- constexpr说明符声明该变量或函数在编译期进行求值，从而适用于需要编译器常量表达式的地方
- 在变量声明constexpr时，对象或非静态成员函数蕴含const，函数或静态成员变量蕴含inline
- constexpr变量必须立刻被初始化
constexpr int a = 5;
// a = 6; /*error*/
- 如果一个函数或模板的一个声明具有constexpr，那么该函数或模板的所有声明都必须具有constexpr
- const承担“只读”的修饰，而constexpr承担“常量”的修饰，并且在编译期就可以求出该变量或函数的值
int num = 5;
// constexpr auto n1 = num; /*error*/
// constexpr array<int, num> arr1(); /*error*/
constexpr auto n2 = 4;
constexpr array<int, n2> arr2();
在上面的例子中，n1与arr1的定义都需要num的参与，而num在编译期无法获得它的值，故无法正确定义n1和arr1。而n2是constexpr的，故arr2在编译期可以得到n2的值。
六、值类别与decltype
- 每个表达式都属于三种基本值类别中的一种：纯右值、亡值、左值
- 我们可以通过decltype判断一个表达式的值类别，若产生T&&，则为亡值；若产生T&，则为左值；若产生T，则为纯右值
- 除了字符串字面量，其他所有字面量都为纯右值字面量
- const T&方式的左值引用可以接收右值（纯右值和亡值）
int operator""_i(size_t num)
{
return num;
}
int num(int n)
{
return n;
}
void func(const int &num)
{
cout << num << endl;
}
int main()
{
cout << "---begin---" << endl;
int val{0};
// 以下表达式均能传参成功，即均为右值
func(val);
func(num(5));
func(move(val));
func(12_i);
cout << "---end---" << endl;
return 0;
}
- 使用decltype时，带有括号的对象通常被认为是左值表达式
int main()
{
cout << "---begin---" << endl;
int val{0};
using T1 = decltype((val));
using T2 = decltype(val);
T2 b = 5;
T1 a = b;
cout << &a << endl;
cout << &b << endl;
cout << "---end---" << endl;
return 0;
}
输出结果：
---begin---
0x8f29bff8ac
0x8f29bff8ac
---end---
可以看出，当我们把b赋值给a后，两者的地址相同，易见T1是T2的引用类型。
七、lambda表达式
- lambda是一个无名非联合非聚合类类型，被称为闭包类型，类的操作同样适用于它（注：下列代码只适用于C++20之后的版本）
auto lambda = [](int n)
{ cout << n << endl; };
// 继承适用
struct Test : decltype(lambda){};
int main()
{
cout << "---begin---" << endl;
Test test;
test(1);
// 指针适用
auto ptr = make_shared<decltype(lambda)>(lambda);
(*ptr)(2);
cout << "---end---" << endl;
return 0;
}
输出结果：
---begin---
1
2
---end---
- lambda对象常用auto进行自动类型推导
- lambda捕获符只有=和&，其中，=是以复制的形式进行捕获，&是通过引用的形式进行捕获
- 捕获的组合应保证每个变量的捕获不重复，且名字不能与传入形参相同
int main()
{
cout << "---begin---" << endl;
int a = 5, b = 5;
// 值传递捕获指定对象
auto ptr1 = [a]
{
cout << a << endl;
// b++; /*error*/
};
ptr1();
// 引用传递捕获指定对象
auto ptr2 = [&a]
{
cout << ++a << endl;
};
ptr2();
cout << a << endl;
// 值传递捕获所有变量
auto ptr3 = [=]
{
cout << a << ' ' << b << endl;
// a++, b++; /*error*/
};
ptr3();
// 引用传递捕获所有变量
auto ptr4 = [&]
{
cout << ++a << ' ' << ++b << endl;
};
ptr4();
// 值传递捕获所有变量，引用传递捕获部分变量
auto ptr5 = [=, &a]
{
cout << a << ' ' << b << endl;
a++;
// b++; /*error*/
};
ptr5();
// auto ptr6 = [&, &a] {}; /*error:对a重复进行引用捕获*/
// auto ptr7 = [&a](int a){}; /*error:捕获的变量名与传入形参名称相同*/
cout << "---end---" << endl;
return 0;
}
输出结果：
---begin---
5
6
6
6 5
7 6
7 6
---end---
- lambda捕获对象默认为const，若使用mutable进行修饰则可以去除const
int main()
{
cout << "---begin---" << endl;
// auto p = [num = 0]
// {
// num++; /*error*/
// cout << num << endl;
// };
auto p = [num = 0] mutable
{
num++;
cout << num << endl;
};
p();
cout << "---end---" << endl;
return 0;
}
- 对所有局部变量进行捕获时，只会捕获lambda体中被调用的对象
int main()
{
cout << "---begin---" << endl;
int a = 5, b = 5;
auto ptr1 = [=] {};
auto ptr2 = [=]
{
cout << a << endl;
};
cout << "ptr1 memory:" << sizeof ptr1 << "\nptr2 memory:" << sizeof ptr2 << endl;
cout << "---end---" << endl;
return 0;
}
在上面的实例中，ptr1虽然为全域捕获，但lambda体中没有使用外部变量，因此实际上为空类，故只有1字节来进行定址；而ptr2中由于只使用了对象a，故内存大小为4。
- 如果变量是非局部变量，或具有静态或线程局部存储期的时候，或该变量是以常量表达式初始化的引用，lambda表达式在使用该变量前不需要对其进行捕获
int main()
{
cout << "---begin---" << endl;
static int a = 5;
int b = 5;
auto ptr = [=]()
{
a++;
// b++; /*error*/
};
ptr();
cout << a << endl;
cout << "---end---" << endl;
return 0;
}
输出结果：
---begin---
6
---end---
- 如果变量满足下列条件时，lambda在读取它的值前不需要进行捕获：该变量具有const而非volatile的整型或枚举类型并已经用常量表达式初始化，或该变量是constexpr的且没有mutable成员
int main()
{
cout << "---begin---" << endl;
const int a = 5;
auto ptr = []
{
cout << a << endl;
};
ptr();
cout << "size:" << sizeof ptr << endl;
cout << "---end---" << endl;
return 0;
}
输出结果：
---begin---
5
size:1
---end---
可以看到，lambda体可以正常读取a的值，但本身仍为一个空类，可见lambda在读取a前并没有捕获a。
但是，我们并不能直接使用该常量：
const int a = 5;
auto ptr = []
{
// cout << &a << endl; /*error*/
};
- 若外部对象在typeid中被使用，lambda体会捕获该const对象
int main()
{
cout << "---begin---" << endl;
const int a = 5;
auto ptr = [=](auto n)
{
typeid(a + n);
};
cout << "size:" << sizeof ptr << endl;
cout << "---end---" << endl;
return 0;
}
输出结果：
---begin---
size:4
---end---
- 泛型lambda：在lambda的形参中使用auto传参，都会虚设一个与auto参数顺序相对应的模板形参，效果与显式的模板参数类似
int main()
{
cout << "---begin---" << endl;
auto p = [](auto a, auto b)
{
return a + b;
};
cout << p(1, 2) << endl;
cout << p(string("1"), string("2")) << endl;
auto p2 = []<typename T>(T a, T b)
{
return a + b;
};
cout << p2(1, 2) << endl;
cout << p2(string("1"), string("2")) << endl;
cout << "---end---" << endl;
return 0;
}
输出结果：
---begin---
3
12
3
12
---end---
- 每一个lambda都对应了一个不同的类，如果要保持lambda的泛型性进行存储，可以使用C++17中的any，并通过any_cast重新获取对象
int main()
{
cout << "---begin---" << endl;
auto ptr1 = [](auto x)
{ cout << x << endl; };
auto ptr2 = [](auto x)
{ cout << x + 1 << endl; };
vector<any> v = {ptr1, ptr2};
any_cast<decltype(ptr1)>(v[0])(1);
any_cast<decltype(ptr2)>(v[1])(2);
cout << "---end---" << endl;
return 0;
}
输出结果：
---begin---
1
3
---end---
- lambda可以通过转换函数变为函数指针，而泛型lambda转化为函数指针时将无法保持泛型性，但指定类型后仍可以正常转化
int main()
{
cout << "---begin---" << endl;
auto ptr1 = [](auto x)
{ cout << x << endl; };
// void (*p0)(auto x) = ptr1; /*error*/
void (*p)(int x) = ptr1;
(*p)(1);
cout << "---end---" << endl;
return 0;
}
输出结果：
---begin---
1
---end---
- 可以显示指定lambda为constexpr，但如果没有指定constexpr，而能满足constexpr的所有要求，那么它也将是constexpr的
from: https://blog.csdn.net/weixin_62712365/article/details/128742582