C++ const总结

1、const 修饰普通变量

C/C++中常量用于记录程序中不可更改的数据，在数据类型前加const，就得到了一个不可更改的常量。

• 常量声明：const用于定义常量

const int MAX = 100;//MAX的值在程序运行期间无法被修改，所以必须在定义时初始化。

2、const与指针的组合

如果被const修饰的数据类型是指针，要关心下const的位置，const在*左边，表示指向的数据是常量；const在*右边，表示指针本身是常量。口诀：左定值，右定向

• 常量指针：这种指针不能修改它所指向的内存中的值，但可以改变指针指向其他地址。可以用于函数参数，避免函数修改传入的数据。

int a = 10;
int b = 20;
const int *ptr = &a; // 非常量指针转换为指向常量的指针（转换规则）
int const *ptrr; // 等价上面
// *ptr = 20;  // 错误，不能修改x的值
ptr = &b; // ok
// int* p = ptr; // 错误，指向常量的指针不能隐式转换为非常量指针，需要const_cast
int* pp = const_cast<int*>(ptr); // ok，但使用需谨慎，
// const_cast只能去除指针或引用的const属性，不能去除对象本身的const属性

• 指针常量：指针本身是常量，必须初始化，不能改变指针的指向，但指向的值可变。用于需要固定指向某个对象，但可能需要修改该对象内容的情况。

int a = 10;
int b = 20;
int* const ptr = &a;  // ptr是一个常指针，不能改变ptr指向的地址
*ptr = 50; // ok
// ptr = &b;  // 错误，ptr不能指向其他变量

• 完全常量指针：指向常量的常量指针，指针本身是常量，指针指向的数据也是常量。指针和值都不可变，是最严格的const指针。可以用于配置参数、固定常量等绝对不能修改的情况。

int x = 10;
const int* const ptr = &x;
//ptr = &y; // 错
//*ptr = 20; // 错

• 多层指针与const：指向上述指针的指针

const int** pp1;
int* const* pp2;
int const** pp3;
const int* const* pp4;

3、const与引用

• 常量引用：引用一个常量，不能通过引用修改数据。可以用于函数参数和返回值，避免拷贝，同时保证不修改原数据，且同时支持常量和变量参数。

int a = 10;
const int& ref = a;
// ref = 20; //错
double d = 3.14;
//int& rj = d; // 错误
const int& ri = d; //ok，创建临时int变量3，绑定ri到临时变量（转换规则）

• 绑定字面量：只有常量引用可以绑定字面量

const int& a = 10; // 可以用右值（字面量）或同类型的对象初始化（初始化规则）
const double& b = 5; // 可以用不同但相关的对象初始化，会创建临时对象
const int& c = 5.5; // double隐式转换int会丢失精度

4、const在类中的应用

• 常量成员变量：const成员变量必须在构造函数的初始化列表中初始化，不能在构造函数体内赋值

class Myclass{
private:const int m_v;
public:Myclass(int value):m_v(value){}// ok// 错误//Myclass(int value){//    m_v = value;//}
};

• const成员函数：1、const成员函数不会修改类的非mutable成员变量，这是一种接口契约。2、const成员函数在编译时会将'this'指针转换为‘const T*'类型，因此不能修改成员变量。3、C++允许const和非const版本的成员函数重载，编译器会根据对象是否为const来选择调用哪个版本。4、const对象只能调用const成员函数，不能调用非const成员函数，非const对象可以调用const和非const成员函数。5、const对象的非mutable成员变量被视为const，可以通过const成员函数获取成员变量的值。

// 对于非const成员函数，this的类型是 T*
// 对于const成员函数，this的类型是 const T*
class StringBuffer{
private:int m_count;string m_buffer;mutable int m_accessCount;
public:const char& operator[](size_t index) const{//m_count++; // 错m_accessCount++; // okcout << "const char&" << endl;return m_buffer[index];}char& operator[](size_t index){cout << "char&" << endl;return m_buffer[index];}int getCount() {return m_count;}int constGetCount() const {return m_count;}
};
int main(){StringBuffer buffer;const StringBuffer constBuffer;buffer[0] = 'A'; // char& 调用非const版本//constBuffer[0] = 'B'; // 错误，const版本返回const引用，不能修改char c1 = buffer[0]; // char& 调用非const版本char c2 = constBuffer[0];// const char& 调用const版本int count = constBuffer.constGetCount(); // ok// count = constBuffer.getCount(); // 错count = buffer.constGetCount(); //okcount = buffer.getCount(); //ok
}

类的设计原则：

对于不修改成员变量的函数，声明为const，提供const和非const重载版本，以支持不同使用场景。合理使用const来约束接口，提高代码的安全性。

实现高效的接口：

返回成员变量的const引用，避免拷贝，允许只读访问，同时保护内部数据。

5、const在实际开发中的最佳实践详解

• 优先使用const的原则：尽早const，尽可能const，对于不需要修改的数据，从设计初期就声明为const

const double PI = 3.1415926535;
const std::string COMPANY_NAME = "TechCorp";

• 函数参数的最佳实践：对于内置类型：对于简单类型（int，double等），直接传值即可。对于指针，根据是否需要修改指针指向的数据决定是否使用const；对于自定义类型和容器

void processValue(int value){}
void printValue(const int* valuePtr){}
。。。