实现C++实用的时间库

最新推荐文章于 2022-11-07 09:01:29 发布
最新推荐文章于 2022-11-07 09:01:29 发布
阅读量741 收藏
点赞数
分类专栏： 跨平台C++开发
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yjwwyygy1990/article/details/48418551
版权

    完整工程代码放在我的github上：https://github.com/yjwwyygy/CrossPlatformLibrary

    根据C库提供的时间函数，实现一个方便实用的时间类。它应该具有以下基本功能：

    （1）方便的获取当前时间/指定时间的年、月、日、时、分、秒以及毫秒值。

    （2）支持时间的简单运算、比较。

    （3）支持时间对象转换为简单格式字符串以及简单字符串转换成时间对象。

    （4）不用特别复杂，功能够用就行，若再有必要的功能，再添加。

    类组成如下：

类名

说明

Time

精确到秒的时间类

TimeSpan

Time做算术运算的结果类

MilliTime

精确到毫秒的时间类

MilliTimeSpan

MilliTime做算术运算的结果类

     类继承关系如下：



    代码如下（以下是已经写好的代码，有点多，可以只关注头文件中类接口的定义）：

#ifndef BASE_TIME_H
#define BASE_TIME_H

#include "base_def.h"
#include 
   
   
    
    
#include 
    
    
     
     
#include "err.h"

#ifdef WIN32
#include 
     
     
      
      
#endif

#ifndef WIN32
#include 
      
      
       
       
#endif

// 秒级别的时间差类
class BASE_EXPORT TimeSpan
{
public:
    TimeSpan();
    TimeSpan(time_t time);
    TimeSpan(long nDays, int nHours, int nMins, int nSecs);
    TimeSpan(const TimeSpan& timeSpan);

    const TimeSpan& operator = (const TimeSpan& timeSpan);

    long GetDays() const;
    long GetTotalHours() const;
    long GetTotalMinutes() const;
    long GetTotalSeconds() const;
    int GetHours() const;
    int GetMinutes() const;
    int GetSeconds() const;

	TimeSpan operator + (const TimeSpan& timeSpan) const;
	TimeSpan operator - (const TimeSpan& timeSpan) const;
    const TimeSpan& operator += (const TimeSpan& timeSpan);
    const TimeSpan& operator -= (const TimeSpan& timeSpan);
    bool operator == (const TimeSpan& timeSpan) const;
    bool operator != (const TimeSpan& timeSpan) const;
    bool operator < (const TimeSpan& timeSpan) const;
    bool operator > (const TimeSpan& timeSpan) const;
    bool operator <= (const TimeSpan& timeSpan) const;
    bool operator >= (const TimeSpan& timeSpan) const;

protected:
    time_t m_timeSpan;
    friend class Time;
};

// 秒级别的时间类
class BASE_EXPORT Time
{
public:
    Time();
    Time(time_t tm);
    Time(int nYear, int nMonth, int nDay, int nHour, int nMin, int nSec);

    static Time GetCurrentTime();

    bool SetUTCTime(int nYear, int nMonth, int nDay, int nHour, int nMin, int nSec);
    void GetUTCTime(int &nYear, int &nMonth, int &nDay, int &nHour, int &nMin, int &nSec) const;
    void GetLocalTm(struct tm* localtime) const;
    void GetGmTm(struct tm* gm) const;
	std::string ToString() const;
	std::string ToUTCString() const;
	std::string DateToString() const;
	std::string UTCDateToString() const;
	std::string TimeToString() const;
	std::string UTCTimeToString() const;

    time_t GetTime() const;

    int GetUTCYear() const;
    int GetUTCMonth() const;
    int GetUTCDay() const;
    int GetUTCHour() const;
    int GetUTCMinute() const;
    int GetUTCSecond() const;
    int GetUTCDayOfWeek() const;
    int GetUTCDayOfMonth() const;
    int GetUTCDayOfYear() const;

    int GetYear() const;
    int GetMonth() const;
    int GetDay() const;
    int GetHour() const;
    int GetMinute() const;
    int GetSecond() const;
    int GetDayOfWeek() const;
    int GetDayOfMonth() const;
    int GetDayOfYear() const;

    TimeSpan operator - (const Time& time) const;
    Time operator - (const TimeSpan& time) const;
    Time operator + (const TimeSpan& timeSpan) const;
    const Time& operator += (const TimeSpan& timeSpan);
    const Time& operator -= (const TimeSpan& timeSpan);
    bool operator == (const Time& time) const;
    bool operator != (const Time& time) const;
    bool operator < (const Time& time) const;
    bool operator > (const Time& time) const;
    bool operator <= (const Time& time) const;
    bool operator >= (const Time& time) const;

protected:
    time_t m_time;
};

// 毫秒级别的时间差类
class BASE_EXPORT MilliTimeSpan : public TimeSpan
{
public:
	MilliTimeSpan();
	MilliTimeSpan(time_t time, int nMins);
	MilliTimeSpan(long lDays, int nHours, int nMins, int nSecs, int nMills);

	MilliTimeSpan(const MilliTimeSpan& timeSpanSrc);
	const MilliTimeSpan& operator=(const MilliTimeSpan& timeSpanSrc);

	int GetMillisecond() const { return m_nMilli; }

	MilliTimeSpan operator-(const MilliTimeSpan& timeSpan) const;
	MilliTimeSpan operator+(const MilliTimeSpan& timeSpan) const;
	const MilliTimeSpan& operator+=(const MilliTimeSpan& timeSpan);
	const MilliTimeSpan& operator-=(const MilliTimeSpan& timeSpan);
	bool operator==(const MilliTimeSpan& timeSpan) const;
	bool operator!=(const MilliTimeSpan& timeSpan) const;
	bool operator<(const MilliTimeSpan& timeSpan) const;
	bool operator>(const MilliTimeSpan& timeSpan) const;
	bool operator<=(const MilliTimeSpan& timeSpan) const;
	bool operator>=(const MilliTimeSpan& timeSpan) const;

protected:
	int m_nMilli;    // 毫秒值
	friend class MilliTime;
};

