C++进阶面试题

激昂～逐流

已于 2024-09-04 17:38:39 修改

阅读量609

点赞数 19

分类专栏： C++面试题文章标签： c++ 面试

于 2024-09-03 17:40:11 首次发布

本文链接：https://blog.csdn.net/qq_71286244/article/details/141867267

版权

C++面试题专栏收录该内容

8 篇文章 0 订阅

订阅专栏

1.介绍下C++从编写到可执行的整个过程？

C++从编写到可执行的整个过程可以分为以下几个主要步骤：

编写源代码：

使用文本编辑器或集成开发环境（IDE）编写C++源代码，文件扩展名通常为.cpp。

预处理：

在编译之前，C++编译器会进行预处理。预处理器处理以#开头的指令，如#include和#define。这一步骤会将头文件的内容插入到源代码中，并处理宏定义。

编译：

预处理后的代码被传递给编译器，编译器将其转换为中间代码（通常是汇编语言）。这个过程会检查语法错误并生成相应的汇编代码。

汇编：

汇编器将汇编代码转换为机器代码，生成目标文件（通常是.o或.obj文件）。目标文件包含了机器可读的代码，但尚未链接成可执行文件。

链接：

链接器将一个或多个目标文件与所需的库文件（如标准库）链接在一起，生成最终的可执行文件（通常是.exe或无扩展名的文件）。链接器会解决外部符号引用，确保所有函数和变量都能正确连接。

执行：

最后，用户可以运行生成的可执行文件，操作系统会加载该文件到内存中并开始执行程序。

这个过程可以通过命令行工具（如g++）或IDE（如Visual Studio、Code::Blocks等）来完成。

2. 什么是C++中的auto和decltype?

在C++中，auto和decltype是两种类型推导机制，用于简化类型声明和提高代码的可读性。

auto

定义：auto关键字用于自动推导变量的类型。编译器根据初始化表达式的类型来确定变量的类型。
用法：

当你声明一个变量时，可以使用auto来避免手动指定类型。
适用于复杂类型，尤其是模板和迭代器。

示例：

auto x = 5;          // x的类型为int  
auto y = 3.14;       // y的类型为double  
auto str = "Hello";  // str的类型为const char*

decltype

定义：decltype关键字用于获取表达式的类型，而不计算该表达式的值。它可以用于声明变量或返回类型。
用法：

当你需要知道某个表达式的类型，但不想实际计算它时，可以使用decltype。
适用于模板编程和函数返回类型推导。

示例：

int a = 10;  
decltype(a) b = 20; // b的类型为int，与a相同  

auto func() -> decltype(a + b) { // 返回类型为int  
    return a + b;  
}

总结

auto用于自动推导变量类型，简化声明。
decltype用于获取表达式的类型，适用于更复杂的类型推导场景。

3. 请介绍C++多态的实现原理？

C++中的多态是面向对象编程的一个重要特性，它允许通过基类指针或引用来调用派生类的成员函数。多态主要分为两种类型：编译时多态（静态多态）和运行时多态（动态多态）。以下是多态的实现原理：

编译时多态（静态多态）

编译时多态主要通过函数重载和运算符重载实现。编译器在编译时根据函数的参数类型和数量来决定调用哪个函数。

函数重载：

void print(int i) {  
    std::cout << "Integer: " << i << std::endl;  
}  

void print(double d) {  
    std::cout << "Double: " << d << std::endl;  
}

运算符重载：

可以重载运算符以支持自定义类型的操作。

运行时多态（动态多态）

运行时多态通过虚函数实现。虚函数允许在基类中声明一个函数，并在派生类中重写它。通过基类指针或引用调用虚函数时，程序会根据对象的实际类型来决定调用哪个函数。

实现原理：

虚函数表（vtable）：

每个包含虚函数的类都有一个虚函数表（vtable），它是一个指针数组，指向该类的虚函数实现。每个对象实例中有一个指向其类的虚函数表的指针（vptr）。

虚函数的调用：

当通过基类指针或引用调用虚函数时，程序会查找该指针所指向对象的虚函数表，找到对应的函数地址并调用。

示例代码：

#include <iostream>  

class Base {  
public:  
    virtual void show() { // 虚函数  
        std::cout << "Base class show function called." << std::endl;  
    }  
};  

class Derived : public Base {  
public:  
    void show() override { // 重写虚函数  
        std::cout << "Derived class show function called." << std::endl;  
    }  
};  

int main() {  
    Base* b;           // 基类指针  
    Derived d;        // 派生类对象  
    b = &d;           // 指向派生类对象  

    b->show();        // 调用派生类的show()，输出：Derived class show function called.  
    return 0;  
}

