【面经分享-CPP篇】[建议收藏！！] C++基础20问-01

🍭 大家好这里是清隆学长 ，一枚热爱算法的程序员

✨ 本系列打算持续跟新c++面试基础

👏 感谢大家的订阅➕ 和 喜欢💗

1.题目：解释C++中的RAII机制。

考点：C++基础
答案解析：
RAII（Resource Acquisition Is Initialization）是一种管理资源的编程惯用法。它的核心思想是将资源的获取和释放绑定到对象的生命周期。资源在对象创建时获取，在对象销毁时释放。常见的应用包括文件句柄、内存管理等。C++中的智能指针（如std::unique_ptr和std::shared_ptr）就是RAII的典型实现。

2.题目：解释C++中的智能指针及其类型。

考点：内存管理
答案解析：
C++11引入了智能指针来自动管理内存，避免内存泄漏。主要有三种类型：

• std::unique_ptr：独占所有权的智能指针，不能复制，只能移动。
• std::shared_ptr：共享所有权的智能指针，多个shared_ptr可以指向同一个对象，使用引用计数来管理对象的生命周期。
• std::weak_ptr：弱引用，不影响shared_ptr的引用计数，通常用于解决循环引用问题。

3.题目：解释C++中的多态性及其实现方式。

考点：面向对象编程
答案解析：
多态性是面向对象编程的一个基本特性，允许同一接口调用不同的实现。C++中通过虚函数实现多态性。基类中声明虚函数，派生类中重写该虚函数，通过基类指针或引用调用派生类的实现。

class Base {
public:
    virtual void show() {
        std::cout << "Base class" << std::endl;
    }
};

class Derived : public Base {
public:
    void show() override {
        std::cout << "Derived class" << std::endl;
    }
};

int main() {
    Base* b = new Derived();
    b->show(); // 输出 "Derived class"
    delete b;
    return 0;
}

4.题目：解释C++中的引用和指针的区别。

考点：C++基础
答案解析：

• 引用：引用是一个变量的别名，必须在声明时初始化，不能改变引用的对象。引用使用起来更安全，因为它不能为null。
• 指针：指针是一个变量，存储另一个变量的地址，可以在声明后初始化，也可以改变指向的对象。指针可以为null，使用时需要注意内存管理。

5.题目：如何在C++中进行异常处理？

考点：异常处理
答案解析：
C++中使用try、catch和throw关键字进行异常处理。try块中包含可能抛出异常的代码，catch块中处理异常，throw用于抛出异常。

try {
    // 可能抛出异常的代码
    throw std::runtime_error("An error occurred");
} catch (const std::exception& e) {
    std::cout << "Caught exception: " << e.what() << std::endl;
}

6.题目：解释C++11中的std::move和std::forward。

考点：C++ 高级特性
答案解析：

• std::move：用于将对象转换为右值引用，从而启用移动语义，避免不必要的拷贝。
• std::forward：用于完美转发，将参数保持其原有的左值或右值属性，通常在模板中使用。

7.题目：如何实现一个线程安全的单例模式？

考点：多线程与并发
答案解析：
线程安全的单例模式可以通过双重检查锁定（Double-Checked Locking）来实现。以下是一个示例代码：

#include <mutex>

class Singleton {
public:
    static Singleton* getInstance() {
        if (instance == nullptr) {
            std::lock_guard<std::mutex> lock(mutex_);
            if (instance == nullptr) {
                instance = new Singleton();
            }
        }
        return instance;
    }

private:
    Singleton() {}
    static Singleton* instance;
    static std::mutex mutex_;
};

Singleton* Singleton::instance = nullptr;
std::mutex Singleton::mutex_;

8.题目：解释C++中的虚函数和纯虚函数。

考点：继承与多态
答案解析：

• 虚函数：在基类中使用virtual关键字声明的函数，允许在派生类中重写，实现多态性。
• 纯虚函数：在基类中声明但不提供实现的虚函数，使用= 0语法，表示该类是抽象类，不能实例化，必须在派生类中实现。

class Base {
public:
    virtual void show() {
        std::cout << "Base class" << std::endl;
    }
    virtual void pureVirtualFunction() = 0; // 纯虚函数
};

class Derived : public Base {
public:
    void show() override {
        std::cout << "Derived class" << std::endl;
    }
    void pureVirtualFunction() override {
        std::cout << "Implemented pure virtual function" << std::endl;
    }
};

int main() {
    Base* b = new Derived();
    b->show(); // 输出 "Derived class"
    b->pureVirtualFunction(); // 输出 "Implemented pure virtual function"
    delete b;
    return 0;
}

9.题目：解释C++中的命名空间及其用途。

考点：名字空间
答案解析：
命名空间用于组织代码，避免命名冲突。可以使用namespace关键字定义命名空间，并使用::操作符访问命名空间中的成员。

namespace MyNamespace {
    void myFunction() {
        std::cout << "Hello from MyNamespace" << std::endl;
    }
}

int main() {
    MyNamespace::myFunction(); // 输出 "Hello from MyNamespace"
    return 0;
}

10.题目：解释C++中的四种类型转换：static_cast、dynamic_cast、const_cast、reinterpret_cast。

考点：类型转换
答案解析：

