C/C++中const关键字用法总结

C++基础专栏：http://t.csdnimg.cn/4FdOH

1.引言

2.修饰变量

2.1.修饰普通变量

2.2.修饰指针

2.3.修饰对象

3.修饰函数形参

4.修饰函数返回值

5.修饰类成员函数

6.const与constexpr区别

7.总结

1.引言

在面试的过程，面试官经常都会问到const关键字有哪些用法？在C/C++中各有些什么作用？今天就在这里我们好好的总结一下const的全方位用法。

2.修饰变量

2.1.修饰普通变量

在普通变量前面加上const，表示该变量是常量，不能随便更改值的变量。const 类型的变量必须在定义时进行初始化，之后不能对const型的变量赋值。示例如下：

在变量定义前加关键字const，修饰该变量为常量，不可修改
const int year= 12; 
const char p = 'f';

注意：在函数内部定义的const局部变量和全局定义的const变量还是有很大的不同的？函数内部定义的局部const变量存放在栈区中，会分配内存（也就是说可以通过地址间接修改变量的值), 如：

void func()
{
    const int a = 10;
    //a += 1; //编译错误，常量是不能修改的
    int* p = &a;
    *p = 20; //a = 20, 通过指针间接是可以修改a的值的
}

全局const变量存放在只读数据段（不能通过地址修改，会发生写入错误），默认为外部联编，可以给其他源文件使用（需要用extern关键字修饰）。如：

const int  a = 10;
//const int b = a; //不能用全局变量全局初始化const变量，编译不通过，表达式必须含有常量值

void func()
{
    int* p = &a;
    *p = 20;//编译通过，但运行时会发生写入错误
}

如果是在C++类中定义的const成员变量，那么必须在初始化列表中赋值，如：

//类定义
class CBase
{
public:
    explicit CBase();

private:
    const int m_a;
};

//类构造函数
CBase::CBase()
    : m_a(100)
{
    //m_a = 200; //在这里赋初值会出现编译错误，因为这里不是m_a不是赋初值的地方
}

2.2.修饰指针

const修饰指针有几种情况：

① const修饰指针 --- 常量指针

语法：const 数据类型 * 变量名；如：const int* p;

② const修饰常量 --- 指针常量

语法：数据类型 * const 变量名；如：int* cont p;

③ const即修饰指针，又修饰常量

语法：const 数据类型 * const 变量名；如：const int* const p;

综合示例如下：

int func() {
	int a = 10;
	int b = 10;

	//1)常量指针：const修饰的是指针，指针指向可以改，指针指向的值不可以更改
	const int * p1 = &a; 
	p1 = &b; //正确
	//*p1 = 100;  报错

	//2)指针常量：const修饰的是常量，指针指向不可以改，指针指向的值可以更改
	int * const p2 = &a;
	//p2 = &b; //错误
	*p2 = 100; //正确

    //3)const既修饰指针又修饰常量
	const int * const p3 = &a;
	//p3 = &b; //错误
	//*p3 = 100; //错误

	return 0;
}

技巧：看const右侧紧跟着的是指针还是常量, 是指针就是常量指针，是常量就是指针常量

2.3.修饰对象

const修饰类对象表示该对象为常量对象，其中的任何成员都不能被修改。对于对象指针和对象引用也是一样。
const修饰的对象，该对象的任何非const成员函数都不能被调用，因为任何非const成员函数会有修改成员变量的企图。

示例如下：

class CMyTest
{
public:
    CMyTest() : m_a2(10),m_b2(20) {}
    void func1(){
        m_b1 = 10; //OK
        //m_b2 = 30; //ERROR: m_b2是常量不能修改
        m_a3 = 40; //OK
    }

    void func2() const{
        //m_b1 = 10; //ERROR: const成员函数不能修改非const成员变量
        //m_b2 = 60; //ERROR: m_b2是常量不能修改
        m_a3 = 80; //OK
    }

public:
    int m_a1;
    const int m_a2;
    mutable int m_a3;

private:
    int m_b1;
    const int m_b2;
    mutable int m_b3;  
};

int main()
{
    const CMyTest test;
    
    //test.m_a1 = 1000; //ERROR : 编译错误，常对象不能非const成员变量
    //test.m_a2 =  2000; ; //ERROR : 编译错误，常对象不能修改const成员变量
    test.m_a3 =  3000; ; //OK，常对象能修改mutable成员变量

    return 0;
}

3.修饰函数形参

在函数参数前面加上const，表示在函数内部不能修改该参数的值，用const来防止误操作。如：

struct student {int num};

void func(const student &stu){
    stu.num = 56;  //这句就错误了，不能修改stu中的内容
}

student abc;
abc.num = 100;
func(abc);
std::cout << abc.num << std::endl; //100

4.修饰函数返回值

返回基本数据类型的常量值：当函数返回基本数据类型（如 int、float 等）时，使用 const 修饰返回值通常没有太大意义。因为基本类型的返回值通常是按值返回，即返回的是一个副本。修改这个副本并不会影响原始值。如：

const int getValue() {
    return 11000;
}

