【C++】智能指针的使用及其原理

Code Warrior2025-12-22 18:15

1. 智能指针的使用场景分析

下面程序中我们可以看到，new 了以后，我们也 delete 了，但是因为抛异常导致后面的 delete 没有得到执行，所以就内存泄漏了。因此我们需要 new 以后捕获异常，捕获到异常后 delete 内存，再把异常抛出。但 new 本身也可能抛异常，连续的两个 new 和下面的 Divide 都可能会抛异常，让处理变得很麻烦。智能指针放到这样的场景里就让问题简单多了。

cpp 复制代码 
double Divide(int a, int b)
{
    // 当b == 0时抛出异常
    if (b == 0)
    {
        throw "Divide by zero condition!";
    }
    else
    {
        return (double)a / (double)b;
    }
}

void Func()
{
    // 这里可以看到如果发生除0错误抛出异常，另外下面的array和array2没有得到释放。
    // 所以这里捕获异常后并不处理异常，异常还是交给外面处理，这里捕获了再重新抛出去。
    // 但是如果array2 new的时候抛异常呢，就还需要套一层捕获释放逻辑，这里更好解决方案
    // 是智能指针，否则代码太繁琐了
    int* array1 = new int[10];
    int* array2 = new int[10]; // 抛异常呢
    try
    {
        int len, time;
        cin >> len >> time;
        cout << Divide(len, time) << endl;
    }
    catch (...)
    {
        cout << "delete []" << array1 << endl;
        cout << "delete []" << array2 << endl;
        delete[] array1;
        delete[] array2;
        throw; // 异常重新抛出，捕获到什么抛出什么
    }
    // ...
    cout << "delete []" << array1 << endl;
    delete[] array1;
    cout << "delete []" << array2 << endl;
    delete[] array2;
}

int main()
{
    try
    {
        Func();
    }
    catch (const char* errmsg)
    {
        cout << errmsg << endl;
    }
    catch (const exception& e)
    {
        cout << e.what() << endl;
    }
    catch (...)
    {
        cout << "未知异常" << endl;
    }
    return 0;
}

2. RAII 和智能指针的设计思路

  • RAII 是 Resource Acquisition Is Initialization 的缩写，它是一种管理资源的类的设计思想，本质是一种利用对象生命周期来管理获取到的动态资源，避免资源泄漏。这里的资源可以是内存、文件指针、网络连接、互斥锁等等。RAII 在获取资源时把资源委托给一个对象，接着控制对资源的访问，资源在对象的生命周期内始终保持有效，最后在对象析构的时候释放资源，这样保障了资源的正常释放，避免资源泄漏问题。
  • 智能指针类除了满足 RAII 的设计思路，还要方便资源的访问，所以智能指针类还会像迭代器类一样，重载 operator*、operator->、operator [] 等运算符，方便访问资源。
cpp 复制代码 
template<class T>
class SmartPtr
{
public:
    // RAII：获取资源时初始化对象
    SmartPtr(T* ptr)
        :_ptr(ptr)
    {}

    // 析构时释放资源
    ~SmartPtr()
    {
        cout << "delete[] " << _ptr << endl;
        delete[] _ptr;
    }

    // 重载运算符，模拟指针的行为，方便访问资源
    T& operator*()
    {
        return *_ptr;
    }

    T* operator->()
    {
        return _ptr;
    }

    T& operator[](size_t i)
    {
        return _ptr[i];
    }

private:
    T* _ptr;
};

double Divide(int a, int b)
{
    // 当b == 0时抛出异常
    if (b == 0)
    {
        throw "Divide by zero condition!";
    }
    else
    {
        return (double)a / (double)b;
    }
}

void Func()
{
    // 这里使用RAII的智能指针类管理new出来的数组以后，程序简单多了
    SmartPtr<int> sp1 = new int[10];
    SmartPtr<int> sp2 = new int[10];

    for (size_t i = 0; i < 10; i++)
    {
        sp1[i] = sp2[i] = i;
    }

    int len, time;
    cin >> len >> time;
    cout << Divide(len, time) << endl;
}

int main()
{
    try
    {
        Func();
    }
    catch (const char* errmsg)
    {
        cout << errmsg << endl;
    }
    catch (const exception& e)
    {
        cout << e.what() << endl;
    }
    catch (...)
    {
        cout << "未知异常" << endl;
    }
    return 0;
}

