c++ 写一个log日志，类似google的glog，但更简单

最新推荐文章于 2024-06-17 22:57:19 发布
最新推荐文章于 2024-06-17 22:57:19 发布
阅读量1.2k 收藏 2
点赞数
分类专栏： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/baidu_31872269/article/details/88698026
版权

功能：
1：将log 日志保存到文件
2：文件名字以时间戳命名
3：可以自动删除老的日志文件
4：可以设置每个日志文件的大小 5M或者其他

源码提供，超级简单，可以非常简单的添加到工程中，终于不用配一些第三方库了
共两个文件
myLog.h myLog.cpp
测试文件为
main.cpp

myLog.h

#ifndef __myLog_H_
#define __myLog_H_
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <string>

#include <iostream>
#include <ratio>
#include <chrono>
#include <mutex>

#define CLAMPXX(a, s, m) ((a) < (s)? (s) : ((a) > (m) ? (m) : (a)))


std::string GetName(const char * fileName);

std::string getCurrentSystemTime();

long long getCurrentMs();

int LOGINIT();

int LOGEnd();

int LOGSetMaxSpace(int mSize);

int logWrite(char * s);

#define  LOGEM(...)  {\
                        char temp[8192] = {0};      \
						sprintf(temp, "%s", getCurrentSystemTime().c_str());  \
						sprintf(temp+strlen(temp), " %s %d ", GetName(__FILE__).c_str(), __LINE__);  \
                        sprintf(temp+strlen(temp), __VA_ARGS__); \
						sprintf(temp + strlen(temp), "\n");    \
                        printf("%s", temp);   \
						logWrite(temp); \
                    }
#endif

myLog.cpp


//#include "Config.h"
#define OS_S OS_Linux
#include "myLog.h"
#include <vector>
#include <string>
#include <fstream>  
#define OS_Linux 0
#define OS_Windows 1
#define OS_iOS 2

#if OS_S==OS_Linux
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <malloc.h>
#include <dirent.h>


#elif OS_S== OS_iOS
#include <sys/stat.h>
#include <unistd.h>
#include <stdlib.h>
#elif OS_S == OS_Windows
#include <io.h>
#include <direct.h>
#endif



std::string dumpRoot = "./cpplog"; //
std::mutex mux;
static FILE * fp = NULL;
int MaxLenChar = 1024 * 1024 * 10; // ,  1024 * 1024 * 5
int MaxLogNum = 5;

static int com(const void *a, const void *b)
{
    long long * p1, *p2;
    p1 = (long long *)a;  //
    p2 = (long long *)b;  //

    return *p1 > *p2 ? 1 : -1;
}


void GetAllFiles(std::string path, std::vector<std::string>& files)
{
	intptr_t   hFile = 0;


#if OS_S == OS_Windows
	struct _finddata_t fileinfo;//    
	std::string p;
	if ((hFile = _findfirst(p.assign(path).append("\\*").c_str(), &fileinfo)) != -1)  //  
	{
		do
		{
			if ((fileinfo.attrib &  _A_SUBDIR))  //  
			{
				if (strcmp(fileinfo.name, ".") != 0 && strcmp(fileinfo.name, "..") != 0)  //  
				{
					files.push_back(p.assign(path).append("\\").append(fileinfo.name));
					GetAllFiles(p.assign(path).append("\\").append(fileinfo.name), files);

				}
			}
			else //   
			{
				

				files.push_back(p.assign(path).append("\\").append(fileinfo.name));
			}

		} while (_findnext(hFile, &fileinfo) == 0);

		_findclose(hFile); //  
	}
#elif OS_S == OS_Linux


	dirent * dirt;		// linux
	DIR * dir;;
	char *s[100];
	int i = 0, n = 1;
	int onePathLen = 256;
	s[0] = new  char[onePathLen];
	memset(s[0], 0, onePathLen);
	sprintf(s[0], "%s", path.c_str());
	do {
		dir = opendir(s[i]);		//
									//
		if (dir != NULL)
		{
			while ((dirt = readdir(dir)) != NULL) {     // 
														//
				if (strcmp(dirt->d_name, ".") == 0 || strcmp(dirt->d_name, "..") == 0)
					continue;
				s[n] = new  char[onePathLen];
				memset(s[n], 0, onePathLen);
				sprintf(s[n], "%s/%s", s[i], dirt->d_name);
				n++;
			}
		}
		i++;
	} while (i < n);
	for (i = 1; i < n; i++)     // 
	{
		printf("%s\n", s[i]);

		std::string temp = s[i];
		files.push_back(temp);

	}

	closedir(dir);
	while (n--) {
		//remove(s[n]);
		delete[]s[n];
	}

#endif
}