// 毫秒级别的时间类
class BASE_EXPORT MilliTime : public Time
{
public:
	MilliTime();
	MilliTime(time_t tm, int nMills);

	MilliTime(Time& t) : Time(t), m_nMilli(0)    {}
	MilliTime(const char * str)    { SetLocalByStringA(str); }
	MilliTime(const wchar_t* str)    { SetLocalByStringW(str); }

	MilliTime(int nYear, int nMonth, int nDay, int nHour, int nMin, int nSec, int nMilli);
	MilliTime(const MilliTime& right);

public:
	void SetMillisecond(int nMilli) { m_nMilli = nMilli; }
	int GetMillisecond() const { return m_nMilli; }
	void SetUTCByStringA(const char * str);
	void SetUTCByStringW(const wchar_t* str);
	void SetLocalByStringA(const char * str);
	void SetLocalByStringW(const wchar_t* str);
	std::string ToStringA();
	std::wstring ToStringW();
	std::string ToUTCStringA();
	std::wstring ToUTCStringW();
	static bool ParseStrW(const wchar_t* str, int &nYear, int &nMonth, int &nDay, int &nHour, int &nMin, int &nSec, int &nMilli);
	static bool ParseStrA(const char * str, int &nYear, int &nMonth, int &nDay, int &nHour, int &nMin, int &nSec, int &nMilli);

public:
	MilliTimeSpan operator-(const MilliTime& time) const;
	MilliTime operator-(const MilliTimeSpan& timeSpan) const;
	MilliTime operator+(const MilliTimeSpan& timeSpan) const;
	const MilliTime& operator+=(const MilliTimeSpan& timeSpan);
	const MilliTime& operator-=(const MilliTimeSpan& timeSpan);
	bool operator==(const MilliTime& time) const;
	bool operator!=(const MilliTime& time) const;
	bool operator<(const MilliTime& time) const;
	bool operator>(const MilliTime& time) const;
	bool operator<=(const MilliTime& time) const;
	bool operator>=(const MilliTime& time) const;

protected:
	int m_nMilli; // 毫秒值
};

/************************************************************************/
/* TimeSpan内联定义 */
/************************************************************************/
inline TimeSpan::TimeSpan()
{
}

inline TimeSpan::TimeSpan(time_t time)
{
    m_timeSpan = time; 
}

inline TimeSpan::TimeSpan(long lDays, int nHours, int nMins, int nSecs)
{
    m_timeSpan = nSecs + 60* (nMins + 60* (nHours + 24* lDays)); 
}

inline TimeSpan::TimeSpan(const TimeSpan& timeSpanSrc)
{
    m_timeSpan = timeSpanSrc.m_timeSpan; 
}

inline const TimeSpan& TimeSpan::operator=(const TimeSpan& timeSpanSrc)
{
    m_timeSpan = timeSpanSrc.m_timeSpan; 
    return *this; 
}

inline long TimeSpan::GetDays() const
{
    return (long)m_timeSpan / (24 * 3600L); 
}

inline long TimeSpan::GetTotalHours() const
{
    return (long)m_timeSpan/3600; 
}

inline int TimeSpan::GetHours() const
{
    return (int)(GetTotalHours() - GetDays() * 24); 
}

inline long TimeSpan::GetTotalMinutes() const
{
    return (long)m_timeSpan / 60; 
}

inline int TimeSpan::GetMinutes() const
{
    return (int)(GetTotalMinutes() - GetTotalHours() * 60); 
}

inline long TimeSpan::GetTotalSeconds() const
{
    return (long)m_timeSpan; 
}

inline int TimeSpan::GetSeconds() const
{
    return (int)(GetTotalSeconds() - GetTotalMinutes() * 60); 
}

inline TimeSpan TimeSpan::operator + (const TimeSpan& timeSpan) const
{
	return TimeSpan(m_timeSpan + timeSpan.m_timeSpan);
}

inline TimeSpan TimeSpan::operator - (const TimeSpan& timeSpan) const
{
    return TimeSpan(m_timeSpan - timeSpan.m_timeSpan); 
}

inline const TimeSpan& TimeSpan::operator += (const TimeSpan& timeSpan)
{
    m_timeSpan += timeSpan.m_timeSpan; 
    return *this; 
}

inline const TimeSpan& TimeSpan::operator -= (const TimeSpan& timeSpan)
{
    m_timeSpan -= timeSpan.m_timeSpan; 
    return *this; 
}

inline bool TimeSpan::operator == (const TimeSpan& timeSpan) const
{
    return m_timeSpan == timeSpan.m_timeSpan; 
}

inline bool TimeSpan::operator != (const TimeSpan& timeSpan) const
{
    return m_timeSpan != timeSpan.m_timeSpan; 
}

inline bool TimeSpan::operator < (const TimeSpan& timeSpan) const
{
    return m_timeSpan < timeSpan.m_timeSpan;
}

inline bool TimeSpan::operator > (const TimeSpan& timeSpan) const
{
    return m_timeSpan > timeSpan.m_timeSpan; 
}

inline bool TimeSpan::operator <= (const TimeSpan& timeSpan) const
{
    return m_timeSpan <= timeSpan.m_timeSpan; 
}

inline bool TimeSpan::operator >= (const TimeSpan& timeSpan) const
{
    return m_timeSpan >= timeSpan.m_timeSpan; 
}

/************************************************************************/
/* Time内联定义 */
/************************************************************************/
inline time_t Time::GetTime() const
{
    return m_time; 
}

inline int Time::GetYear() const
{
	tm t;
#ifdef WIN32
    localtime_s(&t, &m_time);
#else
	localtime_r(&m_time, &t);
#endif
	return t.tm_year + 1900; 
}

inline int Time::GetMonth() const
{
	tm t;
#ifdef WIN32
    localtime_s(&t, &m_time);
#else
	localtime_r(&m_time, &t);
#endif
	return t.tm_mon + 1;
}

inline int Time::GetDay() const
{
	tm t;
#ifdef WIN32
    localtime_s(&t, &m_time);
#else
	localtime_r(&m_time, &t);
#endif 
	return t.tm_mday; 
}

