RAII和智能指针

发布时间：2026/7/15 2:49:37

RAII和智能指针

RAII

Resource Acquisition Is Initialization，它是一种C++编程技术，它通过在对象的构造函数中获取资源，在对象的析构函数中释放资源，从而确保资源的正确获取和释放。

一般情况下，C++申请资源后都需要手动释放资源，一旦忘记资源的释放就会造成内存泄漏，为了解决内存泄漏问题，C++引入了RAII机制。

RAII 的用法是在构造函数中获取资源，在析构函数中释放资源，并使用栈上的对象或者智能指针来管理堆上的资源。C++ 标准库提供了许多 RAII 类型，如 std::fstream、std::unique_ptr、std::lock_guard 等，我们可以直接使用它们或者参考它们来实现自己的 RAII 类型。

遵循RAII设计原则的好处有以下几点：

  • 简化资源管理：RAII可以将资源的获取和释放封装在对象中，从而简化了资源管理的代码。使用RAII可以避免手动管理资源的复杂性和错误，减少了代码的出错率。
  • 避免资源泄漏：RAII可以确保资源在对象生命周期结束时被正确释放，从而避免了资源泄漏的问题。如果不使用RAII，可能会因为忘记释放资源或者异常情况导致资源泄漏。
  • 提高代码可读性：RAII可以将资源的获取和释放封装在对象中，从而使代码更加清晰和易于理解。使用RAII可以使代码更加模块化，从而提高代码的可读性和可维护性。
  • 支持异常安全：RAII可以确保资源在异常情况下也能够被正确释放，从而支持异常安全。如果不使用RAII，可能会因为异常情况导致资源没有被正确释放，从而导致程序出现错误。

智能指针

智能指针的特点：

  • 不用显式地写出析构函数。
  • 资源在智能指针的生命周期中始终有效。
  • 可以像指针一样的使用。
  • 最重要的是：具有RAII特性。

c++ 98提供的auto_prt

std::auto_ptr 的基本用法如下代码所示：

#include <memory>int main()
{//初始化方式1std::auto_ptr<int> sp1(new int(8));//初始化方式2std::auto_ptr<int> sp2;sp2.reset(new int(8));return 0;
}
// sp 是 smart pointer（智能指针）的简写。

智能指针对象 sp1 和 sp2 均持有一个在堆上分配 int 对象，其值均是 8，这两块堆内存均可以在 sp1 和 sp2 释放时得到释放。这是 std::auto_ptr 的基本用法。

问题

std::auto_ptr 真正让人容易误用的地方是其不常用的复制语义，即当复制一个 std::auto_ptr 对象时（拷贝复制或 operator = 复制），原对象所持有的堆内存对象也会转移给复制出来的对象。示例代码如下：

#include <iostream>
#include <memory>int main()
{//测试拷贝构造std::auto_ptr<int> sp1(new int(8));std::auto_ptr<int> sp2(sp1);if (sp1.get() != NULL){std::cout << "sp1 is not empty." << std::endl;}else{std::cout << "sp1 is empty." << std::endl;}if (sp2.get() != NULL){std::cout << "sp2 is not empty." << std::endl;}else{std::cout << "sp2 is empty." << std::endl;}//测试赋值构造std::auto_ptr<int> sp3(new int(8));std::auto_ptr<int> sp4;sp4 = sp3;if (sp3.get() != NULL){std::cout << "sp3 is not empty." << std::endl;}else{std::cout << "sp3 is empty." << std::endl;}if (sp4.get() != NULL){std::cout << "sp4 is not empty." << std::endl;}else{std::cout << "sp4 is empty." << std::endl;}return 0;
}
// 结果如下:
sp1 is empty.
sp2 is not empty.
sp3 is empty.
sp4 is not empty.

上述代码中分别利用拷贝构造（sp1 => sp2）和 赋值构造（sp3 => sp4）来创建新的 std::auto_ptr 对象，因此 sp1 持有的堆对象被转移给 sp2，sp3 持有的堆对象被转移给 sp4。