// 
void GetName(std::vector<std::string> &vPath, std::vector<std::string> &vName)
{
	if (vPath.size() <= 0)
	{
		printf("vPath.size <= 0");
		return;
	}
	for (int i = 0; i < vPath.size(); i++)
	{
		std::string path = vPath[i];

		int pointDot = path.find_last_of('.');

#if OS_S == OS_Windows
		int pointN = path.find_last_of('\\');
#elif OS_S == OS_Linux
		int pointN = path.find_last_of('/');
#endif

		std::string name = path.substr(pointN + 1, pointDot - pointN - 1);

		vName.push_back(name);

	}

}



static int removeOldFile(std::string &rootPath)
{

    std::vector<std::string> files;

    std::vector<long long> filesNum;
    GetAllFiles(rootPath, files);

	printf("rootPath = %s files.size = %d \n", rootPath.c_str(), files.size());
    if (files.size() > MaxLogNum)
    {
        for (int i = 0; i < files.size(); i++)
        {
            int pos0 = files[i].find("LOG_");

            std::string cut = files[i].substr(pos0 + 4, files[i].size());

            char* endptr = NULL;
            long long num = std::strtoll(cut.c_str(), &endptr, 10);

            printf("cut = %s num = %lld \n", cut.c_str(), num);

            filesNum.push_back(num);

        }
        qsort(&filesNum.data()[0], filesNum.size(), sizeof(long long), com);

        // 
        printf(" delete num = %d   \n", filesNum.size() - 5);
        long long deleteNum = filesNum.size() - MaxLogNum;

        for (int i = 0; i < deleteNum; i++)
        {
            std::string logPath = rootPath + std::string("/LOG_") + std::to_string(filesNum[i]);
            printf("删除文件= %s   \n", logPath.c_str());
            remove(logPath.c_str());
        }
    }

    return 0;
}