inline int Time::GetHour() const
{
	tm t;
#ifdef WIN32
    localtime_s(&t, &m_time);
#else
	localtime_r(&m_time, &t);
#endif
	return t.tm_hour; 
}

inline int Time::GetMinute() const
{
	tm t;
#ifdef WIN32
    localtime_s(&t, &m_time);
#else
	localtime_r(&m_time, &t);
#endif 
	return t.tm_min; 
}

inline int Time::GetSecond() const
{
	tm t;
#ifdef WIN32
    localtime_s(&t, &m_time);
#else
	localtime_r(&m_time, &t);
#endif
	return t.tm_sec; 
}

inline int Time::GetDayOfWeek() const
{
	tm t;
#ifdef WIN32
    localtime_s(&t, &m_time);
#else
	localtime_r(&m_time, &t);
#endif
	return t.tm_wday + 1;
}

inline int Time::GetDayOfMonth() const
{
	tm t;
#ifdef WIN32
    localtime_s(&t, &m_time);
#else
	localtime_r(&m_time, &t);
#endif
	return t.tm_mday;
}

inline int Time::GetDayOfYear() const
{
	tm t;
#ifdef WIN32
    localtime_s(&t, &m_time);
#else
	localtime_r(&m_time, &t);
#endif
	return t.tm_yday + 1;
}

inline int Time::GetUTCYear() const
{
	tm t;
#ifdef WIN32
    gmtime_s(&t, &m_time);
#else
	gmtime_r(&m_time, &t);
#endif
	return t.tm_year + 1900;
}

inline int Time::GetUTCMonth() const
{
	tm t;
#ifdef WIN32
    gmtime_s(&t, &m_time);
#else
	gmtime_r(&m_time, &t);
#endif
	return t.tm_mon + 1;
}

inline int Time::GetUTCDay() const
{
	tm t;
#ifdef WIN32
    gmtime_s(&t, &m_time);
#else
	gmtime_r(&m_time, &t);
#endif
	return t.tm_mday; 
}

inline int Time::GetUTCHour() const
{
	tm t;
#ifdef WIN32
    gmtime_s(&t, &m_time);
#else
	gmtime_r(&m_time, &t);
#endif
	return t.tm_hour; 
}

inline int Time::GetUTCMinute() const
{
	tm t;
#ifdef WIN32
    gmtime_s(&t, &m_time);
#else
	gmtime_r(&m_time, &t);
#endif
	return t.tm_min; 
}

inline int Time::GetUTCSecond() const
{
	tm t;
#ifdef WIN32
    gmtime_s(&t, &m_time);
#else
	gmtime_r(&m_time, &t);
#endif
	return t.tm_sec; 
}

inline int Time::GetUTCDayOfWeek() const
{
	tm t;
#ifdef WIN32
    gmtime_s(&t, &m_time);
#else
	gmtime_r(&m_time, &t);
#endif
	return t.tm_wday + 1; 
}

inline int Time::GetUTCDayOfMonth() const
{
	tm t;
#ifdef WIN32
    gmtime_s(&t, &m_time);
#else
	gmtime_r(&m_time, &t);
#endif
	return t.tm_mday; 
}

inline int Time::GetUTCDayOfYear() const
{
	tm t;
#ifdef WIN32
    gmtime_s(&t, &m_time);
#else
	gmtime_r(&m_time, &t);
#endif
	return t.tm_yday + 1; 
}

inline TimeSpan Time::operator - (const Time& time) const
{
    return TimeSpan(m_time - time.m_time); 
}

inline Time Time::operator - (const TimeSpan& timeSpan) const
{
    return Time(m_time - timeSpan.m_timeSpan); 
}

inline Time Time::operator + (const TimeSpan& timeSpan) const
{
    return Time(m_time + timeSpan.m_timeSpan); 
}

inline const Time& Time::operator += (const TimeSpan& timeSpan)
{
    m_time += timeSpan.m_timeSpan; 
    return *this; 
}

inline const Time& Time::operator -= (const TimeSpan& timeSpan)
{
    m_time -= timeSpan.m_timeSpan; 
    return *this; 
}

inline bool Time::operator==(const Time& time) const
{
    return m_time == time.m_time; 
}

inline bool Time::operator!=(const Time& time) const
{
    return m_time != time.m_time; 
}

inline bool Time::operator<(const Time& time) const
{
    return m_time < time.m_time; 
}

inline bool Time::operator>(const Time& time) const
{
    return m_time > time.m_time; 
}

inline bool Time::operator<=(const Time& time) const
{
    return m_time <= time.m_time; 
}

inline bool Time::operator>=(const Time& time) const
{
    return m_time >= time.m_time; 
}

/************************************************************************/
/* MilliTimeSpan内联定义 */
/************************************************************************/
inline MilliTimeSpan::MilliTimeSpan() : m_nMilli(0)
{

}

inline MilliTimeSpan::MilliTimeSpan(time_t time, int nMilli) : TimeSpan(time)
{
	BASE_ASSERT(nMilli >= 0 && nMilli < 1000);
	m_nMilli = nMilli;
}

inline MilliTimeSpan::MilliTimeSpan(long lDays, int nHours, int nMins, int nSecs, int nMilli)
	: TimeSpan(lDays, nHours, nMins, nSecs)
{
	BASE_ASSERT(nMilli >= 0 && nMilli < 1000);
	m_nMilli = nMilli;
}

inline MilliTimeSpan::MilliTimeSpan(const MilliTimeSpan& timeSpanSrc)
	: TimeSpan(timeSpanSrc), m_nMilli(timeSpanSrc.m_nMilli)
{

}

inline const MilliTimeSpan& MilliTimeSpan::operator=(const MilliTimeSpan& timeSpanSrc)
{
	m_timeSpan = timeSpanSrc.m_timeSpan;
	m_nMilli = timeSpanSrc.m_nMilli;
	return *this;
}