3. C++ 标准库智能指针的使用

  • C++ 标准库中的智能指针都在<memory>这个头文件下面，包含<memory>就可以使用了。智能指针有好几种，除了 weak_ptr，它们都符合 RAII 和像指针一样访问的行为，原理上而言主要是解决智能指针拷贝时的思路不同。
  • auto_ptr 是 C++98 时设计出来的智能指针，它的特点是拷贝时把被拷贝对象的资源的管理权转移给拷贝对象，这是一个非常糟糕的设计，因为会导致被拷贝对象悬空，访问报错。C++11 设计出新的智能指针后，强烈建议不要使用 auto_ptr。C++11 出来之前很多公司也明令禁止使用这个智能指针。
  • unique_ptr 是 C++11 设计出来的智能指针，名字 翻译为 "唯一指针"，特点是不支持拷贝，只支持移动。如果不需要拷贝的场景，非常建议使用它。
  • shared_ptr 是 C++11 设计出来的智能指针，名字翻译为 "共享指针"，特点是支持拷贝和移动。如果需要拷贝的场景，需要使用它，底层用引用计数的方式实现。
  • weak_ptr 是 C++11 设计出来的智能指针，名字翻译为 "弱指针"，完全不同于上面的智能指针，它不支持 RAII，意味着不能用它直接管理资源。weak_ptr 的产生本质是要解决 shared_ptr 的循环引用导致内存泄漏的问题。
  • 智能指针析构时默认进行 delete 释放资源，因此如果不是 new 出来的资源交给智能指针管理，析构时会崩溃。智能指针支持在构造时传入一个删除器（本质是可调⽤对象），在智能指针析构时会调用删除器释放资源。因为 new [] 经常使用，所以 unique_ptr 和 shared_ptr 都特化了一份 [] 的版本，使用时unique_ptr<Date[]> up1(new Date[5]);、shared_ptr<Date[]> sp1(new Date[5]);就可以管理 new [] 的资源。
  • template <class T, class... Args> shared_ptr<T> make_shared(Args&&... args);：shared_ptr 除了支持用指向资源的指针构造，还支持 make_shared 用初始化资源对象的值直接构造。
  • shared_ptr 和 unique_ptr 都支持了 operator bool 的类型转换，如果智能指针对象是空对象（没有管理资源），则返回 false，否则返回 true，意味着可以直接把智能指针对象用于 if 判断是否为空。
  • shared_ptr 和 unique_ptr 的构造函数都使用 explicit 修饰，防止普通指针隐式类型转换为智能指针对象。
cpp 复制代码 
struct Date
{
    int _year;
    int _month;
    int _day;

    Date(int year = 1, int month = 1, int day = 1)
        :_year(year)
        ,_month(month)
        ,_day(day)
    {}

    ~Date()
    {
        cout << "~Date()" << endl;
    }
};

int main()
{
    auto_ptr<Date> ap1(new Date);
    // 拷贝时，管理权限转移，被拷贝对象ap1悬空
    auto_ptr<Date> ap2(ap1);
    // 空指针访问，ap1对象已经悬空，禁止访问
    // ap1->_year++;

    unique_ptr<Date> up1(new Date);
    // 不支持拷贝，编译报错
    // unique_ptr<Date> up2(up1);
    // 支持移动，但是移动后up1悬空，使用移动要谨慎
    unique_ptr<Date> up3(move(up1));

    shared_ptr<Date> sp1(new Date);
    // 支持拷贝
    shared_ptr<Date> sp2(sp1);
    shared_ptr<Date> sp3(sp2);
    cout << sp1.use_count() << endl; // 输出3

    sp1->_year++;
    cout << sp1->_year << endl; // 输出2
    cout << sp2->_year << endl; // 输出2
    cout << sp3->_year << endl; // 输出2

    // 支持移动，移动后sp1悬空，使用移动要谨慎
    shared_ptr<Date> sp4(move(sp1));
    return 0;
}

// 自定义删除器：函数指针（用于new[]资源）
template<class T>
void DeleteArrayFunc(T* ptr)
{
    delete[] ptr;
}

// 自定义删除器：仿函数（用于new[]资源）
template<class T>
class DeleteArray
{
public:
    void operator()(T* ptr)
    {
        delete[] ptr;
    }
};

// 自定义删除器：仿函数（用于文件指针资源）
class Fclose
{
public:
    void operator()(FILE* ptr)
    {
        cout << "fclose:" << ptr << endl;
        fclose(ptr);
    }
};

