子线程中慎用CString, std::string

最新推荐文章于 2025-01-16 17:50:24 发布
最新推荐文章于 2025-01-16 17:50:24 发布
阅读量3.1k 收藏 1
点赞数
文章标签： string mfc 多线程 fun winapi delete
本文探讨了在子线程中使用CString类导致内存泄漏的问题，特别是在非正常退出时。介绍了CString类的工作原理，并提供了几种解决方案，包括使用TCHAR、char、std::string或适当管理内存。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

 
今天CODING时遇到了内存泄露问题,发现原因在子线程中,当程序退出的时候,子线程被强行退出(非正常退出),导致内存泄露.于是开始调试,寻找,却没发现自己子线程中有任何的new或者malloc了,郁闷了很久也没找到原因.

突然,目光停留在了一行看上去再平常不过的代码.
一个子函数的调用:fun(str);
该函数的原型是
void fun(std::string xxxx).

问题居然就出在这个让人觉得再可靠不过的函数身上.
因为,在调用此函数过程中,行参需要被创建,COPY.然而string函数内部是会使用堆内存来存储字符的.在平时他很安全,因为他肯定会被析构,删除堆内存.然而在子线程非正常退出的情况下,就完全不同了.线程的非正常退出,只会删除string类本身所占的内存，也就是出栈,然而string的析构函数此时却不会被调用到了,因而导致在堆中创建的内存无法被正确删除.
由此想到,任何会创建堆内存的类,在子线程中都是危险的.几乎包括std,MFC中绝大多数类,对象.
就是简单的一句
CString str = "hello, world!", 在子线程中居然也成了极度危险任务.

解决的方法只有一个，不用，或者使用外部主线程中的这类对象.子线程函数参数一定要使用指针或者引用.
例如,上面的函数改成
void fun(const string&) 或者 void fun(string&)

回头看了一下windows核心编程中关于线程非正常退出的说明，这次有了更深的体会

按说一般局部变量是分配在stack上的，不会内存泄漏；
但是这个Cstring类型的变量就特殊了，“该管理器从进程堆（在 ATL 中）或 CRT 堆（在 MFC 中）分配内存。”既然分配在堆上，那就要回收。默认是到了该变量生存期结束的时候有管理器回收，但是如果你强行 ExitThread(0); 或者exit(0)，让该线程“不得好死”，自然就内存泄漏按说一般局部变量是分配在stack上的，不会内存泄漏；
但是这个Cstring类型的变量就特殊了，“该管理器从进程堆（在 ATL 中）或 CRT 堆（在 MFC 中）分配内存。”既然分配在堆上，那就要回收。默认是到了该变量生存期结束的时候有管理器回收，但是如果你强行 ExitThread(0); 或者exit(0)，让该线程“不得好死”，自然就内存泄漏

std::string也一样

////////////////////////////////////////////////////////////////////////////////////////

如果多线程编程中，多个线程用到了一个全局的CString, 这样是很危险的。

因为CString不是线程安全的，

CString只保证类级的线程安全,
要做到对象级别的线程安全,需要你自己进行同步,
也就是说,
可以同时有N个线程在读,
但是写的时候,必须保证没有任何线程"正在"读和写
才可以写入.
CString str;

CCriticalSection cs;
cs->Lock( );
str+="abcdefg";........
do anything you want
cs->Unlock( );  


 

多线程中CString内存泄漏的解决方法。

多线程导致的内存泄漏
DWORD WINAPI ConnectionWorkerProc(LPVOID pObject)
{
CString strPath;
CString strFileName;
CString currentStr;
TCHAR currentPath[512] = _T("");
TCHAR sendPfilePath[256] = _T("");
GetCurrentDirectory(sizeof(currentPath), currentPath);

strPath=CString(currentPath);
currentStr=CString(currentPath);
strFileName=strPath + strFileName;
CString strTest;
char test[30] = "sasdsdsaasd";
        strTest = CString(test);
        while{
             Sleep(30);
        }
}

      
f:\dd\vctools\vc7libs\ship\atlmfc\src\mfc\strcore.cpp(141) : {1500} normal block at