inline MilliTimeSpan MilliTimeSpan::operator-(const MilliTimeSpan& timeSpan) const
{
	if (m_nMilli < timeSpan.m_nMilli)
	{
		return MilliTimeSpan(m_timeSpan - timeSpan.m_timeSpan - 1, m_nMilli - timeSpan.m_nMilli + 1000);
	}
	else
	{
		return MilliTimeSpan(m_timeSpan - timeSpan.m_timeSpan, m_nMilli - timeSpan.m_nMilli);
	}
}

inline const MilliTimeSpan& MilliTimeSpan::operator-=(const MilliTimeSpan& timeSpan)
{
	if (m_nMilli < timeSpan.m_nMilli)
	{
		m_timeSpan -= (timeSpan.m_timeSpan + 1), m_nMilli -= (timeSpan.m_nMilli - 1000);
	}
	else
	{
		m_timeSpan -= timeSpan.m_timeSpan, m_nMilli -= timeSpan.m_nMilli;
	}

	return *this;
}

inline MilliTimeSpan MilliTimeSpan::operator+(const MilliTimeSpan& timeSpan) const
{
	int nMilli = m_nMilli + timeSpan.m_nMilli;
	if (nMilli >= 1000)
	{
		return MilliTimeSpan(m_timeSpan + timeSpan.m_timeSpan + 1, nMilli - 1000);
	}
	else
	{
		return MilliTimeSpan(m_timeSpan + timeSpan.m_timeSpan, nMilli);
	}
}

inline const MilliTimeSpan& MilliTimeSpan::operator+=(const MilliTimeSpan& timeSpan)
{
	int nMilli = m_nMilli + timeSpan.m_nMilli;
	if (nMilli >= 1000)
	{
		m_timeSpan += (timeSpan.m_timeSpan + 1), m_nMilli = (nMilli - 1000);
	}
	else
	{
		m_timeSpan += timeSpan.m_timeSpan, m_nMilli = nMilli;
	}

	return *this;
}

inline bool MilliTimeSpan::operator==(const MilliTimeSpan& timeSpan) const
{
	return m_timeSpan == timeSpan.m_timeSpan && m_nMilli == timeSpan.m_nMilli;
}

inline bool MilliTimeSpan::operator!=(const MilliTimeSpan& timeSpan) const
{
	return m_timeSpan != timeSpan.m_timeSpan || m_nMilli != timeSpan.m_nMilli;
}

inline bool MilliTimeSpan::operator<(const MilliTimeSpan& timeSpan) const
{
	return (m_timeSpan == timeSpan.m_timeSpan) ? (m_nMilli < timeSpan.m_nMilli) : (m_timeSpan < timeSpan.m_timeSpan);
}

inline bool MilliTimeSpan::operator>(const MilliTimeSpan& timeSpan) const
{
	return (m_timeSpan == timeSpan.m_timeSpan) ? (m_nMilli > timeSpan.m_nMilli) : (m_timeSpan > timeSpan.m_timeSpan);
}

inline bool MilliTimeSpan::operator<=(const MilliTimeSpan& timeSpan) const
{
	return (m_timeSpan == timeSpan.m_timeSpan) ? (m_nMilli <= timeSpan.m_nMilli) : (m_timeSpan <= timeSpan.m_timeSpan);
}

inline bool MilliTimeSpan::operator>=(const MilliTimeSpan& timeSpan) const
{
	return (m_timeSpan == timeSpan.m_timeSpan) ? (m_nMilli >= timeSpan.m_nMilli) : (m_timeSpan >= timeSpan.m_timeSpan);
}

/************************************************************************/
/* MilliTime内联定义 */
/************************************************************************/
inline MilliTime::MilliTime()
{
#ifdef WIN32
	SYSTEMTIME   st;
	GetLocalTime(&st);
	m_nMilli = st.wMilliseconds;
#else
	struct timeval nowtimeval;
	gettimeofday(&nowtimeval, 0);
	m_nMilli = nowtimeval.tv_usec / 1000;
	//m_time = nowtimeval.tv_sec;
#endif
}

inline MilliTime::MilliTime(time_t tm, int nMills) : Time(tm), m_nMilli(nMills)
{
	BASE_ASSERT(m_nMilli >= 0 && m_nMilli < 1000);
}

inline MilliTime::MilliTime(int nYear, int nMonth, int nDay, int nHour, int nMin, int nSec, int nMilli)
	: Time(nYear, nMonth, nDay, nHour, nMin, nSec)
{
	BASE_ASSERT(nMilli >= 0 && nMilli < 1000);
	m_nMilli = nMilli;
}

inline MilliTime::MilliTime(const MilliTime& right) : Time(right), m_nMilli(right.m_nMilli)
{

}

inline MilliTimeSpan MilliTime::operator-(const MilliTime& right) const
{
	if (m_nMilli < right.m_nMilli)
	{
		return MilliTimeSpan(m_time - right.m_time - 1, m_nMilli - right.m_nMilli + 1000);
	}
	else
	{
		return MilliTimeSpan(m_time - right.m_time, m_nMilli - right.m_nMilli);
	}
}

inline MilliTime MilliTime::operator-(const MilliTimeSpan& right) const
{
	if (m_nMilli < right.m_nMilli)
	{
		return MilliTime(m_time - right.m_timeSpan - 1, m_nMilli - right.m_nMilli + 1000);
	}
	else
	{
		return MilliTime(m_time - right.m_timeSpan, m_nMilli - right.m_nMilli);
	}
}

inline const MilliTime& MilliTime::operator-=(const MilliTimeSpan& timeSpan)
{
	if (m_nMilli < timeSpan.m_nMilli)
	{
		m_time -= timeSpan.m_timeSpan - 1, m_nMilli -= (timeSpan.m_nMilli - 1000);
	}
	else
	{
		m_time -= timeSpan.m_timeSpan, m_nMilli -= timeSpan.m_nMilli;
	}

	return *this;
}

inline MilliTime MilliTime::operator+(const MilliTimeSpan& timeSpan) const
{
	if ((m_nMilli + timeSpan.m_nMilli) >= 1000)
	{
		return MilliTime(m_time + timeSpan.m_timeSpan + 1, m_nMilli + timeSpan.m_nMilli - 1000);
	}
	else
	{
		return MilliTime(m_time + timeSpan.m_timeSpan, m_nMilli + timeSpan.m_nMilli);
	}
}

