• C++类设计：一个比较复杂的日志类 支持多线程、文件切换、信息缓存（源码）

    初级代码游戏的专栏介绍与文章目录-CSDN博客

    github位置：codetoys/ctfc.git src/env/myLog.h和.cpp  

            这个类功能细节比较多，因为是长期使用的版本，累积了各种功能。之前介绍的两个是我的测试代码用的版本，非常简单，那两个在这里：

    C++类设计：设计一个日志类（源码）_初级代码游戏的博客-CSDN博客

    C++类设计：一个不同版本的日志类（完整源码）_初级代码游戏的博客-CSDN博客

            其实这个版本跟上面两个很不一样，这个版本是基于unix/linux的（64位），控制台程序，支持多线程（需要链接pthread），支持日志文件切换，统计各种信息的条数，能缓存信息，可用于如果一段代码正确结束就不输出、出错才输出。

    目录

    一、完整源码

    二、详解

    2.1 关于endi、ende、endr

    2.2 多线程支持

    2.3 缓存支持

    2.4 日志切换

    一、完整源码

            头文件：

    1. 	//输出信息所在位置的日志宏------g_pEnv->GetLog()返回Log，可以直接定义为全局变量
    2. #define thelog ((g_pEnv->GetLog()).LogPos(__FILE__,__LINE__,__func__))
    3. #define theLog (g_pEnv->GetLog())  //不带文件名行号函数名
    4.  
    5.  
    6. //输出调试信息的宏，G_DEBUG G_TRANCE可以直接定义为全局变量
    7. #define DEBUG_LOG if(G_DEBUG)thelog
    8. #define TRANCE_LOG if(G_TRANCE)thelog
    9.  
    10. 	//
    11. 	//日至
    12.  
    13. 	struct LogEnd
    14. 	{
    15. 		enum { fENDE = 1, fENDW, fENDI, fENDF, fENDD };
    16. 		char end;
    17. 		LogEnd(int ,int n):end(n){}
    18. 	};
    19. 	ostream & operator<<(ostream & s, LogEnd const & end);//这个好像没啥用，但是我暂时没验证，不敢删
    20. 	LogEnd const ende(0, LogEnd::fENDE); // error
    21. 	LogEnd const endw(0, LogEnd::fENDW); // warning
    22. 	LogEnd const endi(0, LogEnd::fENDI); // information
    23. 	LogEnd const endf(0, LogEnd::fENDF); // fatal
    24. 	LogEnd const endd(0, LogEnd::fENDD); // debug
    25.  
    26. 	class Log
    27. 	{
    28. 	private:
    29. 		//线程数据
    30. 		struct _ThreadSpec
    31. 		{
    32. 			long m_thread_id;
    33. 			stringstream m_buf;
    34. 			string m_strSource;
    35. 			bool m_bOutputThis;//仅控制当前一行输出
    36. 			string m__file;
    37. 			long m__line;
    38. 			string m__func;
    39. 			_ThreadSpec() :m_thread_id(0), m_bOutputThis(true), m__line(0) {}
    40. 		};
    41. 		static void _CloseThreadSpec(void * _p)
    42. 		{
    43. 			_ThreadSpec * p=(_ThreadSpec *)_p;
    44. 			delete p;
    45. 		}
    46. 		_ThreadSpec * _getThreadSpec()
    47. 		{
    48. 			_ThreadSpec * p = (_ThreadSpec *)pthread_getspecific(tsd_key);
    49. 			if (p)return p;
    50. 			else
    51. 			{
    52. 				p = new _ThreadSpec;
    53. 				if (!p)
    54. 				{
    55. 					throw "new _ThreadSpec return NULL";
    56. 				}
    57. 				m_mutex.lock();
    58. 				p->m_thread_id = m_thread_count;
    59. 				++m_thread_count;
    60. 				m_mutex.unlock();
    61. 				if (0 == pthread_setspecific(tsd_key, p))
    62. 				{
    63. 					return p;
    64. 				}
    65. 				else
    66. 				{
    67. 					throw "pthread_setspecific error";
    68. 				}
    69. 			}
    70. 		}
    71. 	private:
    72. 		long m_thread_count;//线程计数
    73. 		pthread_key_t tsd_key;//线程存储key	
    74. 		CPThreadMutex m_mutex;
    75. 		string m_appname;//用来构造m_filename，用于定时切换文件，若未设置则直接使用m_filename
    76. 		string m_appname_old;//切换日志时用来保存原来的，以便切换换回来
    77. 		string m_filename;//当前的日志文件名
    78. 		ofstream m_ofs;
    79. 		bool m_bOutput;//控制所有输出
    80. 		bool m_bCache;//当!m_bOutput时缓存输出结果
    81. 		string::size_type m_maxcache;//最大缓存的数目
    82. 		string m_cache;//缓存的输出
    83.  
    84. 		void(*m_pUD)(const string& strLog);//用户定义的函数，输出的时候会执行一次，一般也不用
    85.  
    86. 		//错误和警告统计
    87. 		long countw;
    88. 		long counte;
    89. 		long countall;
    90. 		//正常记录统计
    91. 		long countn;
    92. 	public:
    93.         //设置用户定义的函数，输出的时候会执行一次，一般也不用
    94. 		void SetUserFunction(void(*pUD)(const string& strLog)) { m_pUD = pUD; }
    95. 	public:
    96. 		Log()
    97. 		{
    98. 			m_thread_count = 0;
    99. 			pthread_key_create(&tsd_key, _CloseThreadSpec);
    100. 			m_mutex.init();
    101. 			SetSource("应用");
    102. 			m_bOutput = true;
    103. 			m_bCache = false;
    104. 			m_maxcache = 0;
    105. 			m_pUD = NULL;
    106.  
    107. 			countw = 0;
    108. 			counte = 0;
    109. 			countn = 0;
    110. 			countall = 0;
    111. 		}
    112.  
    113. 		void GetCount(long & c_w, long & c_e, long & c_all)const { c_w = countw; c_e = counte; c_all = countall; }
    114. 		string const &GetFileName()const { return m_filename; }
    115. 		Log& LogPos(char const * file, long line,char const * func)
    116. 		{
    117. 			string tmp = file;
    118. 			string::size_type pos = tmp.find_last_of("/");
    119. 			if (pos != tmp.npos)_getThreadSpec()->m__file = tmp.substr(pos + 1);
    120. 			else _getThreadSpec()->m__file = file;
    121.  
    122. 			_getThreadSpec()->m__line = line;
    123. 			_getThreadSpec()->m__func = func;
    124. 			return *this;
    125. 		}
    126.  
    127. 		string const & _makesource(string const & source, string & ret);
    128. 		template <typename T>
    129. 		Log& operator<<(T const& t)
    130. 		{
    131. 			_getThreadSpec()->m_buf << (t);
    132. 			return *this;
    133. 		}
    134. 		Log& operator<<(stringstream const& ss)
    135. 		{
    136. 			_getThreadSpec()->m_buf << ss.str();
    137. 			return *this;
    138. 		}
    139. 		Log & operator<<(ostream &(*p)(ostream &))
    140. 		{
    141. 			_getThreadSpec()->m_buf <<(p);
    142. 			return *this;
    143. 		}
    144. 		Log & operator<<(LogEnd const & end)
    145. 		{
    146. 			m_mutex.lock();
    147. 			_ThreadSpec * ThreadSpec = _getThreadSpec();
    148. 			char nCh = end.end;
    149. 			bool isImportant = false;
    150.  
    151. 			string strType;
    152.  
    153. 			switch (nCh)
    154. 			{
    155. 			case LogEnd::fENDI:
    156. 				strType = "[信息]";
    157. 				++countn;
    158. 				break;
    159. 			case LogEnd::fENDW:
    160. 				strType = "[警告]";
    161. 				isImportant = true;
    162. 				++countw;
    163. 				break;
    164. 			case LogEnd::fENDE:
    165. 				strType = "[出错]";
    166. 				isImportant = true;
    167. 				++counte;
    168. 				break;
    169. 			case LogEnd::fENDF:
    170. 				strType = "[致命]";
    171. 				isImportant = true;
    172. 				break;
    173. 			case LogEnd::fENDD:
    174. 				strType = "[调试]";
    175. 				break;
    176. 			}
    177. 			if (isImportant)++countall;
    178.  
    179. 			time_t t;
    180. 			tm const * t2;
    181. 			char buf[2048];
    182. 			time(&t);
    183. 			t2 = localtime(&t);
    184. 			sprintf(buf, "%02d-%02d %02d:%02d:%02d", t2->tm_mon + 1, t2->tm_mday, t2->tm_hour, t2->tm_min, t2->tm_sec);
    185.  
    186. 			string strTime = buf;
    187.  
    188. 			strTime = "[" + strTime + "]";
    189.  
    190. 			//若未设置则不输出文件名和行号
    191. 			if (0 != ThreadSpec->m__file.size())
    192. 			{
    193. 				sprintf(buf, "[%-24s:%4ld(%s)][%6.2f]", ThreadSpec->m__file.c_str()
    194. 					, ThreadSpec->m__line, ThreadSpec->m__func.c_str(), (clock() / (float)CLOCKS_PER_SEC));
    195. 			}
    196. 			else buf[0] = '\0';
    197.  
    198. 			string tmpSource;
    199. 			string strMsg;
    200. 			strMsg = strTime + _makesource(ThreadSpec->m_strSource, tmpSource) + strType + buf + ThreadSpec->m_buf.str();
    201.  
    202. 			if (LogEnd::fENDE == nCh)
    203. 			{
    204. 				if (G_ERROR_MESSAGE().str().size() > 1024 * 1024)G_ERROR_MESSAGE().str(G_ERROR_MESSAGE().str().substr(512 * 1024));
    205. 				G_ERROR_MESSAGE() << strMsg << endl;
    206. 			}
    207.  
    208. 			if (!m_bCache && m_filename.size() != 0)
    209. 			{
    210. 				string newfile = makelogfilename();
    211. 				if (m_filename != newfile)
    212. 				{
    213. 					m_ofs.close();
    214. 					_Open(newfile);
    215. 					cout << "文件切换，原文件 " << m_filename << " 新文件 " << newfile << endl;
    216. 					m_ofs << "文件切换，原文件 " << m_filename << " 新文件 " << newfile << endl;
    217. 				}
    218. 				m_ofs << strMsg.c_str() << endl;
    219. 				m_ofs.flush();
    220. 				if (m_ofs.bad())
    221. 				{
    222. 					m_ofs.close();
    223. 					_Open(newfile);
    224. 					cout << "写文件错误，关闭后重新打开文件" << endl;
    225. 					m_ofs << "写文件错误，关闭后重新打开文件" << endl;
    226. 					m_ofs << strMsg.c_str() << endl;
    227. 					m_ofs.flush();
    228. 				}
    229. 			}
    230.  
    231. 			if (m_bOutput && ThreadSpec->m_bOutputThis)
    232. 			{
    233. 				cout << strMsg.c_str() << endl;
    234. 			}
    235. 			else
    236. 			{
    237. 				if (m_bCache)
    238. 				{
    239. 					if (m_cache.size() > m_maxcache)
    240. 					{
    241. 						m_cache.erase(0, m_cache.size() / 2);//超长时删去前半部分
    242. 					}
    243. 					m_cache += strMsg + "\n";
    244. 				}
    245. 			}
    246. 			ThreadSpec->m_bOutputThis = true;
    247.  
    248. 			if (m_pUD) (*m_pUD)(strMsg); // 用户定义功能
    249.  
    250. 			ThreadSpec->m__file = "";
    251. 			ThreadSpec->m__line = 0;
    252. 			ThreadSpec->m_buf.str("");
    253. 			
    254. 			m_mutex.unlock();
    255. 			return *this;
    256. 		}
    257.  
    258. 		Log& SetSource(const string& strSource)
    259. 		{
    260. 			_getThreadSpec()->m_strSource = "[" + strSource + "]";
    261. 			return *this;
    262. 		}
    263. 		void setMaxFileSize(long)
    264. 		{
    265. 			cout << "theLog.setMaxFileSize(maxsize) 此功能已取消" << endl;
    266. 		}
    267. 		void setCache(string::size_type maxcache)
    268. 		{
    269. 			m_maxcache = maxcache;
    270. 			m_bCache = (maxcache > 0);
    271. 		}
    272. 		bool getCache()const { return m_bCache; }
    273. 		string & GetCachedLog(string & ret)//获得缓存的日志并清理缓存
    274. 		{
    275. 			ret = m_cache;
    276. 			m_cache.clear();
    277. 			return ret;
    278. 		}
    279. 		void ClearCache()//结束缓存，丢弃缓存的东西
    280. 		{
    281. 			m_cache.clear();
    282. 			setCache(0);
    283. 		}
    284.  
    285. 		void setOutput(bool bEnable = true) { m_bOutput = bEnable; }
    286. 		bool getOutput() { return m_bOutput; }
    287. 		Log & setOutputThis(bool bEnable = false) { _getThreadSpec()->m_bOutputThis = bEnable; return *this; }
    288. #ifdef _LINUXOS
    289. 		int _Open(const string& strFile, std::_Ios_Openmode nMode = ios::out | ios::app)
    290. #else
    291. 		int _Open(const string& strFile, int nMode = ios::out | ios::app)
    292. #endif
    293. 		{
    294. 			m_ofs.close();
    295. 			m_ofs.clear();
    296. 			m_ofs.open(strFile.c_str(), nMode);
    297. 			if (!m_ofs.good())
    298. 			{
    299. 				cout << "打开文件出错 " << strFile << " " << strerror(errno) << endl;
    300. 				return -1;
    301. 			}
    302. 			m_filename = strFile;
    303.  
    304. 			return 1;
    305. 		}
    306. 		//以固定文件方式打开日志，不会根据日期切换
    307. 		int Open(char const * filename)
    308. 		{
    309. 			cout << "theLog.Open(filename) 此操作将取消按日期生成日志文件的功能，若要使用按日期分文件请取消此调用" << endl;
    310. 			m_appname_old = m_appname;
    311. 			m_appname = "";
    312. 			return _Open(filename);
    313. 		}
    314. 		int ReturnToOldFile()
    315. 		{
    316. 			return ActiveOpen(m_appname_old.c_str());
    317. 		}
    318. 		//根据当前年月日构造日志文件名，若未设置m_appname则为m_filename
    319. 		string makelogfilename()
    320. 		{
    321. 			if (0 == m_appname.size())return m_filename;
    322. 			time_t t;
    323. 			tm const * t2;
    324. 			char buf[256];
    325. 			time(&t);
    326. 			t2 = localtime(&t);
    327. 			sprintf(buf, "%s.%04d%02d%02d.log", m_appname.c_str(), t2->tm_year + 1900, t2->tm_mon + 1, t2->tm_mday);
    328. 			return buf;
    329. 		}
    330. 		//按日期打开日志，日期改变日志文件自动切换，格式为“appname.YYYYMMDD.log”
    331. 		int ActiveOpen(char const * appname)
    332. 		{
    333. 			m_appname = appname;
    334. 			return _Open(makelogfilename());
    335. 		}
    336. 		//获得当前日志位置
    337. 		long tellEndP()
    338. 		{
    339. 			m_ofs.seekp(0, ios::end);
    340. 			return m_ofs.tellp();
    341. 		}
    342. 		//返回当前日志记录数
    343. 		long getCountN()
    344. 		{
    345. 			return countn;
    346. 		}
    347. 		long getCountW()
    348. 		{
    349. 			return countw;
    350. 		}
    351. 		long getCountE()
    352. 		{
    353. 			return counte;
    354. 		}
    355. 	};
    356. 	//日志接口
    357. #define LOG (thelog)
    358. #define ENDI (endi)
    359. #define ENDW (endw)
    360. #define ENDE (ende)

            源文件：

    1.     //这个好像没啥用，但是我暂时没验证，不敢删
    2. 	ostream & operator<<(ostream & s, LogEnd const & end)
    3. 	{
    4. 		switch (end.end)
    5. 		{
    6. 		case LogEnd::fENDI:
    7. 			s << "[信息]";
    8. 			break;
    9. 		case LogEnd::fENDW:
    10. 			s << "[警告]";
    11. 			break;
    12. 		case LogEnd::fENDE:
    13. 			s << "[出错]";
    14. 			break;
    15. 		case LogEnd::fENDF:
    16. 			s << "[致命]";
    17. 			break;
    18. 		case LogEnd::fENDD:
    19. 			s << "[调试]";
    20. 			break;
    21. 		}
    22. 		s << endl;
    23. 		return s;
    24. 	}
    25.  
    26. 	string const & Log::_makesource(string const & source, string & ret)
    27. 	{
    28. 		if (m_thread_count < 2)return source;
    29.  
    30. 		_ThreadSpec * ThreadSpec = _getThreadSpec();
    31. 		char buf[256];
    32. 		if (0 == ThreadSpec->m_thread_id)
    33. 		{
    34. 			sprintf(buf, "[%lu]", (unsigned long)getpid());
    35. 		}
    36. 		else
    37. 		{
    38. 			sprintf(buf, "[%lu-%2ld]", (unsigned long)getpid(), ThreadSpec->m_thread_id);
    39. 		}
    40. 		return ret = source + buf;
    41. 	}

            代码里面用到了一个互斥对象，代码是这样的，简单包装而已：

    1. 	//线程同步对象
    2. 	class CPThreadMutex
    3. 	{
    4. 	private:
    5. 		pthread_mutex_t m_mutex;//互斥对象
    6. 		pthread_cond_t m_cond;//条件变量
    7. 	public:
    8. 		void init()
    9. 		{
    10. 			pthread_mutex_init(&m_mutex, NULL);
    11. 			pthread_cond_init(&m_cond, NULL);
    12. 		}
    13. 		void destory()
    14. 		{
    15. 			pthread_cond_destroy(&m_cond);
    16. 			pthread_mutex_destroy(&m_mutex);
    17. 		}
    18. 		int lock()const { return pthread_mutex_lock((pthread_mutex_t*)&m_mutex); }
    19. 		int unlock()const { return pthread_mutex_unlock((pthread_mutex_t*)&m_mutex); }
    20. 		int wait()const { return pthread_cond_wait((pthread_cond_t*)&m_cond, (pthread_mutex_t*)&m_mutex); }
    21. 		int reltimedwait()const
    22. 		{
    23. 			timespec to;
    24. 			to.tv_sec = time(NULL) + 1;
    25. 			to.tv_nsec = 0;
    26. 			int ret;
    27.  
    28. 			ret = pthread_cond_timedwait((pthread_cond_t*)&m_cond, (pthread_mutex_t*)&m_mutex, &to);
    29. 			if (0 == ret)return true;
    30. 			else if (ETIMEDOUT == ret)return false;
    31. 			else throw ret;
    32. 			return false;
    33. 		}
    34. 		int signal()const { return pthread_cond_signal((pthread_cond_t*)&m_cond); }
    35. 	};

    二、详解

    2.1 关于endi、ende、endr

            这一套是传统留下来的，在结束输出的时候表明这是什么性质的日志。含义很简单：

            endi 信息

            endd 调试

            ende 出错

            endr 报告——由于endr和某些版本的oracle客户端冲突，再说也没有实际使用，所以就删掉了

            这个东西可以根据需要扩展。

    2.2 多线程支持

            由于日志对象是个全局对象，为了支持多线程使用，需要在内部实现多线程支持。具体办法是将临时缓存的数据放在线程存储里面。这里用的是POSIX线程库：

    1. 		//线程数据
    2. 		struct _ThreadSpec
    3. 		{
    4. 			long m_thread_id;
    5. 			stringstream m_buf;
    6. 			string m_strSource;
    7. 			bool m_bOutputThis;//仅控制当前一行输出
    8. 			string m__file;
    9. 			long m__line;
    10. 			string m__func;
    11. 			_ThreadSpec() :m_thread_id(0), m_bOutputThis(true), m__line(0) {}
    12. 		};
    13. 		static void _CloseThreadSpec(void * _p)
    14. 		{
    15. 			_ThreadSpec * p=(_ThreadSpec *)_p;
    16. 			delete p;
    17. 		}
    18. 		_ThreadSpec * _getThreadSpec()
    19. 		{
    20. 			_ThreadSpec * p = (_ThreadSpec *)pthread_getspecific(tsd_key);
    21. 			if (p)return p;
    22. 			else
    23. 			{
    24. 				p = new _ThreadSpec;
    25. 				if (!p)
    26. 				{
    27. 					throw "new _ThreadSpec return NULL";
    28. 				}
    29. 				m_mutex.lock();
    30. 				p->m_thread_id = m_thread_count;
    31. 				++m_thread_count;
    32. 				m_mutex.unlock();
    33. 				if (0 == pthread_setspecific(tsd_key, p))
    34. 				{
    35. 					return p;
    36. 				}
    37. 				else
    38. 				{
    39. 					throw "pthread_setspecific error";
    40. 				}
    41. 			}
    42. 		}

            _getThreadSpec()用于获取线程数据，日志类的其他部分只用这个函数来操作数据。

            为了保证输出文件不混乱，在输出的时候使用了互斥锁。

    2.3 缓存支持

            如果执行没有失败，就没有必要输出详细日志。程序在开始一段操作时打开缓存，执行结束检查状态，成功就清除缓存，失败才输出缓存的日志。

    2.4 日志切换

            日志文件不能越滚越大，一般我们按天切换文件，在每次输出的时候检查日期是否已经改变，如果改变了就关闭文件再重新打开一个。

            日志太大搜索信息也很慢，一度我还用过这种策略：增加一个日志文件专门输出错误信息。

            日志处理的功能全看自己的需要。

    （这里是结束）

  • 相关阅读:
    Python使用psycopg2读取PostgreSQL的geometry字段出现二进制乱码
    如何愉快地搞定本科毕业论文、查重 / 计算机、人工智能、数据科学等专业
    校园报修维修小程序,微信小程序报修系统,微信小程序宿舍报修系统毕设作品
    【golang】探索for-range遍历实现原理（slice、map、channel）
    前端工程师都在用的 VSCode 常用插件
    Qt包含文件不存在问题解决 QNetworkAccessManager
    Android音视频——OMX 中 Nodeinstance 列表的管理与节点的操作
    【踩坑录】Javascript的预解析
    STL-list
    基于华为云IOT平台实现多节点温度采集(STM32+NBIOT)
  • 原文地址：https://blog.csdn.net/2301_77171572/article/details/132255518