muduo网络库源码学习———

muduo库里面的日志使方法如下

这里定义了一个宏

#define LOG_INFO if (muduo::Logger::logLevel() <= muduo::Logger::INFO) \

  muduo::Logger(__FILE__, __LINE__).stream()

返回的stream重载了一系列的运算符，使用方法如下

LOG_INFO<<“info ...”;   // 使用方式

上面那句其实就是

muduo::Logger(__FILE__, __LINE__).stream()<<“info”;

调用过程实际是如下所示的

Logger => Impl => LogStream => operator<< FixedBuffer => g_output => g_flush

muduo库里面的日志类封装相关的文件为Logging.h，Logging.cc，LogSrtream.h，LogSrtream.cc，附带一个StringPiece.h文件，几个文件的注解如下所示：

Logging.h

//日志输出

#ifndef MUDUO_BASE_LOGGING_H

#define MUDUO_BASE_LOGGING_H

#include <muduo/base/LogStream.h>

#include <muduo/base/Timestamp.h>

namespace muduo

{

class Logger

{

 public:

    //日志级别

  enum LogLevel

  {

    TRACE,

    DEBUG,

    INFO,

    WARN,

    ERROR,

    FATAL,

    NUM_LOG_LEVELS,//级别个数6

  };

  // compile time calculation of basename of source file

  class SourceFile

  {

   public:

    template<int N>

    inline SourceFile(const char (&arr)[N])

      : data_(arr),

        size_(N-1)

    {

      const char* slash = strrchr(data_, '/'); // builtin function

      if (slash)

      {

        data_ = slash + 1;

        size_ -= static_cast<int>(data_ - arr);

      }

    }

    explicit SourceFile(const char* filename)

      : data_(filename)

    {

      const char* slash = strrchr(filename, '/');

      if (slash)

      {

        data_ = slash + 1;

      }

      size_ = static_cast<int>(strlen(data_));

    }

    const char* data_;

    int size_;

  };

//四个构造函数

  Logger(SourceFile file, int line);

  Logger(SourceFile file, int line, LogLevel level);

  Logger(SourceFile file, int line, LogLevel level, const char* func);

  Logger(SourceFile file, int line, bool toAbort);

  ~Logger();

  LogStream& stream() { return impl_.stream_; }

  static LogLevel logLevel();

  static void setLogLevel(LogLevel level);

  typedef void (*OutputFunc)(const char* msg, int len);

  typedef void (*FlushFunc)();

  static void setOutput(OutputFunc);

  static void setFlush(FlushFunc);

 private:

//Loger类的内部嵌套类

//Impl类主要是负责日志的格式化

class Impl

{

 public:

  typedef Logger::LogLevel LogLevel;

  //构造函数

  Impl(LogLevel level, int old_errno, const SourceFile& file, int line);

  //格式化时间函数

  void formatTime();

  void finish();

  Timestamp time_;//Timestamp时间戳

  LogStream stream_;//LogStream类对象成员

  LogLevel level_;//日志级别

  int line_;//行号

  SourceFile basename_;

};

  Impl impl_;//Impl类对象成员

};

extern Logger::LogLevel g_logLevel;

inline Logger::LogLevel Logger::logLevel()

{

  return g_logLevel;//日志级别

}

//日志输出宏，输出在哪个文件? 哪一行? 哪个函数? 哪种级别?

//无名对象所在语句执行后就立即被析构，然后调用析构函数将缓冲区的内容分输出

// muduo::Logger(__FILE__, __LINE__, muduo::Logger::TRACE, __func__).stream()返回的是一个LogStream对象

#define LOG_TRACE if (muduo::Logger::logLevel() <= muduo::Logger::TRACE) \

  muduo::Logger(__FILE__, __LINE__, muduo::Logger::TRACE, __func__).stream()

#define LOG_DEBUG if (muduo::Logger::logLevel() <= muduo::Logger::DEBUG) \

  muduo::Logger(__FILE__, __LINE__, muduo::Logger::DEBUG, __func__).stream()

#define LOG_INFO if (muduo::Logger::logLevel() <= muduo::Logger::INFO) \