导致的问题是：管理权的转移，比如将sp1拷贝给sp2，也就是将sp1对于资源的管理权转移给了sp2，即将sp1的指针置空，带来的问题是：后面的代码不能使用sp1对象。由于这个问题的存在auto_ptr指针被很多人诟病，并且许多公司明确要求不能使用auto_ptr指针，因为管理权转移导致了原指针不能使用，相比后续的智能指针，auto_ptr确实是个失败的设计。

std::unique_ptr

之后c++11引入了三种指针：std::unique_ptr、std::shared_ptr 和 std::weak_ptr。

std::unique_ptr解决智能指针拷贝问题的方案是：禁止拷贝
std::unique_ptr 对其持有的堆内存具有唯一拥有权，也就是说引用计数永远是 1。std::unique_ptr 对象销毁时会释放其持有的堆内存。可以使用以下方式初始化一个std::unique_ptr 对象：

//初始化方式1
std::unique_ptr<int> sp1(new int(123));//初始化方式2
std::unique_ptr<int> sp2;
sp2.reset(new int(123));//初始化方式3
std::unique_ptr<int> sp3 = std::make_unique<int>(123);应该尽量使用初始化方式 3 的方式去创建一个 std::unique_ptr 而不是方式 1 和 2，因为形式 3 更安全，原因 Scott Meyers 在其《Effective Modern C++》中已经解释过了

令很多人对 C++11 规范不满的地方是，C++11 新增了 std::make_shared() 方法创建一个 std::shared_ptr 对象，却没有提供相应的 std::make_unique() 方法创建一个 std::unique_ptr 对象，这个方法直到 C++14 才被添加进来。当然，在 C++11 中你很容易实现出这样一个方法来： 

template<typename T, typename... Ts>
std::unique_ptr<T> make_unique(Ts&& ...params)
{return std::unique_ptr<T>(new T(std::forward<Ts>(params)...));
}

鉴于 std::auto_ptr 的前车之鉴，std::unique_ptr 禁止复制语义，为了达到这个效果，std::unique_ptr 类的拷贝构造函数和赋值运算符（operator =）被标记为 delete。

template <class T>
class unique_ptr
{
public:unique_ptr(T* ptr):_ptr(ptr){}unique_ptr(const unique_ptr<T>& p) = delete;unique_ptr<T>& operator=(const unique_ptr<T>& p) = delete;~unique_ptr(){cout << "delete:" << _ptr << endl;delete _ptr;_ptr = nullptr;}T& operator*() { return *_ptr; }T* operator->() { return _ptr; }private:T* _ptr;
};

在拷贝构造函数和赋值重载函数后加上delete，表示不能调用该函数，并且不能定义该函数。unique用这种简单粗暴的方式解决智能指针的拷贝问题，带来的缺陷是：unique独自占有资源，即不能使用拷贝构造和赋值，每一个unique都指向不同的资源。

其它

禁止复制语义也存在特例，即可以通过一个函数返回一个 std::unique_ptr：

#include <memory>std::unique_ptr<int> func(int val)
{std::unique_ptr<int> up(new int(val));return up;
}int main()
{std::unique_ptr<int> sp1 = func(123);return 0;
}

上述代码从 func 函数中得到一个 std::unique_ptr 对象，然后返回给 sp1。

既然 std::unique_ptr 不能复制，那么如何将一个 std::unique_ptr 对象持有的堆内存转移给另外一个呢？答案是使用移动构造，示例代码如下：

#include <memory>int main()
{std::unique_ptr<int> sp1(std::make_unique<int>(123));std::unique_ptr<int> sp2(std::move(sp1));std::unique_ptr<int> sp3;sp3 = std::move(sp2);return 0;
}

以上代码利用 std::move 将 sp1 持有的堆内存（值为 123）转移给 sp2，再把 sp2 转移给 sp3。最后，sp1 和 sp2 不再持有堆内存的引用，变成一个空的智能指针对象。并不是所有的对象的 std::move 操作都有意义，只有实现了移动构造函数（Move Constructor）或移动赋值运算符（operator =）的类才行，而 std::unique_ptr 正好实现了这二者，以下是实现伪码：

