const深度用法

在cpp中const是声明一个常量，与其说是一个声明，不如说是一个承诺，在承诺你不回去改变他，在cpp中如同c语言一样，想要修改const声明的值是可以通过指针手段实现的。

例子如下：

1
2
3
4
5
6
7
8
9
10
11
#include <iostream>

int main()
{
    const int a=10;
    int* p=new int;
    //此时就实现了对const的值的修改
    p=(int*)&a;
    p*=20;
}

在平常中const的值不如我们所想的安全，在cpp的类中const也有它独有的使用的地方。包括于引用得一些配合

例子如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
#include <iostream>

class A
{
private:
    int a=10;
public:
    int B() const//此处const加上后这个方法无法修改类内所有的变量，只能调用无法修改
    {
        //此处会报错
        a=2
       	return a;
    }
    const int* const C() const {}//此处为我们返回一个不可修改的地址，值得指针并且只能调用
};

void change(const A& e)//如果有两个B函数另一个未修饰这种情况下会调用const修饰的函数，否则就调用另一个
{
    //此时类中的B函数有const修饰才能正常调用，如果没有const修饰方法他会报错
    cout << e.B()<,std::endl;
}

int main()
{
    const A a;
    a.B();//只有有const修饰过的实体对象才能调用const修饰的方法，否则会报错
}

在以上例子中在外部函数的调用中我们可以发现，const在数据的保护和程序的规范具有很强大的作用，那么当我们在众多数据中都被规定了无法修改，也是对数据的保护。

multable

在multable中可以修饰数据使其能在类中的被const修饰的方法中支持修改数据。

multable有两种用法：

  • 与const联合使用
  • 用在lambda表达式里
  • 或者两者混合使用

首先与const混合使用，在class构建过程中我们入股一直使用const修饰的函数但是其中的某些变量却是我们必修得改变的，或者为了代码的整体维护更加方便，所以我们不得不将一些变量变得可以修改，那么我们就需要multable关键字。使得数据可以在const方法中被修改。

例子如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

#include <iostream>

class A
{
private:
    const char* name="abc";
    multable int a=10;
public:
    cosnt std::string& B() const//此处const加上后这个方法无法修改类内所有的变量，只能调用无法修改
    {
        //此时可以正常修改a
        a++;
       	return name;
    }
};

int main()
{
    //在实体中const修饰的对象也可以轻松调用
    cont A a;
    a.B();
}

以上是最常见的在类中的使用。

其次是与lambda内的使用。

例子如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

int main()
{
    int x=0;
    
    auto f=[=]()mutable//此处multable的作用是让x依旧为0进入
    {
        x++;
        std::cout << x << std::endl;
    };
    //由于是值传递进入f则在f以外的地方引用x值时x依旧为0
    
    auto f=[=]()
    {//不使用multable时并且想继续使用值传递就得用新变量去接收他并且改变
        int y=x;
        y++;
        std::cout << y << std::endl;
    }
    
    f();
    
}

资料参考

youtube上的thecharno的cpp系列