每日面经（十一）

个人回收

已于 2023-04-26 09:23:18 修改

阅读量291

点赞数

文章标签： java 数据库开发语言面试 c++

于 2023-04-26 09:23:01 首次发布

本文链接：https://blog.csdn.net/m0_57747934/article/details/130378265

版权

文章探讨了C++中vector的1.5倍扩容策略优于2倍的原因，包括减少扩容次数、降低内存浪费和碎片化。同时，解释了shared_ptr不是线程安全的，需要手动同步。接着，讨论了类默认生成的成员方法，拷贝构造在何种情况下不会自动生成。还涉及了空类、空基类优化以及栈和堆的内存分配区别。最后，简述了释放内存的流程和C++内存模型的关键概念。

摘要由CSDN通过智能技术生成

1.vector扩容策略，1.5倍扩容为什么比2倍好？

2.shard_ptr是线程安全的吗，为什么不保证线程安全

3.类默认生成了哪些成员方法，拷贝构造在哪些情况下不自动生成

4.空类 / 空类继承 / 空基类优化

5.栈为什么比堆快

6.free一个对象指针中间发生了什么

7.我有一个类文件有一个私有成员，如何在不修改我文件的前提下（友元打咩），访问该成员。

8.写一个右值赋值运算符

9.运行一个exe程序详细流程

10.C++内存模型

1.vector扩容策略，1.5倍扩容为什么比2倍好？

1.5倍扩容比2倍好的主要原因是：

缩短了扩容次数：当vector需要多次扩容时，1.5倍扩容可以使扩容的次数更少，因为每次扩容的增量更大，从而减少了内存分配的次数和开销。
减少了内存的浪费：2倍扩容可能会导致内存浪费现象，因为每次扩容时，会分配比实际需要更多的内存空间。而1.5倍扩容能够有效降低这种浪费，因为每次扩容后的内存块大小更接近实际需要的大小。
降低了碎片化的可能性：2倍扩容可能导致内存块大小差异较大，从而容易形成内存碎片，影响内存的利用率。而1.5倍扩容能够有效地避免这种情况，因为内存块大小变化较小，内存的利用率更高。

因此，综合考虑，1.5倍扩容策略更加灵活和高效，是一个更好的选择。

2.shard_ptr是线程安全的吗，为什么不保证线程安全

shared_ptr并不是线程安全的，因为它的内部状态包含了引用计数（reference count），当多个线程对同一个对象持有shared_ptr时，如果同时对其进行释放操作，就可能会导致内存泄漏或者double free等问题。此外，当对同一个对象的shared_ptr进行读写操作时，也可能会发生竞态条件，导致程序崩溃或者出现未定义行为。

虽然某些实现中可能提供了一些线程安全的扩展，如std::shared_timed_mutex，但这只是部分实现提供的方案，并不是C++标准规定的。要想在多线程环境中使用shared_ptr，通常需要配合线程安全的同步机制（如互斥锁、读写锁）来保护对shared_ptr的操作，以确保其线程安全。

但是，C++标准委员会并没有将线程安全作为shared_ptr的基本功能之一，主要考虑到线程安全会带来一定的性能开销，而且并不是所有场景都需要线程安全，因此仅将其定义为语言的一种基本支持，留给具体实现来决定是否提供线程安全的扩展。开发者在使用shared_ptr时，需要自行判断是否需要线程安全，并进行必要的保护。

3.类默认生成了哪些成员方法，拷贝构造在哪些情况下不自动生成

在 C++ 中，一个类至少会自动生成默认的构造函数、析构函数、拷贝构造函数和拷贝赋值运算符。当我们没有定义任何构造函数和析构函数时，C++ 编译器会自动生成默认构造函数和析构函数；当我们没有定义拷贝构造函数和拷贝赋值运算符时，C++ 编译器也会自动生成默认的拷贝构造函数和拷贝赋值运算符。

但是，在以下情况下，编译器会禁止自动生成拷贝构造函数（或拷贝赋值运算符）：

类中包含 const 或者 reference 类型的成员变量，因为这些成员变量无法拷贝。
类中定义了自己的拷贝构造函数（或拷贝赋值运算符）。
类中定义了移动构造函数（或移动赋值运算符），因为移动语义和拷贝语义是互斥的。如果一个类中定义了移动构造函数（或移动赋值运算符），则编译器不会自动生成拷贝构造函数（或拷贝赋值运算符）。
类声明为 final 或者 delete，禁止生成默认拷贝构造函数和拷贝赋值运算符。

