Logger类

最新推荐文章于 2024-07-04 23:00:52 发布
最新推荐文章于 2024-07-04 23:00:52 发布
阅读量5.3k 收藏
点赞数
分类专栏： C/C++/C#
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/callmeback/article/details/48317839
版权

找到了一个LOGGER类，但是输出中文有点毛病，就修改了一下贴出来。

第二次修改将指针改为了智能指针，不用显式释放资源了。

/************************************************************************/
/* CLogger类                                                            */
/************************************************************************/
#pragma once

#include <iostream>
#include <fstream>
#include <sstream>
#include <string>
#include <memory>

#include <Windows.h>
#include <process.h>


namespace hangba
{
    namespace logger
    {

#ifndef tstring
#ifdef UNICODE
#define tstring wstring
#else
#define tstring string
#endif
#endif

#ifndef tostringstream
#ifdef UNICODE
#define tostringstream wostringstream
#else
#define tostringstream ostringstream
#endif
#endif

#ifndef tofstream
#ifdef UNICODE
#define tofstream wofstream
#else
#define tofstream ofstream
#endif
#endif

#ifndef tcout
#ifdef UNICODE
#define tcout wcout
#else
#define tcout cout
#endif
#endif

#ifndef tsetlocale
#ifdef UNICODE
#define tsetlocale _wsetlocale
#else
#define tsetlocale setlocale
#endif
#endif

#ifndef tctime_s
#ifdef UNICODE
#define tctime_s _wctime_s
#else
#define tctime_s ctime_s
#endif
#endif


#define LOG_ERROR(x)    CLogger::GetInstance()->error(x)
#define LOG_ALARM(x)    CLogger::GetInstance()->alarm(x)
#define LOG_ALWAYS(x)    CLogger::GetInstance()->always(x)
#define LOG_INFO(x)        CLogger::GetInstance()->info(x)
#define LOG_BUFFER(x)    CLogger::GetInstance()->buffer(x)
#define LOG_TRACE(x)    CLogger::GetInstance()->trace(x)
#define LOG_DEBUG(x)    CLogger::GetInstance()->debug(x)

        typedef enum LOG_LEVEL
        {
            DISABLE_LOG = 1,
            LOG_LEVEL_INFO,
            LOG_LEVEL_BUFFER,
            LOG_LEVEL_TRACE,
            LOG_LEVEL_DEBUG,
            ENABLE_LOG,
        } LogLevel;

        typedef enum LOG_TYPE
        {
            NO_LOG = 1,
            CONSOLE,
            FILE_LOG,
        } LogType;

        class CLogger
        {
        public:
            static CLogger* GetInstance() throw();

            void error(const _TCHAR *text) throw();
            void error(std::tstring& text) throw();
            void error(std::tostringstream& stream) throw();

            void alarm(const _TCHAR *text) throw();
            void alarm(std::tstring& text) throw();
            void alarm(std::tostringstream& stream) throw();

            void always(const _TCHAR *text) throw();
            void always(std::tstring& text) throw();
            void always(std::tostringstream& stream) throw();

            void buffer(const _TCHAR *text) throw();
            void buffer(std::tstring& text) throw();
            void buffer(std::tostringstream& stream) throw();

            void info(const _TCHAR *text) throw();
            void info(std::tstring& text) throw();
            void info(std::tostringstream& stream) throw();

            void trace(const _TCHAR *text) throw();
            void trace(std::tstring& text) throw();
            void trace(std::tostringstream& stream) throw();

            void debug(const _TCHAR *text) throw();
            void debug(std::tstring& text) throw();
            void debug(std::tostringstream& stream) throw();

            void UpdateLogLevel(LogLevel level);
            void EnableLog();
            void DisableLog();

            void UpdateLogType(LogType type);
            void EnableConsoleLogging();
            void EnableFileLogging();

            CLogger();
            ~CLogger();

        protected:
            void lock();
            void unlock();

            std::tstring GetCurrentTime();

        private:
            void LogIntoFile(std::tstring& data);
            void LogOnConsole(std::tstring& data);
            CLogger(const CLogger& obj) {}
            void operator=(const CLogger& obj) {}

        private:
            static std::auto_ptr<CLogger> m_Instance;
            std::tofstream m_File;
            LogLevel m_LogLevel;
            LogType m_LogType;

            CRITICAL_SECTION m_Mutex;
        };
    }
}


#include "stdafx.h"
#include "Logger.h"
#include <stdio.h>
#include <time.h>


using namespace std;
using namespace hangba::logger;

std::auto_ptr<CLogger> CLogger::m_Instance;

const tstring strLogFileName = _T("logfile.log");

