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

Ne0inhk

— 18 min read
【C++】智能指针的使用及其原理

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

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

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 [] 等运算符，方便访问资源。
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 修饰，防止普通指针隐式类型转换为智能指针对象。
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

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 时不会增加引用计数，不参与资源释放管理逻辑，从而打破循环引用。

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 可安全访问资源。
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（原子操作），或使用互斥锁加锁保护引用计数的修改。

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 什么是内存泄漏，内存泄漏的危害

  • 什么是内存泄漏：指因疏忽或错误导致程序未能释放不再使用的内存。通常是忘记释放内存，或因异常导致释放代码未能执行。内存泄漏并非物理内存消失，而是程序分配内存后失去控制，造成内存浪费。
  • 内存泄漏的危害：
    • 普通短时运行程序：影响较小，进程结束后操作系统会回收所有资源；
    • 长期运行程序（如操作系统、后台服务、长时间运行的客户端）：内存泄漏会导致可用内存持续减少，程序响应变慢，最终卡死。
int main() { // 申请1G内存未释放，程序运行后立即结束，资源会被系统回收，无明显危害 char* ptr = new char[1024 * 1024 * 1024]; cout << (void*)ptr << endl; return 0; }

Read more

Flutter for OpenHarmony: Flutter 三方库 jaspr 为鸿蒙端开启极速渲染的现代 Web 开发新范式（Dart Web 框架首选）

Flutter for OpenHarmony: Flutter 三方库 jaspr 为鸿蒙端开启极速渲染的现代 Web 开发新范式（Dart Web 框架首选）

欢迎加入开源鸿蒙跨平台社区：https://openharmonycrossplatform.ZEEKLOG.net 前言 在进行 OpenHarmony 开发时，我们偶尔需要跳出原生的 HAP 容器，寻找更轻量、更适合在移动端 Web 加载的方案。虽然 Flutter Web 极其强大，但其生成的 Canvas/Wasm 产物体积巨大，在鸿蒙系统加载较慢。是否存在一种方案，既能使用 Dart 的声明式开发体验，又能产出纯正、轻量的 HTML/CSS/JS 节点？ jaspr 就是这个问题的终极答案。它是一个模仿 Flutter 语法、但专注于渲染原生 Web DOM 的现代框架。通过 Jaspr，鸿蒙开发者可以利用熟悉的 Widget、Component 和生命周期，

By Ne0inhk
Flutter for OpenHarmony: Flutter 三方库 sanitize_html 彻底杜绝 XSS 注入风险（鸿蒙 Web 内容安全净化）

Flutter for OpenHarmony: Flutter 三方库 sanitize_html 彻底杜绝 XSS 注入风险（鸿蒙 Web 内容安全净化）

欢迎加入开源鸿蒙跨平台社区：https://openharmonycrossplatform.ZEEKLOG.net 前言 在开发 OpenHarmony 应用时，如果我们需要在 UI 中渲染来自后端的 HTML 内容（例如文章正文、用户评论），或者使用 flutter_html 等库，一个致命的安全风险就是 XSS (跨站脚本攻击)。恶意代码可能会通过 <script> 标签或 onerror 属性在你的 App 内执行非法逻辑。 sanitize_html 是一个轻量级且极高效的 HTML 净化库。它采用白名单机制，能瞬间过滤掉所有不安全的标签和属性，确保你在鸿蒙 App 内渲染的每一行 Web 内容都是绝对安全的。 一、核心防御机制解析 sanitize_html 遵循“默认拒绝”

By Ne0inhk
【前端】win11操作系统安装完最新版本的NodeJs运行npm install报错，提示在此系统上禁止运行脚本

【前端】win11操作系统安装完最新版本的NodeJs运行npm install报错，提示在此系统上禁止运行脚本

🌹欢迎来到《小5讲堂》🌹 🌹这是《前端》系列文章，每篇文章将以博主理解的角度展开讲解。🌹 🌹温馨提示：博主能力有限，理解水平有限，若有不对之处望指正！🌹 目录 * 前言 * 解决方案 * 方法1：以管理员身份运行 PowerShell 并更改执行策略 * 方法2：只为当前会话临时允许 * 方法3：使用命令提示符 (CMD) * 方法4：绕过策略执行单个脚本 * 推荐解决方案 * Node.js 详细介绍 * 什么是 Node.js？ * 核心特点 * 1. **非阻塞 I/O 和事件驱动** * 2. **单线程但高并发** * 架构组成 * 1. **V8 JavaScript 引擎** * 2. **LibUV 库** * 3. **核心模块** * 安装与使用

By Ne0inhk
排序算法（1）

排序算法（1）

先赞后看，养成习惯！！！ ^ _ ^ ❤️ ❤️ ❤️ 码字不易，大家的支持就是我坚持下去的动力，点赞后不要忘记关注我哦 个人主页：伯明翰java 文章专栏：数据结构和算法 如有错误，请您指正批评 ^ _ ^ 什么是排序 排序：所谓排序，就是使⼀串记录，按照其中的某个或某些关键字的⼤⼩，递增或递减的排列起来的 操作 稳定性：如果待排序的一组数据中，有多个相同的数据，经过排序后如果这些相同数据的相对次序不变就是稳定排序，如果相对次序发生变化就是不稳定排序 注：如果这个排序算法是稳定的，它可以变成不稳定排序，如果是不稳定排序，它变不成稳定排序 常见的排序算法 常见排序算法实现 插入排序 直接插⼊排序是⼀种简单的插⼊排序法，其基本思想是：把待排序的记录按其关键码值的⼤⼩逐个插⼊到⼀个已经排好序的有序序列中，直到所有的记录插⼊完为⽌，得到⼀个新的有序序列。 当插⼊第i(i>=1)

By Ne0inhk