C++面试题和笔试题（二）

1.什么是C++中的RAII？

RAII，全称Resource Acquisition Is Initialization，是C++中的一种编程技巧。其核心思想是在对象的构造函数中获取资源，在析构函数中释放资源，以确保资源的正确管理。通过这种方式，资源的使用和维护被封装在类中，从而避免了资源泄露，并提高了代码的可读性、可维护性和安全性。

自己的理解：

RAII就像我们上学一样。当你早上到学校时，你会打开教室的门（获取资源），然后开始学习。当你放学离开教室时，你会记得关上教室的门（释放资源）。这样，教室的门就不会一直被打开，浪费能源，或者被其他人误用。

在C++编程里，有时候我们需要用到一些资源，比如内存、文件、网络连接等。如果我们不小心忘记了释放这些资源，就可能会出问题，比如程序崩溃或者数据丢失。RAII就是为了帮助我们更好地管理这些资源。

代码例子：
假设我们有一个简单的“灯”类，当灯被打开时，我们获取资源（比如电），当灯被关闭时，我们释放资源。

class Light {  
private:  
    bool isOn; // 灯是否亮着  
  
public:  
    // 打开灯，获取资源  
    Light() {  
        isOn = true;  
        std::cout << "灯打开了，获取了资源！" << std::endl;  
    }  
  
    // 当灯不再需要时，自动关闭灯，释放资源  
    ~Light() {  
        isOn = false;  
        std::cout << "灯关闭了，释放了资源！" << std::endl;  
    }  
  
    void turnOn() {  
        if (!isOn) {  
            isOn = true;  
            std::cout << "灯被打开了！" << std::endl;  
        }  
    }  
  
    void turnOff() {  
        if (isOn) {  
            isOn = false;  
            std::cout << "灯被关闭了！" << std::endl;  
        }  
    }  
};  
  
int main() {  
    {  
        // 当这个代码块开始时，Light对象被创建，灯被打开，获取了资源  
        Light myLight;  
        myLight.turnOn(); // 实际上这行代码是多余的，因为构造函数已经打开了灯  
  
        // ... 在这里做一些与灯有关的事情 ...  
  
        // 当这个代码块结束时，myLight对象被销毁，灯被关闭，释放了资源  
    } // 这里，myLight对象离开作用域，它的析构函数被自动调用，灯被关闭  
  
    return 0;  
}

在上面的例子中，当myLight对象被创建时，它的构造函数被调用，就像我们打开灯一样，获取了资源。当myLight对象离开它的作用域时（比如上面的代码块结束），它的析构函数被自动调用，就像我们离开教室时关上灯一样，释放了资源。这样，我们就不用担心忘记关灯或者忘记释放资源了。

• RAII（Resource Acquisition Is Initialization）与垃圾回收机制（Garbage Collection）在资源管理方面有着不同的方式和特点。以下是一个通俗易懂的表格，用来比较它们之间的不同：

概念	垃圾回收机制	RAII
定义	自动管理内存的机制	用于管理资源的获取和释放
实现方式	由编程语言的运行时系统实现	使用智能指针等技术实现
手动干预	不需要程序员手动干预	需要程序员在适当的时候手动释放资源
适用范围	主要用于管理内存	可以用于管理各种资源，如文件句柄、网络连接等

2.什么是STL？请举例一些常用的STL容器

 STL 是指 C++ 标准模板库（Standard Template Library），它是一组用于通用编程的类和算法的集合。STL 提供了一系列高效、灵活和可重用的容器、迭代器、算法和函数，用于管理和操作各种数据结构，如链表、队列、堆栈、映射、集合等。

以下是一些常用的 STL 容器：

• vector（向量）：动态数组容器，可以存储一系列相同类型的元素，并提供快速随机访问。
• list（列表）：双向链表容器，可以存储一系列相同类型的元素，并提供高效的插入和删除操作。
• deque（双端队列）：双向队列容器，可以在两端进行快速插入和删除操作。
• map（映射）：关联容器，将键（Key）与值（Value）进行关联，并提供快速的键查找操作。
• set（集合）：无序集合容器，存储唯一的元素，并提供快速的查找和删除操作。
• multimap（多重映射）：关联容器，将键（Key）与多个值（Value）进行关联，并提供快速的键查找操作。
• multiset（多重集合）：无序集合容器，存储多个相同的元素，并提供快速的查找和删除操作。

这些只是 STL 中常用的一些容器，还有其他一些容器，如 priority_queue（优先队列）、stack（堆栈）等，具体使用哪种容器取决于你的具体需求 。

3.什么是STL算法？请列举一些常用的STL算法

STL（Standard Template Library，标准模板库）算法是 C++标准库中的一部分，提供了一系列用于处理各种数据结构的通用算法。这些算法使用迭代器来遍历数据结构，并以高效、灵活和可重用的方式执行常见的操作，如排序、查找、遍历、过滤等。

以下是一些常用的 STL 算法：

1. forEach()：循环遍历容器中的每个元素，并对每个元素执行指定的操作。

2. find()：在容器中查找满足特定条件的第一个元素。

3. find_if()：在容器中查找满足特定条件的第一个元素，并返回指向该元素的迭代器。

4. count()：统计容器中满足特定条件的元素数量。

5. sort()：对容器中的元素进行排序。

6. binary_search()：在有序容器中查找特定元素是否存在。

7. lower_bound()：在有序容器中查找第一个不小于特定元素的元素。

8. upper_bound()：在有序容器中查找第一个大于特定元素的元素。

9. equal_range()：在有序容器中查找特定元素的范围。

10. merge()：将两个有序容器合并成一个有序容器。

11. copy()：将一个容器中的元素复制到另一个容器中。

12. unique()：从容器中删除重复的元素。