  muduo::Logger(__FILE__, __LINE__).stream()

#define LOG_WARN muduo::Logger(__FILE__, __LINE__, muduo::Logger::WARN).stream()

#define LOG_ERROR muduo::Logger(__FILE__, __LINE__, muduo::Logger::ERROR).stream()

#define LOG_FATAL muduo::Logger(__FILE__, __LINE__, muduo::Logger::FATAL).stream()

//false表示不会退出程序

#define LOG_SYSERR muduo::Logger(__FILE__, __LINE__, false).stream()//ERROR

//true表示会退出程序

#define LOG_SYSFATAL muduo::Logger(__FILE__, __LINE__, true).stream()//FATAL

const char* strerror_tl(int savedErrno);

// Taken from glog/logging.h

//

// Check that the input is non NULL.  This very useful in constructor

// initializer lists.

#define CHECK_NOTNULL(val) \

  ::muduo::CheckNotNull(__FILE__, __LINE__, "'" #val "' Must be non NULL", (val))

// A small helper for CHECK_NOTNULL().

template <typename T>

T* CheckNotNull(Logger::SourceFile file, int line, const char *names, T* ptr) {

  if (ptr == NULL) {

   Logger(file, line, Logger::FATAL).stream() << names;

  }

  return ptr;

}

}

#endif  // MUDUO_BASE_LOGGING_H

Logging.cc

#include <muduo/base/Logging.h>

#include <muduo/base/CurrentThread.h>

#include <muduo/base/StringPiece.h>

#include <muduo/base/Timestamp.h>

#include <errno.h>

#include <stdio.h>

#include <string.h>

#include <sstream>

namespace muduo

{

/*

class LoggerImpl

{

 public:

  typedef Logger::LogLevel LogLevel;

  LoggerImpl(LogLevel level, int old_errno, const char* file, int line);

  void finish();

  Timestamp time_;

  LogStream stream_;

  LogLevel level_;

  int line_;

  const char* fullname_;

  const char* basename_;

};

*/

__thread char t_errnobuf[512];

__thread char t_time[32];

__thread time_t t_lastSecond;

const char* strerror_tl(int savedErrno)

{

  return strerror_r(savedErrno, t_errnobuf, sizeof t_errnobuf);

}

//初始化日志级别

Logger::LogLevel initLogLevel()

{//获取环境变量

  if (::getenv("MUDUO_LOG_TRACE"))//如果获取到了这个环境变量

    return Logger::TRACE;//日志级别为TRACE

  else if (::getenv("MUDUO_LOG_DEBUG"))//如果获取到了这个环境变量

    return Logger::DEBUG;//日志级别为DEBUG

  else

    return Logger::INFO;//否则日志级别为INFO

}

Logger::LogLevel g_logLevel = initLogLevel();

//日志级别

const char* LogLevelName[Logger::NUM_LOG_LEVELS] =

{

  "TRACE ",

  "DEBUG ",

  "INFO  ",

  "WARN  ",

  "ERROR ",

  "FATAL ",

};

// helper class for known string length at compile time

class T

{

 public:

  T(const char* str, unsigned len)

    :str_(str),

     len_(len)

  {

    assert(strlen(str) == len_);

  }

  const char* str_;

  const unsigned len_;

};

inline LogStream& operator<<(LogStream& s, T v)

{

  s.append(v.str_, v.len_);

  return s;

}

inline LogStream& operator<<(LogStream& s, const Logger::SourceFile& v)

{

  s.append(v.data_, v.size_);

  return s;

}

//默认输出

void defaultOutput(const char* msg, int len)

{//输出到标准输出

  size_t n = fwrite(msg, 1, len, stdout);

  //FIXME check n

  (void)n;

}

//默认清空

void defaultFlush()

{//默认清空标准输出

  fflush(stdout);

}

Logger::OutputFunc g_output = defaultOutput;

Logger::FlushFunc g_flush = defaultFlush;

}

using namespace muduo;

//Impl类的构造函数

//级别，错误(没有错误则传0),文件，行

//Impl类主要是负责日志的格式化

Logger::Impl::Impl(LogLevel level, int savedErrno, const SourceFile& file, int line)

  : time_(Timestamp::now()),//登记当前的时间

    stream_(),//LogStream类

    level_(level),//级别

    line_(line),//行