CLogger::CLogger()
{
    m_File.open(strLogFileName.c_str(), ios::out | ios::app);
    m_File.imbue(locale(""));

    m_LogLevel = LOG_LEVEL_TRACE;
    m_LogType = FILE_LOG;

    InitializeCriticalSection(&m_Mutex);
}


CLogger::~CLogger()
{
    m_File.close();
    m_File.clear();
    DeleteCriticalSection(&m_Mutex);
}

CLogger* CLogger::GetInstance() throw()
{
    if (m_Instance.get() == NULL)
    {
        m_Instance.reset(new CLogger());
    }
    return m_Instance.get();
}

void CLogger::lock()
{
    EnterCriticalSection(&m_Mutex);
}

void CLogger::unlock()
{
    LeaveCriticalSection(&m_Mutex);
}

void CLogger::LogIntoFile(std::tstring& data)
{
    lock();
    m_File << GetCurrentTime() << _T(" ") << data << endl;
    unlock();
}

void CLogger::LogOnConsole(std::tstring& data)
{
    lock();
    tcout << GetCurrentTime() << _T(" ") << data << endl;
    unlock();
}

tstring CLogger::GetCurrentTime()
{
    time_t now = time(0);
    tstring strCurTime;
    _TCHAR t[128];
    tctime_s(t, 128, &now);

    strCurTime.assign(t);
    tstring strRet = strCurTime.substr(0, strCurTime.size() - 1);
    return strRet;
}

void CLogger::error(const _TCHAR *text) throw()
{
    tstring data;
    data.append(_T("[ERROR]: "));
    data.append(text);

    if (m_LogType == FILE_LOG)
    {
        LogIntoFile(data);
    }
    else if (m_LogType == CONSOLE)
    {
        LogOnConsole(data);
    }
}

void CLogger::error(std::tstring& text) throw()
{
    error(text.data());
}

void CLogger::error(std::tostringstream& stream) throw()
{
    tstring text = stream.str();
    error(text.data());
}

void CLogger::alarm(const _TCHAR *text) throw()
{
    tstring data;
    data.append(_T("[ALARM]: "));
    data.append(text);

    if (m_LogType == FILE_LOG)
    {
        LogIntoFile(data);
    }
    else if (m_LogType == CONSOLE)
    {
        LogOnConsole(data);
    }
}

void CLogger::alarm(std::tstring& text) throw()
{
    alarm(text.data());
}

void CLogger::alarm(std::tostringstream& stream) throw()
{
    tstring text = stream.str();
    alarm(text.data());
}

void CLogger::always(const _TCHAR *text) throw()
{
    tstring data;
    data.append(_T("[ALWAYS]: "));
    data.append(text);

    if (m_LogType == FILE_LOG)
    {
        LogIntoFile(data);
    }
    else if (m_LogType == CONSOLE)
    {
        LogOnConsole(data);
    }
}

void CLogger::always(std::tstring& text) throw()
{
    always(text.data());
}

void CLogger::always(std::tostringstream& stream) throw()
{
    tstring text = stream.str();
    always(text.data());
}

// 除了输出字符什么也不变
void CLogger::buffer(const _TCHAR *text) throw()
{
    if (m_LogType == FILE_LOG && m_LogLevel >= LOG_LEVEL_BUFFER)
    {
        m_File << text << endl;
    }
    else if (m_LogType == CONSOLE && m_LogLevel >= LOG_LEVEL_BUFFER)
    {
        cout << text << endl;
    }
}

void CLogger::buffer(std::tstring& text) throw()
{
    buffer(text.data());
}

void CLogger::buffer(std::tostringstream& stream) throw()
{
    tstring text = stream.str();
    buffer(text.data());
}

void CLogger::info(const _TCHAR *text) throw()
{
    tstring data;
    data.append(_T("[INFO]: "));
    data.append(text);

    if (m_LogType == FILE_LOG)
    {
        LogIntoFile(data);
    }
    else if (m_LogType == CONSOLE)
    {
        LogOnConsole(data);
    }
}

void CLogger::info(std::tstring& text) throw()
{
    info(text.data());
}

void CLogger::info(std::tostringstream& stream) throw()
{
    tstring text = stream.str();
    info(text.data());
}

void CLogger::trace(const _TCHAR *text) throw()
{
    tstring data;
    data.append(_T("[TRACE]: "));
    data.append(text);

    if (m_LogType == FILE_LOG)
    {
        LogIntoFile(data);
    }
    else if (m_LogType == CONSOLE)
    {
        LogOnConsole(data);
    }
}

void CLogger::trace(std::tstring& text) throw()
{
    trace(text.data());
}

void CLogger::trace(std::tostringstream& stream) throw()
{
    tstring text = stream.str();
    trace(text.data());
}

