相对printf()，对于多线程的cout<<输出乱码的问题

最新推荐文章于 2025-07-12 17:49:05 发布

原创最新推荐文章于 2025-07-12 17:49:05 发布 · 2k 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#多线程

并行设计专栏收录该内容

2 篇文章

订阅专栏

本文探讨了printf()函数与cout对象的区别。printf()属于标准C库，而cout是C++标准库的一部分，为ostream类的一个实例。文章指出，在考虑线程同步问题时，使用printf()更为高效；cout虽然提供更丰富的功能，但输出速度相对较慢。

首先从他们各自本身出发，printf()是一个函数，而cout是预定义ostream一个对象。

因此就涉及到了对象线程同步问题。

则在使用打印输出时，应该考虑到这个问题。简单的话直接用printf()输出，而采用同步互斥进行cout会进一步增加编译处理时间。从而影响效率。另外cout输出确实比printf()慢呐，编个小程序输出下就会有很大感触。

确定要放弃本次机会？

福利倒计时

: :

立减 ¥

普通VIP年卡可用

立即使用

xcaoco

关注关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
分享

复制链接

分享到 QQ

分享到新浪微博

扫一扫
举报

举报

专栏目录

c++ 多线程屏幕输出会乱，且无法定位问题

m0_56306892的博客

11-16

154

为每个线程创建一个日志文件。

多线程下控制台输出乱序的问题

huanggang982的专栏

12-21

3733

我看到很多人对这样一个问题寻求帮助：在多线程时，往控制台窗口输出的内容是乱序的。举个非常简单的例子，如下： #include "stdafx.h" #include using namespace std; DWORD WINAPI ThreadProc1( LPVOID lpParameter

参与评论您还未登录，请先登录后发表或查看评论

面试题-C++多线程打印的问题

HyaZz_的博客

08-24

1045

面试中的一道涉及多线程打印的问题，本文给出了博主的思考和办法。还请读者朋友仁者见仁，智者见智，多多指导交流

C++两个线程交替打印

SunrayME的专栏

06-17

2078

#include <iostream> #include <condition_variable> using namespace std; mutex mtx; condition_variable cond_var; bool flag = true; void fun1() { while (1) { this_thread::sleep_for(chr...

C++控制台输出中文时乱码的解决方案

田螺姑娘的博客

10-31

1万+

C++控制台输出中文时乱码的解决方案起因使用cmd程序进行编码和C++程序编码（源文件编码）不同。cmd程序默认的编码格式是gbk，而C++程序编码格式是utf-8。解决方案 1、C++源代码里更改cmd编码源码实例： #include <iostream> using std::cout; using std::endl; using std::cin; int main() { system("chcp 65001"); cout << "测试" <<

【问题记录】多线程环境下，使用 std::cout 输出内容会显示混乱

weixin_43729127的博客

07-03

1154

多线程环境下，使用 std::cout 输出内容会显示混乱，因为std::cout是不具有原子性，不是线程安全的

qDebug() << "本次循环间隔：" << interval << "ms";改成printf输出

03-26

在多线程中使用 `printf` 时需加锁： ```cpp #include <mutex> std::mutex print_mutex; { std::lock_guard<std::mutex> lock(print_mutex); printf(...); } ``` 3. **性能敏感场景优化** 减少格式化...

那cout和printf呢

03-03

| 混合类型输出 | `cout` | `cout << a << " " << b`比`printf`多次调用更简洁 | | 需要本地化（如数字千分位）| `cout` + `<locale>` | 流式输出更容易集成本地化设置 | --- ### **5. 关键陷阱** #### **`printf`...