    basename_(file)//文件名称

{

  formatTime();//格式化时间

  CurrentThread::tid();//缓存当前线程的id

  //输出字符串格式的线程id

  stream_ << T(CurrentThread::tidString(), 6);

  stream_ << T(LogLevelName[level], 6);

  if (savedErrno != 0)//如果savedErrno不为零，还要输出对应的信息

  {

    stream_ << strerror_tl(savedErrno) << " (errno=" << savedErrno << ") ";

  }

}

void Logger::Impl::formatTime()

{

  int64_t microSecondsSinceEpoch = time_.microSecondsSinceEpoch();//获得微秒格式的时间

  time_t seconds = static_cast<time_t>(microSecondsSinceEpoch / 1000000);//获得秒

  int microseconds = static_cast<int>(microSecondsSinceEpoch % 1000000);//微秒

  if (seconds != t_lastSecond)

  {

    t_lastSecond = seconds;

    struct tm tm_time;

    ::gmtime_r(&seconds, &tm_time); // FIXME TimeZone::fromUtcTime

    int len = snprintf(t_time, sizeof(t_time), "%4d%02d%02d %02d:%02d:%02d",

        tm_time.tm_year + 1900, tm_time.tm_mon + 1, tm_time.tm_mday,

        tm_time.tm_hour, tm_time.tm_min, tm_time.tm_sec);

    assert(len == 17); (void)len;

  }

  Fmt us(".%06dZ ", microseconds);

  assert(us.length() == 9);

  //LogStream类重载运算符，把信息输出到缓冲区

  stream_ << T(t_time, 17) << T(us.data(), 9);

}

void Logger::Impl::finish()

{

  stream_ << " - " << basename_ << ':' << line_ << '\n';

}

//构造函数，都是构造Impl对象

Logger::Logger(SourceFile file, int line) : impl_(INFO, 0, file, line)

{

}

//文件名，行，级别，函数名称

Logger::Logger(SourceFile file, int line, LogLevel level, const char* func) : impl_(level, 0, file, line)

{//格式化函数名称

  impl_.stream_ << func << ' ';

}

Logger::Logger(SourceFile file, int line, LogLevel level): impl_(level, 0, file, line)

{

}

//如果toAbort是真，则级别为FATAL，否则为ERROR

Logger::Logger(SourceFile file, int line, bool toAbort) : impl_(toAbort?FATAL:ERROR, errno, file, line)

{

}

//析构函数

Logger::~Logger()

{

  impl_.finish();

  //取出stream类缓冲区的内容放到buf

  const LogStream::Buffer& buf(stream().buffer());

  //输出，g_output有一个默认的输出stdout

  g_output(buf.data(), buf.length());

  if (impl_.level_ == FATAL)//如果是FATAL

  {

    g_flush();//清空缓冲区

    abort();//终止程序

  }

}

void Logger::setLogLevel(Logger::LogLevel level)

{

  g_logLevel = level;

}

//更改输出函数

void Logger::setOutput(OutputFunc out)

{

  g_output = out;

}

void Logger::setFlush(FlushFunc flush)

{

  g_flush = flush;

}

LogSrtream.h

//日志流

#ifndef MUDUO_BASE_LOGSTREAM_H

#define MUDUO_BASE_LOGSTREAM_H

#include <muduo/base/StringPiece.h>

#include <muduo/base/Types.h>

#include <assert.h>

#include <string.h> // memcpy

#ifndef MUDUO_STD_STRING

#include <string>

#endif

#include <boost/noncopyable.hpp>

namespace muduo

{

namespace detail

{

//定义两个缓冲区大小的常量

const int kSmallBuffer = 4000;

const int kLargeBuffer = 4000*1000;

//缓冲区类

//模板，但是SIZE是非类型参数

template<int SIZE>

class FixedBuffer : boost::noncopyable//不可被拷贝

{

 public:

    //构造函数

  FixedBuffer() : cur_(data_)//初始化当前指针

  {//设置函数指针

    setCookie(cookieStart);

  }

//析构函数

  ~FixedBuffer()

  {//传递函数指针，这个和构造函数传递的两个函数在下面

    setCookie(cookieEnd);

  }

//添加数据

  void append(const char* /*restrict*/ buf, size_t len)

  {

    // FIXME: append partially当前可用空间长度大于len

    if (implicit_cast<size_t>(avail()) > len)

    {//复制数据

      memcpy(cur_, buf, len);

      //更新当前指针

      cur_ += len;

    }

    //如果当前空间不够用了，这里并没有实现添加部分进来

  }

  const char* data() const { return data_; }