void CLogger::debug(const _TCHAR *text) throw()
{
    tstring data;
    data.append(_T("[DEBUG]: "));
    data.append(text);

    if (m_LogType == FILE_LOG)
    {
        LogIntoFile(data);
    }
    else if (m_LogType == CONSOLE)
    {
        LogOnConsole(data);
    }
}

void CLogger::debug(std::tstring& text) throw()
{
    debug(text.data());
}

void CLogger::debug(std::tostringstream& stream) throw()
{
    tstring text = stream.str();
    debug(text.data());
}

void CLogger::UpdateLogLevel(LogLevel level)
{
    m_LogLevel = level;
}

void CLogger::EnableLog()
{
    m_LogLevel = ENABLE_LOG;
}

void CLogger::DisableLog()
{
    m_LogLevel = DISABLE_LOG;
}

void CLogger::UpdateLogType(LogType type)
{
    m_LogType = type;
    if (m_LogType == FILE_LOG)
    {
        m_File.imbue(locale(""));
    }
    if (m_LogType == CONSOLE)
    {
        std::locale::global(std::locale(""));
    }
}

void CLogger::EnableConsoleLogging()
{
    std::locale::global(std::locale(""));
    m_LogType = CONSOLE;
}

void CLogger::EnableFileLogging()
{
    m_File.imbue(locale(""));
    m_LogType = FILE_LOG;
}