int main()
{
    // 错误用法：默认delete释放new[]资源，程序崩溃
    // unique_ptr<Date> up1(new Date[10]);
    // shared_ptr<Date> sp1(new Date[10]);

    // 解决方案1：使用智能指针的new[]特化版本
    unique_ptr<Date[]> up1(new Date[5]);
    shared_ptr<Date[]> sp1(new Date[5]);

    // 解决方案2：仿函数对象做删除器
    unique_ptr<Date, DeleteArray<Date>> up2(new Date[5]);
    shared_ptr<Date> sp2(new Date[5], DeleteArray<Date>());

    // 解决方案3：函数指针做删除器
    unique_ptr<Date, void(*)(Date*)> up3(new Date[5], DeleteArrayFunc<Date>);
    shared_ptr<Date> sp3(new Date[5], DeleteArrayFunc<Date>);

    // 解决方案4：lambda表达式做删除器
    auto delArrOBJ = [](Date* ptr) {delete[] ptr; };
    unique_ptr<Date, decltype(delArrOBJ)> up4(new Date[5], delArrOBJ);
    shared_ptr<Date> sp4(new Date[5], delArrOBJ);

    // 管理其他资源（文件指针）
    shared_ptr<FILE> sp5(fopen("Test.cpp", "r"), Fclose());
    shared_ptr<FILE> sp6(fopen("Test.cpp", "r"), [](FILE* ptr) {
        cout << "fclose:" << ptr << endl;
        fclose(ptr);
    });

    return 0;
}

int main()
{
    shared_ptr<Date> sp1(new Date(2024, 9, 11));
    shared_ptr<Date> sp2 = make_shared<Date>(2024, 9, 11);
    auto sp3 = make_shared<Date>(2024, 9, 11);

    shared_ptr<Date> sp4;
    // 支持operator bool判断是否为空
    if (sp1)
        cout << "sp1 is not nullptr" << endl;
    if (!sp4)
        cout << "sp4 is nullptr" << endl;

    // 错误：explicit修饰构造函数，禁止隐式转换
    // shared_ptr<Date> sp5 = new Date(2024, 9, 11);
    // unique_ptr<Date> sp6 = new Date(2024, 9, 11);

    return 0;
}

4. 智能指针的原理

下面模拟实现了 auto_ptr 和 unique_ptr 的核心功能，这两个智能指针的实现比较简单，了解原理即可。auto_ptr 的思路是拷贝时转移资源管理权给被拷贝对象，这种思路不被认可，不建议使用。unique_ptr 的思路是不支持拷贝。重点要理解 shared_ptr 的设计，尤其是引用计数的设计：一份资源对应一个引用计数，因此引用计数不能用静态成员实现，需要用堆上动态开辟的方式。构造智能指针对象时，每管理一份新资源，就 new 一个引用计数。多个 shared_ptr 指向同一资源时，引用计数 ++；shared_ptr 对象析构时，引用计数 --；引用计数减到 0 时，代表当前是最后一个管理该资源的对象，析构资源。ee3

cpp 复制代码 
namespace bit
{
    // 模拟实现auto_ptr（不推荐使用）
    template<class T>
    class auto_ptr
    {
    public:
        auto_ptr(T* ptr)
            :_ptr(ptr)
        {}

        // 拷贝构造：转移资源管理权
        auto_ptr(auto_ptr<T>& ap)
            :_ptr(ap._ptr)
        {
            ap._ptr = nullptr;
        }

        // 赋值运算符：转移资源管理权
        auto_ptr<T>& operator=(auto_ptr<T>& ap)
        {
            // 检测是否为自己给自己赋值
            if (this != &ap)
            {
                // 释放当前对象中资源
                if (_ptr)
                    delete _ptr;

                // 转移ap中资源到当前对象中
                _ptr = ap._ptr;
                ap._ptr = NULL;
            }
            return *this;
        }

        ~auto_ptr()
        {
            if (_ptr)
            {
                cout << "delete:" << _ptr << endl;
                delete _ptr;
            }
        }

        // 像指针一样使用
        T& operator*()
        {
            return *_ptr;
        }

        T* operator->()
        {
            return _ptr;
        }

    private:
        T* _ptr;
    };

    // 模拟实现unique_ptr（禁止拷贝，支持移动）
    template<class T>
    class unique_ptr
    {
    public:
        explicit unique_ptr(T* ptr)
            :_ptr(ptr)
        {}

        ~unique_ptr()
        {
            if (_ptr)
            {
                cout << "delete:" << _ptr << endl;
                delete _ptr;
            }
        }

        // 像指针一样使用
        T& operator*()
        {
            return *_ptr;
        }