总结

编译时多态通过函数重载和运算符重载实现，决定在编译时调用哪个函数。
运行时多态通过虚函数和虚函数表实现，允许在运行时根据对象的实际类型调用相应的函数。这种机制使得C++能够支持动态绑定和接口的灵活性。

4. C++中为什么new[]和delete[]一定要配合使用？

在C++中，new[]和delete[]必须配合使用的原因主要与内存管理和对象的构造与析构有关。以下是几个关键点：

内存分配与释放：new[]用于分配一个数组的内存，并返回指向该数组首元素的指针。相应地，delete[]用于释放由new[]分配的数组内存。如果使用delete而不是delete[]，将只释放第一个元素的内存，可能导致内存泄漏或未定义行为。
调用析构函数：当使用new[]分配对象数组时，C++会为每个对象调用构造函数。相应地，使用delete[]时，C++会为每个对象调用析构函数。如果使用delete，则只会调用第一个对象的析构函数，导致其他对象的资源未被正确释放。
内存管理一致性：C++的内存管理机制要求配对使用相应的分配和释放操作，以确保内存的正确管理和避免潜在的错误。使用不匹配的操作可能导致程序崩溃或内存损坏。

因此，为了确保内存的正确分配和释放，以及对象生命周期的管理，new[]和delete[]必须配合使用。

5. C++中malloc申请的内存，可以用delete释放吗？

在C++中，malloc申请的内存不能使用delete释放。原因如下：

内存分配方式不同：malloc是C语言中的内存分配函数，它分配的内存是未初始化的，并且不调用构造函数。而new运算符不仅分配内存，还会调用对象的构造函数。
内存释放方式不同：delete用于释放通过new分配的内存，并会调用对象的析构函数。而free是C语言中的内存释放函数，用于释放通过malloc分配的内存。
类型安全：使用delete释放通过malloc分配的内存可能导致未定义行为，因为delete期望的是通过new分配的对象，而不是原始的内存块。

因此，正确的做法是：

使用malloc分配的内存应使用free释放。
使用new分配的内存应使用delete释放。

如果在C++中使用动态内存分配，建议优先使用new和delete，以确保对象的构造和析构过程得到正确处理。

6.什么情况下会出现内存泄漏？如何避免内存泄漏？

内存泄漏是指程序在运行过程中动态分配的内存未被释放，导致可用内存逐渐减少，最终可能导致程序崩溃或系统性能下降。以下是一些常见的导致内存泄漏的情况以及避免内存泄漏的方法：

常见导致内存泄漏的情况

未释放动态分配的内存：

使用new或malloc分配内存后，未调用delete或free释放。

异常处理：

在分配内存后发生异常，导致后续的释放代码未执行。

丢失指针：

将指向动态分配内存的指针重新赋值或超出作用域，导致无法访问原来的内存块。

循环引用：

在使用智能指针时，两个或多个对象相互引用，导致引用计数无法归零，从而无法释放内存。

使用不当的容器：

在使用标准库容器（如std::vector、std::map等）时，未正确管理存储在容器中的动态分配对象。

避免内存泄漏的方法

使用智能指针：

使用std::unique_ptr或std::shared_ptr等智能指针来管理动态分配的内存，智能指针会自动释放内存。

确保释放内存：

在每个new或malloc后，确保有相应的delete或free，并在适当的地方释放内存。

异常安全：

使用RAII（资源获取即初始化）原则，确保资源在对象生命周期结束时自动释放。可以使用局部对象或智能指针来管理资源。

避免丢失指针：

在重新赋值指针之前，确保先释放原有内存，或者使用智能指针来避免手动管理内存。

使用内存检测工具：

使用工具如Valgrind、AddressSanitizer等来检测内存泄漏和其他内存管理问题。

代码审查和测试：

定期进行代码审查，确保内存管理的正确性，并进行充分的测试以发现潜在的内存泄漏。

通过遵循这些原则和方法，可以有效地避免内存泄漏，提高程序的稳定性和性能。

7.请介绍C++中unique_ptr的原理？

std::unique_ptr是C++11引入的一种智能指针，用于管理动态分配的内存。它的主要特点是独占所有权，确保在其生命周期结束时自动释放所管理的内存。以下是std::unique_ptr的原理和关键特性：

原理

独占所有权：

std::unique_ptr确保同一时间只有一个unique_ptr实例可以拥有某个动态分配的对象。这种独占性防止了多个指针同时管理同一块内存，从而避免了内存泄漏和双重释放的问题。

构造与析构：

