一、const方法

二、指针常量 和常量指针

三、multable

1. 修饰变量，使可以在常量方法中被修改

2. 修饰lambada表达式，

#include<iostream>

// 标记， lambada表达式中，访问外部变量数据
void mutableLambadaFunction() {
    int x = 8;
    // [=] 值传递；[&] 引用传递
    auto lambadaFunction = [=]() mutable {
        //auto lambadaFunction = [&]() mutable {
        x++;
        //9
        std::cout << "in: x = " << x << std::endl;
        };

    lambadaFunction();
    //值传递是8，引用传递是9
    std::cout << "out: x = " << x << std::endl;
}

//字符串字面量
int main() {
    mutableLambadaFunction();

    std::cin.get();
}

四、代码示例

#include<iostream>

class Entity {
private:
    int x, y;
    //可修改的变量，保障变量在const方法中可修改
    mutable int var;
public:
    //我承诺x是不可变的
    //如果调用此方法的变量被设置成了常量，const是必须的
    int getX() const {
        //x = 20; //不被允许
        var = 30;
        return x;
    }

    //所以，有时候要定义2个getX方法，一个用来给常量调用，一个用来给变量调用
    int getX() {
        //x = 20; //不被允许
        return x;
    }

    void setX(int x) {
        this->x = x;
    }
};

//可以改变指针指向，但不能改变指针指向的数据
void printEntity(const Entity* e) {
    //1.可以重新分配指针，但是不能改变内容
    e = NULL;
    e = new Entity();

    //2. 参数是常量类型，不可以做任何修改
    //e->setX(20);
    
    //3. 虽然我没有直接修改Entity，但是如果我调用了一个可以修改Entity的方法，是不被允许的。
    //   如果所调用的方法必须保证getX()方法没有定义成const的，是不被允许的
    std::cout << e->getX() << std::endl;
}

//引用并没有指针本身 和 指针指向内容的区别，引用就是对象本身，所以你不能修改这个对象。
void printEntity2(const Entity& e) {
    //不能重新分配
    //e = new Entity();
    std::cout << e.getX() << std::endl;
}

void testPrintEntity() {
    Entity e;
    printEntity(&e);
}

void testConstPointer() {
    const int MAX_AGE = 90;
    //常量指针：常量数据的指针，不可以改指针指向数据内容，
    const int* a = new int;
    //int const* a = new int;  //等价于 const int* （const 在 * 的左边）

    *a = 10;
    a = &MAX_AGE;

    //指针常量：指针是常量，不可以改指针指向数据内容，
    int* const b = new int;
    *b = 20;
    b = &MAX_AGE;

    std::cout << *a << std::endl;
}

int main() {
    testConstPointer();
    std::cin.get();
}