c++关键字const

C++中的const是一种常量修饰符。在变量、函数参数和成员函数中使用const可以限制其对数据的修改。

const修饰的数据在定义时必须进行初始化，且不能被修改，因此使用const可以提高代码的安全性和可读性。在C++中，const修饰的成员函数表示该函数保证不会修改类的成员变量，从而保证对象的状态不会被改变。使用const修饰的成员函数可以帮助程序员更好地实现不变类（不修改内部状态的类）和避免不必要的拷贝构造函数的调用。

C++中使用`const`的主要目的是为了告诉编译器某些变量或函数参数、类成员函数、关键字等不会被修改，从而提高代码的可读性、可维护性和安全性。使用`const`的主要注意事项如下：

1. 使用const修饰变量

使用const修饰变量时，需要注意以下几点：

- 定义时必须进行初始化，一旦初始化后，就不能再修改变量的值。

- const定义的常量存放在静态存储区，而不是栈中。

- 通常采用const全大写的命名方式来表示常量，提高可读性。

- 在函数参数列表中，const修饰的参数表明函数不能修改该参数的值。

2. 在类中使用const修饰成员变量

在类中使用const修饰成员变量时，需要注意以下几点：

- const成员变量必须在定义时进行初始化，在构造函数中无法进行初始化。

- const成员变量只能通过成员初始化列表进行初始化。

- 可以在构造函数中通过调用其他函数或者使用默认参数对const成员变量进行初始化。

- const成员变量的值不能在构造函数中被修改。

3. 在类中使用const修饰成员函数

在类中使用const修饰成员函数时，需要注意以下几点：

- const成员函数不能修改类的非静态成员变量。

- 如果类中有一个const成员函数，那么该成员函数是类的常量成员函数，只能被const对象调用，不能被非const对象调用。

- 具有相同名称和参数的另外一个非const成员函数可以修改类的成员变量。

使用const可以使你的代码更加安全、可读性更高，并且有助于防止一些不必要的错误。

为了避免const使用时出现的错误，需要在使用时注意以上细节，如常量的定义和初始化、使用const修饰的指针、const修饰的成员变量和成员函数、以及常量对象的初始化等细节。

// const修饰变量
#include <iostream>int main()
{// 定义并初始化Nconst int N = 10;// 使用const修饰变量N，使其成为一个常量。因为N是常量，所以可以用它定义数组并使用，但是在后面试图修改N的值是会编译错误。int arr[N];for (int i = 0; i < N; i++){arr[i] = i;std::cout << arr[i] << " ";}std::cout << std::endl;//const修饰的N不能修改, 编译报错，error: assignment of read-only variable ‘N’// N = 20;return 0;
}

// const修饰函数参数
#include <iostream>// const修饰函数参数
void arrPrint(const int arr[], const int size)
{for (int i = 0; i < size; i++){std::cout << arr[i]  << " ";}std::cout << std::endl;// const修饰的参数不能修改，编译报错试图对只读的数组元素进行赋值。error: assignment of read-only location ‘* arr’// arr[0] = 10;// size = 6;
}int main()
{int arr[5] = {1, 2, 3, 4, 5};int size = sizeof(arr) / sizeof(arr[0]);arrPrint(arr, size);return 0;
}

// const修饰成员函数
#include <iostream>class Circle {
public:// 常量数据成员通常不直接在声明时初始化赋值，不合适，一般使用成员初始化列表进行赋值Circle(double r) : radius(r) {}// const修饰成员函数double getArea() const {return 3.1415926 * radius * radius;}// const修饰成员函数double getRadius() const {// const修饰的radius不能修改,编译报错，error: assignment of member ‘Circle::radius’ in read-only object// radius = 3;return radius;}// const修饰数据成员const double radius;// 常量数据成员通常不直接在声明时初始化赋值，不合适，一般使用成员初始化列表进行赋值// const double radius = 5.0;
};int main()
{Circle c(5.0);std::cout << "radius : " << c.getRadius() << std::endl;std::cout << "area   : " << c.getArea() << std::endl;// const修饰的radius不能修改,编译报错，error: assignment of read-only member ‘Circle::radius’// c.radius = 3;return 0;
}

