C++中const的使用

概述

在开发中const常用来修饰一些变量，像：函数的形参，函数返回值，指针.本文就const使用进行了总结。

const使用

修饰变量

这里的变量包含三种，局部变量，全局变量，类成员变量。
不管为哪种变量，其被const修饰之后就变为只读。一旦赋初值之后，后面的操作不可以修改其值。
下面是示例：

#include <iostream>

const int g_num = 10;//g_num不可修改其值

int main()
{
	cout<<g_num<<endl;
    return 0;
}

当const修饰局部变量。也不可修改其值。

void fun() {
    const string str = "hello!";
    cout << "str=" <<str<< endl;
}

const修改类的成员变量。不可在构造对象之后修改该成员变量的值。

class Base {
private:
    const int m_count = 2;
public:
    void getCount() const{
        cout << m_count << endl;
    }
};

可以直接在声明const成员变量的时候赋初值。这之后就不能通过其它方式来修改变量的值。
也可以在构造函数的初始化列表中给const成员变量赋初值。这之后不能通过其它方式修改其值。

class Base {
private:
    const int m_count;
public:
    Base() :m_count(3) {
        cout << m_count << endl;
    }
    void getCount() const{
        cout << m_count << endl;
    }
};

这个例子还有一个神奇的改写。如下面这样：

class Base {
private:
    const int m_count = 2;
public:
    Base() :m_count(3) {
        cout << m_count << endl;
    }
    void getCount() const{
        cout << m_count << endl;
    }
};

在声明的时候赋初值，又在构造函数初始化列表中赋值，但它也是正确的。
const成员变量可以在声明时直接初始化，也可以在构造函数的初始化列表中初始化，但不能在构造函数体内部初始化。因为一旦对象构造完成，const成员变量的值就不能再被修改。

修饰函数形参

const修饰函数的形参，则这个形参不能在函数内部修改其值，变成了只读。

#include <iostream>

using namespace std;

int add(const int &a,const int &b) {
    return a + b;
}

int main()
{
    int n1 = 2; 
    int n2 = 4;
    cout<<"3+5="<<add(3, 5)<<endl;
    cout << "n1+n2=" << add(n1, n2) << endl;
    return 0;
}

修饰函数返回值

返回值本身不可被修改，但是可以通过将返回值赋给其它变量，来修改其它变量。实质上const 修饰函数的返回值在 C++ 中实际上并没有太大用处。通常，const 用于修饰函数的返回值是为了表明这个返回值是一个常量引用或常量值，不能被修改。然而，在实际编程中，这通常不是必需的，因为函数返回的值本身就是临时的，并且不能被直接修改。

#include <iostream>

using namespace std;


const int add(const int &a, const int &b) {
    return a+b;
}

int main()
{
    int ret = add(3,5);
    ret = 2;
    return 0;
}

修饰类成员函数

const关键字来修饰类成员函数是为了表明这个成员函数不会修改类对象的任何数据成员，即它是“只读”的。这样的成员函数通常用于那些只需要访问对象状态而不需要修改它的操作。

当你声明一个成员函数为const时，意味着这个成员函数不能调用任何非const成员函数，也不能修改任何成员变量（除非这些成员变量被声明为mutable）。这样可以保证const对象也可以安全地调用这个函数，因为它不会修改对象的状态。

#include <iostream>

using namespace std;

class Base {
private:
    int m_n;
public:
    int getValue(int a)const {//正确的，成员函数不会修改类对象的任何数据成员
        a = 1;
        return m_n + a;
    }
    void setValue(int n) {
        m_n = n;
    }

};

int main()
{
    Base b;
    b.setValue(5);
    cout <<"getValue="<< b.getValue(3) << endl;;
    return 0;
}

修饰类对象

const可以修饰类对象，代表这个类对象的所有数据成员不可以被改变，是只读的。
下面是示例：

#include <iostream>

using namespace std;

class Base {
private:
    int m_n;
public:
	Base() {}
    Base(int a) :m_n(a){}
    int getValue()const {
        return m_n;
    }
    void setValue(int n) {
        m_n = n;
    }
};

int main()  
{
    const Base b(6);
    cout <<"getValue="<< b.getValue() << endl;
    
    Base b1;
    b1.setValue(7);
    cout <<"getValue="<< b1.getValue() << endl;;
    return 0;
}

这个例子中，Base的对象b是一个常对象，该对象的成员变量不可以被改变，只能调用getValue得到，不可以调用setValue()函数来设置其成员变量的值。

修饰指针

const修饰指针，有三种不同的使用场景。

不可改变其指针的值

int a = 4;
const int * p = &a;
int b = 5;
p = &b;

指针p的值不能改变。所以当出现p=3;会导致编译报错。可以改变p的指向。

不可改变指针的指向

  int a = 3;
  int* const p = &a;
  *p = 2;

p的指向不能改变，但是可以修改*p的值。

指针的指向和值都不可改变

 int a = 3;
 const int* const p = &a;

p的指向和*p的值都不可以改变。