• static_cast：用于基本类型之间的转换和具有明确继承关系的指针或引用的转换。
• dynamic_cast：用于多态类型的安全向下转换，运行时检查类型。
• const_cast：用于去除或添加const属性。
• reinterpret_cast：用于任意类型的指针转换，通常用于底层操作。

11.题目：如何在C++中使用函数指针？

考点：函数指针
答案解析：
函数指针是指向函数的指针，可以用于回调函数或实现多态性。

#include <iostream>

void hello() {
    std::cout << "Hello, world!" << std::endl;
}

int main() {
    void (*funcPtr)() = &hello;
    funcPtr(); // 输出 "Hello, world!"
    return 0;
}

12.题目：解释C++11中的Lambda表达式及其用途。

考点：Lambda 表达式
答案解析：
Lambda表达式是匿名函数，用于简化代码，特别是在STL算法中。语法为[捕获列表](参数列表) -> 返回类型 { 函数体 }。

#include <iostream>
#include <vector>
#include <algorithm>

int main() {
    std::vector<int> vec = {1, 2, 3, 4, 5};
    std::for_each(vec.begin(), vec.end(), [](int x) {
        std::cout << x << " ";
    }); // 输出 "1 2 3 4 5"
    return 0;
}

13.题目：什么是内联函数？如何在C++中定义内联函数？

考点：内联函数
答案解析：
内联函数是建议编译器将函数调用展开为函数体，以减少函数调用的开销。使用inline关键字定义内联函数。

inline int add(int a, int b) {
    return a + b;
}

int main() {
    std::cout << add(3, 4) << std::endl; // 输出 7
    return 0;
}

14.题目：解释C++中的构造函数和析构函数。

考点：构造函数与析构函数
答案解析：

• 构造函数：在对象创建时自动调用，用于初始化对象。可以重载。
• 析构函数：在对象销毁时自动调用，用于清理资源。不能重载，类中只能有一个析构函数。

class MyClass {
public:
    MyClass() {
        std::cout << "Constructor called" << std::endl;
    }
    ~MyClass() {
        std::cout << "Destructor called" << std::endl;
    }
};

int main() {
    MyClass obj; // 输出 "Constructor called"
    // 程序结束时输出 "Destructor called"
    return 0;
}

15.题目：什么是友元函数？如何在C++中定义友元函数？

考点：友元函数
答案解析：
友元函数是可以访问类的私有和保护成员的非成员函数。使用friend关键字声明友元函数。

class MyClass {
private:
    int data;
public:
    MyClass(int d) : data(d) {}
    friend void showData(const MyClass& obj);
};

void showData(const MyClass& obj) {
    std::cout << "Data: " << obj.data << std::endl;
}

int main() {
    MyClass obj(42);
    showData(obj); // 输出 "Data: 42"
    return 0;
}

16.题目：解释C++ STL中的std::vector和std::list的区别。

考点：STL 容器
答案解析：

• std::vector：动态数组，支持随机访问，插入和删除操作的时间复杂度为O(n)，适用于需要频繁访问元素的场景。
• std::list：双向链表，不支持随机访问，插入和删除操作的时间复杂度为O(1)，适用于需要频繁插入和删除元素的场景。

17.题目：解释C++11中的auto和decltype关键字。

考点：C++11 新特性
答案解析：

• auto：用于自动推导变量的类型，简化代码。
• decltype：用于推导表达式的类型，通常用于模板编程。

int main() {
    auto x = 5; // x 的类型为 int
    decltype(x) y = 10; // y 的类型为 int
    std::cout << x << " " << y << std::endl; // 输出 "5 10"
    return 0;
}

18.题目：如何检测和防止内存泄漏？

考点：内存泄漏
答案解析：

• 检测：可以使用工具如Valgrind、AddressSanitizer等来检测内存泄漏。
• 防止：使用RAII和智能指针（如std::unique_ptr和std::shared_ptr）来自动管理内存，避免手动管理内存带来的风险。

19.题目：解释C++中的模板及其用途。

考点：模板编程
答案解析：
模板是C++中的一种泛型编程工具，允许编写与类型无关的代码。模板分为函数模板和类模板。函数模板用于定义与类型无关的函数，类模板用于定义与类型无关的类。

template <typename T>
T add(T a, T b) {
    return a + b;
}

template <typename T>
class Stack {
private:
    std::vector<T> elems;
public:
    void push(T const& elem) {
        elems.push_back(elem);
    }
    void pop() {
        if (elems.empty()) {
            throw std::out_of_range("Stack<>::pop(): empty stack");
        }
        elems.pop_back();
    }
    T top() const {
        if (elems.empty()) {
            throw std::out_of_range("Stack<>::top(): empty stack");
        }
        return elems.back();
    }
};

20.题目：如何在C++中重载运算符？

考点：运算符重载
答案解析：
运算符重载允许为用户定义的类型定义新的运算符行为。可以通过成员函数或友元函数来重载运算符。

class Complex {
private:
    double real, imag;
public:
    Complex(double r, double i) : real(r), imag(i) {}
    Complex operator+(const Complex& other) const {
        return Complex(real + other.real, imag + other.imag);
    }
    void print() const {
        std::cout << "(" << real << ", " << imag << ")" << std::endl;
    }
};

int main() {
    Complex c1(1.0, 2.0), c2(2.0, 3.0);
    Complex c3 = c1 + c2;
    c3.print(); // 输出 (3.0, 5.0)
    return 0;
}