0x01A7D220, 40 bytes long.
Data: <, x            > 2C FB BF 78 0B 00 00 00 0B 00 00 00 01 00 00 00
f:\dd\vctools\vc7libs\ship\atlmfc\src\mfc\strcore.cpp(141) : {1498} normal block at

0x01A7E340, 46 bytes long.
Data: <, x            > 2C FB BF 78 0E 00 00 00 0E 00 00 00 01 00 00 00
f:\dd\vctools\vc7libs\ship\atlmfc\src\mfc\strcore.cpp(141) : {1497} normal block at

0x01A7DAB8, 46 bytes long.
Data: <, x            > 2C FB BF 78 0E 00 00 00 0E 00 00 00 01 00 00 00
f:\dd\vctools\vc7libs\ship\atlmfc\src\mfc\strcore.cpp(141) : {1496} normal block at

0x01A7CCD0, 46 bytes long.

一直到程序运行结束，线程函数都没有结束，在栈上没有弹出，导致了内存泄漏。
在转化和赋值的过程，CString内部分配了内存，但是由于该函数一直没有执行结束，CString内部申请的

内存便一直没有释放掉。

解决的方法：
1，当知道线程有可能或者确定不会结束，不要在线程中使用CString的copy,assignment,add,使用TCHAR

或者char的，strcat,strcpy等，或者使用std::string，也不会造成内存泄漏
2，使用CString的时候，new和delete,CString *pStr = new CString;用完了之后delete，也可以避免

 

我们用MFC开发时经常会用到CString类，无可否认，CString类是很好用，但很少人注意到CString类不是线程安全的。一般地，界面编程都是在主线程，很少用到多线程，所以不会遇到什么问题。但是，当我们多个线程同时操作同一个CString类型变量时，就可能会出现内存地址错误，最终导致进程异常退出。内存错误导致的问题也很难调查，通常导致内存错误的地方没有马上报异常，而且在程序的其他地方才捕获异常。

CString类的Debug版本和Release版本不完全一样，Debug版本则直接分配（MFC在Debug版本有内存管理，主要是为了排错，内存泄漏等），CString类在Release版本会使用定长内存管理（CFixedAlloc类），主要管理是4个长度的内存，如下：1AFX_STATIC CFixedAlloc _afxAlloc64(ROUND4(65*sizeof(TCHAR)+sizeof(CStringData)));

2AFX_STATIC CFixedAlloc _afxAlloc128(ROUND4(129*sizeof(TCHAR)+sizeof(CStringData)));

3AFX_STATIC CFixedAlloc _afxAlloc256(ROUND4(257*sizeof(TCHAR)+sizeof(CStringData)));

4AFX_STATIC CFixedAlloc _afxAlloc512(ROUND4(513*sizeof(TCHAR)+sizeof(CStringData)));这样做应该是防止内存碎片和提高效率，由于CString类都会重用分配的定长内存，所以一般异常的地方大多数也是在CString操作的地方。有兴趣可以看看CString类的实现。

避免这样的问题最简单的办法就是加锁或者不用CString类。加锁用临界区就可以，实现比较简单，在这里不多说。


 