4.空类 / 空类继承 / 空基类优化

空类是指除了继承自 Object 对象之外没有其他成员的类，例如以下代码中的 EmptyClass：

class Object {
   //....
};

class EmptyClass : public Object {
   // empty class
};

空类对应的实例占用的空间大小为 1 个字节（C++11 标准，之前的标准中可能为 0 个字节），其中这 1 个字节是由编译器为了确保每个对象都拥有独一无二的内存地址而分配的。空类的存在，在某些情况下可以被视为是一种非常轻量级的占位符，比如用于类型特化或者行为标记。

空类继承是指一个类继承一个空类，例如 EmptyInheritedClass 继承 EmptyClass：

class EmptyInheritedClass : public EmptyClass {
   // empty inherited class
};

由于 EmptyInheritedClass 继承了 EmptyClass，所以其实例仍然占用 1 个字节，实际上这个字节仍然只是用来保证每个对象拥有独一无二内存地址的，对空类的继承不会导致空间占用的增加。

空基类优化是一种编译器将继承层次中的空基类移除的优化，可以有效减小对象的占用空间。对于以下代码中的 EmptyBaseClass：

class EmptyBaseClass {
   // empty base class
};

class DerivedClass : public EmptyBaseClass {
   // derived class
};

int main() {
   std::cout << sizeof(EmptyBaseClass) << std::endl; // 1
   std::cout << sizeof(DerivedClass) << std::endl;   // 1
   return 0;
}

编译器会自动进行优化，移除 EmptyBaseClass 对象，因此不会增加 DerivedClass 对象的占用空间。需要注意的是，空基类优化只在派生类不包含任何数据成员时才会被执行。

5.栈为什么比堆快

栈和堆都是内存分配的方式，但它们的实现机制不同。在栈中，分配的内存是连续的、固定大小的，而且分配的速度相对较快，只需要在栈顶移动下标即可。在堆中，分配的内存是不连续的、大小可变的，分配的速度比较慢，还需要频繁地进行内存的分配、释放和管理。

因此，相比于堆，栈的内存分配和管理速度更快，对于一些局部变量、函数调用等来说，栈分配比堆更加高效。

此外，栈的内存分配是由编译器进行管理的，因此更容易被优化。例如，在栈中分配数组时，编译器可以使用循环展开、向量化等方式进行优化，从而提高程序的运行效率。而在堆中分配数组时，由于不连续的内存空间，优化难度较大，因此效率相对较低。

需要注意的是，在一些情况下，堆仍然是必需的，例如需要动态分配内存的情况，或者需要在程序运行期间创建对象的情况下，堆通常是必不可少的。

总的来说，栈的优势在于速度快、管理简单、易于优化，用于局部变量和函数调用等场景相对较好；堆的优势在于可以动态分配内存、大小可变，适用于需要动态内存和长时间使用的场景。

6.free一个对象指针中间发生了什么

当一个对象指针被释放时，发生了以下步骤：

1.程序调用free函数：当程序调用free函数时，指向要释放内存的指针传递给函数。

2.指针所指向的内存被标记为可重用：free函数将指针所指向的内存标记为可重用。这意味着，该内存现在可以重新分配给新的对象。

3.指针被设置为NULL：为了避免悬浮指针的问题，程序会将被释放的指针设置为NULL。这就是防止指针被意外使用的方法。

总的来说，当一个对象指针被释放时，其所指向的内存变为可重用状态，并且该指针被设置为NULL。

7.我有一个类文件有一个私有成员，如何在不修改我文件的前提下（友元打咩），访问该成员。

在不修改文件或使用友元的情况下，可以借助该类的公有成员函数来访问私有成员。可以在类中提供一个公有成员函数，该函数返回私有成员的值。例如：

class MyClass {
private:
    int privateData;
public:
    int getPrivateData() const {
        return privateData;
    }
    //其他成员函数和声明
}