        T* operator->()
        {
            return _ptr;
        }

        // 禁止拷贝（删除拷贝构造和赋值运算符）
        unique_ptr(const unique_ptr<T>& sp) = delete;
        unique_ptr<T>& operator=(const unique_ptr<T>& sp) = delete;

        // 支持移动构造
        unique_ptr(unique_ptr<T>&& sp)
            :_ptr(sp._ptr)
        {
            sp._ptr = nullptr;
        }

        // 支持移动赋值
        unique_ptr<T>& operator=(unique_ptr<T>&& sp)
        {
            delete _ptr;
            _ptr = sp._ptr;
            sp._ptr = nullptr;
            return *this;
        }

    private:
        T* _ptr;
    };

    // 模拟实现shared_ptr（支持拷贝，引用计数）
    template<class T>
    class shared_ptr
    {
    public:
        // 构造函数：默认初始化或传入资源指针
        explicit shared_ptr(T* ptr = nullptr)
            : _ptr(ptr)
            , _pcount(new int(1))
        {}

        // 带删除器的构造函数
        template<class D>
        shared_ptr(T* ptr, D del)
            : _ptr(ptr)
            , _pcount(new int(1))
            , _del(del)
        {}

        // 拷贝构造：引用计数++
        shared_ptr(const shared_ptr<T>& sp)
            :_ptr(sp._ptr)
            , _pcount(sp._pcount)
            , _del(sp._del)
        {
            ++(*_pcount);
        }

        // 释放资源：引用计数--，为0时释放资源和引用计数
        void release()
        {
            if (--(*_pcount) == 0)
            {
                // 最后一个管理资源的对象，释放资源
                _del(_ptr);
                delete _pcount;
                _ptr = nullptr;
                _pcount = nullptr;
            }
        }

        // 赋值运算符：引用计数转移
        shared_ptr<T>& operator=(const shared_ptr<T>& sp)
        {
            if (_ptr != sp._ptr)
            {
                release();

                _ptr = sp._ptr;
                _pcount = sp._pcount;
                ++(*_pcount);
                _del = sp._del;
            }
            return *this;
        }

        ~shared_ptr()
        {
            release();
        }

        // 获取原始指针
        T* get() const
        {
            return _ptr;
        }

        // 获取引用计数
        int use_count() const
        {
            return *_pcount;
        }

        // 像指针一样使用
        T& operator*()
        {
            return *_ptr;
        }

        T* operator->()
        {
            return _ptr;
        }

    private:
        T* _ptr;              // 指向管理的资源
        int* _pcount;         // 引用计数（堆上开辟，多个对象共享）
        // atomic<int>* _pcount; // 线程安全的引用计数（原子操作）
        function<void(T*)> _del = [](T* ptr) {delete ptr; }; // 默认删除器
    };

    // 模拟实现weak_ptr（辅助shared_ptr，解决循环引用）
    // 注意：此处为简化实现，无法完全实现标准weak_ptr的所有功能（如lock）
    template<class T>
    class weak_ptr
    {
    public:
        weak_ptr()
        {}

        // 从shared_ptr构造，不增加引用计数
        weak_ptr(const shared_ptr<T>& sp)
            :_ptr(sp.get())
        {}

        // 从shared_ptr赋值，不增加引用计数
        weak_ptr<T>& operator=(const shared_ptr<T>& sp)
        {
            _ptr = sp.get();
            return *this;
        }

    private:
        T* _ptr = nullptr;
    };
}

// 测试模拟实现的智能指针
int main()
{
    bit::auto_ptr<Date> ap1(new Date);
    // 拷贝时，管理权限转移，被拷贝对象ap1悬空
    bit::auto_ptr<Date> ap2(ap1);
    // 空指针访问，ap1对象已经悬空，禁止访问
    // ap1->_year++;

    bit::unique_ptr<Date> up1(new Date);
    // 不支持拷贝，编译报错
    // bit::unique_ptr<Date> up2(up1);
    // 支持移动，移动后up1悬空，使用需谨慎
    bit::unique_ptr<Date> up3(move(up1));

    bit::shared_ptr<Date> sp1(new Date);
    // 支持拷贝，引用计数递增
    bit::shared_ptr<Date> sp2(sp1);
    bit::shared_ptr<Date> sp3(sp2);
    cout << sp1.use_count() << endl; // 输出3

    sp1->_year++;
    cout << sp1->_year << endl; // 输出2
    cout << sp2->_year << endl; // 输出2
    cout << sp3->_year << endl; // 输出2

    return 0;
}