inline const MilliTime& MilliTime::operator+=(const MilliTimeSpan &timeSpan)
{
	if ((m_nMilli + timeSpan.m_nMilli) >= 1000)
	{
		m_time += (timeSpan.m_timeSpan + 1), m_nMilli += (timeSpan.m_nMilli - 1000);
	}
	else
	{
		m_time += timeSpan.m_timeSpan, m_nMilli += timeSpan.m_nMilli;
	}

	return *this;
}

inline bool MilliTime::operator==(const MilliTime& time) const
{
	return (m_time == time.m_time) && (m_nMilli == time.m_nMilli);
}

inline bool MilliTime::operator!=(const MilliTime& time) const
{
	return (m_time != time.m_time) || (m_nMilli != time.m_nMilli);
}

inline bool MilliTime::operator<(const MilliTime& time) const
{
	return (m_time == time.m_time) ? (m_nMilli < time.m_nMilli) : (m_time < time.m_time);
}

inline bool MilliTime::operator>(const MilliTime& time) const
{
	return (m_time == time.m_time) ? (m_nMilli > time.m_nMilli) : (m_time > time.m_time);
}

inline bool MilliTime::operator<=(const MilliTime& time) const
{
	return (m_time == time.m_time) ? (m_nMilli <= time.m_nMilli) : (m_time <= time.m_time);
}

inline bool MilliTime::operator>=(const MilliTime& time) const
{
	return (m_time == time.m_time) ? (m_nMilli >= time.m_nMilli) : (m_time >= time.m_time);
}

extern wchar_t* my_wcstok(wchar_t *wcs, const wchar_t *delim);
extern char* my_strtok(char *wcs, const char *delim);

#endif
      
      
     
     
    
    
   
   
#include "base_time.h"
#include "except.h"
#include 
   
   
    
    
#include 
    
    
     
     
#include 
     
     
      
      

using namespace std;

#define _MAX__TIME64_T     0x793406fffLL 

// 参考Linux源代码中的实现
// 详解访问：http://blog.csdn.net/axx1611/article/details/1792827
static inline unsigned long linux_mktime (
              unsigned int year, unsigned int mon,
              unsigned int day, unsigned int hour,
              unsigned int min, unsigned int sec)
{
    /* 1..12 -> 11,12,1..10 */
    if (0 >= (int) (mon -= 2)) 
    {    
        mon += 12;        /* Puts Feb last since it has leap day */
        year -= 1;
    }

    return ((((unsigned long) (year / 4 - year / 100 + year / 400 + 367 * mon / 12 + day)
              + year * 365 - 719499) * 24 + hour) * 60 + min ) * 60 + sec; /* finally seconds */
}


/************************************************************************/
/* Time定义 */
/************************************************************************/
Time::Time()
{
    m_time = time(NULL);
}

Time::Time(time_t tm)
{
    m_time = tm;
}

Time::Time(int nYear, int nMonth, int nDay, int nHour, int nMin, int nSec)
{
    if (SetUTCTime (nYear, nMonth, nDay, nHour, nMin, nSec))
    {
#ifdef WIN32
        _tzset ();
        long timezone;
        _get_timezone(&timezone);
        m_time += timezone;
#else
        tzset ();
        m_time += timezone;        
#endif
    }
}

bool Time::SetUTCTime (int nYear, int nMonth, int nDay, int nHour, int nMin, int nSec)
{
    if ((nDay >= 1 && nDay <= 31)
        && (nMonth >= 1 && nMonth <= 12)
        && (nYear >= 1900)
		&& (nHour >= 0 && nHour <= 23)
		&& (nMin >= 0 && nMin <= 59)
		&& (nSec >= 0 && nSec <= 59))
    {
        m_time = linux_mktime (nYear, nMonth, nDay, nHour, nMin, nSec);
        return true;
    }

    m_time = -1;

    return false;
}

void Time::GetLocalTm(struct tm* lc) const
{
#ifdef WIN32
    localtime_s(lc, &m_time);
#else
	localtime_r(&m_time, lc);
#endif
}

void Time::GetGmTm (struct tm* gm) const
{
#ifdef WIN32
    gmtime_s(gm, &m_time);
#else
	gmtime_r(&m_time, gm);
#endif
}

void Time::GetUTCTime (int &nYear, int &nMonth, int &nDay, int &nHour, int &nMin, int &nSec) const
{
    if (m_time > 0 && m_time <= _MAX__TIME64_T)
    {
        struct tm g;
        GetGmTm(&g);

        nYear = g.tm_year + 1900;
        nMonth = g.tm_mon + 1;
        nDay = g.tm_mday;
        nHour = g.tm_hour;
        nMin = g.tm_min;
        nSec = g.tm_sec;
    }
}

Time Time::GetCurrentTime ()
{
    return Time(time(NULL));
}

string Time::ToString() const
{
    char szTime[100] = {0};
    if (m_time > 0 && m_time <= _MAX__TIME64_T )
    {
#ifdef WIN32
        sprintf_s(szTime, 100, "%4d-%02d-%02d %02d:%02d:%02d",
            GetYear(), GetMonth(), GetDay(),
            GetHour(), GetMinute(), GetSecond());
#else
        sprintf(szTime, "%4d-%02d-%02d %02d:%02d:%02d",
            GetYear(), GetMonth(), GetDay(),
            GetHour(), GetMinute(), GetSecond());
#endif
    }
    return string(szTime);
}

string Time::ToUTCString() const
{
    char szTime[100] = {0};
    if (m_time > 0 && m_time <= _MAX__TIME64_T )
    {
#ifdef WIN32
        sprintf_s(szTime, 100, "%4d-%02d-%02d %02d:%02d:%02d",
            GetUTCYear(), GetUTCMonth(), GetUTCDay(),
            GetUTCHour(), GetUTCMinute(), GetUTCSecond());
#else
        sprintf(szTime, "%4d-%02d-%02d %02d:%02d:%02d",
            GetUTCYear(), GetUTCMonth(), GetUTCDay(),
            GetUTCHour(), GetUTCMinute(), GetUTCSecond());
#endif
    }
    return string(szTime);
}