分析下下面的代码：XAFS_CSDKResult GeneralTypeControllerSDK::SocketSendMessage(SOCKET socket, const int * Protocol, unsigned int memSize,int waitTime) { //开始之前先进行设置 m_ReceiveCmdSuccedFlag = false; GInterface::Instance()->g_OrderSign = 0; GInterface::Instance()->g_AddrSign = 0; unsigned char buffer[1024] = { 0 }; m_WriteAddr = Protocol[2]; for (int i = 0; i < memSize; i++) { //调用调换大小端问题 uint32_t swapped = swapEndian(Protocol[i]); memcpy(buffer + i * sizeof(int), &swapped, sizeof(int)); } if (send(socket, (char*)buffer, memSize, 0) < 0) { cout << "发送失败！" << endl; return ERR_SOCKET; } else { cout << "发送成功！" << endl; DWORD tick = ::GetTickCount(); while (true) { if (::GetTickCount() - tick > waitTime) { /*delete m_ReturnData; m_ReturnData = nullptr;*/ return ERR_TIMEOUT; } /*else if(m_ReceiveCmdSuccedFlag) { return ERR_OK; }*/ else { /*cout << "GInterface::Instance()->g_OrderSign==" << GInterface::Instance()->g_OrderSign<<endl; cout << "GInterface::Instance()->g_AddrSign==" << GInterface::Instance()->g_AddrSign << endl;*/ if (GInterface::Instance()->g_OrderSign == STATUS_INST) { return ERR_OK; } else if ((GInterface::Instance()->g_OrderSign == Protocol[1])&&(GInterface::Instance()->g_AddrSign == Protocol[2])) { return ERR_OK; } else if ((GInterface::Instance()->g_OrderSign == FDBK_INST) &&(GInterface::Instance()->g_AddrSign == Protocol[2])) { return ERR_OK; } } GInterface::Instance()->MsSleep(10); } } } XAFS_CSDKResult GeneralTypeControllerSDK::SocketSendNoWaitData(SOCKET socket, const int* Protocol, unsigned int memSize) { //开始之前先进行设置 m_ReceiveCmdSuccedFlag = false; unsigned char buffer[1024] = { 0 }; m_WriteAddr = Protocol[2]; for (int i = 0; i < memSize; i++) { //调用调换大小端问题 uint32_t swapped = swapEndian(Protocol[i]); memcpy(buffer + i * sizeof(int), &swapped, sizeof(int)); } if (send(socket, (char*)buffer, memSize, 0) < 0) { //cout << "发送失败！" << endl; return ERR_SOCKET; } else { //cout << "发送成功！" << endl; return ERR_OK; } } XAFS_CSDKResult GeneralTypeControllerSDK::SocketSendRemoteUp(SOCKET socket, const char * data, unsigned int binSize) { if (send(socket, (char*)data, binSize, 0) < 0) { cout << "发送失败！" << endl; return ERR_SOCKET; } else { //cout << "发送远程升级bin进网络端成功！" << endl; return ERR_OK; } } //线程中不断的读取网口中的数据 void GeneralTypeControllerSDK::SocketLisntenThread() { unsigned char rec_Buffer[8192] = { 0 }; cout << " enter SocketLisntenThread1111111====" << endl; while (m_ListenFlag) { int recvLength = recv(m_SocketClient, (char*)rec_Buffer, sizeof(rec_Buffer), 0); cout << "实际接收==recvLength===" << recvLength << endl; if (recvLength < 0) { cout << "接受失败！通信断开" << endl; break; } else if (recvLength == 0) { cout << "服务器已主动断开连接" << endl; } else { //组数进缓存区 m_BufferMutex.lock(); memmove(m_RawDataBuff + m_RawLength, rec_Buffer, recvLength); m_RawLength += recvLength; cout << "服务端信息:" << rec_Buffer << endl; cout << "recvLength==" << recvLength << endl; //for (int i = 0; i< recvLength;i++) //{ // printf("11111111111111recvLength==%x\n", rec_Buffer[i]); //} m_BufferMutex.unlock(); } //每隔20ms读取网口一次 Sleep(20); } } //线程中不断的尝试过滤读取到的数据 void GeneralTypeControllerSDK::SocketFilterDataThread() { unsigned char dealData[8192] = { 0 }; bool b_findHead = false; cout << " enter SocketFilterDataThread2222222===" << endl; while (m_HandDataFlag) { m_BufferMutex.lock(); //接收到的数据一定比协议数据最短包大 if (m_RawLength < MIN_BAG) { m_BufferMutex.unlock(); Sleep(20); continue; } //寻找头字节 int offset = 0; b_findHead = false; //判断容器内第一个数据 if ((m_RawDataBuff[0] == HEAD_ID1) && (m_RawDataBuff[1] == HEAD_ID2) && (m_RawDataBuff[2] == HEAD_ID3) && (m_RawDataBuff[3] == HEAD_ID4)) { b_findHead = true; } /***************找数据包头的过程***********/ if (!b_findHead) { //循环遍历找包头 while (((m_RawDataBuff[offset] != HEAD_ID1) || (m_RawDataBuff[offset + 1] != HEAD_ID2) || (m_RawDataBuff[offset + 2] != HEAD_ID3) || (m_RawDataBuff[offset + 3] != HEAD_ID4)) && (offset < (m_RawLength - 4))) { offset++; } //找包头的位置是数据容器的尾部， if (offset >= (m_RawLength - 4)) { m_BufferMutex.unlock(); m_RawLength = 0; Sleep(20); continue; } //整体搬运，清理无效数据,提取有效的部分 if (offset > 0) { m_RawLength -= offset; memmove(m_RawDataBuff, m_RawDataBuff + offset, m_RawLength); if (m_RawLength < MIN_BAG) { m_BufferMutex.unlock(); Sleep(20); continue; } } } /*********************************************************************************/ //获取完整包长度加上头和长度部分的大小 int ActualLength = 0; /*if((g_RawDataBuff[offset] != HEAD_ID1) && (g_RawDataBuff[offset + 1] != HEAD_ID2)) {}*/ //判断帧标识[4]/[5]/[6]/[7],判断帧标识是：写返回/读返回/批量返回/ //重新定义length的长度，确定最终读与写都是20，但是批量的需要自己判断，是否需要判断 if ((m_RawDataBuff[4] == WRITE_TYPE1) && (m_RawDataBuff[5] == WRITE_TYPE2) && (m_RawDataBuff[6] == WRITE_TYPE3) && (m_RawDataBuff[7] == WRITE_TYPE4)) { ActualLength = 20; } /*else if ((m_RawDataBuff[4] == READ_TYPE1) && (m_RawDataBuff[5] == READ_TYPE2) && (m_RawDataBuff[6] == READ_TYPE3) && (m_RawDataBuff[7] == READ_TYPE4)) { ActualLength = 20; }*/ else if ((m_RawDataBuff[4] == FBACK_TYPE1) && (m_RawDataBuff[5] == FBACK_TYPE2) && (m_RawDataBuff[6] == FBACK_TYPE3) && (m_RawDataBuff[7] == FBACK_TYPE4)) { ActualLength = 20; } else if ((m_RawDataBuff[4] == DEVICE_STATEFLOW1) && (m_RawDataBuff[5] == DEVICE_STATEFLOW2) && (m_RawDataBuff[6] == DEVICE_STATEFLOW3) && (m_RawDataBuff[7] == DEVICE_STATEFLOW4)) { //状态查询数据流 unsigned char dataLength = m_RawDataBuff[15]; int totalLength = 16 + dataLength; ActualLength = totalLength; //cout << "dataLength11111===" << dataLength << endl; //printf("dataLength111= %d\n",dataLength); //cout << "ActualLength11111===" << ActualLength << endl; } else { // 补充：未知包类型，跳过当前字节（避免死锁） m_RawLength--; memmove(m_RawDataBuff, m_RawDataBuff + 1, m_RawLength); m_BufferMutex.unlock(); Sleep(20); continue; } //else if ((m_RawDataBuff[4] == SYNC_DATAFLOW1) && (m_RawDataBuff[5] == SYNC_DATAFLOW2) // && (m_RawDataBuff[6] == SYNC_DATAFLOW3) && (m_RawDataBuff[7] == SYNC_DATAFLOW4)) //{ // //状态同步数据流 // unsigned char dataLength = m_RawDataBuff[15]; // int totalLength = 16 + dataLength*8 + 8; // ActualLength = totalLength; //} //cout << "ActualLength1111==" << ActualLength; //如果获取的数据长度不满足一包的长度，则等待一会后重新解析 if (m_RawLength < ActualLength) { m_BufferMutex.unlock(); Sleep(20); continue; } //判断帧尾,有问题清理重新开始 if ((m_RawDataBuff[ActualLength - 4] != TAIL_ID1) || (m_RawDataBuff[ActualLength - 3] != TAIL_ID2) || (m_RawDataBuff[ActualLength - 2] != TAIL_ID3) || (m_RawDataBuff[ActualLength - 1] != TAIL_ID4)) { m_BufferMutex.unlock(); m_RawLength -= ActualLength; memmove(m_RawDataBuff, m_RawDataBuff + ActualLength, m_RawLength); if (m_RawLength < MIN_BAG) { m_BufferMutex.unlock(); Sleep(20); continue; } } //清空待处理数据 memset(dealData, 0, sizeof(dealData)); //复制有效包数据到待处理缓冲中 memcpy(dealData, m_RawDataBuff, ActualLength); m_RawLength -= ActualLength; cout << "ActualLength2222==" << ActualLength<<endl; //cout << "m_RawLength2222==" << m_RawLength; //单条指令帧进行收发，不需要进行和校验 int getCheckSum = (dealData[ActualLength - 8] << 24) | (dealData[ActualLength - 7] << 16) | (dealData[ActualLength - 6] << 8) | (dealData[ActualLength - 5]); uint32_t actualChecksum = 0; if (((m_RawDataBuff[4] == DEVICE_STATEFLOW1) && (m_RawDataBuff[5] == DEVICE_STATEFLOW2) && (m_RawDataBuff[6] == DEVICE_STATEFLOW3) && (m_RawDataBuff[7] == DEVICE_STATEFLOW4))) { // 确保不会越界访问，i+3 < dataLength-8 for (int i = 0; (i + 3) < (ActualLength - 8); i += 4) { // 修正了最后一个字节的索引错误 uint32_t j = (dealData[i] << 24) | (dealData[i + 1] << 16) | (dealData[i + 2] << 8) | dealData[i + 3]; actualChecksum += j; } if (getCheckSum != actualChecksum) { printf("sumError==%x\n"); continue; } } //从原始数据缓冲中移除有效包数据 memcpy(m_RawDataBuff, m_RawDataBuff + ActualLength, m_RawLength); //包长度小于最小包长度时，直接返回重新解析 if (ActualLength < MIN_BAG) { continue; } //在应用层处理合法的数据包，开始解析一包正常的数据 //将数据进行回传处理 //memcpy(m_ReturnData, dealData, ActualLength); //*returnLength = length; cout << "ActualLength===" << ActualLength << endl; for (int k = 0; k < ActualLength; k++) { //printf("dealData==%x\n", dealData[i]); } //对数据进行分类过滤 this->FilterData(dealData); //结束加锁 m_BufferMutex.unlock(); } } unsigned int GeneralTypeControllerSDK::JointHexData(unsigned char *pData) { unsigned int data = (*(pData + 0) << 24) | (*(pData + 1) << 16) | (*(pData + 2) << 8) | (*(pData + 3)); return data; } void GeneralTypeControllerSDK::FilterData(unsigned char * pData) { //int cmd = (pData[4]<<24)|(pData[5] << 16)|(pData[6] << 8)|(pData[7]); //int regAddr = (pData[8] << 24) | (pData[9] << 16) | (pData[10] << 8) | (pData[11]); //m_ReturnValue = (pData[12] << 24) | (pData[13] << 16) | (pData[14] << 8) | (pData[15]); int cmd = JointHexData(&pData[4]); int regAddr = JointHexData(&pData[8]); m_ReturnValue = JointHexData(&pData[12]); int registerNum = JointHexData(&pData[12]); int byteNum = JointHexData(&pData[12]); cout << "m_ReturnValue===" << m_ReturnValue << endl; if (cmd == WRITE_INST) { //写入返回值寄存器值 if (m_WriteAddr == regAddr) { m_ReceiveCmdSuccedFlag = true; GInterface::Instance()->g_AddrSign = regAddr; GInterface::Instance()->g_OrderSign = cmd; } } else if (cmd == FDBK_INST) { //读返回值寄存器值 if (m_WriteAddr == regAddr) { m_ReceiveCmdSuccedFlag = true; GInterface::Instance()->g_AddrSign = regAddr; GInterface::Instance()->g_OrderSign = cmd; } } else if (cmd == STATUS_INST) { GInterface::Instance()->g_OrderSign = cmd; int count = 0; int syncEnd = byteNum+16-8-4; GInterface::Instance()->g_GetSyncFlag = false; for (int i = STATUS_START; i <= syncEnd; i= i+4) { int data = JointHexData(&pData[i]); StateDataArr[count] = data; count++; } GInterface::Instance()->g_GetStateFlag = true; m_ReceiveCmdSuccedFlag = true; } }

最新发布

10-22

- 在接收线程中，打印接收到的数据（cout << "服务端信息:" << rec_Buffer << endl;）可能不安全，因为rec_Buffer可能不是字符串（没有'\0'结尾），导致打印乱码或内存越界。另外，打印二进制数据对调试帮助不大，...

print和cout的区别

08-16

C++ 宏定义打印日志

shuizhizhiyin的专栏

09-05

861

该类提供了 `addTask` 方法以添加任务队列，并使用条件变量 `cond_` 唤醒空闲线程来执行任务。在宏定义中，使用线程池的 `ThreadPoo::addTask` 方法来将任务加入任务队列中。为了解决这个问题，可以考虑使用线程池来重用线程，减少创建和销毁线程的开销。线程池可以通过预先创建一定数量的线程，并维护一个任务队列来实现。当需要执行任务时，先将任务加入队列，然后由线程池内的线程来执行。使用线程来延迟日志输出的做法可以避免当前线程暂停，但也会带来线程频繁创建与销毁的问题。

按序打印 多线程(C和C++)

amwpynnpyu的专栏

11-12

1014

#include "lib/common.h" pthread_mutex_t mutex; pthread_cond_t cond1; pthread_cond_t cond2; pthread_cond_t cond3; int testcount = 0; void block_queue_init() { pthread_mutex_init(&mutex, NULL); pthread_cond_init(&cond1, NULL); pthread_cond_init...

C++中cout打印输出中文是乱码

lsy1649909501的博客

11-07

323

命令将控制台代码页设置为 65001，即 UTF-8。（1）添加库：#include。在main函数中，添加。

已解决：多线程环境中，新线程在使用cout函数打印输出到显示器出现数据混乱的情况

DEXTERFUTIAN的博客

07-28

4264

最近学习Linux多线程的时候，创建新线程后使用cout打印输出到显示器上面的内容老是不对齐，数据混乱，搞得我强迫症都犯了。那么有什么方法呢？本文已解决

[c++11]多线程编程(一)——初识

weixin_34192993的博客

08-28

258

什么是并发并发在生活中随处可见，边走路边说话，边听歌边写代码。计算机术语中的"并发"，指的是在单个系统里同时执行多个独立的活动，而不是顺序的一个接一个的执行。对于单核CPU来说，在某个时刻只可能处理一个任务，但它却不是完全执行完一个任务再执行一个下一任务，而是一直在任务间切换，每个任务完成一点就去执行下一个任务，看起来就像任务在并行发生...

C++ `std::cout` 在多线程环境下的线程安全性与性能

weixin_41455464的博客

07-12

509

咱们C++程序员的老朋友，往屏幕上打印点啥，第一个想到的就是它。在单线程的世界里，它兢兢业业，你给它啥，它就吐啥，从来不含糊。是一个RAII（Resource Acquisition Is Initialization）风格的锁，它会在构造时获取锁，在析构时自动释放锁，避免了手动释放锁的麻烦。选择最适合你的方案，才能让你的程序跑得更快，更稳。特别是在高并发的情况下，锁的竞争会非常激烈，导致线程阻塞，降低程序的整体性能。如果没有协调好，你一句，我一句，最后输出的结果可能就是一锅粥，乱七八糟，不堪入目。

C++ 解决cout输出中文乱码

weixin_43996915的博客

10-17

1391

设置控制台版本控制台打开——》右击——》属性——》使用旧版控制台——》重启就可以了。

C语言之printf输出中文乱码