自己测试过没有问题。
灵魂
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
c++日志管理
liangbaqiang的博客
01-07 420
VC-Logger 是一个简单易用的 C++ 程序通用日志组件。设计时着重考虑三个方面：功能、可用性和性能。 Logger.h /* * Copyright Bruce Liang (ldcsaa@gmail.com) * * Version : 2.0.3 * Author : Bruce Liang * Website : http://www.jessma.org * Project : https://github.com/ldcsaa * Blog : http://www.cnb
Log4j的进阶使用-自定义Logger类 + 自定义打印文件位置
lihongtai的专栏
05-05 3798
1.log4j配置文件信息 #自定义日志打印类的配置文件信息 log4j.logger.customerLogger = INFO,customerLogger #文件大小到达指定尺寸的时候产生一个新的文件 log4j.appender.customerLogger = org.apache.log4j.RollingFileAppender #指定输出目录 log4j.appender....
Logger类使用
SPJ的博客
05-18 935
Logger日志的使用
logger类
weixin_30608131的博客
12-27 659
日志Logger类 java开发过程中经常需要打印日志信息，往往会在每个类的第一行加上形如以下代码： protected static final Logger logger = LoggerFactory.getLogger(XXX.class); 目的：使用指定的类XXX初始化日志对象，方便在日志输出的时候，可以打印出日志信息所属的类。 示例：protected static fina...
2.2.Logger类
tcy-阿春
07-08 861
目录： 1.1.logging日志用途（tcy）https://mp.csdn.net/postedit/95102043 1.2.logging日志流处理流程 https://blog.csdn.net/tcy23456/article/details/95102217 2.1.logging模块级函数 https: //mp.csdn.net/postedit/951024...
java Logger 类
Rocky的专栏
08-04 2543
package org.rx.common; import org.slf4j.LoggerFactory; import java.util.Collections; import java.util.List; import java.util.function.Function; import java.util.regex.Pattern; import sta...
Java中Logger类应用
Sundy_sc的专栏
12-25 3855
类 Logger java.lang.Object java.util.logging.LoggerLogger 对象用来记录特定系统或应用程序组件的日志消息。一般使用圆点分隔的层次名称空间来命名 Logger。Logger 名称可以是任意的字符串，但是它们一般应该基于被记录组件的包名或类名，如 java.net 或 javax.swing。此外，可以创建“匿名”的 Logger，其名称未存
spdlog日志库源码：日志记录器logger类
一枚菜鸡
05-30 1336
一个logger类对象代表一个日志记录器，为用户提供日志记录接口。每个 logger 对象都有一个唯一的名称，用于标识该 logger。logger 对象维护一个日志等级（如 DEBUG、INFO、WARN、ERROR 等）。只有当日志消息的等级高于或等于 logger 的当前等级时，消息才会被记录下来。logger 提供了多种接口方法，允许用户记录不同类型的日志消息（如字符串、格式化字符串、异常信息等）。其维护一个 sink 指针数组，指向日志的输出目标（如文件、控制台、远程服务器等）。
spdlog一个非常好用的C++日志库(四): 源码分析之logger类
最新发布
红军不怕远征难，万水千山只等闲
07-04 1043
一个logger类对象代表一个日志记录器，为用户提供日志记录接口。包括哪些功能？ 基本功能： logger名称，用于唯一标识该logger 日志等级 接收用户日志消息的接口 提供一个sink（目标文件）指针数组和formatter（格式化），用于转换格式串并写到目标文件 线程安全 错误处理 高级功能： 环形队列缓存最近消息，便于回溯 自定义错误处理
C++实现Logger日志类
m0_64428335的博客
03-05 1259
在计算机软件中，日志对记录动作、定位错误起到了至关重要的作用。通常在软件发布后，在用户使用中遇到问题的情况下使用，通过日志定位错误，从而快速解决问题。 而在C++中却没有自己的日志类，想要使用日志通常需要自己定义或者下载使用boost。所以为了方便使用，我简单的实现了日志类的功能。 实现代码如下(Logger.hpp)： #pragmaonce #include<iostream> #include<string> #include&...
简单的logger类
09-03
本文将详细介绍一个名为“简单的logger类”的实现，它支持自动创建文件来存储日志信息。 首先，我们需要理解日志记录的基本概念。日志记录允许程序员在程序执行过程中记录事件和信息，这有助于调试、性能分析和故障...
多线程时间记录logger类
07-13
在IT领域，多线程时间记录logger类是一个关键的工具，尤其在开发高效并发系统时。这个logger类设计用于在多线程环境下记录程序运行的时间信息，帮助开发者追踪和优化性能。下面我们将深入探讨相关知识点。 1. **多...
PHP-Logger-Class:PHP Logger类可轻松将通知，警告，错误或致命错误记录到带有时间戳的日志文件中
05-17
PHP-Logger-Class是一个专门为PHP设计的轻量级日志记录类，它提供了一种简单有效的方式来将不同级别的消息（如通知、警告、错误和致命错误）记录到具有时间戳的日志文件中，这对于开发和维护PHP应用程序来说非常实用...
Logger工具类
05-13
`Logger`工具类通常是指Java的`java.util.logging.Logger`，它是Java内置的日志框架提供的核心类。这个工具类允许我们以不同级别（如SEVERE、WARNING、INFO、CONFIG、FINE、FINER、FINEST）记录日志，方便后期分析...
as_logger:AS3 Logger类
05-20
输出调用Logger.log方法的方法名称和类名称 -如果compile.debug是用true编译的，则可以输出源文件名和行数。 以下是ASDoc。 概要 使用代码 import com.github.sugamasao.as_logger.Logger Logger . log ({ "hoge" ...
c#制作简单启动画面
热门推荐
每天进步一点点...
03-29 1万+
声明：代码照搬自SharpDevelop源码。   启动画面是程序启动加载组件时一个让用户稍微耐心等待的提示框。一个好的软件在有启动等待需求时必定做一个启动画面。启动画面可以让用户有心理准备来接受程序加载的缓慢，还可以让用户知道加载的进度和内容。本文只是记录最简单的构架。 VS2010创建一个C# Windows窗体应用程序，将主窗体改名为FormMain，再创建一个窗体起名为SplashS
优先级反转和解决方法
每天进步一点点...
10-15 1万+
优先级反转的描述： 假设任务1，任务2，任务3；他们的优先级顺序分别为1 > 2 > 3。有一个稀缺资源S，S由一个信号量控制为互斥访问。 任务3正在执行，并申请到了资源S；任务1抢占了任务3的执行，任务3挂起，任务1执行；任务1申请资源S，发现被占用，所以挂起，任务3恢复执行；任务2抢占了任务3的执行，任务3挂起，任务2执行；任务2执行完毕，任务3恢复；任务3释放资源S，任务1抢占资源S
Explicit 关键字
每天进步一点点...
03-31 1万+
说实话，从来没有感觉到这个关键字有用，直到今天。explicit的意思是明显的,和它相对应的一个词是implicit意思是隐藏的。我参考了MSDN和《c++标准程序库》对这个关键字的描述，并参考了网络上对这个关键字的解释。现将它的使用方法和总结记录如下：首先这个关键字只能用在类构造函数。它的作用是不能进行隐式转换。class gxgExplicit  //没有关键字explic
IEnumerable和IEnumrator用法
每天进步一点点...
12-14 8139
先用一个修改过的代码来演示用法，只来干的，不来稀的。 /* * Created by SharpDevelop. * User: Owner * Date: 2012-12-14 * Time: 13:43 * * To change this template use Tools | Options | Coding | Edit Standard Headers.
logger类的常用方法java的debug
05-23
在Java中，常用的logger类的方法包括： 1. getLogger(String name)：获取一个logger对象，参数name指定了logger的名称，通常使用类的全限定名称作为名称。 2. setLevel(Level level)：设置logger的日志级别，级别...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值