5. shared_ptr 和 weak_ptr

5.1 shared_ptr 循环引用问题

shared_ptr 大多数情况下管理资源非常合适，支持 RAII 和拷贝，但在循环引用的场景下会导致资源无法释放，造成内存泄漏。需要认识循环引用的场景和资源未释放的原因，并学会使用 weak_ptr 解决该问题。

循环引用场景分析：

  1. 右边的节点何时释放？由左边节点的_next 管理，_next 析构后，右边节点才释放；
  2. _next 何时析构？_next 是左边节点的成员，左边节点释放后，_next 才析构；
  3. 左边的节点何时释放？由右边节点的_prev 管理，_prev 析构后，左边节点才释放；
  4. _prev 何时析构？_prev 是右边节点的成员，右边节点释放后，_prev 才析构。

至此形成循环引用，两个节点互相依赖，谁都无法释放，导致内存泄漏。解决方案：把 ListNode 结构体中的_next 和_prev 改成 weak_ptr。weak_ptr 绑定到 shared_ptr 时不会增加引用计数，不参与资源释放管理逻辑，从而打破循环引用。

cpp 复制代码 
struct ListNode
{
    int _data;
    // 循环引用：shared_ptr互相指向，导致内存泄漏
    std::shared_ptr<ListNode> _next;
    std::shared_ptr<ListNode> _prev;

    // 解决方案：改用weak_ptr，不增加引用计数
    /*std::weak_ptr<ListNode> _next;
    std::weak_ptr<ListNode> _prev;*/

    ~ListNode()
    {
        cout << "~ListNode()" << endl;
    }
};

int main()
{
    // 循环引用 -- 内存泄露
    std::shared_ptr<ListNode> n1(new ListNode);
    std::shared_ptr<ListNode> n2(new ListNode);

    cout << n1.use_count() << endl; // 输出1
    cout << n2.use_count() << endl; // 输出1

    n1->_next = n2;
    n2->_prev = n1;

    cout << n1.use_count() << endl; // 输出2
    cout << n2.use_count() << endl; // 输出2

    // weak_ptr不支持管理资源，不支持RAII
    // weak_ptr是专门绑定shared_ptr，不增加其引用计数，作为辅助管理
    // std::weak_ptr<ListNode> wp(new ListNode); // 编译报错，不能直接绑定资源

    return 0;
}

5.2 weak_ptr

weak_ptr 不支持 RAII，也不支持直接访问资源（未重载 operator * 和 operator->）。其构造时不支持绑定到资源，只支持绑定到 shared_ptr，且绑定后不增加 shared_ptr 的引用计数，专门用于解决 shared_ptr 的循环引用问题。

weak_ptr 的常用接口：

  • expired ()：检查指向的资源是否过期（即对应的 shared_ptr 是否已释放资源）；
  • use_count ()：获取对应的 shared_ptr 的引用计数；
  • lock ()：尝试获取资源的管理权，返回一个 shared_ptr。若资源已释放，返回空的 shared_ptr；若资源未释放，返回的 shared_ptr 可安全访问资源。
cpp 复制代码 
int main()
{
    std::shared_ptr<string> sp1(new string("111111"));
    std::shared_ptr<string> sp2(sp1);
    std::weak_ptr<string> wp = sp1;

    cout << wp.expired() << endl;    // 输出0（资源未过期）
    cout << wp.use_count() << endl;  // 输出2

    // sp1指向新资源，原资源的引用计数变为1
    sp1 = make_shared<string>("222222");
    cout << wp.expired() << endl;    // 输出0（原资源仍未过期）
    cout << wp.use_count() << endl;  // 输出1

    // sp2指向新资源，原资源的引用计数变为0，资源释放
    sp2 = make_shared<string>("333333");
    cout << wp.expired() << endl;    // 输出1（原资源已过期）
    cout << wp.use_count() << endl;  // 输出0

    // 重新绑定新资源
    wp = sp1;
    auto sp3 = wp.lock(); // 获取资源管理权，sp1的引用计数变为2
    cout << wp.expired() << endl;    // 输出0（新资源未过期）
    cout << wp.use_count() << endl;  // 输出2

    *sp3 += "###";
    cout << *sp1 << endl; // 输出"222222###"

    return 0;
}

6. shared_ptr 的线程安全问题

  • shared_ptr 的引用计数对象在堆上，如果多个线程中存在 shared_ptr 的拷贝或析构操作，会导致多个线程同时访问和修改引用计数，存在线程安全问题。因此 shared_ptr 的引用计数需要通过加锁或原子操作保证线程安全。
  • shared_ptr 指向的对象本身存在线程安全问题，但该问题不归 shared_ptr 管理，需由外层使用者通过加锁等方式控制。

