【C++ 面试 - 基础题】每日 3 题（七）

✍个人博客：Pandaconda-CSDN博客

📣专栏地址：http://t.csdnimg.cn/fYaBd

📚专栏简介：在这个专栏中，我将会分享 C++ 面试中常见的面试题给大家~
❤️如果有收获的话，欢迎点赞👍收藏📁，您的支持就是我创作的最大动力💪

19. C++ 中 const 和 static 的作用

static

不考虑类的情况
- 隐藏。所有不加 static 的全局变量和函数具有全局可见性，可以在其他文件中使用，加了之后只能在该文件所在的编译模块中使用。

默认初始化为 0，包括未初始化的全局静态变量与局部静态变量，都存在全局未初始化区。
静态变量在函数内定义，始终存在，且只进行一次初始化，具有记忆性，其作用范围与局部变量相同，函数退出后仍然存在，但不能使用。
考虑类的情况
- static 成员变量：只与类关联，不与类的对象关联。定义时要分配空间，不能在类声明中初始化，必须在类定义体外部初始化，初始化时不需要标示为 static；可以被非 static 成员函数任意访问。
- static 成员函数：不具有 this 指针，无法访问类对象的非 static 成员变量和非 static 成员函数；不能被声明为 const、虚函数和 volatile；可以被非 static 成员函数任意访问。

从面向过程角度回答

static 修饰全局变量
- 在符号表中，符号的作用域就从 globle 变成了 local（static 修饰函数也会这样）。
static 修饰局部变量
- 局部变量本身不产生符号，通过 ebp - 偏移量来访问。

注意：全局变量、静态全局变量、静态局部变量都在静态存储区分配空间，而局部变量在栈分配空间。

两个编译单元相同名字的 static 函数会报错吗？

不会，因为 static 具有隐藏特性。

存储区域

由 static 修饰的变量存储在虚拟内存空间的数据区，而非静态成员变量一般存放在堆区或者栈区（全局变量和常量也存放在数据区）。
由 static 修饰的函数以及非静态函数都存在于存储在虚拟地址空间的代码区。

const

不考虑类的情况
- const 常量在定义时必须初始化，之后无法更改。
- const 形参可以接收 const 和非 const 类型的实参，例如：
```
// i 可以是 int 型或者 const int 型
void fun(const int& i){ 
    //...
}
```

考虑类的情况
- const 成员变量：不能在类定义外部初始化，只能通过构造函数初始化列表进行初始化，并且必须有构造函数；不同类对其 const 数据成员的值可以不同，所以不能在类中声明时初始化。
- const 成员函数：const 对象不可以调用非 const 成员函数；非 const 对象都可以调用；不可以改变非 mutable（用该关键字声明的变量可以在 const 成员函数中被修改）数据的值。
```
void Print() const{
    //实现
}
```

补充一点 const 相关：const 修饰变量也是与 static 有一样的隐藏作用。只能在该文件中使用，其他文件不可以引用声明使用。因此在头文件中声明 const 变量是没问题的，因为即使被多个文件包含，链接性都是内部的，不会出现符号冲突。

const 替换特性

编译过程中，把出现常量名字的地方，用常量的值进行替换。

const int a = 10;
int* p = (int)*a;
*p = 20;
cout<< a << " " << *p << endl;

上面输出结果是 10 20，这是因为 a 在编译过程中会被替换成 10。

const 和 static 的区别

面向过程：

const：全局变量、局部变量、形参变量，且不能修饰函数。
static：全局变量、局部变量，且可以修饰函数。

面向对象：

const：常方法、成员变量，函数调用依赖对象即有 this 指针。
static：静态方法、成员变量，函数调用不依赖对象即没有 this 指针。

20. final 和 override 关键字

override

当在父类中使用了虚函数时候，你可能需要在某个子类中对这个虚函数进行重写，以下方法都可以：

class A
{
    virtual void foo();
}
class B : public A
{
    void foo(); //OK
    virtual void foo(); // OK
    void foo() override; //OK
}

如果不使用 override，当你手一抖，将 foo() 写成了 f00() 会怎么样呢？结果是编译器并不会报错，因为它并不知道你的目的是重写虚函数，而是把它当成了新的函数。如果这个虚函数很重要的话，那就会对整个程序不利。所以，override 的作用就出来了，它指定了子类的这个虚函数是重写的父类的，如果你名字不小心打错了的话，编译器是不会编译通过的：

