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

[C++面试] const相关面试题

news 来源：原创 2025/9/13 21:29:25

1、非 `const` 的引用必须指向一个已存在的变量

int main() {int &a = 20;  // 错误const int &b = 30;
}

字面量 20 是临时值（右值），没有明确的内存地址。
非常量引用（左值引用）不能直接绑定到右值（如字面量）。
常量引用可以绑定到右值。编译器会为字面量 30 生成一个临时变量，并将 b 作为该临时变量的别名。此时临时变量的生命周期会被延长至引用 b 的作用域结束。

2、在内存的 0x0018ff44 处写一个4字节的10

*reinterpret_cast<int*>(0x0018ff44) = 10;

3、指针与 const 的结合

int main() {int a = 10;const int* p1 = &a;int* const p2 = &a;const int* const p3 = &a;// 哪些赋值是合法的？*p1 = 20;    // ①p1 = &a;     // ②*p2 = 20;    // ③p2 = &a;     // ④*p3 = 20;    // ⑤p3 = &a;     // ⑥return 0;
}

合法：②、③
非法：①（p1 指向 const int）、④（p2 是常量指针）、⑤（p3 指向 const int）、⑥（p3 是常量指针）。

4、引用与 const 的结合

int main() {int a = 10;const int& r1 = a;int& const r2 = a;  // 编译错误// 哪些赋值是合法的？a = 20;     // ①r1 = 20;    // ②return 0;
}

int& const r2 这种写法是冗余且错误的。若想让引用不能修改所绑定的对象，应使用 const int& r2 = a;（常量引用）

引用本身具有 “一旦绑定某个对象，就不能再绑定其他对象” 的特性

①合法

②不合法。r1 是 const int&（常量引用），它承诺不通过自身修改所绑定的对象（即不能通过 r1 改变 a 的值）。因此，r1 = 20; 试图通过常量引用修改值，是非法操作，会导致编译错误。

5、指针、引用与临时对象

int& getRef() {int temp = 10;return temp;  // 危险？
}const int& createRef() {return 10;    // 合法？
}int* getPtr() {int arr[3] = {1, 2, 3};return arr;   // 危险？
}

6、const int& func(int& p);

func 是一个函数，接受 int*&（指针的引用），返回 const int*&（指向常量 int 的指针的引用）。

int x = 10;
int* ptr = &x;
const int*& ref = func(ptr);  // ref 是一个指向 const int* 的引用

7、const 对象，不能调用非 const 方法

class MyClass {  
public:  void nonConstFunc() { /* 可能修改对象状态 */ }  void constFunc() const { /* 承诺不修改对象状态 */ }  
};  int main() {  const MyClass obj;  obj.nonConstFunc(); // 编译错误，const 对象不能调用非 const 方法  obj.constFunc();    // 合法，调用 const 成员方法  return 0;  
}

8、解释以下声明的含义并指出区别

const int* p1;  
int* const p2;  
const int* const p3;

区分「指针指向的内容不可变」与「指针本身不可变」

const int* p1：指向常量的指针，指针可重定向，但内容不可通过p1修改（保护数据）
int* const p2：常量指针，指针不可重定向，但内容可通过p2修改（保护指针）
const int* const p3：指针和内容均不可变（双重保护）

在 C++ 中，const 修饰离它最近的类型

序号	声明	`const`修饰的部分	指针性质	能否通过指针修改所指内容
1	`const int *p;`	`int`	普通指针（指针可变）	否
2	`int const* p;`	`int。`与 `const int p;` 等价*	普通指针（指针可变，没修饰*p）	否
3	`int *const p;`	`p`（指针本身）	常量指针（指针不可变；内容可变，没修饰*p）	是
4	`const int *const p;`	`int`和`p`（指针本身）	常量指针（指针不可变）	否

int *const p;：const 修饰 p，p 是一个常量指针（指针本身不可变，不能再指向其他地址），但它指向普通 int，可以通过 p 修改所指内容。

9、指针与引用声明的类型匹配规则

int a = 10;  
int *p = &a;  
int *&q = p;

int *&q = p; 中 q 是指针 p 的引用，类型完全匹配，声明合法。

int a = 10;  
int *const p = &a;  
int *&q = p;

int *const p = &a; 中 p 是常量指针（指针本身不可变），类型为 int *const；而 int *&q = p; 中 q 是 int *&，int *const 与 int *& 类型不匹配（常量性不同），声明非法。

int a = 10;  
const int *p = &a;  
int *&q = p;

const int *p = &a; 中 p 是指向 const int 的指针，类型为 const int *；int *&q = p; 中 q 是 int *&，const int * 与 int *& 类型不匹配（底层 const 存在差异），声明非法

int a = 10;  
int *p = &a;  
const int *&q = p;

int *p = &a; 中 p 是普通指针（int *）；const int *&q = p; 中 q 是 const int *&，int * 与 const int *& 类型不匹配（底层 const 存在差异），声明非法。

10、普通指针指向常量——错误

const int a = 10;
int *p = &a; // 错误：普通指针不能指向常量对象

普通指针不能指向常量（否则可能通过指针修改常量，破坏常量的 “只读” 特性），应使用 const int *p = &a;（const int * 类型指针指向 const int 对象）。所以原代码编译不通过

const 常量：初始化后值不可改变，不能作为左值重新赋值。
const 常量：可能在编译期直接将值放入符号表，供编译器优化使用（类似宏常量，但有类型安全检查）。
普通变量：运行时分配内存，值存于内存中，每次访问从内存读取。
const 常量：通常存储在只读数据段（某些优化场景下可能不分配实际内存，直接用符号表值替代）。
普通变量：存储在栈（局部变量）或全局数据区（全局 / 静态变量），有实际内存空间。

const int arr_size = 5;  
int arr[arr_size];  // C++ 中合法，const 常量可用于数组长度（编译期确定）  int non_const_size = 5;  
// int arr2[non_const_size];  // C++ 中非法，普通变量值运行时确定，不能用于数组长度

在 C++ 中，“不能把常量的地址泄露给一个普通的指针或者普通的引用变量”

1、非 const 的引用必须指向一个已存在的变量