解决引用计数的线程安全问题：将模拟实现的 shared_ptr 中的int* _pcount改为**atomic<int>* _pcount（原子操作**），或使用互斥锁加锁保护引用计数的修改。

cpp 复制代码 
struct AA
{
    int _a1 = 0;
    int _a2 = 0;

    ~AA()
    {
        cout << "~AA()" << endl;
    }
};

int main()
{
    bit::shared_ptr<AA> p(new AA);
    const size_t n = 100000;
    mutex mtx;

    auto func = [&]()
    {
        for (size_t i = 0; i < n; ++i)
        {
            // 智能指针拷贝会++引用计数（线程不安全，需原子操作或加锁）
            bit::shared_ptr<AA> copy(p);
            {
                unique_lock<mutex> lk(mtx); // 保护对象的线程安全
                copy->_a1++;
                copy->_a2++;
            }
        }
    };

    thread t1(func);
    thread t2(func);

    t1.join();
    t2.join();

    cout << p->_a1 << endl; // 预期输出200000
    cout << p->_a2 << endl; // 预期输出200000
    cout << p.use_count() << endl; // 输出1

    return 0;
}

7. C++11 和 boost 中智能指针的关系

  • Boost 库是为 C++ 标准库提供扩展的 C++ 程序库总称，Boost 社区的初衷之一是为 C++ 标准化工作提供参考实现，Boost 社区发起人 Dawes 是 C++ 标准委员会成员之一。C++11 及之后的新语法和库很多都源自 Boost。
  • C++ 98：产生第一个智能指针 auto_ptr；
  • Boost 库：提供更实用的 scoped_ptr/scoped_array、shared_ptr/shared_array、weak_ptr 等；
  • C++ TR1：引入 shared_ptr 等，但 TR1 并非标准版；
  • C++ 11：引入 unique_ptr、shared_ptr、weak_ptr（其中 unique_ptr 对应 Boost 的 scoped_ptr），其实现原理参考了 Boost 中的智能指针。

8. 内存泄漏

8.1 什么是内存泄漏，内存泄漏的危害

  • 什么是内存泄漏：指因疏忽或错误导致程序未能释放不再使用的内存。通常是忘记释放内存，或因异常导致释放代码未能执行。内存泄漏并非物理内存消失，而是程序分配内存后失去控制，造成内存浪费。
  • 内存泄漏的危害：
    • 普通短时运行程序：影响较小，进程结束后操作系统会回收所有资源；
    • 长期运行程序（如操作系统、后台服务、长时间运行的客户端）：内存泄漏会导致可用内存持续减少，程序响应变慢，最终卡死。
cpp 复制代码 
int main()
{
    // 申请1G内存未释放，程序运行后立即结束，资源会被系统回收，无明显危害
    char* ptr = new char[1024 * 1024 * 1024];
    cout << (void*)ptr << endl;
    return 0;
}
相关推荐
05大叔2 小时前
多线程的学习
java·开发语言·学习
lly2024062 小时前
C 位域：深度解析其概念、应用与未来趋势
开发语言
刺客xs2 小时前
多路IO复用
开发语言
月光在发光2 小时前
多态(虚函数核心作用原理)--C++学习（0）
c++·学习
Sunsets_Red3 小时前
2025 FZYZ夏令营游记
java·c语言·c++·python·算法·c#
自由生长20243 小时前
从流式系统中思考-C++生态和Java生态的区别
java·c++
培培说证3 小时前
2026大专Java开发工程师，考什么证加分？
java·开发语言·python
qq_336313933 小时前
java基础-方法引用
java·开发语言·算法
总是学不会.3 小时前
【JUC编程】一、线程的基础概念
java·开发语言·jvm
热门推荐
01GitHub 镜像站点02UV安装并设置国内源03Linux下V2Ray安装配置指南04在VSCode配置Java开发环境的保姆级教程（适配各类AI编程IDE）05Labelme从安装到标注：零基础完整指南06安娜的档案(Anna’s Archive) 镜像网站/国内最新可访问入口（持续更新）07BongoCat - 跨平台键盘猫动画工具08jdk21下载、安装（Windows、Linux、macOS）09CentOS的ISO镜像下载10NVIDIA显卡驱动、CUDA、cuDNN 和 TensorRT 版本匹配指南