// const修饰的类枚举
#include <iostream>class Shape {
public:enum class Type : int {Circle = 0,Square = 1,};Shape(Type t) : type(t) {}void getType() const {switch (type){case Type::Circle:std::cout << "circle" << std::endl;break;case Type::Square :std::cout << "square" << std::endl;default:break;}}// const修饰的类枚举const Type type;
};int main()
{// 创建Shape对象，指定类型为CircleShape c(Shape::Type::Circle);c.getType();Shape s(Shape::Type::Square);s.getType();// const修饰的类枚举不能修改,编译错误，error: assignment of read-only member ‘Shape::type’// c.type = Shape::Type::Square;return 0;
}

// const修饰的静态类变量
#include <iostream>class Counter {
public:Counter() {count++;}Counter(const Counter & c) {count++;}static int getCount() {return count;}
private:// const修饰的静态成员变量static const int LIMIT = 10;// 类静态变量static int count;
};
// 定义静态成员变量
int Counter::count = 0;int main()
{Counter c1, c2, c3;std::cout << "count : " << Counter::getCount() << std::endl;// const修饰的类静态变量不能修改,编译错误,error: assignment of read-only variable ‘Counter::LIMIT’// Counter::LIMIT = 20;return 0;
}

// const修饰的非静态成员函数
#include <iostream>class Circle{
public:Circle(double r) : radius(r) {}double getArea() const {return PI * radius * radius;}double getRadius() const {return radius;}private:// 定义静态常量static const double PI;double radius;
};const double Circle::PI = 3.1415926;int main()
{const Circle c(5.0);std::cout << "area : " << c.getArea() << std::endl;return 0;
}

// const修饰的类转换函数
#include <iostream>class Point {
public:Point(int x, int y) : _x(x), _y(y) {}int getX() const {return _x;}int getY() const {return _y;}// 类中定义了一个使用const修饰的类转换函数：`operator int()`。// 该函数将一个Point对象转换为一个整数，这里我们将`_x`和`_y`简单地相加。// 在`main()`函数中，我们创建了一个`Point`对象，并将其转换为整数输出。// 由于在类转换函数中使用了const修饰，保证了不会修改对象operator int() const {return _x + _y;}
private:int _x;int _y;
};int main()
{Point p(3, 4);std::cout << static_cast<int>(p) << std::endl;return 0;
}

