muduo/base库学习笔记（1）-----Timestamp类

最新推荐文章于 2024-05-14 08:13:15 发布

原创最新推荐文章于 2024-05-14 08:13:15 发布 · 393 阅读

1 ·

CC 4.0 BY-SA版权

文章标签：

#muduo学习笔记

muduo 专栏收录该内容

13 篇文章

订阅专栏

本文详细介绍了Timestamp类的功能与实现，包括其变量定义、构造函数、静态成员函数、普通成员函数及内联函数等内容。Timestamp类用于处理时间戳相关操作，如获取当前时间、构造指定时间的时间戳等。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

Timestamp类

在这里插入图片描述

1 变量

static const int kMicroSecondsPerSecond = 1000 * 1000;

 private:
  int64_t microSecondsSinceEpoch_;

2 构造函数

无参构造函数

Timestamp()
    : microSecondsSinceEpoch_(0)
  {
  }

有参数构造函数

explicit Timestamp(int64_t microSecondsSinceEpochArg)
    : microSecondsSinceEpoch_(microSecondsSinceEpochArg)
  {
  }

3 静态成员函数

Timestamp Timestamp::now()函数的实现

static Timestamp Timestamp::now()
{
  struct timeval tv;
  //获得当前的事件
  gettimeofday(&tv, NULL);
  int64_t seconds = tv.tv_sec;
  //利用当前时间构造一个Timestamp时间戳对象
  return Timestamp(seconds * kMicroSecondsPerSecond + tv.tv_usec);
}

Timestamp invalid()函数的实现

//利用无参构造函数构造一个Timestamp类的实例
 static Timestamp invalid()
  {
    return Timestamp();
  }

** Timestamp fromUnixTime(time_t t, int microseconds)函数的实现**

static Timestamp fromUnixTime(time_t t, int microseconds)
  {
    //给定秒数和微秒数，构造一个该类的实例
    return Timestamp(static_cast<int64_t>(t) * kMicroSecondsPerSecond + microseconds);
  }

Timestamp fromUnixTime(time_t t)的实现

 static Timestamp fromUnixTime(time_t t)
  {
    //调用上一个函数
    return fromUnixTime(t, 0);
  }

4 普通成员函数

void swap(Timestamp& that)函数的实现

 void swap(Timestamp& that)
  {
    std::swap(microSecondsSinceEpoch_, that.microSecondsSinceEpoch_);
  }

bool valid() const函数的实现

 bool valid() const { return microSecondsSinceEpoch_ > 0; }

** int64_t microSecondsSinceEpoch() const函数的实现**

int64_t microSecondsSinceEpoch() const { return microSecondsSinceEpoch_; }

time_t secondsSinceEpoch() const函数的实现

time_t secondsSinceEpoch() const
  { return static_cast<time_t>(microSecondsSinceEpoch_ / kMicroSecondsPerSecond); }

string toString() const函数的实现

string Timestamp::toString() const
{
  char buf[32] = {0};
  //这是秒数
  int64_t seconds = microSecondsSinceEpoch_ / kMicroSecondsPerSecond;
  //这是微秒数
  int64_t microseconds = microSecondsSinceEpoch_ % kMicroSecondsPerSecond;
  //格式为秒数.微秒数
  snprintf(buf, sizeof(buf)-1, "%" PRId64 ".%06" PRId64 "", seconds, microseconds);
  return buf;
}

string Timestamp::toFormattedString(bool showMicroseconds) const函数的实现

//传入是否要显示秒数数
string Timestamp::toFormattedString(bool showMicroseconds) const
{
  char buf[64] = {0};
  time_t seconds = static_cast<time_t>(microSecondsSinceEpoch_ / kMicroSecondsPerSecond);
  struct tm tm_time;
  gmtime_r(&seconds, &tm_time);

  if (showMicroseconds)
  {
    int microseconds = static_cast<int>(microSecondsSinceEpoch_ % kMicroSecondsPerSecond);
    snprintf(buf, sizeof(buf), "%4d%02d%02d %02d:%02d:%02d.%06d",
             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,
             microseconds);
  }
  else
  {
    snprintf(buf, sizeof(buf), "%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);
  }
  return buf;
}

5 内联函数的实现

inline double timeDifference(Timestamp high, Timestamp low)函数的实现

inline double timeDifference(Timestamp high, Timestamp low)
{
  int64_t diff = high.microSecondsSinceEpoch() - low.microSecondsSinceEpoch();
  return static_cast<double>(diff) / Timestamp::kMicroSecondsPerSecond;
}

inline Timestamp addTime(Timestamp timestamp, double seconds)函数的实现

inline Timestamp addTime(Timestamp timestamp, double seconds)
{
  int64_t delta = static_cast<int64_t>(seconds * Timestamp::kMicroSecondsPerSecond);
  return Timestamp(timestamp.microSecondsSinceEpoch() + delta);
}

inline bool operator<(Timestamp lhs, Timestamp rhs)函数的实现

inline bool operator<(Timestamp lhs, Timestamp rhs)
{
  return lhs.microSecondsSinceEpoch() < rhs.microSecondsSinceEpoch();
}

inline bool operator==(Timestamp lhs, Timestamp rhs)函数的实现

inline double timeDifference(Timestamp high, Timestamp low)
{
  int64_t diff = high.microSecondsSinceEpoch() - low.microSecondsSinceEpoch();
  return static_cast<double>(diff) / Timestamp::kMicroSecondsPerSecond;
}