string Time::DateToString() const
{
	char szTime[100] = { 0 };
	if (m_time > 0 && m_time <= _MAX__TIME64_T)
	{
#ifdef WIN32
		sprintf_s(szTime, 100, "%4d%02d%02d", GetYear(), GetMonth(), GetDay());
#else
		sprintf(szTime, "%4d%02d%02d", GetYear(), GetMonth(), GetDay());
#endif
	}

	return string(szTime);
}

string Time::UTCDateToString() const
{
	char szTime[100] = {0};
	if (m_time > 0 && m_time <= _MAX__TIME64_T )
	{
#ifdef WIN32
		sprintf_s(szTime, 100, "%4d%02d%02d", GetUTCYear(), GetUTCMonth(), GetUTCDay());
#else
		sprintf(szTime, "%4d%02d%02d",	GetUTCYear(), GetUTCMonth(), GetUTCDay());
#endif
	}

	return string(szTime);
}

string Time::TimeToString() const
{
 	char szTime[100] = {0};
 	if (m_time > 0 && m_time <= _MAX__TIME64_T )
 	{
#ifdef WIN32
 		sprintf_s(szTime, 100, "%02d%02d%02d", GetHour(), GetMinute(), GetSecond());
#else
 		sprintf(szTime, "%02d%02d%02d",	GetHour(), GetMinute(), GetSecond());
#endif
 	}

	return string(szTime);
}

string Time::UTCTimeToString() const
{
	char szTime[100] = { 0 };
	if (m_time > 0 && m_time <= _MAX__TIME64_T)
	{
#ifdef WIN32
		sprintf_s(szTime, 100, "%02d%02d%02d", GetUTCHour(), GetUTCMinute(), GetUTCSecond());
#else
		sprintf(szTime, "%02d%02d%02d", GetUTCHour(), GetUTCMinute(), GetUTCSecond());
#endif
	}

	return string(szTime);
}

/************************************************************************/
/* MilliTime定义 */
/************************************************************************/
std::string MilliTime::ToStringA ()
{
    char szTime[100] = {0};
    if (m_time > 0 && m_time <= _MAX__TIME64_T)
    {
#ifdef WIN32
        sprintf_s(szTime, 100, "%04d-%02d-%02d %02d:%02d:%02d.%03d", 
            GetYear(), GetMonth(), GetDay(),
            GetHour(), GetMinute(), GetSecond(), GetMillisecond());
#else
        sprintf(szTime, "%04d-%02d-%02d %02d:%02d:%02d.%03d", 
            GetYear(), GetMonth(), GetDay(),
            GetHour(), GetMinute(), GetSecond(), GetMillisecond());
#endif
    }

    return string(szTime);
}

std::wstring MilliTime::ToStringW ()
{
    wchar_t buf[30];
    if (m_time > 0 && m_time <= _MAX__TIME64_T )
    {
        swprintf(buf,30, L"%04d-%02d-%02d %02d:%02d:%02d.%03d", 
            GetYear(), GetMonth(), GetDay(),
            GetHour(), GetMinute(), GetSecond(), GetMillisecond());
    }
    return buf;
}

std::string MilliTime::ToUTCStringA()
{
    char szTime[100] = {0};
    if (m_time > 0 && m_time <= _MAX__TIME64_T)
    {
#ifdef WIN32
        sprintf_s(szTime, 100, "%04d-%02d-%02d %02d:%02d:%02d.%03d", 
            GetUTCYear(), GetUTCMonth(), GetUTCDay(),
            GetUTCHour(), GetUTCMinute(), GetUTCSecond(), GetMillisecond());
#else
        sprintf(szTime, "%04d-%02d-%02d %02d:%02d:%02d.%03d", 
            GetUTCYear(), GetUTCMonth(), GetUTCDay(),
            GetUTCHour(), GetUTCMinute(), GetUTCSecond(), GetMillisecond());
#endif
    }

    return string(szTime);
}

std::wstring MilliTime::ToUTCStringW()
{
    wchar_t buf[30];
    if (m_time > 0 && m_time <= _MAX__TIME64_T )
    {
        swprintf(buf,30, L"%04d-%02d-%02d %02d:%02d:%02d.%03d", 
            GetUTCYear(), GetUTCMonth(), GetUTCDay(),
            GetUTCHour(), GetUTCMinute(), GetUTCSecond(), GetMillisecond());
    }
    return buf;
}

#ifdef WIN32
// 自定义字符拆分函数
wchar_t* my_wcstok(wchar_t *wcs, const wchar_t *delim)
{
    static wchar_t *state = NULL;
    return wcstok_s(wcs, delim, &state);
}

char* my_strtok(char* cs, const char* delim)
{
    static char* state = NULL;
    return strtok_s(cs, delim, &state);
}
#else
long _wtoi(const wchar_t *ptr)
{
    wchar_t *end_ptr = NULL;
    return wcstol(ptr, &end_ptr, 10);
}

wchar_t *my_wcstok(wchar_t *wcs, const wchar_t *delim)
{
    static wchar_t *state = NULL;
    return wcstok (wcs, delim, &state);
}

char* my_strtok(char* cs, const char* delim)
{
	static char *state = NULL;
    return strtok_r(cs, delim, &state);
}
#endif // WIN32