// const在函数前面修饰
// 在C++中，const可以用在函数的前面和后面，
// 用在函数后面是用来修饰成员函数，用在函数前面则是用来修饰函数返回值。它们的区别在于const的含义不同。
// const修饰成员函数和修饰函数返回值都能达到保护数据不被修改的目的，但用法和意义不同。必须根据实际情况选择适当的修饰。
// const在函数前面为常量函数，const在函数后面为常量成员函数
// 常量成员函数用于定义不能修改任何非静态成员数据的函数（或称“只读”函数），而常量函数用于定义不能修改其返回值的函数，使返回值更安全。
#include <iostream>class Rectangle {
public:Rectangle(int w, int h) : width(w), height(h) {}// const在函数后面用来修饰成员函数，表示该成员函数是一个常量成员函数，不能修改类的非静态成员变量。// 常量成员函数也不能被非const对象调用。int getArea() const;// 返回值类型为`const int &`，表示返回的是一个常量引用，不能修改它所引用的变量。// const在函数前面用来修饰函数返回值，表示该函数返回的值是一个常量。// 通常用于返回一个常量指针或常量引用，以避免返回值被修改。const int &max(const int &a, const int &b) {return (a > b) ? a : b;}// C++中`const`关键字可以用在函数返回值的前面或后面，// 用在函数返回类型前面就表示返回值是一个`const`常量，用在类型后面表示该函数是一个常量函数。// 所以`int const func()`和`const int func()`是等同的，它们都表示一个返回值是`const int`类型的函数。// 这种用法通常用于返回一个常量对象，或常量指针、常量引用等等，以避免返回值被修改。const int get100() {return 100;}int const get200() {// const修饰的是返回值，函数可以修改成员变量的值this->width = 200;return 200;}int getWidth() const {// 函数被声明为常量成员函数，因此不能修改成员变量的值// 不能修改成员变量，编译错误，error: assignment of member ‘Rectangle::m_val’ in read-only object// this->m_val = 100;return this->width;}void setValue(int value) {this->width = value;}// 当`const`关键字放在成员函数的前面时，它修饰的是函数的返回值，表示这个函数的返回值是一个常量。// 这种函数返回类型前加`const`关键字的写法，通常用于返回一个常量整数、常量指针或常量引用等，以避免返回值被修改。// 常量函数的常量限制作用于函数的返回值上，而非函数的实现代码中。// 函数的返回值类型被定义成`const int`，表明函数返回了一个常量整数const int getHeight() const {return this->height;}
private:int width, height;
};// 常成员函数，在函数尾部加const，常成员函数在类外实现的时候const不能丢掉，因为const时函数的一部分
// 在常成员函数中不能修改任何数据成员的值，常成员函数内不能对类的任何数据成员进行修改，
// 即当前类中凡是能用this指出来的成员都改不了，但是可以访问，就是只能看不能改，但是静态成员变量可以修改。
int Rectangle::getArea() const {// error: assignment of member ‘Rectangle::width’ in read-only object// width = 10;return width * height;
}int main()
{const Rectangle r(5, 10);std::cout << "area : " << r.getArea() << std::endl;// const放函数前面Rectangle r1(5, 10);// 常量引用`maxVal`来引用`max()`函数返回的值，因此不能修改`maxVal`的值。// 报错，error: passing ‘const Rectangle’ as ‘this’ argument discards qualifiers [-fpermissive]// const int & max = r.max(5, 10);const int & maxVal = r1.max(5, 10);// error: assignment of read-only reference ‘maxVal’// maxVal = 20;std::cout << "max val : " << maxVal << std::endl;// 报错，error: passing ‘const Rectangle’ as ‘this’ argument discards qualifiers [-fpermissive]// r.get100();const int a1 = r1.get100();// 报错，error: expected initializer before ‘a2’// 这个错误是因为`r1`对象是一个`const`对象，在`const`对象上调用非常量成员函数是不允许的，// 因为非常量成员函数可以修改对象的状态，会破坏对象的不可变性。// int cosnt a2 = r1.get100();std::cout << "get100  : " << r1.get100() << std::endl;std::cout << "get200  : " << r1.get200() << std::endl;// 创建了一个常量对象`obj`，也不能修改其中的成员变量。const Rectangle obj0(10, 20);std::cout << obj0.getWidth() << std::endl;// 不能修改常量对象的成员变量,编译错误，error: passing ‘const Rectangle’ as ‘this’ argument discards qualifiers [-fpermissive]// obj0.setValue(10);Rectangle obj1(10, 30);std::cout << obj1.getHeight() << std::endl;// 通过调用常量函数`obj.getValue()`来获取常量整数值，并将结果保存到一个常量值`value`中，这样可以防止常量值被修改。int a3 = obj1.getHeight();const int a4 = obj1.getHeight();std::cout << "a3 = " << a3 << ", a4 = " << a4 << std::endl;return 0;
}