牛 魔 王
关注
C++多线程--std::thread
qls315的博客
08-14 1434
在C++多线程专栏中，我讲解了std::async,std::future,std::promise以及内存序相关概念，基本上涵盖了C++事件处理相关的基本构建块。为了保证对C++多线程中相关线程概念的全部介绍，后期会增加相应的std::thread, std::mutex, std::lock_guard, std::unique_lock等相关介绍。而本文便是第一部分，std::thread的相关介绍和使用讲解。一个std::thread代表一个可执行单元。简单来说下面是四种创建线程的方式 若你构建
C ++：将MFC CString转换为std :: string
04-06
在UNICODE中：CString str = L“ Test”; std :: wstring ws（str）; std :: string s; s.assign（ws.begin（），ws.end（））;
CString、std::string格式化字符串
人在旅途/章鸽 的专栏
12-12 8698
=============================CString================================== 当有多个字串时，比如     int   n1   =   5;     int   n2   =   10;     char   sz1[]   =   "abcdefg";     char   sz2[]   =   "hijklmn";    
CString与std::string相互转换
热门推荐
Pc620的专栏
04-29 2万+
<br />之前在用MFC编Bayes时遇到一个问题，就是CString与std::string的相互转换，后来发现转换方法其实很简单，就是直接利用这两个类的构造函数。当然，在做参数传入时，CString得通过(LPCTSTR)转换一下，而std::string则需调用c_str()函数：<br /> <br />CString转成std::string：<br />CString cs("Hello");<br />std::string s((LPCTSTR)cs);<br /> <br /> <br
CString转换成std::string
weixin_30883777的博客
07-09 366
unicode的编码格式： CString strCS; std::string strSTD =CT2A(strCS.GetBuffer()); 其他的编码格式： CString strCS; std::string strSTD = strCS.GetBuffer(...
CString在多线程中的问题
Think88666的博客
05-17 640
闲来没事，聊聊CString在多线程中很容易踩的坑，这个坑很可能存在于你现在的项目中。 举例： int main() { CString str = L"test"; CString strThread1 = str; CString strThread2 = str; //将两个参数传递到各自的线程中，以下使用伪代码 CThread thread1(strThread1); CThread thread2(strThread2); thread1.wait();
多线程c++实现（2）之向子线程中传数据（std::this_thread::get_id() 、 std::ref()）
请叫我少爷的博客
09-09 1923
上一个博客https://blog.youkuaiyun.com/shaochuang1/article/details/100302439介绍了创建多线程的几种方法，但是都是没有参数的那种，这篇博客我们来向子线程中传入参数。 #include <iostream> #include <thread> using namespace std; void Myprint(int...
std::async的使用
weixin_47326789的博客
08-26 1079
C++11提供了thread线程库,可以通过std::thread启动线程,同时也提供了std::async来执行异步任务。std::async与std::thread对象等待的方式不同,std::async会返回一个std::future对象，这个对象持有最终计算出来的结果,当需要这个值的时候，只需要调用这个对象的get()成员函数，并且会阻塞线程直到期望值状态变为就绪。
C++之std::bind()函数的使用
qq_44237695的博客
03-11 5622
C++ std::bind()函数的使用
C++11异步编程(std::async, std::future, std::packaged_task, std::promise)
Charles_Zaqdt的博客
02-08 966
std::async是一个函数模板，会启动一个异步任务，最终返回一个std::future对象。在之前我们都是通过thread去创建一个子线程，但是如果我们要得到这个子线程所返回的结果，那么可能就需要用全局变量或者引用的方法来得到结果，这样或多或少都会不太方便，那么async这个函数就可以将得到的结果保存在future中，然后通过future来获取想要得到的结果。async比起...
CString转std::string
Jane_Yih的博客
10-25 2074
std::string CString2String(CString cstr) { std::string strTemp = CT2A(cstr); return strTemp; }
cstring转为std::string
Sailor of World
09-16 583
sfile=(LPSTR)(LPCTSTR)strf;
Unicode字符集---MFC中CString与std::string转换
m0_64703894的博客
09-26 1907
MFC中CString与std::string转换
CString与std::string转换
chenzhisi的专栏
11-04 775
Ansi的情况： CString cs("Hello"); std::string s((LPCTSTR)cs); std::string s("Hello"); CString cs(s.c_str()); Unicode的情况： 把string都替换成wstring CString cs ("Hello"); // Convert a TCHAR string to a LPCST
实现CString到std::string的转换
fairypwq的专栏
04-18 1280
第一种：在新建MFC工程中如果选择了Unicode编码，用如下方法转换：下面一段程序可以实现CString到std::string的转换，主要用于MFC获取图像文件路径到OpenCV2.3读取图像的路径格式不同之间的转换size_t i; // 转换后的串中字符的个数 size_t buff = image.GetLength() * 2; // 因为是Unicode编码方式，所以每个字的存储
CString使用(多线程、线程安全)
优快云CShuan的博客
06-07 2859
CString的线程安全问题 在多线程中使用一个局部CString变量相加时发现相加的结果是后一个字符串值，没有时间过多研究，只好改成了char*，不过如下方法也可以避免： CWin32Heap stringHeap( HEAP_NO_SERIALIZE, 0, 0 ); CAtlStringMgr stringMgr( &stringHeap ); CString strstate(&s
CString与std::string的转换
lxcxuebao的专栏
11-17 1894
上面的这些转换与工程的编码格式无关，其中CStringA和std::string，CStringW和std::wstring 是相对应的，可以直接提取其内部的字串指针进行转换。在MFC中字串类是CString，std中是string、wstring,他们之间差别是内部包含的字符编码不一样，本文中介绍了几个微软的宏，可以轻松的对这几种字串进行转换。①:std::string内部是char单字节字符。②:std::wstring内部是WCHAR宽字符。其内部是char单字节字符。是与编码方式有关的宏定义。
C++实现CString和std::string的相互转换
CyberByte的博客
10-02 832
需要注意的是，当将std::string转换为CString时，CString只能访问到std::string的字符数据，而不能访问std::string的长度信息。要将std::string转换为CString，我们需要使用std::string的c_str()方法，该方法返回一个const char*指针，指向std::string的内部字符数组。要将CString转换为std::string，我们可以使用std::string的构造函数，它接受一个const char*类型的参数。
MFC中CString和std::string互转
qq_45059758的博客
01-16 152
原文链接
std::promise std::future是什么
最新发布
02-21
<think>嗯，用户之前问过如何在std::async创建子线程时立即获取线程号，我介绍了用promise和future的方法。现在他问这两个是什么，所以需要详细解释一下这两个的概念和用途。 用户可能对C++的并发编程不太熟悉，特别是异步操作部分。需要先明确std::promise和std::future的基本定义，然后说明它们如何协同工作。用户可能想知道它们解决了什么问题，或者为什么在之前的例子中需要用到它们。 可能需要用简单的例子来辅助说明，比如数据传递或线程间通信。还要注意用户可能对线程同步、数据共享等概念有疑问，需要解释promise和future如何帮助安全地传递数据，避免竞争条件。 另外，用户可能想知道两者的区别，比如promise是设置值的一方，future是获取值的一方。需要强调它们的一对一关系，以及一次性的特性，即只能设置一次值，获取一次结果。 可能还需要提到异常传递的情况，如果promise中设置了异常，future在get时会抛出，这也是处理异步错误的一种方式。用户可能在实际使用中遇到异常处理的问题，这部分要说明清楚。 最后，结合之前的例子，说明在获取线程ID的场景下，promise和future是如何传递线程ID的，这样用户能更好地理解它们的实际应用。可能还需要提醒一些注意事项，比如生命周期管理和移动语义，避免悬空引用或对象复制的问题。 总结来说，用户需要的是对promise和future的全面介绍，包括它们的作用、如何使用、以及在实际中的应用场景，同时结合之前的例子加深理解。</think>`std::promise` 和 `std::future` 是 C++11 标准中引入的并发编程工具，用于实现 **跨线程的数据传递** 和 **同步**。它们通常结合使用，允许一个线程生成数据（通过 `promise`），另一个线程异步获取数据（通过 `future`）。以下是它们的核心概念和用法： --- ### **1. `std::promise`** #### **作用** - **生产者端**：用于在子线程中存储一个值（或异常），并通知其他线程该值已就绪。 - **核心方法**： - `set_value()`：设置值（只能调用一次）。 - `set_exception()`：设置异常（如任务执行失败时的错误信息）。 - `get_future()`：返回与当前 `promise` 关联的 `future` 对象。 #### **特点** - 一个 `promise` 只能和一个 `future` 关联。 - 通过 `set_value` 或 `set_exception` 通知 `future` 数据已就绪。 --- ### **2. `std::future`** #### **作用** - **消费者端**：用于从异步操作中获取结果，支持阻塞或非阻塞的方式等待数据。 - **核心方法**： - `get()`：阻塞等待，直到数据就绪后返回结果（只能调用一次）。 - `wait()`：阻塞等待直到数据就绪。 - `wait_for()` / `wait_until()`：限时等待数据就绪。 - `valid()`：检查 `future` 是否关联有效的结果。 #### **特点** - `future` 只能通过 `promise` 或 `std::async` 创建。 - `get()` 会转移所有权，调用后 `future` 不再有效。 -- ### **3. 协作流程** ```cpp std::promise<T> promise; // 生产者创建 promise std::future<T> future = promise.get_future(); // 消费者获取 future // 子线程（生产者）设置值 std::thread([&promise] { promise.set_value(42); // 设置结果 }).detach(); // 主线程（消费者）等待结果 T result = future.get(); // 阻塞直到结果就绪 ``` -- ### **4. 核心应用场景** #### **(1) 跨线程传递数据** ```cpp std::promise<int> p; std::future<int> f = p.get_future(); std::thread([&p] { p.set_value(100); // 子线程设置值 }).detach(); int value = f.get(); // 主线程获取值（阻塞等待） ``` #### **(2) 异步任务结果获取** 结合 `std::async` 实现异步计算： ```cpp std::future<int> future = std::async([] { return 42; // 在子线程中计算 }); int result = future.get(); // 主线程获取结果 ``` #### **(3) 异常传递** 子线程的异常可以通过 `promise` 传递到主线程： ```cpp std::promise<void> p; std::future<void> f = p.get_future(); std::thread([&p] { try { // 子线程可能抛出异常 throw std::runtime_error("子线程错误"); } catch (...) { p.set_exception(std::current_exception()); // 传递异常 } }).detach(); try { f.get(); // 主线程捕获异常 } catch (const std::exception& e) { std::cout << "捕获异常: " << e.what() << std::endl; } ``` --- ### **5. 关键特性** #### **(1) 一次性所有权** - `promise` 和 `future` 是一对一的关系，一个 `promise` 只能设置一次值，一个 `future` 只能调用一次 `get()`。 #### **(2) 线程安全** - `promise` 和 `future` 的方法本身是线程安全的，但需注意共享数据的竞态条件。 #### **(3) 移动语义** - `promise` 和 `future` 不可复制，但可以通过 `std::move` 转移所有权： ```cpp std::promise<int> p1; std::promise<int> p2 = std::move(p1); // 转移所有权 ``` --- ### **6. 与 `std::async` 的关系** - `std::async` 返回的 `future` 会自动关联到异步任务的结果： ```cpp std::future<int> f = std::async([] { return 42; }); int result = f.get(); // 获取结果 ``` - 若需要手动控制结果的传递（如传递线程号），需显式使用 `promise`。 --- ### **7. 示例：线程间传递复杂数据** ```cpp #include <iostream> #include <future> #include <thread> void task(std::promise<std::string> p) { std::this_thread::sleep_for(std::chrono::seconds(1)); p.set_value("子线程完成任务"); // 传递字符串 } int main() { std::promise<std::string> p; std::future<std::string> f = p.get_future(); std::thread(task, std::move(p)).detach(); std::cout << "主线程等待结果..." << std::endl; std::string result = f.get(); // 阻塞等待 std::cout << "结果: " << result << std::endl; return 0; } ``` --- ### **总结** - **`std::promise`**：生产者端工具，负责设置值或异常。 - **`std::future`**：消费者端工具，负责异步获取结果。 - **协作机制**：通过共享状态实现线程间数据同步，避免手动使用锁或条件变量。 - **适用场景**：异步任务结果传递、跨线程通信、异常处理等。 它们为 C++ 提供了一种高效、安全的异步编程范式，是并发编程的重要基础组件。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值