在这个示例中，私有成员变量privateData被类的公有成员函数getPrivateData()访问。因为该函数是公有的，所以其他类可以调用该函数来获取私有成员变量的值，而不直接访问私有成员变量。注意，这种方法只适用于读取私有成员变量的值，如果想要修改私有成员变量的值，则必须使用类的成员函数进行操作。

8.写一个右值赋值运算符

右值赋值运算符是一个类成员函数，以移动语义来实现自定义类型对象的右值赋值操作。如下所示：

class MyObject {
public:
    /* 构造函数和其他成员函数 */
    MyObject& operator=(MyObject&& rhs) noexcept {
        if(this != &rhs) {
            // 释放当前对象资源
            // ...

            // 移动赋值运算
            // ...
        }
        return *this;
    }
};

在这个示例中，我们定义了一个移动赋值运算符operator=，它接受一个右值引用参数rhs，并返回一个指向自身的引用。在函数体内，我们首先检查当前对象和右值对象是否相等，这是为了避免自我赋值的问题。接下来，我们释放当前对象已有的资源，如果有的话。最后，我们使用移动语义，将右值对象的资源移动到当前对象中，以实现赋值操作。

需要注意的是，移动构造函数和移动赋值运算符必须同时实现，以确保对象的移动语义正确实现。

9.运行一个exe程序详细流程

当你双击一个Windows可执行文件，系统将启动一个进程来加载和执行该程序。具体的流程如下：

加载可执行文件

系统首先将可执行文件加载到内存中，包括程序代码、数据和其他资源，如图标、菜单等。这个过程被称为映射文件，操作系统会在当前进程的虚拟地址空间中分配一块连续的空间，将文件的内容复制到其中，并根据EXE文件头的信息对其进行修补（例如，修复跳转地址、导入表和导出表等信息）。

分配内存

程序代码、全局变量和静态变量将被映射到进程地址空间的代码段和数据段中，这两个段都是虚拟内存的一部分。操作系统为进程分配一定数量的虚拟地址空间，随着进程需要内存，这些地址空间将被映射到物理内存上。

加载DLL

如果该程序使用了Dynamic Link Library（DLL），那么系统将尝试加载这些DLL并将其映射到该进程的地址空间中。这个过程涉及到解析DLL的导入表和执行它的方式，步骤类似于加载可执行文件到进程地址空间中。

程序初始化

接下来，进程会执行一些初始化代码，包括调用CRT的入口函数，分配堆内存等等。CRT是C运行时库，它提供了一些标准函数、变量和宏，用于帮助C程序员在不同的平台上编写可移植的代码。

程序执行

现在，程序已经准备就绪可以开始执行了。首先，进程会执行可执行文件的入口点函数，该函数位于EXE文件的代码段中，并以PE文件头中的地址为入口点指针，该函数在这里也被称为WinMain或mainCRTStartup。这个函数通常包含一些初始化代码，然后调用程序的主函数，最后返回程序的退出状态码。

程序退出

当程序执行完主函数后，操作系统会释放进程占用的内存资源，并将进程标记为“已终止”状态，同时将退出状态码返回给操作系统。在Windows下，通常使用ExitProcess函数来终止进程，它将调用CRT的一些清理函数并退出进程。

10.C++内存模型

C++11引入了一个内存模型，它规范了在多线程环境下，每个线程如何访问内存。C++内存模型规定了各种线程间的内存访问所执行的指令序列，从而保证在任意操作执行期间，程序行为的可预测性。

在C++内存模型中，内存由原子操作单元、内存模型和内存屏障三个部分组成：

原子操作单元

原子操作单元是指任何不能被中断的操作，例如读取或写入单个字节或字或其他固定大小的数据。C++标准库提供了一些原子类型，例如 std::atomic_int。

内存模型

C++内存模型定义了内存访问的同步规则，确保执行顺序的正确性，以及多个线程之间的内存同步。C++中的基本内存操作可以分为栅栏和原子操作两类。

栅栏(barrier)：内存栅栏是一个同步操作，它强制所有高速缓存数据和修改数据的寄存器都与主内存中的数据进行同步，防止优化过程中出现未定义行为。
原子操作：原子操作是一种以不可分割的方式来执行的操作，这意味着一旦启动，它们就完成了，不能被另一个线程中断。C++提供了一组原子操作，例如 std::atomic_fetch_add()、std::atomic_fetch_sub() 等。