// 常量成员函数和常量函数的区别
// - 常量成员函数在函数声明的结尾处加上`const`修饰符，用于定义不会修改任何非静态成员数据的函数。
// 也就是说，常量成员函数将其所操作的对象指定为常量，从而导致它不能在函数调用中修改类中的任何非静态成员变量。
// - 常量函数在函数返回类型前加上`const`修饰符，用于定义不能修改其返回值的函数。
// 也就是说，常量函数指定了函数返回的值是一个常量，无法被修改。
#include <iostream>class Rectangle {
public:Rectangle(int width, int height) : m_width(width), m_height(height) {}// 常量成员函数int getArea() const;int getValue() const;void setValue(int value);// 常量函数int const getWidth() const {return m_width;}const int getHeight() const {return m_height;}const int get100() {return m_height;}const int get200() {return m_height;}private:int m_width;int m_height;int m_value;
};// 常成员函数，在函数尾部加const，常成员函数在类外实现的时候const不能丢掉，因为const时函数的一部分
// 在常成员函数中不能修改任何数据成员的值，常成员函数内不能对类的任何数据成员进行修改，
// 即当前类中凡是能用this指出来的成员都改不了，但是可以访问，就是只能看不能改，但是静态成员变量可以修改。
int Rectangle::getArea() const {return m_width * m_height;
}int Rectangle::getValue() const {return m_value;
}void Rectangle::setValue(int value) {m_value = value;
}int main()
{// c++非常量对象可以调用类的常量成员函数,常量对象不能调用非常量成员函数const Rectangle r(3, 4);// 调用常量成员函数std::cout << "Area: " << r.getArea() << std::endl;// 调用常量函数const int value = r.getValue();std::cout << "Value: " << value << std::endl;// 不能在常量对象上调用非常量成员函数// r.setValue(5);  // 编译错误const Rectangle r1(10, 20);std::cout << "width : " << r1.getWidth() << ", height : " << r1.getHeight() << std::endl;// 常量对象不能调用非常量成员函数，报错，error: no matching function for call to ‘Rectangle::setValue() const’// r1.setValue();// r1.get100();// r1.get200();return 0;
}

// const常量对象
// C++中，如果对象被声明为常量对象，那么就意味着该对象的值不能被修改。
// 常量对象是指对象在创建后，其值被确定不变，不允许被修改。// 非常量对象可以调用常量成员函数，因为常量成员函数不会修改对象的状态，所以没有任何风险和限制。
// 而常量对象不能调用非常量成员函数，因为非常量成员函数有可能会修改对象的状态，这会与常量对象的定义相矛盾，所以编译器会拒绝这样的调用并报错。
#include <iostream>class Rectangle {
public:Rectangle(int width, int height) : m_width(width), m_height(height) {}int getArea() const;void setValue(int value);
private:int m_width;int m_height;
};// 常成员函数，在函数尾部加const，常成员函数在类外实现的时候const不能丢掉，因为const时函数的一部分
// 在常成员函数中不能修改任何数据成员的值，常成员函数内不能对类的任何数据成员进行修改，
// 即当前类中凡是能用this指出来的成员都改不了，但是可以访问，就是只能看不能改，但是静态成员变量可以修改。
int Rectangle::getArea() const {return m_width * m_height;
}void Rectangle::setValue(int value) {m_width = value;m_height = value;
}int main() {Rectangle r1(2, 3);  // 非常量对象// 在C++中，`const`关键字可以用在类型的右侧或左侧。// 当`const`关键字出现在类型名称的左侧时，它会作用于变量名之前的类型部分；// 当`const`关键字出现在类型名称的右侧时，它会作用于变量名之后的类型部分。// int const b = 20;  // 常量整数，等价于const int b = 20;// Rectangle const r3(5, 6);  // 常量对象，值不可修改，等价于const Rectangle r3(5, 6);const Rectangle r2(3, 4);  // 常量对象Rectangle const r3(5, 6);  // 常量对象r1.getArea();  // 非常量对象调用常量成员函数r2.getArea();  // 常量对象调用常量成员函数// r2.setValue(5);  // 编译错误，常量对象不能调用非常量成员函数r1.setValue(5);  // 非常量对象可以调用非常量成员函数return 0;
}