template<typename T, typename Deletor>
class unique_ptr
{//其他函数省略...
public:unique_ptr(unique_ptr&& rhs){this->m_pT = rhs.m_pT;//源对象释放rhs.m_pT = nullptr;}unique_ptr& operator=(unique_ptr&& rhs){this->m_pT = rhs.m_pT;//源对象释放rhs.m_pT = nullptr;return *this;}private:T*    m_pT;
};

std::unique_ptr 不仅可以持有一个堆对象，也可以持有一组堆对象，示例如下：

#include <iostream>
#include <memory>int main()
{//创建10个int类型的堆对象//形式1std::unique_ptr<int[]> sp1(new int[10]);//形式2std::unique_ptr<int[]> sp2;sp2.reset(new int[10]);//形式3std::unique_ptr<int[]> sp3(std::make_unique<int[]>(10));for (int i = 0; i < 10; ++i){sp1[i] = i;sp2[i] = i;sp3[i] = i;}for (int i = 0; i < 10; ++i){std::cout << sp1[i] << ", " << sp2[i] << ", " << sp3[i] << std::endl;}return 0;
}
// 结果如下：
0, 0, 0
1, 1, 1
2, 2, 2
3, 3, 3
4, 4, 4
5, 5, 5
6, 6, 6
7, 7, 7
8, 8, 8
9, 9, 9

std::shared_ptr 和 std::weak_ptr 也可以持有一组堆对象，用法与 std::unique_ptr 相同。

std::shared_ptr

shared_ptr允许拷贝智能指针，其采用了计数的方式进行拷贝，只有一个指针指向资源时，计数为1，两个指针指向，计数为2，以此类推。对象析构时，只要将计数减一，如果减一后的计数为0，说明该对象是指向资源的最后一个对象，需要完成资源的释放。

注意：shared_ptr中又存储了一个指向_count的指针，在拷贝构造后，两对象的_ptr指向同一块空间，需要将_count的值+1，达到计数增加的效果。
 

template <class T>
class shared_ptr
{
public:shared_ptr(T* ptr): _ptr(ptr), _pCount(new int(1)){}shared_ptr(const shared_ptr<T>& p){_ptr = p._ptr;_pCount = p._pCount;(*_pCount)++;}void Release()	{if (--(*_pCount) == 0) // 当计数为0，需要释放pCount{if (_ptr) // 如果_ptr为空，只要释放pCount{delete _ptr;_ptr = nullptr;}cout << "~shared_ptr()" << endl;delete _pCount;_pCount = nullptr;}}shared_ptr<T>& operator=(const shared_ptr<T>& p){// 指向资源不同时，使两指针指向同一资源，并且计数增加if (_ptr != p._ptr) // 当指向资源相同时，没有必要进行赋值{Release(); // 先释放该指针之前指向的空间_ptr = p._ptr;_pCount = p._pCount;* _pCount++;}}~shared_ptr(){Release();}T& operator*() { return *_ptr; }T* operator->() { return _ptr; }private:T* _ptr;int* _pCount;
};

下面是一个初始化 std::shared_ptr 的示例：

//初始化方式1
std::shared_ptr<int> sp1(new int(123));//初始化方式2
std::shared_ptr<int> sp2;
sp2.reset(new int(123));//初始化方式3
std::shared_ptr<int> sp3;
sp3 = std::make_shared<int>(123);

例子：

#include <iostream>
#include <memory>class A
{
public:A(){std::cout << "A constructor" << std::endl;}~A(){std::cout << "A destructor" << std::endl;}
};int main()
{{//初始化方式1std::shared_ptr<A> sp1(new A());std::cout << "use count: " << sp1.use_count() << std::endl;//初始化方式2std::shared_ptr<A> sp2(sp1);std::cout << "use count: " << sp1.use_count() << std::endl;sp2.reset();std::cout << "use count: " << sp1.use_count() << std::endl;{std::shared_ptr<A> sp3 = sp1;std::cout << "use count: " << sp1.use_count() << std::endl;}std::cout << "use count: " << sp1.use_count() << std::endl;}return 0;
}
// 结果如下：
A constructor
use count: 1
use count: 2
use count: 1
use count: 2
use count: 1
A destructor

执行过程如下：

  • 上述代码 22 行 sp1 构造时，同时触发对象 A 的构造，因此 A 的构造函数会执行；
  • 此时只有一个 sp1 对象引用 22 行 new 出来的 A 对象（为了叙述方便，下文统一称之为资源对象 A），因此代码 24 行打印出来的引用计数值为 1；
  • 代码 27 行，利用 sp1 拷贝一份 sp2，导致代码 28 行打印出来的引用计数为 2；
  • 代码 30 行调用 sp2 的 reset() 方法，sp2 释放对资源对象 A 的引用，因此代码 31 行打印的引用计数值再次变为 1；
  • 代码 34 行 利用 sp1 再次 创建 sp3，因此代码 35 行打印的引用计数变为 2；
  • 程序执行到 36 行以后，sp3 出了其作用域被析构，资源 A 的引用计数递减 1，因此 代码 38 行打印的引用计数为 1；
  • 程序执行到 39 行以后，sp1 出了其作用域被析构，在其析构时递减资源 A 的引用计数至 0，并析构资源 A 对象，因此类 A 的析构函数被调用。

问题

虽然shared_ptr比其他智能指针完美（因为支持了拷贝构造和赋值），但其存在一个问题：循环引用。假设现在有Node这样一个类，有三个成员，两个分别指向前后节点的智能指针，一个保存数据的成员变量_val。当申请了Node类型的资源后，用shared_ptr托管，此时的智能指针可以正常的释放资源。

struct Node
{Node(): _prev(nullptr), _next(nullptr), _val(0){}myPtr::shared_ptr<Node> _prev;myPtr::shared_ptr<Node> _next;int _val;
};int main()
{myPtr::shared_ptr<Node> p1(new Node);myPtr::shared_ptr<Node> p2(new Node);// p1->_next = p2;// p2->_prev = p1;return 0;
}

当两智能指针没有产生连接时，p1和p2的计数都为1，释放资源正常。

但是当p1指针的_next指向p2，p2的_prev指向p1后，资源就不能正常释放，产生了内存泄漏。

当它们产生连接后，p1的_next也是一个智能指针，将_next指向p2，相当于shared_ptr的一次赋值，此时的p2计数为2，p2的_prev指向p1后，p1的计数也为2。当main函数指向完，p1和p2的生命周期结束，自动调用其析构函数，但其析构函数是根据计数决定是否析构，两指针的计数都为2，析构后只是将计数减小为1，并没有释放资源。

此时要释放p1的资源，就要释放p2的_prev，_prev作为Node类的成员，只有Node类释放时才会被释放，所以现在要释放p2，而要释放p2就要释放p1的_next，要释放_next就要释放p1，这就回到了开头的问题。对于循环引用的问题，需要使用weak_ptr来解决。

std::weak_ptr

weak_ptr是解决shared_ptr循环引用问题的关键，用shared_ptr作为Node的前后指针类型，使得Node的前后指针也参与了资源的管理，weak_ptr作为弱指针，即不参与资源的管理，只是用来指向资源，类似于容器里的迭代器。

template <class T>
class weak_ptr
{
public:weak_ptr(T* ptr):_ptr(ptr){}weak_ptr(weak_ptr<T>& p){_ptr = p._ptr;}weak_ptr<T>& operator=(weak_ptr<T>& p){_ptr = p._ptr;return *this;}weak_ptr<T>& operator=(shared_ptr<T>& p){_ptr = p.get();return *this;}T& operator*() { return *_ptr; }T* operator->() { return _ptr; }private:T* _ptr;
};// Node的前后指针类型改为weak_ptr	
struct Node
{Node(): _prev(nullptr), _next(nullptr), _val(0){}myPtr::weak_ptr<Node> _prev;myPtr::weak_ptr<Node> _next;int _val;
};

std::weak_ptr 可以从一个 std::shared_ptr 或另一个 std::weak_ptr 对象构造，std::shared_ptr 可以直接赋值给 std::weak_ptr ，也可以通过 std::weak_ptr 的 lock() 函数来获得 std::shared_ptr。它的构造和析构不会引起引用计数的增加或减少。std::weak_ptr 可用来解决 std::shared_ptr 相互引用时的死锁问题（即两个std::shared_ptr 相互引用，那么这两个指针的引用计数永远不可能下降为 0， 资源永远不会释放）。

#include <iostream>
#include <memory>int main()
{//创建一个std::shared_ptr对象std::shared_ptr<int> sp1(new int(123));std::cout << "use count: " << sp1.use_count() << std::endl;//通过构造函数得到一个std::weak_ptr对象std::weak_ptr<int> sp2(sp1);std::cout << "use count: " << sp1.use_count() << std::endl;//通过赋值运算符得到一个std::weak_ptr对象std::weak_ptr<int> sp3 = sp1;std::cout << "use count: " << sp1.use_count() << std::endl;//通过一个std::weak_ptr对象得到另外一个std::weak_ptr对象std::weak_ptr<int> sp4 = sp2;std::cout << "use count: " << sp1.use_count() << std::endl;return 0;
}
// 结果如下：
use count: 1
use count: 1
use count: 1
use count: 1

无论通过何种方式创建 std::weak_ptr 都不会增加资源的引用计数，因此每次输出引用计数的值都是 1。

既然，std::weak_ptr 不管理对象的生命周期，那么其引用的对象可能在某个时刻被销毁了，如何得知呢？std::weak_ptr 提供了一个 expired() 方法来做这一项检测，返回 true，说明其引用的资源已经不存在了；返回 false，说明该资源仍然存在，这个时候可以使用 std::weak_ptr 的 lock() 方法得到一个 std::shared_ptr 对象然后继续操作资源。

参考：

https://github.com/balloonwj/CppGuide/blob/master/articles/C%2B%2B%E5%BF%85%E7%9F%A5%E5%BF%85%E4%BC%9A%E7%9A%84%E7%9F%A5%E8%AF%86%E7%82%B9/%E8%AF%A6%E8%A7%A3C%2B%2B11%E4%B8%AD%E7%9A%84%E6%99%BA%E8%83%BD%E6%8C%87%E9%92%88.md

C++的RAII思想以及在智能指针上的应用-CSDN博客

相关新闻

网工内推 | 高级网工，H3C认证优先，朝九晚六，周末双休

网工内推 | 高级网工，H3C认证优先，朝九晚六，周末双休

01 万德 招聘岗位&#xff1a;高级网络工程师 职责描述&#xff1a; 1、项目交付&#xff1a;项目管理和交付&#xff0c;包括项目前期的规划、实施以及后期的运维支持、项目验收等。 2、技术支持&#xff1a;为客户及合作伙伴提供网上问题远程和现场支持&#xff1b;对公司内…

2026/7/10 3:13:39
力扣 | 322. 零钱兑换

力扣 | 322. 零钱兑换

这里使用动态规划&#xff0c;代码简洁更易理解 package _322;import java.util.Arrays;public class Problem_322_CoinChange {public int coinChange(int [] conins,int amount){//1. 状态定义&#xff0c;dp[i]表示凑齐金额为i的时候的最小硬币数量int dp [] new int[amoun…

2026/7/13 14:45:50
Semaphore信号量详解

Semaphore信号量详解

在Java并发编程中&#xff0c;Semaphore是一个非常重要的工具类。它位于java.util.concurrent包中&#xff0c;为我们提供了一种限制对临界资源的访问的机制。你可以将其视为一个同步控制的瑞士军刀&#xff0c;因为它既能够控制对资源的并发访问数量&#xff0c;也能够保证资源…

2026/7/11 23:56:49

最新新闻

从三边到三角：一个不等式如何揭示三角形的全部秘密

从三边到三角：一个不等式如何揭示三角形的全部秘密

1. 三角形形状判定的数学之美记得我第一次接触三角形形状判定时&#xff0c;被这个简单不等式的强大功能震撼到了。只需要比较ab和c的大小关系&#xff0c;就能准确判断三角形的类型&#xff0c;这种数学上的简洁美让人着迷。在实际应用中&#xff0c;无论是建筑测量、游戏开发…

2026/7/15 2:49:08
终极Lua反编译指南：用unluac轻松找回丢失的源代码

终极Lua反编译指南：用unluac轻松找回丢失的源代码

终极Lua反编译指南&#xff1a;用unluac轻松找回丢失的源代码 【免费下载链接】unluac fork from http://hg.code.sf.net/p/unluac/hgcode 项目地址: https://gitcode.com/gh_mirrors/un/unluac 你是否曾经面对一个只有字节码的Lua文件&#xff0c;却急需查看原始源代码…

2026/7/15 2:49:10
数据科学家的5个隐性工程能力：从能跑代码到生产级交付

数据科学家的5个隐性工程能力：从能跑代码到生产级交付

1. 这不是“Python技巧清单”&#xff0c;而是数据科学家的隐性能力图谱你翻过无数份Python数据科学教程&#xff0c;也刷过几十个“30个必学Pandas技巧”的合集&#xff0c;但总在真实项目里卡壳&#xff1a;代码跑通了&#xff0c;结果却和业务方预期差了一截&#xff1b;模型…

2026/7/15 2:49:10
从零到一：在UniApp App中集成高德地图SDK与核心功能实战

从零到一：在UniApp App中集成高德地图SDK与核心功能实战

1. 为什么选择高德地图SDK当你需要在UniApp中集成地图功能时&#xff0c;高德地图SDK是个非常靠谱的选择。我刚开始接触地图开发时也纠结过选哪家&#xff0c;后来发现高德在定位精度、地图渲染速度和功能完整性上都表现不错。特别是对于国内用户来说&#xff0c;高德的地图数据…

2026/7/15 2:49:10
C语言取地址符 `` 极简教程

C语言取地址符 `` 极简教程

一句话&#xff1a;& 就是 **"问地址"** —— 就像问快递柜"我的包裹在哪个格子里&#xff1f;"int a 10;printf("a 的值: %d\n", a); // 输出: 10 printf("a 的地址: %p\n", &a); // 输出: 0x7ffd... (十六进制地址…

2026/7/15 2:49:10
基于STM32与Proteus的酒精检测系统仿真实战：从传感器模拟到报警逻辑实现

基于STM32与Proteus的酒精检测系统仿真实战：从传感器模拟到报警逻辑实现

1. 酒精检测系统仿真设计概述酒精检测系统是智能安防和车载安全领域的重要应用。通过STM32单片机与MQ-3传感器的组合&#xff0c;我们可以快速检测环境中的酒精浓度&#xff0c;并在浓度超标时触发报警。但在实际开发中&#xff0c;频繁烧录芯片测试不仅效率低&#xff0c;还可…

2026/7/15 2:49:10

日新闻

Python ctypes性能优化实战：8大技巧突破C扩展速度瓶颈

Python ctypes性能优化实战：8大技巧突破C扩展速度瓶颈

1. 项目概述&#xff1a;当Python遇上C&#xff0c;速度瓶颈的破局之道“Python调用C太慢&#xff1f;”——这恐怕是很多在性能敏感场景下使用Python的开发者&#xff0c;尤其是那些尝试过用ctypes、CFFI或Cython来集成C/C代码的朋友&#xff0c;心中挥之不去的疑问。你兴冲冲…

2026/7/15 0:00:00
2026 年宜春诚信的塑料缠绕膜厂家哪个好,缠绕膜背后的秘密：你不知道的成本陷阱 - 领域鉴赏官

2026 年宜春诚信的塑料缠绕膜厂家哪个好,缠绕膜背后的秘密：你不知道的成本陷阱 - 领域鉴赏官

缠绕膜的秘密是什么，其中的成本陷阱又是怎样的一种情况呢在我们日常生活中的生产、仓储、运输等行业里经常要使用到塑料缠绕膜。你经营的是一个小小的电子产品制造公司，每天有无数电子产品的出货要装箱发货。你依旧用…

2026/7/15 0:00:00
TPS2551-Q1负载开关：汽车电子电源路径保护与智能管理实战

TPS2551-Q1负载开关：汽车电子电源路径保护与智能管理实战

1. 项目概述与核心价值在车载电子、便携设备乃至工业控制系统的电源路径设计中&#xff0c;我们工程师最头疼的问题之一&#xff0c;就是如何优雅且可靠地处理“意外”。你精心设计的5V电源轨&#xff0c;可能因为一个劣质USB设备的插入、一根内部短路的线缆&#xff0c;或者仅…

2026/7/15 0:00:43

周新闻

PlantUML 实战：5分钟将 UML 2.5 序列图转换为可执行代码草图

PlantUML 实战：5分钟将 UML 2.5 序列图转换为可执行代码草图

PlantUML 实战&#xff1a;5分钟将 UML 2.5 序列图转换为可执行代码草图 在软件开发过程中&#xff0c;清晰的系统设计往往比编码本身更为关键。传统拖拽式UML工具虽然直观&#xff0c;却常常成为效率杀手——频繁的鼠标操作打断设计思路&#xff0c;版本控制困难&#xff0c;…

2026/7/15 2:03:19
【RT-DETR涨点改进】29 动态Batch推理：让RT-DETR在低延迟下吃满GPU算力

【RT-DETR涨点改进】29 动态Batch推理：让RT-DETR在低延迟下吃满GPU算力

29 动态Batch推理：让RT-DETR在低延迟下吃满GPU算力 开篇故事 上个月帮一家安防厂商做项目优化，他们用RT-DETR做实时人流统计，部署在NVIDIA A10上。客户反馈说：“GPU利用率才30%，但延迟已经飙到40ms了，加人流量就丢帧。” 我远程一看，好家伙——生产环境里每个请求单独…

2026/7/14 3:20:10
Postman 环境变量实战：3种动态设置方法与CI/CD集成避坑指南

Postman 环境变量实战：3种动态设置方法与CI/CD集成避坑指南

Postman 环境变量高阶实战&#xff1a;动态管理与 CI/CD 深度集成在接口自动化测试领域&#xff0c;环境变量的灵活运用往往成为区分初级与高级测试工程师的关键能力。本文将深入探讨 Postman 环境变量的三种动态设置模式&#xff0c;并分享 Newman 在 CI/CD 流水线中的实战避坑…

2026/7/14 5:00:42

月新闻

[C++]内存管理：串顺序存储的内存回收

[C++]内存管理：串顺序存储的内存回收

在串&#xff08;字符串&#xff09;的顺序存储中&#xff0c;内存回收的方式取决于字符串的存储方式以及所使用的编程语言和相关库。以下以 C 为例进行说明&#xff0c;因为 C 对内存管理有较为直接的控制。 1. 基于 char 数组的串顺序存储 如果使用普通的 char 数组来存储字…

2026/7/14 17:38:00
移动端游戏功耗测试实战：电流、功率、亮度和场景对比

移动端游戏功耗测试实战：电流、功率、亮度和场景对比

移动端游戏功耗测试：先控制变量，再比较优化是否真的省电 摘要：功耗测试最容易犯的错误，是拿两次不同温度、不同亮度、不同场景的平均功率直接比较。本文给出一套可复现的游戏功耗测试方法，覆盖引擎特性验证、版本回归和黑盒体验测试，并说明如何把功耗与帧率、温控、CPU/G…

2026/7/14 5:33:13
足球口袋教练 HarmonyOS 离线应用实战（03/20）：ArkUI 首页仪表盘搭建

足球口袋教练 HarmonyOS 离线应用实战（03/20）：ArkUI 首页仪表盘搭建

本文是“足球口袋教练 HarmonyOS 离线应用实战”系列第 3 篇。示例项目是一个 HarmonyOS / ArkTS / ArkUI 编写的离线足球训练助手&#xff0c;围绕真实页面、真实截图和可复现操作展开。 本篇要解决的问题 训练 App 的首页不能只展示欢迎语&#xff0c;它要解决“我现在该点哪…

2026/7/15 2:03:22