当前位置：首页 > news >正文

C++中const的不同使用方法和意义

news 来源：原创 2025/5/9 22:11:16

在 C++ 里，const 是一个用途广泛的关键字，它能用来修饰变量、函数参数、函数返回值以及成员函数等，在不同场景下含义不同，下面为你详细介绍：

1. 修饰常量

修饰普通变量

当 const 用于修饰普通变量时，该变量会成为常量，一旦初始化就不能再被修改。

#include <iostream>int main() {const int num = 10;// num = 20; // 错误，不能修改常量的值std::cout << "num: " << num << std::endl;return 0;
}

修饰指针

const 修饰指针时情况较为复杂，主要有以下几种：

常量指针（指向常量的指针）

指针指向的对象是常量，不能通过该指针修改所指向对象的值，但指针本身可以指向其他对象。

#include <iostream>int main() {int a = 10;int b = 20;const int* ptr = &a;// *ptr = 20; // 错误，不能通过指针修改所指向对象的值ptr = &b; // 指针本身可以指向其他对象std::cout << "*ptr: " << *ptr << std::endl;return 0;
}

指针常量

指针本身是常量，初始化后不能再指向其他对象，但可以通过该指针修改所指向对象的值。

#include <iostream>int main() {int a = 10;int b = 20;int* const ptr = &a;*ptr = 20; // 可以通过指针修改所指向对象的值// ptr = &b; // 错误，指针本身不能再指向其他对象std::cout << "*ptr: " << *ptr << std::endl;return 0;
}

指向常量的指针常量

指针本身和它所指向的对象都是常量，既不能通过指针修改所指向对象的值，指针也不能再指向其他对象。

#include <iostream>int main() {int a = 10;int b = 20;const int* const ptr = &a;// *ptr = 20; // 错误，不能通过指针修改所指向对象的值// ptr = &b; // 错误，指针本身不能再指向其他对象std::cout << "*ptr: " << *ptr << std::endl;return 0;
}

2. 修饰函数参数

传递常量引用

当函数参数为 const 引用时，函数内部不能修改该参数所引用的对象，常用于避免不必要的对象复制，同时保证数据的安全性。

#include <iostream>
#include <string>void printString(const std::string& str) {// str = "new string"; // 错误，不能修改引用的对象std::cout << "String: " << str << std::endl;
}int main() {std::string myString = "Hello";printString(myString);return 0;
}

传递常量指针

当函数参数为 const 指针时，函数内部不能通过该指针修改所指向的对象。

#include <iostream>void printValue(const int* ptr) {// *ptr = 20; // 错误，不能通过指针修改所指向对象的值std::cout << "*ptr: " << *ptr << std::endl;
}int main() {int num = 10;printValue(&num);return 0;
}

3. 修饰函数返回值

返回常量值

当函数返回值为 const 类型时，返回值是一个常量，不能被修改。

#include <iostream>const int getValue() {return 10;
}int main() {// getValue() = 20; // 错误，不能修改常量返回值std::cout << "Value: " << getValue() << std::endl;return 0;
}

返回常量引用

当函数返回常量引用时，返回的引用所指向的对象不能通过该引用被修改。

#include <iostream>
#include <vector>const int& getElement(const std::vector<int>& vec, size_t index) {return vec[index];
}int main() {std::vector<int> myVector = {1, 2, 3};// getElement(myVector, 0) = 10; // 错误，不能通过常量引用修改对象std::cout << "Element: " << getElement(myVector, 0) << std::endl;return 0;
}

4. 修饰类的成员函数

当 const 用于修饰类的成员函数时，该成员函数被称为常量成员函数，在常量成员函数内部不能修改类的非静态成员变量（mutable 修饰的变量除外）。

#include <iostream>class MyClass {
private:int value;
public:MyClass(int val) : value(val) {}int getValue() const {// value = 20; // 错误，不能在常量成员函数中修改非静态成员变量return value;}
};int main() {MyClass obj(10);std::cout << "Value: " << obj.getValue() << std::endl;return 0;
}

5. 修饰类的静态成员变量

静态成员变量必须在类外初始化，但当 const 用于修饰类的了整型和枚举类型的静态成员变量时，该静态成员变量成为常量，在类内进行初始化，并且初始化后不能再被修改。

#include <iostream>class MyClass {
public:static const int staticConstVar;
};// 类外初始化静态常量成员变量
const int MyClass::staticConstVar = 10;int main() {std::cout << "Static const variable: " << MyClass::staticConstVar << std::endl;return 0;
}