class A
{
    virtual void foo();
};
class B : public A
{
    virtual void f00(); //OK，这个函数是B新增的，不是继承的
    virtual void f0o() override; //Error, 加了override之后，这个函数一定是继承自A的，A找不到就报错
};

final

当不希望某个类被继承，或不希望某个虚函数被重写，可以在类名和虚函数后添加 final 关键字，添加 final 关键字后被继承或重写，编译器会报错。例子如下：

class Base
{
    virtual void foo();
};
 
class A : public Base
{
    void foo() final; // foo 被override并且是最后一个override，在其子类中不可以重写
};

class B final : A // 指明B是不可以被继承的
{
    void foo() override; // Error: 在A中已经被final了
};
 
class C : B // Error: B is final
{
};

21. vo latile、mutable 和 explicit 关键字的用法

（1）volatile

主要用于告诉编译器不要对其所修饰的变量进行优化，因为这些变量可能会在程序执行过程中被外部因素改变，而编译器不应该假定它们的值是稳定的。

volatile 的作用：
1. volatile 主要用于修饰变量，告诉编译器不要对该变量进行优化。这通常用于描述一些可能会被外部因素（如硬件、操作系统、其他线程等）更改的变量。
使用场景：
1. 硬件寄存器：volatile 可用于描述与硬件寄存器通信的变量，因为这些变量的值可能在编译器无法预测的时间被硬件更改。
2. 多线程编程：在多线程环境中，一个线程修改的变量可能会被另一个线程读取，这时 volatile 可以确保对变量的读取和写入不会被优化掉，比如不要从各自的寄存器中读取该变量。
3. 信号处理器中使用：在信号处理器中，被信号处理函数修改的变量应该声明为 volatile，以确保编译器不会对它们进行优化。
不足之处：
1. volatile 仅告诉编译器不要对变量进行优化，但它并不能解决多线程并发问题。在多线程环境中，还需要使用更强大的同步机制（如互斥锁、条件变量等）来确保线程安全性。
2. volatile 并不适用于所有情况，因为它仅告诉编译器不要优化，但不提供同步机制。如果需要精确的同步和互斥，应该使用其他多线程编程工具。

示例

volatile int hardwareRegister; // 描述硬件寄存器的变量

void signalHandler(int sig) {
    volatile bool flag = true; // 信号处理器中的变量
    // ...
}

总之，volatile 关键字用于告诉编译器不要对变量进行优化，通常用于描述那些可能被外部因素改变的变量。在多线程环境中，它应该与其他同步机制一起使用来确保线程安全性。但需要注意，volatile 并不是解决多线程问题的最终解决方案，更复杂的同步机制可能需要用于确保数据一致性。

（2）mutable

mutable 的中文意思是 “可变的，易变的”，跟 constant（既 C++ 中的 const）是反义词。在 C++ 中，mutable 也是为了突破 const 的限制而设置的。被 mutable 修饰的变量，将永远处于可变的状态，即使在一个 const 函数中。我们知道，如果类的成员函数不会改变对象的状态，那么这个成员函数一般会声明成 const 的。但是，有些时候，我们需要在 const 函数里面修改一些跟类状态无关的数据成员，那么这个函数就应该被 mutable 来修饰，并且放在函数后后面关键字位置。

注意：mutable 只能作用于类的非静态和非常量数据成员。

样例

class person
{
    int m_A;
    mutable int m_B;//特殊变量 在常函数里值也可以被修改
public:
     void add() const//在函数里不可修改this指针指向的值 常量指针
     {
        m_A=10;//错误  不可修改值，this已经被修饰为常量指针
        m_B=20;//正确
     }
}

class person
{
    int m_A;
    mutable int m_B;//特殊变量 在常函数里值也可以被修改
}
int main()
{
    const person p;//修饰常对象 不可修改类成员的值
    p.m_A=10;//错误，被修饰了指针常量
    p.m_B=200;//正确，特殊变量，修饰了mutable
}

（3）explicit

explicit 关键字用来修饰类的构造函数，被修饰的构造函数的类，不能发生相应的隐式类型转换，只能以显示的方式进行类型转换，注意以下几点：