2023年腾讯校招C++10道面试题全解析！

您好！在这篇文章中，我将与大家一起深入探讨腾讯2023年校园招聘中出现的一些精彩C++面试题目。

1. 解释C++中的虚函数和纯虚函数。

• 虚函数：在基类中使用virtual关键字声明的函数，允许在派生类中被重写，实现多态。当通过基类指针或引用调用虚函数时，会根据对象的实际类型调用相应的函数。
• 纯虚函数：在虚函数的声明末尾加上= 0表示这是一个纯虚函数，使得类成为抽象类。抽象类不能被实例化，且派生类必须重写所有纯虚函数才能被实例化。

2. 实现一个字符串的逆转函数。

#include 

std::string reverseString(const std::string& str) {
    std::string reversed;          // 创建一个空字符串用于存放反转后的结果
    for (int i = str.length() - 1; i >= 0; --i) {
        reversed += str[i];        // 从原字符串的末尾开始，逐个字符添加到新字符串
    }
    return reversed;              // 返回反转后的字符串
}

3. 讨论C++中智能指针的类型及其用途。

• std::unique_ptr ：提供对对象的唯一所有权，不允许复制，可用于管理资源，避免内存泄漏。
• std::shared_ptr ：提供共享所有权，使用引用计数机制，当没有任何shared_ptr指向对象时，对象会被自动销毁。
• std::weak_ptr ：与shared_ptr协作，不增加引用计数，用于解决shared_ptr可能导致的循环引用问题。

4. 实现一个二叉树的遍历算法前序遍历非递归算法

思路如下：

1. 我们使用一个栈来存储即将访问的树节点。
2. 首先，将根节点入栈。
3. 进入一个循环，只要栈不为空就继续执行。
4. 在每次循环中，我们从栈中弹出一个节点并访问它（这里是打印它的值）。
5. 然后，如果该节点有右子节点，先将右子节点入栈（因为栈是后进先出的，所以我们希望左子节点先被处理）。
6. 接着，如果该节点有左子节点，将左子节点入栈。
7. 循环继续，直到栈为空，这时所有节点都已按前序遍历的顺序被访问。

代码如下：

struct TreeNode {
    int val;
    TreeNode *left;
    TreeNode *right;
    TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
};

void preorderTraversal(TreeNode* root) {
    if (root == nullptr) return;  // 如果树为空，则直接返回

    std::stack<TreeNode*> stack;  // 创建一个栈来存储节点
    stack.push(root);             // 将根节点入栈

    while (!stack.empty()) {      // 只要栈不为空就继续遍历
        TreeNode* node = stack.top(); // 访问栈顶元素
        stack.pop();                  // 弹出栈顶元素

        std::cout << node->val << " "; // 处理当前节点

        if (node->right) {            // 如果存在右子节点，先将右子节点入栈
            stack.push(node->right);
        }
        if (node->left) {             // 然后将左子节点入栈
            stack.push(node->left);
        }
    }
}

5. 讨论C++11或更高版本中引入的一些新特性。

• 自动类型推断 (auto)：允许编译器自动推断变量的类型。
• 范围基于的循环：简化了容器遍历的语法。
• Lambda表达式：允许定义匿名函数，便于回调和算法操作。
• 智能指针（std::shared_ptr, std::unique_ptr）：改进内存管理。
• 右值引用和移动语义：优化临时对象的处理，提高性能。

6. 如何在C++中避免内存泄漏？

• 使用RAII（资源获取即初始化）模式，通过对象管理资源（如使用智能指针）。
• 遵循“资源创建即初始化”原则，确保资源在创建时立即被合适的对象接管。
• 避免裸指针的使用，尤其是在涉及资源管理时。
• 使用标准库容器而非手动管理的动态数组。

7. 解释C++中的多重继承和虚继承。

• 多重继承 ：一个类可以继承多个基类。这可能导致菱形问题，即两个基类继承自同一个祖先，从而在派生类中产生两个祖先类的副本。
• 虚继承 ：通过使用virtual关键字声明虚基类来解决菱形问题。虚继承确保共同基类只有一个实例。

8. 编写一个程序来检测链表中的循环。

使用快慢指针法：

struct ListNode {
    int val;
    ListNode *next;
    ListNode(int x) : val(x), next(nullptr) {}
};

bool hasCycle(ListNode *head) {
    ListNode *slow = head, *fast = head;  // 初始化两个指针，都指向链表头部

    while (fast != nullptr && fast->next != nullptr) {
        // 当快指针和快指针的下一个节点不为空时继续循环
        slow = slow->next;             // 慢指针每次移动一步
        fast = fast->next->next;       // 快指针每次移动两步

        if (slow == fast) {            // 如果快慢指针相遇，说明存在环
            return true;
        }
    }
    // 如果快指针达到链表末尾（null），则链表无环
    return false;
}

9. 讨论C++中的STL容器以及它们的使用场景。

• vector ：动态数组，用于需要频繁访问元素时。
• list ：双向链表，适用于频繁的插入和删除操作。
• map ：基于红黑树的键值对容器，适用于需要按键访问和维护有序数据的场景。
• unordered_map ：基于哈希表的键值对容器，用于需要快速访问的场景。
• set ：红黑树实现的集合，适用于需要维护有序集合的场景。

10. 实现一个简单的内存池。

一个使用链表实现的简单的内存池示例：

class MemoryPool {
private:
    struct Block {
        Block* next;  // 指向下一个可用的内存块
    };

    Block* freeList = nullptr;  // 指向第一个可用的内存块

public:
    void* allocate(size_t size) {
        if (!freeList) {
            // 如果没有可用的内存块，分配新的内存
            freeList = static_cast<Block*>(malloc(size));
            freeList->next = nullptr;
        }
        // 返回当前可用的内存块，并更新freeList指向下一个内存块
        Block* block = freeList;
        freeList = freeList->next;
        return block;
    }

    void deallocate(void* p) {
        // 将释放的内存块重新加入到可用内存列表中
        Block* block = static_cast<Block*>(p);
        block->next = freeList;
        freeList = block;
    }

    ~MemoryPool() {
        // 析构函数，释放所有分配的内存块
        while (freeList) {
            Block* temp = freeList;
            freeList = freeList->next;
            free(temp);
        }
    }
};