bool MilliTime::ParseStrW (const wchar_t* str_in, int &nYear, int &nMonth, int &nDay, int &nHour, int &nMin, int &nSec, int &nMilli)
{
    wstring str(str_in);
    wchar_t seps1[]   = L"-/";
    wchar_t seps2[]   = L" ";
    wchar_t seps3[]   = L":";
    wchar_t seps4[]   = L".";

    int year = 0, mon = 0, day = 0, hour = 0, min = 0, sec = 0, milli = 0;
    bool ok = false;
    wchar_t* tok = my_wcstok ((wchar_t *)str.c_str(), seps1);    // take year
    if (NULL != tok)
    {
        year = _wtoi(tok);
        tok = my_wcstok (NULL, seps1);    // take month
        if (NULL != tok)
        {
            mon = _wtoi (tok);
            tok = my_wcstok (NULL, seps2);    // take day
            if (NULL != tok)
            {
                day = _wtoi(tok);
                ok = true;
                tok = my_wcstok(NULL, seps3);    // take hour
                if (NULL != tok)
                {
                    ok = false;
                    hour = _wtoi(tok);
                    tok = my_wcstok(NULL, seps3);    // take min
                    if (NULL != tok)
                    {
                        min = _wtoi(tok);
                        tok = my_wcstok(NULL, seps4);    // take second
                        if (NULL != tok)
                        {
                            sec = _wtoi(tok);
                            ok = true;
                            tok = my_wcstok(NULL, seps4);    // take milli
                            if (NULL != tok)
                                milli = _wtoi(tok);
                        }
                    }
                }
            }
        }
    }

    if (ok)
    {
        nYear = year;
        nMonth = mon;
        nDay = day;
        nHour = hour;
        nMin = min;
        nSec = sec;
        nMilli = milli;
        return true;
    }

    return false;
}


bool MilliTime::ParseStrA (const char * str_in, int &nYear, int &nMonth, int &nDay, int &nHour, int &nMin, int &nSec, int &nMilli)
{
    string str(str_in);
    char seps1[]   = "-/";
    char seps2[]   = " ";
    char seps3[]   = ":";
    char seps4[]   = ".";

    int year = 0, mon = 0, day = 0, hour = 0, min = 0, sec = 0, milli = 0;
    bool ok = false;

    const char* tok = my_strtok ((char *)str.c_str(), seps1);    // take year
    if (NULL != tok)
    {
        year = atoi(tok);
        tok = my_strtok (NULL, seps1);    // take month
        if (NULL != tok)
        {
            mon = atoi (tok);
            tok = my_strtok (NULL, seps2);    // take day
            if (NULL != tok)
            {
                day = atoi(tok);
                ok = true;
                tok = my_strtok(NULL, seps3);    // take hour
                if (NULL != tok)
                {
                    ok = false;
                    hour = atoi(tok);
                    tok = my_strtok(NULL, seps3);    // take min
                    if (NULL != tok)
                    {
                        min = atoi(tok);
                        tok = my_strtok(NULL, seps4);    // take second
                        if (NULL != tok)
                        {
                            sec = atoi(tok);
                            ok = true;
                            tok = my_strtok(NULL, seps4);    // take milli
                            if (NULL != tok)
                                milli = atoi(tok);
                        }
                    }
                }
            }
        }
    }

    if (ok)
    {
        nYear = year;
        nMonth = mon;
        nDay = day;
        nHour = hour;
        nMin = min;
        nSec = sec;
        nMilli = milli;
        return true;
    }

    return false;
}

void MilliTime::SetUTCByStringW (const wchar_t* str)
{
    int year = 0, mon = 0, day = 0, hour = 0, min = 0, sec = 0, milli = 0;
    if (ParseStrW(str, year, mon, day, hour, min, sec, milli))
    {
        SetUTCTime(year, mon, day, hour, min, sec);
        m_nMilli = milli;
    }
    else
    {
        throw Except (DATETIME_FMT, "Datetime format error. used as yyyy-mm-dd HH:MM:SS.xxxx");
    }
}
                
void MilliTime::SetLocalByStringW (const wchar_t* str)
{
    int year = 0, mon = 0, day = 0, hour = 0, min = 0, sec = 0, milli = 0;
    if (ParseStrW(str, year, mon, day, hour, min, sec, milli))
    {
        m_time = Time(year, mon, day, hour, min, sec).GetTime();
        m_nMilli = milli;
    }
    else
    {
        throw Except (DATETIME_FMT, "Datetime format error. used as yyyy-mm-dd HH:MM:SS.xxxx");
    }
}

void MilliTime::SetUTCByStringA(const char * str)
{
    int year = 0, mon = 0, day = 0, hour = 0, min = 0, sec = 0, milli = 0;
    if (ParseStrA(str, year, mon, day, hour, min, sec, milli))
    {
        SetUTCTime(year, mon, day, hour, min, sec);
        m_nMilli = milli;
    }
	else
	{
		throw Except (DATETIME_FMT, "Datetime format error. used as yyyy-mm-dd HH:MM:SS.xxxx");
	}
}

void MilliTime::SetLocalByStringA(const char * str)
{
    int year = 0, mon = 0, day = 0, hour = 0, min = 0, sec = 0, milli = 0;
    if (ParseStrA(str, year, mon, day, hour, min, sec, milli))
    {
        m_time = Time(year, mon, day, hour, min, sec).GetTime();
        m_nMilli = milli;
    }
	else
	{
		throw Except (DATETIME_FMT, "Datetime format error. used as yyyy-mm-dd HH:MM:SS.xxxx");
	}
}

 


从文很忙
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C/C++ 日期时间整理备忘
Chengzi_comm的专栏
04-07 1262
在平时的开发过程中，难免会遇到时间相关的处理，比如心跳、定时任务、超时处理等等，总是很难在众多时间处理函数中选择一个。在假期这几天把经常用到的一些时间处理函数整理了一下，算是个梳理也是备忘吧。 一、一些常用时间类型 1、time_t 在VS2015中，time_t的定义为: #ifndef _CRT_NO_TIME_T #ifdef _USE_32BIT_TIME_T ...
用C++操作时间的所有函数库
燕窝
08-28 1059
 /*Name is :time_class.h功能:    用户操作时间日期作者：张树林           Author:woods.zhang日期：2004-12-15       Date:2004-12-15版本：1.0.0            Version:1.0.0Email:hoojar@163.com   QQ:37894354MSN:hoojar@hotmail.com*/
