腾讯云智后端开发-C++ 二面

1. 实习中测试目标与验证方法

2. 增强轻量化项目中最大的技术挑战

在增强轻量化项目中，最大的技术挑战在于如何在保证高性能和低资源占用的前提下，优化现有系统的架构。

需要在设计上实现模块解耦、减少冗余代码，并对项目中关键算法和数据结构进行精细优化。
同时也要考虑兼容性问题，确保新引入的轻量化设计能够无缝集成到原有系统中。

3. 代码迁移项目：从 C# 迁移到 C++ 的原因及遇到的问题

从 C# 迁移到 C++主要目的是：

提升系统性能、降低资源消耗；
适应底层系统或嵌入式环境的要求。在迁移过程中遇到的问题包括：
两种语言在语法、内存管理、异常处理等方面存在较大差异；
原有架构需适配 C++ 的手动内存管理和不同的并发模型。为解决这些问题，我通过对比两种语言的设计模式，采用标准库和 RAII 等技术，逐步重构和优化关键模块。

4. 针对 C# 语法与语言特性在 C++ 中无法直接对应时的解决方案

当C#中的某些功能在C++中没有直接对应时，我会：

查找C++中相似的设计模式（如使用模板、STL、智能指针等替代C#的动态语言特性）；
手动实现缺失的功能或通过第三方库进行补充；
结合异常处理、日志记录等手段保证其功能和稳定性与原设计效果一致。

5. 智能指针的实现

智能指针通常通过封装原始指针、重载运算符以及管理引用计数来实现。

对于 shared_ptr，其内部维护一个引用计数，当计数归零时自动释放资源；
unique_ptr 则强调独占所有权，不允许复制，只能转移所有权，从而实现安全的资源管理。

6. C++ 中内存泄漏的成因及实际项目中的情况

内存泄漏一般由以下原因导致：

动态分配内存后没有及时释放（忘记 delete/free）；
资源泄露，在异常或错误处理流程中未正确释放资源；
循环引用（如智能指针的互相引用）导致引用计数无法归零。在实际项目中，我曾通过应用 RAII 技术和使用智能指针，有效减少了内存泄漏问题，同时借助内存检测工具定期检查项目可能存在的内存缺陷。

7. 使用 Vector 时如何释放其内存

在 C++ 中，std::vector 内部的内存管理是自动的：

当 vector 对象销毁时，其内部数据会自动释放。
如果需要提前释放内存，可以调用 clear() 清空元素，或调用 shrink_to_fit() 让容器尽可能释放未使用的内存空间。

8. C++ 中构造函数与析构函数的作用

构造函数：在对象创建时初始化其内部状态和分配所需资源。
析构函数：在对象生命周期结束时释放分配的资源，确保资源不会泄露。

9. C++ 中虚表（vtable）的作用

虚表用于实现动态多态。

对于含有虚函数的类，编译器会为其生成一个虚表，其中存放各虚函数的地址；
运行时通过该表实现多态调用，确保正确调用派生类中重写的虚方法。

10. 单向链表分组反转（从尾部开始，每组 k 个结点）

题目描述：给定单向链表，例如 1->2->3->4->5->6->7->8，当 k = 3 时，从尾部开始分组反转。例如：

末尾一组为 6-7-8，反转为 8-7-6；
前一组为 3-4-5，反转为 5-4-3；
剩余的 1-2 不满足一组，则保持原样。

#include <iostream>
using namespace std;

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

// 辅助函数：反转连续 k 个节点，返回新头部
ListNode* reverseGroup(ListNode* head, int k) {
    ListNode *prev = nullptr, *curr = head;
    for (int i = 0; i < k; i++) {
        ListNode* nxt = curr->next;
        curr->next = prev;
        prev = curr;
        curr = nxt;
    }
    return prev; // 新的组头部
}

// 主函数：从尾部开始每 k 个节点反转，如果不足 k 个则保持不变
ListNode* reverseFromTail(ListNode* head, int k) {
    // 计算链表长度
    int n = 0;
    for (ListNode* cur = head; cur; cur = cur->next)
        n++;

    // 前面不足 k 个节点保持原状
    int rem = n % k;
    
    ListNode dummy(0);
    dummy.next = head;
    // 指针 prevGroupTail 指向待反转部分的前一个节点
    ListNode* prevGroupTail = &dummy;
    ListNode* current = head;
    // 跳过前面不足 k 个节点
    for (int i = 0; i < rem; i++) {
        prevGroupTail = current;
        current = current->next;
    }
    
    // 反转从当前开始的每个 k 个节点
    while (current) {
        // 检查是否有足够 k 个节点
        ListNode* temp = current;
        for (int i = 0; i < k; i++) {
            if (!temp)
                return dummy.next;
            temp = temp->next;
        }
        
        // 反转这一组
        ListNode* groupTail = current; // 当前组的尾部反转后会成为尾部
        ListNode* newGroupHead = reverseGroup(current, k);
        // 接回链表
        prevGroupTail->next = newGroupHead;
        groupTail->next = temp;
        // 预备下一组
        prevGroupTail = groupTail;
        current = temp;
    }
    return dummy.next;
}

void printList(ListNode* head) {
    while(head) {
        cout << head->val << " ";
        head = head->next;
    }
    cout << endl;
}

int main(){
    // 构造链表 1->2->3->4->5->6->7->8
    ListNode* head = new ListNode(1);
    ListNode* current = head;
    for (int i = 2; i <= 8; i++){
        current->next = new ListNode(i);
        current = current->next;
    }
    
    cout << "原始链表: ";
    printList(head);
    
    int k = 3;
    head = reverseFromTail(head, k);
    
    cout << "修改后链表: ";
    printList(head);
    
    // 内存释放（略）
    return 0;
}