int dump_init_temp() {

#undef FUNC_CODE
#define FUNC_CODE 0x01

	//create dump folder
#if OS_S==OS_Windows
	if (_access(dumpRoot.c_str(), 00) != 0) {
		_mkdir(dumpRoot.c_str());
#else
	if (access(dumpRoot.c_str(), 00) != 0) {
		mkdir(dumpRoot.c_str(), S_IRWXU);
#endif
	}
	return 0;
	}

int LOGINIT()
{

	dump_init_temp();

    removeOldFile(dumpRoot);

    long long currentMs = getCurrentMs();
    char currentMsStr[20];

    sprintf(currentMsStr,"%lld", currentMs);
    std::string logPath = dumpRoot + "/LOG_" + currentMsStr;

	fp = NULL;
    fp = fopen(logPath.c_str(), "w+");
	if (fp == NULL)
	{
		return -1;
	}
	return 0;
}
int LOGSetMaxSpace(int mSize)
{
	MaxLenChar = mSize;
	return 0;
}

int logWrite(char * s)
{
	if (fp)
	{
		int len = ftell(fp);
		if (len > MaxLenChar)
		{
			LOGEnd();
			LOGINIT();
			return 0;
		}
		mux.lock();
		fprintf(fp, "%s", s);
		fflush(fp);
		mux.unlock();
	}

	return 0;
}

int LOGEnd()
{
	if (fp)
	{
		fflush(fp);
		fclose(fp);
		fp = 0;
	}
	return 0;
}

std::string getCurrentSystemTime()
{
	auto time_now = std::chrono::system_clock::now();
	auto tt = std::chrono::system_clock::to_time_t(time_now);
	auto duration_in_ms = std::chrono::duration_cast<std::chrono::milliseconds>(time_now.time_since_epoch());
	auto duration_in_s = std::chrono::duration_cast<std::chrono::seconds>(time_now.time_since_epoch());
	int theMs = duration_in_ms.count() - duration_in_s.count() * 1000;
	struct tm* ptm = localtime(&tt);


	char date[60] = { 0 };
	sprintf(date, "%d-%02d-%02d-%02d.%02d.%02d.%03d%",
		(int)ptm->tm_year + 1900, (int)ptm->tm_mon + 1, (int)ptm->tm_mday,
		(int)ptm->tm_hour, (int)ptm->tm_min, (int)ptm->tm_sec, theMs);
	return std::string(date);
}
long long getCurrentMs()
{
	auto time_now = std::chrono::system_clock::now();
	auto duration_in_ms = std::chrono::duration_cast<std::chrono::milliseconds>(time_now.time_since_epoch());

	return duration_in_ms.count();
}
std::string GetName(const char * fileName)
{
	char temp[256] = { 0 };
	memcpy(temp, fileName, strlen(fileName) + 1);

	std::string sName = temp;

#ifdef WIN32
	int startP = sName.find_last_of("\\");
	if (startP == -1)
	{
		startP = 0;
	}
	std::string theLastName = sName.substr(startP + 1, sName.size() - startP);

#else
	int startP = sName.find_last_of("/");
	if (startP == -1)
	{
		startP = 0;
	}
	std::string theLastName = sName.substr(startP + 1, sName.size() - startP);

#endif
	return theLastName;
}

main.cpp

#include <stdio.h>
#include "myLog.h"
//#include "GetFileName.h"

int main()
{
	LOGINIT();
	for(int i = 0; i < 1000000; i ++)
	{
		LOGE("i = %d ... \n", i);
	}
	LOGEnd();
	return 0;
}

输出文件结果

2019-03-20-19.57.57.278 main.cpp 12 i = 3521 …
2019-03-20-19.57.57.278 main.cpp 12 i = 3522 …
2019-03-20-19.57.57.278 main.cpp 12 i = 3523 …
2019-03-20-19.57.57.279 main.cpp 12 i = 3524 …
2019-03-20-19.57.57.282 main.cpp 12 i = 3525 …
2019-03-20-19.57.57.283 main.cpp 12 i = 3526 …
修改最上面的文件GetFileName.h, 可以支持在linux 下面

#ifndef GETFILENAME_H_
#define GETFILENAME_H_
#include "Config.h"
#if OS_S == OS_Windows
#include <io.h>  
#elif OS_S == OS_Linux

#include <sys/types.h>
#include <sys/stat.h>
#include <dirent.h>
#include <string.h>
#include <stdio.h>


#endif
#include <fstream>  
#include <string>
#include <vector>
#include <iostream>


void GetAllFiles(std::string path, std::vector<std::string>& files)
{
	intptr_t   hFile = 0;
	//文件信息    
#if OS_S == OS_Windows
	struct _finddata_t fileinfo;//用来存储文件信息的结构体    
	std::string p;
	if ((hFile = _findfirst(p.assign(path).append("\\*").c_str(), &fileinfo)) != -1)  //第一次查找  
	{
		do
		{
			if ((fileinfo.attrib &  _A_SUBDIR))  //如果查找到的是文件夹  
			{
				if (strcmp(fileinfo.name, ".") != 0 && strcmp(fileinfo.name, "..") != 0)  //进入文件夹查找  
				{
					files.push_back(p.assign(path).append("\\").append(fileinfo.name));
					GetAllFiles(p.assign(path).append("\\").append(fileinfo.name), files);

				}
			}
			else //如果查找到的不是是文件夹   
			{
				//files.push_back(p.assign(fileinfo.name));  //将文件路径保存，也可以只保存文件名:    p.assign(path).append("\\").append(fileinfo.name)  

				files.push_back(p.assign(path).append("\\").append(fileinfo.name));
			}

		} while (_findnext(hFile, &fileinfo) == 0);

		_findclose(hFile); //结束查找  
	}
#elif OS_S == OS_Linux


	dirent * dirt;		// linux 下的结构体
	DIR * dir;;
	char *s[100];
	int i = 0, n = 1;
	int onePathLen = 256;
	s[0] = new  char[onePathLen];
	memset(s[0], 0, onePathLen);
	sprintf(s[0], "%s", path.c_str());
	do {
		dir = opendir(s[i]);		// 打开指定路径
									//printf("0000000000000 s[0]=%s \n", path);
		if (dir != NULL)
		{
			while ((dirt = readdir(dir)) != NULL) {     // 存储路径下的所有文件和文件夹路径
														//printf("111111111111");
				if (strcmp(dirt->d_name, ".") == 0 || strcmp(dirt->d_name, "..") == 0)
					continue;
				s[n] = new  char[onePathLen];
				memset(s[n], 0, onePathLen);
				sprintf(s[n], "%s/%s", s[i], dirt->d_name);
				n++;
			}
		}
		i++;
	} while (i < n);
	for (i = 1; i < n; i++)     // 广度优先遍历文件夹
	{
		printf("%s\n", s[i]);

		std::string temp = s[i];
		files.push_back(temp);

	}

	closedir(dir);
	while (n--) {
		//remove(s[n]);
		delete[]s[n];
	}

#endif
}


// 在路径中提取文件的名字
void GetName(std::vector<std::string> &vPath, std::vector<std::string> &vName)
{
	if (vPath.size() <= 0)
	{
		printf("vPath.size <= 0");
		return;
	}
	for (int i = 0; i < vPath.size(); i++)
	{
		std::string path = vPath[i];

		int pointDot = path.find_last_of('.');

#if OS_S == OS_Windows
		int pointN = path.find_last_of('\\');
#elif OS_S == OS_Linux
		int pointN = path.find_last_of('/');
#endif

		std::string name = path.substr(pointN + 1, pointDot - pointN - 1);

		vName.push_back(name);

	}

}

#endif
LIZhang2016
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
c++写log日志文件
10-26
一个简单的写log日志的c++代码，可以将日志写入文件用来记录程序调试信息。
用c++写的 log 日志文件
01-16
一个简单的写log日志的c++代码，可以将日志写入文件用来记录程序调试信息。
c++ 写log
Vera_Q
01-21 1107
来由： 有时候需要输出一些程序运行的信息，供我们不需要调试就可以直接查看程序运行状态。所以我们需要在程序中加入一些LOG输出。 适合涉及到虚拟机调试一些关于驱动等的程序时，或进行远程调试时。 搜了些log工具，不够轻……还是简单实现下吧 贴上来，可能有用的上: Log.h /** * 用于输出log文件的类. */ #ifndef LOG_H
C++日志库 glog入门
最新发布
qq_37805392的博客
06-17 1191
你可以设置自定义的日志记录器，以便自定义日志输出行为。
c++实现log文件写入
09-10
利用c++实现 log日志文件写入，编译环境vs2010。
C++写日志Log
WJsuperrunner
11-01 342
GitHub上面下载的代码，挺好用，权当学习 #ifndef YLOG_YLOG_H_ #define YLOG_YLOG_H_ #include <string> #include <fstream> #include <cassert> #include <ctime> class YLog{ private: std::ofstream ...
C++日志框架 Google Glog 源码
09-12
Google Glog是一个高效、灵活的日志记录库，专为C++编程语言设计。它提供了丰富的功能，包括错误处理、堆栈追踪以及多种日志级别，使得开发者能够在程序运行过程中方便地记录和调试信息。Glog的设计理念是简单易用，...
cpp-GoogleGlog是一个C语言的应用级日志记录框架
08-15
1. **流式接口**：Glog 提供了类似 C++ iostream 的流式日志接口，使得日志记录可以像输出流一样方便，如 `LOG(INFO) 这是一个" 信息日志" ;`。 2. **日志级别**：Glog 支持多个日志级别，包括 `DEBUG`、`INFO`、`...
c++开源日志库GLOG
10-26
C++开源日志库GLOG是由Google开发的一款强大的日志处理框架，它的设计目标是提供一个灵活、高效且易于使用的日志系统，适用于各种规模的软件项目。GLOG库不仅支持基本的日志输出，还提供了丰富的特性，如日志级别...
C++日志库GLOG
06-01
总之，GLOG作为一个强大而成熟的日志库，为C++开发者提供了丰富的日志记录功能，有助于提高软件的可维护性和可靠性。通过不断迭代和修复问题，如在0.3.4版本中解决的VS2013兼容性问题，GLOG持续保持着其在C++社区中...
C++日志类libglog使用
11-04
Google glog是一个基于程序级记录日志信息的c++库，编程使用方式与c++的stream操作类似，例： LOG(INFO) ; “LOG”宏为日志输出关键字，“INFO”为严重性程度。 主要支持功能： 1， 参数设置，以命令行参数的方式...
C++ 写日志函数
06-06
1、本资源使用C++实现写日志的类。 5、使用方法非常简单，只需要输入日志文件名称和要写的字符串就能记录日志；
C++写入日志文件
08-09
C++的日志写入文件能按照日期创建文件并向文件中写入数据
一个简单的log用c++编写
weixin_43360707的博客
08-24 925
#ifndef __debug_log__ #define __debug_log__ //#define __WRITE_FILE__ #include <stdio.h> #include <time.h> #include <string.h> #include <stdarg.h> void DEBUG_LOG(const char *...
C++ 实现简易 log 日志库
热门推荐
Dablelv 的博客专栏。
07-16 2万+
DEBUG（调试）：DEBUG级别的日志用于记录应用程序的调试信息，例如变量的值、函数的执行路径等。TRACE（跟踪）：这是最详细的日志级别，通常用于记录应用程序中最细微的操作和事件，以帮助调试和追踪问题。FATAL（致命）： FATAL级别的日志用于记录严重的错误，通常表示应用程序遇到了无法继续运行的情况，可能会导致应用程序崩溃。WARN（警告）：WARNING级别的日志用于记录警告信息，例如潜在的问题或不正常的情况，但不会导致应用程序终止。由此可见log日志在系统中的重要地位和存在的必要性。
C++写log文件
Inversel的博客
06-25 528
1、向文件中写入数据：首先肯定是创建文件，fopen（fileName,“w”）。对于文件名有一些操作符是不允许的，例如“：”，所以当初我的文件名包含了这个字符后，一直都是创建失败。本来按照写打开的话，即使文件名不存在，也会新建文件的。 2、fclose（）函数功能是关闭一个流，可以将缓冲区的最后剩余数据输出到内核缓冲区，并释放文件指针和相关缓冲区。 所以在测试的时候logMessage（“test1”）后，fclose（）掉了文件指针。导致下次进来的日志logMessage（）的时候失败了。 后来将fc.
C++ log日志类实现
MusicMan
01-06 2094
用处 log日志类，主要是用来记录异常 容易排查问题 简单实现了一个log日志记录系统 头文件 #include "stdafx.h" //Log日志 class YTLog { public: YTLog(); ~YTLog(); bool InitLog(std::wstring& log_file_name); //初始化Log bool WriteLog(std::...
C++-实现日志log功能
翟天保的博客
04-26 1万+
分享一个日志log的C++代码
用C++写的一个简单的Log类
aftoy的专栏
03-30 908
这是参考网上的一个了例子【一个简易的C++日志记录类】写的，我的这个不需要boost，而是改成了用windows API。这个Log类，使用了单例模式。思路是单独创建一个线程，获取log文本，并将其写入到文件中。由于是多线程，所以要注意线程同步。代码 ★头文件：MyLogger.h#ifndef __INFO_LOGGER__ #define __INFO_LOGGER__#include <s
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值