C++中时间处理
阿珊境界
07-05 3452
C++中时间处理并不复杂，特别是MFC里，封装了一堆好用的类。只是平时用得比较少，所以一些常用的操作却也不知如何做起。下面做个总结。
c++11时间函数
epeaktop的专栏
05-11 1058
#include <stdio.h> #include <time.h> #include <iostream> using namespace std;const std::string getCurrentSystemTime() { auto tt = std::chrono::system_clock::to_time_t (std::chrono::sy
【UE4 C++】DateTime、Timespan 相关函数
ttod的博客
11-07 568
【UE4 C++】DateTime、Timespan 相关函数
TimeSpan
wk201403010114的博客
04-19 332
TimeSpan(Int32,Int32,Int32)——————&gt;将TimeSpan结构的新实例初始化为指定的小时数，分钟数和秒数。TimeSpan(Int32,Int32,Int32，Int32)——————&gt;将TimeSpan结构的新实例初始化为指定的天数、小时数、分钟数、秒数；TimeSpan(Int32,Int32,Int32，Int32，Int32)——————&gt;将T...
C++用EGE库实现图像化迷宫游戏
06-11
总的来说，"C++用EGE库实现图像化迷宫游戏"是一个结合了C++编程、游戏逻辑设计和EGE库应用的综合项目。通过这个项目，开发者不仅可以锻炼C++编程技能，还能深入理解游戏开发的基本原理和实践。对于初学者来说，这是...
C++实现的的协程库， 以及基于协程实现的简单网络库.zip
最新发布
06-03
C++支持数据封装、继承和多态等面向对象编程的特性和泛型编程的模板，以及丰富的标准库，提供了大量的数据结构和算法，极大地提高了开发效率。12 C++是一种静态类型的、编译式的、通用的、大小写敏感的编程...
c++标准库参考.pdf
06-15
本篇文档参考内容涵盖了C++标准库中各个组件的细节，包括但不限于：算法、分配器、容器、迭代器、函数对象、时间库、文件系统、原子操作等。 在算法方面，C++标准库提供了如、、等头文件中包含的大量算法实现，如...
SIFT 算法 C++ 代码实现(非常实用)
01-07
在OpenCV库中，SIFT算法已经被封装在`cv::Feature2D`类的子类`cv::SIFT`中，可以方便地调用其成员函数来实现关键点检测和描述符提取。例如，创建SIFT对象、检测关键点和计算描述符的代码可能如下： ```cpp #include...
Snap7 C++动态库.zip
05-21
`snap7.cpp` 文件是C++源代码文件，其中实现了Snap7库的函数和类。这些源代码提供了对Snap7库功能的直接访问，例如建立和管理与PLC的连接，读写数据，以及执行其他与PLC通信相关的任务。通过包含并编译这个文件，...
c++ 准确计时_C++精确计时
weixin_39667080的博客
12-21 319
本文首先通过QueryPerformanceFrequency获取高精度计时器的时钟频率，然后通过两次调用QueryPerformanceCounter获取高精度计时器的差值，最后以差值除以时钟频率获取精确计时。但要注意，时钟频率及计时器的值均为LONGLONG类型，需转换为double后才能计算精确的秒数。以下为代码：LARGE_INTEGER frequency;LARGE_INTEGER s...
数据类型:TimeSpan
码路行者
06-14 2844
TimeSpan 实例的值表示一个时间段。该值是实例中包含的刻度数，其范围可以在 Int64.MinValue 到 Int64.MaxValue 之间。        Dim strMsg As String = "离国庆节还有{0}天。"        Dim nowdt As DateTime = DateTime.Now.Date        Dim nextDt As DateTime
TimeSpan的用法
weixin_30307921的博客
05-05 1850
TimeSpan的属性和方法: 下面的列表涵盖了其中的一部分： 属性: Add：与另一个TimeSpan值相加。 Days: 返回用天数计算的TimeSpan值。Hours: 返回用小时计算的TimeSpan值Milliseconds: 返回用毫秒计算的TimeSpan值。Minutes: 返回用分钟计算的TimeSpan值。Seconds: 返回用秒计算的TimeSpan值。Ticks:...
如何将整数转换为timespan
weixin_30794491的博客
08-28 1708
可以使用From方法，这些方法可将Days / Days / minutes / seconds / milliseconds / ticks转换为TimeSpam格式，如下所示： TimeSpan ts = TimeSpan.FromTicks(486000000000); Console.WriteLine(ts.ToString()); 可以替换FromTicks使用...
C++编程中时间使用总结
cay22的专栏
11-07 3543
各种时间类/数据结构 与时间相关的类和数据结构有:  1. CTime 2. CTimeSpan 3. __time64_t和time_t 4. struct tm 5. SYSTEMTIME 6. FILETIME 7. DBTIMESTAMP 一. CTime // 微软文档 http://msdn.microsoft.com/zh-cn/library/78zb0ese
TimeSpan用法详解
vincent_void的专栏
06-13 3781
1.DateTime值类型代表了一个从公元0001年1月1日0点0分0秒到公元9999年12月31日23点59分59秒之间的具体日期时刻。因此，你可以用DateTime值类型来描述任何在想象范围之内的时间。一个DateTime值代表了一个具体的时刻 2.TimeSpan值包含了许多属性与方法，用于访问或处理一个TimeSpan值 下面的列表涵盖了其中的一部分： Add：与另一个TimeSpa
C#中如何使用TimeSpan
勇敢无畏的活着
01-29 3562
例如： DateTime dt1 = DateTime.Now;        DateTime dt2 = DateTime.Now.AddDays(-7);       TimeSpan ts = dt1 - dt2;             int days = ts.Days;//dt1和dt2相差多少天 这样就可以获取时间差值了。 TimeSpan值包含了许多属性与方法，
C++计算当前时间点间隔N天的时间(不使用CTimeSpan类)
Fzuim的博客
03-10 1820
涉及到有效期的设置，需要计算N天时间间隔的时间。其实这只是个工具代码，记录下与己方便，便是与人方便。。 #define QUADPART 10000000i64 std::string CalTime(int v_nTimeSpan) { char chTime[MAX_PATH] = {0}; SYSTEMTIME Curtime; SYSTEMTIME OutTime; GetL
C++标准程序库详解
它涵盖了C++标准程式库的所有部分，包括I/O流、容器、迭代器、算法、字符串、数值计算、时间日期、异常处理、内存管理和线程支持等。译者侯捷和孟岩的翻译确保了中文版的质量，使得国内读者也能无障碍地学习C++标准...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值