当创建std::unique_ptr时，它会接收一个原始指针并接管其所有权。在unique_ptr的生命周期结束时（例如，超出作用域），它会自动调用delete释放所管理的内存。

移动语义：

std::unique_ptr不支持复制构造和复制赋值操作，但支持移动构造和移动赋值。这意味着可以通过std::move将unique_ptr的所有权从一个实例转移到另一个实例，而不会导致内存泄漏。

自定义删除器：

std::unique_ptr允许用户提供自定义删除器，以便在释放内存时执行特定的操作。这对于管理非标准资源（如文件句柄或网络连接）非常有用。

关键特性

内存管理：std::unique_ptr自动管理内存，减少了手动管理内存的复杂性，降低了内存泄漏的风险。
性能：由于std::unique_ptr是轻量级的，通常只包含一个指针，因此在性能上几乎没有开销。
类型安全：std::unique_ptr是类型安全的，确保指针类型的一致性。
与标准库兼容：std::unique_ptr可以与标准库容器（如std::vector、std::map等）一起使用，方便管理动态分配的对象。

示例代码

以下是一个简单的示例，展示了如何使用std::unique_ptr：

#include <iostream>  
#include <memory>  

class MyClass {  
public:  
    MyClass() { std::cout << "MyClass constructed\n"; }  
    ~MyClass() { std::cout << "MyClass destructed\n"; }  
};  

int main() {  
    // 创建一个unique_ptr，管理MyClass的实例  
    std::unique_ptr<MyClass> ptr1(new MyClass());  

    // 转移所有权  
    std::unique_ptr<MyClass> ptr2 = std::move(ptr1);  

    // ptr1现在为空，ptr2拥有MyClass的所有权  
    if (!ptr1) {  
        std::cout << "ptr1 is null\n";  
    }  

    // ptr2超出作用域时，MyClass的实例会被自动释放  
    return 0;  
}

在这个示例中，std::unique_ptr自动管理MyClass的实例，确保在ptr2超出作用域时，内存会被正确释放。通过使用std::unique_ptr，可以有效地避免内存管理中的常见错误。

8.请介绍C++中shared_ptr的原理？shared_ptr线程安全吗？

std::shared_ptr是C++11引入的一种智能指针，用于管理动态分配的内存。与std::unique_ptr不同，std::shared_ptr允许多个指针实例共享同一块内存。以下是std::shared_ptr的原理及其线程安全性分析：

原理

引用计数：

std::shared_ptr通过引用计数机制来管理内存。每当一个shared_ptr实例被创建或复制时，引用计数会增加；每当一个shared_ptr实例被销毁时，引用计数会减少。当引用计数降到零时，shared_ptr会自动释放所管理的内存。

构造与析构：

当创建std::shared_ptr时，它会接收一个原始指针并初始化引用计数为1。在shared_ptr的生命周期结束时（例如，超出作用域），它会检查引用计数，如果计数为零，则调用delete释放所管理的内存。

线程安全：

std::shared_ptr的引用计数是线程安全的。这意味着多个线程可以安全地同时访问同一个shared_ptr实例，而不会导致数据竞争或不一致的引用计数。然而，shared_ptr本身并不保证对所管理对象的线程安全访问。如果多个线程同时访问同一个对象，仍然需要使用其他同步机制（如互斥锁）来确保线程安全。

自定义删除器：

std::shared_ptr允许用户提供自定义删除器，以便在释放内存时执行特定的操作。这对于管理非标准资源（如文件句柄或网络连接）非常有用。

示例代码
以下是一个简单的示例，展示了如何使用std::shared_ptr：

#include <iostream>  
#include <memory>  

class MyClass {  
public:  
    MyClass() { std::cout << "MyClass constructed\n"; }  
    ~MyClass() { std::cout << "MyClass destructed\n"; }  
};  

int main() {  
    // 创建一个shared_ptr，管理MyClass的实例  
    std::shared_ptr<MyClass> ptr1(new MyClass());  

    // 复制shared_ptr，引用计数增加  
    std::shared_ptr<MyClass> ptr2 = ptr1;  

    std::cout << "Reference count: " << ptr1.use_count() << "\n"; // 输出引用计数  

    // ptr2超出作用域时，引用计数减少  
    {  
        std::shared_ptr<MyClass> ptr3 = ptr2;  
        std::cout << "Reference count: " << ptr1.use_count() << "\n"; // 输出引用计数  
    }  

    // ptr1和ptr2仍然有效，引用计数减少到2  
    std::cout << "Reference count: " << ptr1.use_count() << "\n"; // 输出引用计数  

    return 0;  
}