蓝芯机器人 C++开发一面

1、讲讲 C++ 动态内存分配

答案：C++ 里的动态内存分配主要指在程序运行过程中按需从自由存储区申请内存，而不是在编译期就把对象大小和生命周期完全定死。最常见的方式就是 new/delete 和 new[]/delete[]，更工程化一点就是通过智能指针、容器和分配器来管理。

从过程上看，动态内存分配通常分成两层：一层是“拿到原始内存”，另一层是“在这块内存上构造对象”。new 会先调用底层的 operator new 分配足够大小的原始内存，再调用构造函数初始化对象；delete 则反过来，先调用析构函数，再调用 operator delete 释放原始内存。

和 C 里的 malloc/free 相比，C++ 动态内存分配更强调对象语义，而不只是字节块。malloc 只管给一块内存，不会构造对象；new 不只是分配，还会完成初始化。

实际开发里，如果直接手写 new/delete 很多，就容易出现泄漏、悬空指针、重复释放，所以现代 C++ 更推荐容器和智能指针来接管大部分动态内存场景。

代码：

#include <iostream>
using namespace std;

class A {
public:
    A() { cout << "A construct\n"; }
    ~A() { cout << "A destruct\n"; }
};

int main() {
    A* p = new A;   // 分配内存 + 调用构造
    delete p;       // 调用析构 + 释放内存
    return 0;
}

2、`new` 的底层

答案：new 本质上不是单纯的库函数，而是一个运算符。它底层通常做两件事：先通过 operator new 申请原始内存，再在那块内存上调用构造函数。

比如这句：

A* p = new A();

大致可以理解成下面这样的过程：

void* mem = operator new(sizeof(A));
A* p = new(mem) A();

也就是说，operator new 负责分配内存，真正的对象构造是在这块内存上完成的。如果构造函数抛异常，编译器还会自动调用 operator delete 把刚才那块内存释放掉，防止泄漏。

继续往下说，operator new 默认实现一般会向堆申请内存，申请失败时默认抛出 std::bad_alloc。如果用户自己重载了类内 operator new，那这个类的对象分配策略也可以被定制，比如对象池、小块内存池、对齐分配。

代码：

#include <iostream>
#include <new>
using namespace std;

class A {
public:
    A() { cout << "construct\n"; }
    ~A() { cout << "destruct\n"; }

    void* operator new(size_t sz) {
        cout << "custom operator new, size = " << sz << endl;
        return ::operator new(sz);
    }

    void operator delete(void* ptr) {
        cout << "custom operator delete\n";
        ::operator delete(ptr);
    }
};

int main() {
    A* p = new A;
    delete p;
}

3、介绍一下智能指针，然后详细讲一个最常用的

答案：智能指针本质上是用 RAII 思想封装资源管理，把“对象什么时候释放”这件事交给对象生命周期，而不是交给人工记忆。常见的有三种：

unique_ptr：独占所有权，不能拷贝，只能移动
shared_ptr：共享所有权，靠引用计数管理对象生命周期
weak_ptr：弱引用，不拥有对象，主要用来观察 shared_ptr 管理的对象并打破循环引用

如果详细讲最常用的，我会讲 shared_ptr。因为它既常用，也最容易被问深。

shared_ptr 的核心不只是“能共享”，而是它背后有一个控制块。这个控制块里通常会存：

强引用计数
弱引用计数
删除器
分配器信息
被管理对象地址或者对象构造信息

每拷贝一次 shared_ptr，强引用计数加一；每析构一个 shared_ptr，强引用计数减一；当强引用计数变成 0，对象析构；当弱引用计数也归零时，控制块本身才释放。

它的好处是多个模块之间可以共享同一个对象，不用人工协调释放时机。但问题也很明显：

有额外计数开销
有控制块内存开销
容易循环引用
以为“有 shared_ptr 就线程安全”其实是误解

代码：

#include <iostream>
#include <memory>
using namespace std;

class A {
public:
    A() { cout << "A construct\n"; }
    ~A() { cout << "A destruct\n"; }
};

int main() {
    shared_ptr<A> p1 = make_shared<A>();
    cout << p1.use_count() << endl;

    {
        shared_ptr<A> p2 = p1;
        cout << p1.use_count() << endl;
    }

    cout << p1.use_count() << endl;
    return 0;
}