返回对象或复合类型的常量引用：当函数返回对象或复合类型（如自定义类、结构体等）时，使用 const 修饰返回值可以防止返回的对象或复合类型被修改。这是一种常见且有用的做法，特别是在返回类的成员变量时。如：

const MyClass& getClass() const {
    return myObject;
}

getClass 函数返回 MyClass 类型对象的常量引用。这意味着调用者可以读取返回的对象，但不能修改它。这种做法既保证了数据的安全性，又避免了不必要的复制。

class MyClass {
private:
    int value;

public:
    const int& getValue() const {
        return value;
    }
};
// 在使用时
MyClass obj;
int a = obj.getValue(); // a 不是 const
// obj.getValue() = 10; // 错误，不能通过 const 引用修改值

getValue 方法返回 value 成员的常量引用，这样就保护了内部数据不被外部修改。

5.修饰类成员函数

成员函数后加const后我们称为这个函数为常函数；const成员函数，能够访问所有成员变量，但是在函数体内不能直接修改变量的值（包括普通成员变量），如果需要在函数体内修改普通成员变量的值，需要在变量定义的前面添加mutable关键字，或者通过地址间接修改。

注意：const成员函数只能被该类的const对象访问。

示例如下：

class CMyTest
{
public:
    void func() const{
        //a = 40; //没有加mutable修饰的变量在const成员函数内不能直接修改
        //间接修改a的值
        int* p = const_cast<int*>(a);    
        *p = 50;
        //用mutable修饰的变量直接通过
        c = 60;
    }

private:
    int a = 10;
    const int b = 20;
    mutable int c = 30;
};

6.const与constexpr区别

constexpr 和 const 都是 C++ 中用于声明常量的关键字，但它们在使用上有一些重要的区别：

const

const 用于声明一个常量，表示变量的值不可修改。
const 可以用于各种类型的变量，包括基本数据类型、对象、指针等。
const 变量的值可以在运行时确定。这意味着它可以被初始化为在编译时未知的值，比如函数返回值或者用户输入。
const 更加通用，适用于任何需要防止修改的场景。

constexpr

constexpr 用于声明表达式为编译时常量，意味着它的值必须在编译时就已知。
constexpr 常量可以用在需要编译时常量表达式的上下文中，如数组大小、整数模板参数等。
constexpr 函数能在编译时对其输入进行计算，只要所有输入也都是编译时已知的常量。
使用 constexpr 声明的变量或函数表示你希望编译器验证它们能够在编译时求值。
constexpr 要求其初始化表达式必须是一个编译时常量表达式。

主要区别

编译时 vs. 运行时：constexpr 确保变量或函数的值能在编译时被确定，而 const 变量的值可以在运行时确定。
使用场景：constexpr 适用于需要在编译时进行计算的场景，比如作为模板参数或数组大小。const 更适用于程序运行中不需要修改的值。

示例如下：

//使用const 
const int max_size = getSizeFromUser(); // 运行时获取大小
const double pi = 3.14159;

//使用constexpr
constexpr int max_array_size = 100; // 编译时已知的数组大小
constexpr double computeArea(double radius) {
    return 3.14159 * radius * radius; // 编译时计算面积的函数
}

7.总结

使用const还有很多好处：

1) 类型安全：const常量有数据类型，而宏常量没有数据类型。编译器可以对前者进行类型安全检查，而对后者只进行字符替换，没有类型安全检查，并且在字符替换时可能会产生意料不到的错误。

2) 可以节省空间，避免不必要的内存分配: const定义常量从汇编的角度来看，只是给出了对应的内存地址，而不是象宏一样给出的是立即数，所以，const定义的常量在程序运行过程中只有一份拷贝，而宏定义的常量在内存中有若干个拷贝。

3) 优化性能：对于基本数据类型，const对象可能会被编译器优化，因为它们的值在程序的执行过程中不会改变。const方法和constexpr函数可以在编译时进行计算和优化，这可以提高程序的运行效率。

4) 增加代码的可维护性：通过将某些变量或方法标记为const，你可以更容易地重构和修改代码，同时保持对原始设计意图的忠实。const正确性（const-correctness）是一种良好的编程实践，它有助于减少错误并增加代码的稳定性。

5) 为函数重载提供了一个参考：const修饰的函数可以看作是对同名函数的重载。如：

clas MyTest
{
public:
    void func(int a, int b);
    void func(int a, int b) const;
};

6) 接口设计：在设计类和函数接口时，使用const可以明确哪些操作是安全的，哪些操作可能会修改对象状态。这对于库的设计尤其重要，因为它允许库的使用者更加清晰地理解如何与库进行交互。

7) 保护数据：在多线程环境中，将数据声明为const可以确保它不会被多个线程同时修改，从而避免数据竞争和未定义行为。当然，在多线程环境中仅仅使用const是不够的，但它是一个有用的工具。

8) 兼容性和转换：const对象可以安全地转换为非const对象（在不需要修改对象的情况下），这提供了更大的灵活性。

参考：

const (C++) | Microsoft Learn