  //已经用的长度空间

  int length() const { return static_cast<int>(cur_ - data_); }

  // write to data_ directly

  char* current() { return cur_; }

  //当前可用的空间(end减去当前指针)

  int avail() const { return static_cast<int>(end() - cur_); }

  //增加

  void add(size_t len) { cur_ += len; }

  //重置空间

  void reset() { cur_ = data_; }

  //把数据都清零，相当于memset(buf,0,sizeof(buf))

  void bzero() { ::bzero(data_, sizeof data_); }

  // for used by GDB

  //在数据后面加个结束符

  const char* debugString();

  //将函数指针指向传递进来的函数

  void setCookie(void (*cookie)()) { cookie_ = cookie; }

  // for used by unit test

  //把数据构造一个String对象出来

  string asString() const { return string(data_, length()); }

 private:

    //返回的是缓冲区的后一个地址

  const char* end() const { return data_ + sizeof data_; }

  // Must be outline function for cookies.

  static void cookieStart();

  static void cookieEnd();

  void (*cookie_)();//一个函数指针

  char data_[SIZE];//data就是缓冲区,容量为传进来的SIZE

  char* cur_;//当前指针

};

}

//LogStream类主要是封装了插入运算符

class LogStream : boost::noncopyable

{

  typedef LogStream self;

 public:

    //包含了LogStream的缓冲区，kSmallBuffer，k开头的表示一个常量，是谷歌的编程规范

  typedef detail::FixedBuffer<detail::kSmallBuffer> Buffer;

   //输出数据首先是输出到缓冲区当中

   //以下重载了各种类型的插入运算符

   //返回的是自身的引用

  self& operator<<(bool v)

  {//输出布尔类型

    buffer_.append(v ? "1" : "0", 1);//长度是1

    return *this;

  }

  //实现在.cc文件

  self& operator<<(short);

  self& operator<<(unsigned short);

  self& operator<<(int);

  self& operator<<(unsigned int);

  self& operator<<(long);

  self& operator<<(unsigned long);

  self& operator<<(long long);

  self& operator<<(unsigned long long);

    //存放指针

  self& operator<<(const void*);

  //浮点数

  self& operator<<(float v)

  {

    *this << static_cast<double>(v);

    return *this;

  }

  self& operator<<(double);

  // self& operator<<(long double);

 //存放单个字符

  self& operator<<(char v)

  {

    buffer_.append(&v, 1);

    return *this;

  }

  // self& operator<<(signed char);

  // self& operator<<(unsigned char);

 //存放字符串

  self& operator<<(const char* v)

  {//把字符串添加进缓冲区

    buffer_.append(v, strlen(v));

    return *this;

  }

  self& operator<<(const string& v)

  {

    buffer_.append(v.c_str(), v.size());

    return *this;

  }

//如果定义了MUDUO_STD_STRING，则使用的是std::string

//否则使用的是__gnu_cxx::__sso_string

#ifndef MUDUO_STD_STRING

  self& operator<<(const std::string& v)

  {

    buffer_.append(v.c_str(), v.size());

    return *this;

  }

#endif

  self& operator<<(const StringPiece& v)

  {

    buffer_.append(v.data(), v.size());

    return *this;

  }

  //这三个只是改装了以下接口

  void append(const char* data, int len) { buffer_.append(data, len); }

  const Buffer& buffer() const { return buffer_; }

  void resetBuffer() { buffer_.reset(); }

 private:

  void staticCheck();

//成员模板函数

  template<typename T>

  void formatInteger(T);

  Buffer buffer_;//大小为kSmallBuffer的缓冲区

  static const int kMaxNumericSize = 32;

};

class Fmt // : boost::noncopyable

{

 public:

    //成员模板，把val进行格式化，然后存放到buf中

  template<typename T>

  Fmt(const char* fmt, T val);

  const char* data() const { return buf_; }//返回格式化的数据

  int length() const { return length_; }//返回长度

 private:

  char buf_[32];

