C++进阶学习（三）constexpr关键字、值类别与decltype关键字、lambda表达式

五、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的

C++进阶学习（三）constexpr关键字、值类别与decltype关键字、lambda表达式

五、constexpr说明符

六、值类别与decltype

七、lambda表达式

继续阅读

C语言第四章自述2第四章选择结构程序设计

面试题:vector和map的区别，异同。空间分布，100万数据存哪个比较合适。一、迭代器区别二、vector三、Map、Set四、vector_map 为什么比map效率高五、如何选择六、容器选择原则七、效率对比

C++ 多线程用条件变量确定线程的执行顺序而不是使用 sleep(1)

POJ 1284 Primitive Roots (欧拉函数&原根定理)

CQ V1.0分词bates(基于双数组tire树)—应该是目前最快的中文分词算法

成员函数初始化列表

2021-08-13c++——类之操作符重载

swmm与lisflood-fp源码如何一起编译 CMake命令

Windows下VS开发环境环境安装工程项目设置关于Debug和Release的提示

一文看懂字符串的加减乘除

C++ 第十五周报告1--《冒泡法排序》

C++实现简单顺序表

C经典书籍笔记——C陷阱与缺陷②(语法陷阱之优先级)一、错误案列二、优先级规律

线性表之顺序表的实现

C++判断素数、求最大公约数代码判断一个数是否为素数求两个数的最大公约数

SequoiaDB巨杉数据库C++驱动概述