13. reverse()：反转容器中的元素顺序。

这些只是 STL 中常用的一些算法，还有其他一些算法，如next_permutation()、prev_permutation()、random_shuffle()等，具体使用哪种算法取决于你的具体需求。 

 4.请解释C++中的lambda表达式。如何使用它？

lambda 表达式是 C++11 中引入的一种新的语法，它可以用来创建匿名函数。匿名函数是指没有名字的函数，它可以在需要时定义和使用，而不需要提前声明。

自己的理解：lambda表达式就像是一个小魔法盒子，你可以在这个盒子里放入一些代码，然后给它一个名字或者不给它名字。当你想运行这些代码时，就可以打开这个盒子。

lambda表达式的基本语法如下：

[capture](parameters) -> return_type { body_of_lambda }

• capture：捕获子句，决定了哪些外部变量可以在lambda体内使用。捕获方式可以是值捕获（通过等号=）或引用捕获（通过&）。
• parameters：lambda函数的参数列表，与常规函数参数列表类似。
• return_type：lambda函数的返回类型。如果lambda函数不返回任何值，可以省略此部分。
• body_of_lambda：lambda函数的主体，包含要执行的代码。

比如，我们可以定义一个 lambda 表达式来计算两个数的和：

auto add = [](int a, int b) { return a + b; };

这里的 auto 是一个关键字，它告诉编译器根据 lambda 表达式的返回值自动推断出变量的类型。[] 里面的部分就是 lambda 表达式的定义，它接受两个整数参数 a 和 b，然后返回它们的和。 

 下面是一个使用 lambda 表达式的示例：

#include <iostream>
#include <vector>

int main() {
    // 使用 lambda 表达式计算两个数的和
    auto add = [](int a, int b) -> int { return a + b; };
    int result = add(5, 10);
    std::cout << "结果: " << result << std::endl;

    // 使用 lambda 表达式对向量进行排序
    std::vector<int> numbers = {10, 5, 20, 3};
    std::sort(numbers.begin(), numbers.end(), [](int a, int b) -> bool { return a > b; });
    for (int number : numbers) {
        std::cout << number << " ";
    }
    std::cout << std::endl;

    return 0;
}

4.请解释C++中的智能指针。如何使用它？

在 C++ 中，智能指针是一种特殊的指针类型，它可以自动管理动态分配的内存。智能指针的主要目的是避免手动释放内存，从而减少内存泄漏和野指针的出现。

C++ 中主要有以下几种智能指针：

1. unique_ptr：用于管理单个动态分配对象的指针。它提供了自动释放内存的功能，并且确保在所有权转移时正确地删除对象。
   自己的理解：unique_ptr这个小助手只负责一件东西，当东西用完的时候，它就会马上清理掉。
    

   #include <iostream>  
   #include <memory>  
     
   class MyClass {  
   public:  
       MyClass(int value) : value_(value) {}  
       ~MyClass() { std::cout << "Deleting MyClass with value " << value_ << std::endl; }  
       void printValue() { std::cout << "Value: " << value_ << std::endl; }  
   private:  
       int value_;  
   };  
     
   int main() {  
       std::unique_ptr<MyClass> ptr(new MyClass(42)); // 使用new创建对象并用unique_ptr管理  
       ptr->printValue(); // 输出：Value: 42  
       // 当ptr离开作用域时，它会自动删除MyClass对象  
       return 0;  
   }

2. shared_ptr：用于管理多个共享动态分配对象的指针。它提供了自动释放内存的功能，并且可以通过引用计数来管理对象的共享所有权。
   自己的理解：shared_ptr这个小助手可以和其他小助手一起分享负责同一件东西，只有当所有小助手都不再需要这件东西的时候，它才会被清理掉。
    

   #include <iostream>  
   #include <memory>  
     
   class MyClass { /* ... 同上 ... */ };  
     
   int main() {  
       std::shared_ptr<MyClass> ptr1 = std::make_shared<MyClass>(42); // 使用make_shared创建对象并用shared_ptr管理  
       std::shared_ptr<MyClass> ptr2 = ptr1; // ptr2现在与ptr1共享所有权  
       ptr1->printValue(); // 输出：Value: 42  
       ptr2.reset(); // 减少引用计数，但对象不会被删除，因为ptr1仍然指向它  
       // 当ptr1离开作用域时，因为引用计数变为0，所以MyClass对象会被删除  
       return 0;  
   }

3. weak_ptr：用于管理对共享对象的弱引用。它不会增加对象的引用计数，因此不会阻止对象的删除。
   自己的理解：：它有点像一个旁观的小助手，只是看看那件东西，但不会真正去负责它。它可以帮助我们避免小助手们因为互相等待对方而忘记清理东西的情况。

 使用智能指针的基本步骤如下：

1. 包含头文件：首先，需要包含相应的智能指针头文件。例如，如果要使用 unique_ptr，需要包含 <memory> 头文件。

2. 创建智能指针：使用智能指针的构造函数来创建智能指针对象。例如，要创建一个指向动态分配对象的 unique_ptr，可以使用以下语法

   std::unique_ptr<int> ptr(new int(42));

3. 使用智能指针：可以像使用普通指针一样使用智能指针。例如，要访问智能指针指向的对象，可以使用 -> 操作符
    

   std::cout << *ptr << std::endl;

4. 自动释放内存：当智能指针超出其作用域时，它会自动释放所管理的动态分配对象的内存。无需手动调用 delete 运算符。

5. 转移所有权：智能指针支持所有权的转移。可以使用 reset() 或 release() 方法将智能指针的所有权转移给另一个智能指针或释放所有权。

6. 检查智能指针是否拥有对象：可以使用 operator bool() 或 get() 方法来检查智能指针是否拥有对象。