  int length_;

};

inline LogStream& operator<<(LogStream& s, const Fmt& fmt)

{

  s.append(fmt.data(), fmt.length());

  return s;

}

}

#endif  // MUDUO_BASE_LOGSTREAM_H

LogSrtream.cc

#include <muduo/base/LogStream.h>

#include <algorithm>

#include <limits>

#include <boost/static_assert.hpp>

#include <boost/type_traits/is_arithmetic.hpp>

#include <assert.h>

#include <string.h>

#include <stdint.h>

#include <stdio.h>

using namespace muduo;

using namespace muduo::detail;

#pragma GCC diagnostic ignored "-Wtype-limits"

//#pragma GCC diagnostic error "-Wtype-limits"

namespace muduo

{

namespace detail

{

const char digits[] = "9876543210123456789";

const char* zero = digits + 9;//digits + 9就是"0"

BOOST_STATIC_ASSERT(sizeof(digits) == 20);

const char digitsHex[] = "0123456789ABCDEF";

BOOST_STATIC_ASSERT(sizeof digitsHex == 17);

// Efficient Integer to String Conversions, by Matthew Wilson.

//将 一个数转换成字符串

template<typename T>

size_t convert(char buf[], T value)

{

  T i = value;

  char* p = buf;

  do

  {//对10取模得到最后一位数字

    int lsd = static_cast<int>(i % 10);

    i /= 10;//更新当前数

    //zero将数字转换成字符串,zero指针指向的字符是0，再偏移lsd个位置可以得到相应的字符

    *p++ = zero[lsd];

  } while (i != 0);

//比如-123会转成"321-"

  if (value < 0)//如果要转换的值小于0

  {

    *p++ = '-';

  }

  *p = '\0';//添加结束符

  std::reverse(buf, p);//使用reverse将字符串进行逆转

  return p - buf;//返回转换的字符数

}

//uintptr_t类型对于32位平台来说就是unsigned int

//对于64位平台来说就是unsigned long int

size_t convertHex(char buf[], uintptr_t value)

{//转换成16进制的字符，和转换成10进制的差不多

  uintptr_t i = value;

  char* p = buf;

  do

  {

    int lsd = i % 16;

    i /= 16;

    *p++ = digitsHex[lsd];

  } while (i != 0);

  *p = '\0';

  std::reverse(buf, p);

  return p - buf;

}

}

}

//在数据后面加个\0，相当于字符串

template<int SIZE>

const char* FixedBuffer<SIZE>::debugString()

{

  *cur_ = '\0';//加入结束符

  return data_;

}

template<int SIZE>

void FixedBuffer<SIZE>::cookieStart()

{

}

template<int SIZE>

void FixedBuffer<SIZE>::cookieEnd()

{

}

template class FixedBuffer<kSmallBuffer>;

template class FixedBuffer<kLargeBuffer>;

void LogStream::staticCheck()

{

  BOOST_STATIC_ASSERT(kMaxNumericSize - 10 > std::numeric_limits<double>::digits10);

  BOOST_STATIC_ASSERT(kMaxNumericSize - 10 > std::numeric_limits<long double>::digits10);

  BOOST_STATIC_ASSERT(kMaxNumericSize - 10 > std::numeric_limits<long>::digits10);

  BOOST_STATIC_ASSERT(kMaxNumericSize - 10 > std::numeric_limits<long long>::digits10);

}

//类型转换成员模板的实现

template<typename T>

void LogStream::formatInteger(T v)

{//当前缓冲区大于32

  if (buffer_.avail() >= kMaxNumericSize)//kMaxNumericSize为32

  {//把v转换成字符串，存放到buffer_.current()

    size_t len = convert(buffer_.current(), v);

    //调整buffer_.current()指针

    buffer_.add(len);

  }

}

//重载各种运算符

LogStream& LogStream::operator<<(short v)

{//short转成int

  *this << static_cast<int>(v);

  return *this;

}

LogStream& LogStream::operator<<(unsigned short v)

{//unsigned short转成unsigned int

  *this << static_cast<unsigned int>(v);

  return *this;

}

LogStream& LogStream::operator<<(int v)

{

  formatInteger(v);

  return *this;

}

LogStream& LogStream::operator<<(unsigned int v)

{

  formatInteger(v);

  return *this;

}

LogStream& LogStream::operator<<(long v)

{

  formatInteger(v);

  return *this;

}

LogStream& LogStream::operator<<(unsigned long v)

{

  formatInteger(v);

  return *this;

}

LogStream& LogStream::operator<<(long long v)

{

  formatInteger(v);

  return *this;

}

LogStream& LogStream::operator<<(unsigned long long v)

{

  formatInteger(v);

  return *this;

}

//转换指针，是转成16进制的

LogStream& LogStream::operator<<(const void* p)

{//把指针强制转换为uintptr_t类型

//uintptr_t类型对于32位平台来说就是unsigned int

//对于64位平台来说就是unsigned long int

  uintptr_t v = reinterpret_cast<uintptr_t>(p);

  if (buffer_.avail() >= kMaxNumericSize)

  {

    char* buf = buffer_.current();//获取当前的位置

    buf[0] = '0';//添加两个字符表示是16进制

    buf[1] = 'x';

    size_t len = convertHex(buf+2, v);

    buffer_.add(len+2);//更新当前指针

  }

  return *this;

}

// FIXME: replace this with Grisu3 by Florian Loitsch.

LogStream& LogStream::operator<<(double v)

{

  if (buffer_.avail() >= kMaxNumericSize)

  {

    int len = snprintf(buffer_.current(), kMaxNumericSize, "%.12g", v);

    buffer_.add(len);

  }

  return *this;

}

//把T按fmt格式化后存放到buf中

template<typename T>

Fmt::Fmt(const char* fmt, T val)

{//断言T是算术类型

  BOOST_STATIC_ASSERT(boost::is_arithmetic<T>::value == true);

 //使用snprintf函数进行格式化

  length_ = snprintf(buf_, sizeof buf_, fmt, val);

  assert(static_cast<size_t>(length_) < sizeof buf_);

}

// Explicit instantiations

//模板的特化

template Fmt::Fmt(const char* fmt, char);

template Fmt::Fmt(const char* fmt, short);

template Fmt::Fmt(const char* fmt, unsigned short);

template Fmt::Fmt(const char* fmt, int);

template Fmt::Fmt(const char* fmt, unsigned  int);

template Fmt::Fmt(const char* fmt, long);

template Fmt::Fmt(const char* fmt, unsigned long);

template Fmt::Fmt(const char* fmt, long long);

template Fmt::Fmt(const char* fmt, unsigned long long);

template Fmt::Fmt(const char* fmt, float);

template Fmt::Fmt(const char* fmt, double);

编写两个简单的程序使用下日志功能，Log_test1.cc将日志输出到终端，代码如下

//日志输出到标准输出

#include <muduo/base/Logging.h>

#include <errno.h>

using namespace muduo;

int main()

{   //简单的使用下日志输出

    //各种级别的日志输出

    LOG_TRACE<<"trace ...";

    LOG_DEBUG<<"debug ...";

    LOG_INFO<<"info ...";

    LOG_WARN<<"warn ...";

    LOG_ERROR<<"error ...";

    //LOG_FATAL<<"fatal ...";//这里会中断程序，先注释掉

    errno = 13;

    LOG_SYSERR<<"syserr ...";

    //LOG_SYSFATAL<<"sysfatal ...";//这里会中断程序，先注释掉

    return 0;

}

运行结果如下所示：

Log_test2.cc将日志输出到文件，代码如下所示：

//日志输出到文件

#include <muduo/base/Logging.h>

#include <errno.h>

#include <stdio.h>

using namespace muduo;

FILE* g_file;//定义一个文件

//muduo中的  typedef void (*OutputFunc)(const char* msg, int len);

void dummyOutput(const char* msg, int len)

{

    if (g_file)

    {//将内容写到文件里

        fwrite(msg, 1, len, g_file);

    }

}

void dummyFlush()

{

    fflush(g_file);//清空输出

}

int main()

{

    g_file = ::fopen("/mnt/hgfs/lcw_program/lcw_muduo_learning/tests/muduo_log", "ae");//打开文件

    Logger::setOutput(dummyOutput);//设置输出到文件,dummyOutput为函数

    Logger::setFlush(dummyFlush);

    LOG_TRACE<<"trace ...";

    LOG_DEBUG<<"debug ...";

    LOG_INFO<<"info ...";

    LOG_WARN<<"warn ...";

    LOG_ERROR<<"error ...";

    //LOG_FATAL<<"fatal ...";//这里会中断程序，先注释掉

    errno = 13;

    LOG_SYSERR<<"syserr ...";

    //LOG_SYSFATAL<<"sysfatal ...";

    ::fclose(g_file);//关闭文件

    return 0;

}

运行结果如下：

文件内容如下：

巴特西

muduo网络库源码学习————日志类封装

最新文章

热门文章