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

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 修饰离它最近的类型

• 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++ 中，“不能把常量的地址泄露给一个普通的指针或者普通的引用变量”