标准C++写的DateTime对象

头文件

  1#pragma once
  2//#include <eh.h>
  3#include <windows.h>
  4#include <string>
  5#include <stdio.h>
  6#include <time.h>
  7using namespace std;
  8
  9namespace HongYing
 10{
 11
 12    namespace IO
 13    {
 14
 15        class FileStream
 16        {
 17        public:
 18            FileStream(void);
 19            FileStream(const char * filePath);
 20            void Open(const char * filePath,int mode);
 21            void Close(void);
 22            char Putc(char c); //写入一个字符到流中。
 23            char Getc();//从流中读入一个字符。
 24            void Seek(long offset,int seek_origin);//定位到流中指定的位置以字节为单位,成功返回 0
 25            char * Gets(char * buffer,int maxCount) ; //从流中读一行或指定个字符 失败返回NULL
 26            void Puts(char * buffer) ;//写一个行字符串到流中;
 27            int End();
 28            int Error();
 29            void Rewind();//其实本函数相当于fseek(fp,0L,SEEK_SET);
 30            int Read(void *buffer,size_t size,size_t count);//从流中读指定块数的字符,反回实际读入的块数　size 为块的大小，count 要读的块数
 31            int Write(void *buffer,size_t size,size_t count);//向流中写指定的数据
 32            FILE * GetFilePtr(void);
 33        public:
 34            ~FileStream(void);
 35        private:
 36            // 文件指针
 37            FILE *file;
 38        };
 39        class File
 40        {
 41        public:
 42            File(void);
 43            static FileStream Open(const char * filePath,int mode);
 44            static FileStream Create(const char * filePath);
 45            static int Delete(const char *filePath);
 46            static FileStream CreateTempFile();
 47        public:
 48            ~File(void);
 49        };
 50
 51        class OpenFileMode
 52        {
 53        public:
 54            OpenFileMode(void);
 55        public:
 56            ~OpenFileMode(void);
 57        public:
 58            // 打开一个用于读取的文本文件
 59            static const int TxtOpenRead = 0;
 60            //创建一个用于写入的文本文件
 61            static const int TxtCreateWrite = 1;
 62            //附加到一个文本文件
 63            static const int TxtAppend = 2;
 64            //打开一个用于读/写的文本文件
 65            static const int TxtOpenReadOrWrite = 3;
 66            //创建一个用于读/写的文本文件
 67            static const int TxtCreateReadOrWrite = 4;
 68            //打开一个用于读/写的文本文件
 69            static const int TxtOpenAppendReadOrWrite=5;
 70            //打开一个用于读取的二进制文件
 71            static const int BitOpenRead = 6;
 72            //创建一个用于写入的二进制文件
 73            static const int BitCreateWrite = 7;
 74            //附加到一个二进制文件
 75            static const int BitAppend = 8;
 76            //打开一个用于读/写的二进制文件
 77            static const int BitOpenReadOrWrite = 9;
 78            //创建一个用于读/写的二进制文件
 79            static const int BitCreateReadOrWrite = 10;
 80            //打开一个用于读/写的二进制文件
 81            static const int BitOpenAppendReadOrWrite =11;
 82            //得到打开文件mode的字符串
 83            static const char * GetModeStr(int mode);
 84
 85        };
 86
 87        class Exception
 88        {
 89        public:
 90            Exception();
 91            Exception(char *msg,DWORD errorNo, char *file,char *function,int l);
 92            DWORD ErrorNo;//错误号
 93            char Message[MAX_PATH];//错误信息
 94            char FilePath[MAX_PATH];//错误文件路径
 95            char Fun[MAX_PATH];//错误函数名
 96            EXCEPTION_POINTERS PException_poists;
 97            INT line;
 98        public:
 99            static void Trans_func( unsigned int u, EXCEPTION_POINTERS *pExp );
            static void Init();//初始化异常
            string ToString();
        public:
            ~Exception();


        };
        #define THROW_EX(Msg,errorNo) throw  Exception(Msg,errorNo,__FILE__,__FUNCTION__,__LINE__);
    }
    namespace Object
    {
    class Object
    {
    public:
        Object(void);
        virtual bool Equals(const Object *object) = 0;
        virtual int CompareTo(const Object *value) = 0;
        virtual std::string ToString() = 0 ;

    public:
        ~Object(void);
    };

    class DateTime :public Object
    {
    public:    
        DateTime(time_t seconds);
        DateTime(int year,int month,int day);
        DateTime(int year,int month,int day,int hour,int minute,int second);
        DateTime(std::string datetimeStr);//日期字符串格式 年/月/日 时:分:秒 例:2008/02/03 9:30:20 出错返回 01/01/1970 00:00:00
        DateTime(std::string datetimeStr,std::string formaterStr);
    private:
        time_t seconds;//自1970起的秒数
        tm date;
    public:
        void AddYears(const time_t years); //将指定的年份数加到此实例的值上。  
        void AddMonths(const time_t Months);//将指定的月份数加到此实例的值上。  
        void AddDays(const time_t days); //将指定的天数加到此实例的值上。 
        void AddHours(const time_t hours);//将指定的小时数加到此实例的值上。 
        void AddMinutes(const time_t minutes);//将指定的分钟数加到此实例的值上。  
        void AddSeconds(const time_t seconds); //将指定的秒数加到此实例的值上。
        void AddWeeks(const time_t weeks);//将指定的周数加到些实上的值上。
        static int Compare(const DateTime *value1,const DateTime *value2);//对两个 DateTime 的实例进行比较，并返回一个指示第一个实例是早于、等于还是晚于第二个实例的整数。  返回值：小于零 value1 小于 value2。 零 value1 等于 value2。 大于零 value1 大于 value2。 
        int CompareTo(const Object *value);//已重载。 将此实例的值与指定的 DateTime 值相比较，并指示此实例是早于、等于还是晚于指定的 DateTime 值。  
        int CompareTo(const DateTime *value);//小于零 此实例小于 value。 零 此实例等于 value。 大于零 此实例大于 value。 


        int DaysInMonth(const int year,const int months);//返回指定年和月中的天数。    
        bool Equals(const Object *object);
        bool Equals(const DateTime *dateTime);
        static bool Equals(const DateTime *value1,const DateTime *value2);
        static DateTime Parse(std::string datetimeStr);//日期字符串格式 月/日/年 时:分:秒 例:02/03/2008 9:30:20 出错返回 01/01/1970 00:00:00
        static DateTime Parse(std::string dateTimeStr,std::string formaterStr);
        std::string ToShortDateString();//将当前 DateTime 对象的值转换为其等效的短日期字符串表示形式。  
        std::string ToString();
        std::string ToString(const std::string formaterStr);//formaterStr = "%Y-%m-%d %H:%M:%S" %Y=年 %m=月 %d=日 %H=时 %M=分 %S=秒
    public:        
        int GetYear();//获取此实例所表示日期的年份部分。
        int GetMonth();//获取此实例所表示日期的年份部分。
        int GetDay();// 获取此实例所表示的日期为该月中的第几天。
        int GetHour();//获取此实例所表示日期的小时部分。 
        int GetMinute();//获取此实例所表示日期的分钟部分
        int GetSecond();//获取此实例所表示日期的秒部分。 
        int DayOfWeek(); //获取此实例所表示的日期是星期几。
        int DayOfYear();//记录今天是一年里面的第几天,从1月1日起,0-365
        static DateTime GetNow(); //返回当前日期是间
    public:
        bool operator == (DateTime &dateTime);
        bool operator > (DateTime &dateTime);
        bool operator < (DateTime &DateTime);
        bool operator >= (DateTime &DateTime);
        bool operator <= (DateTime &DateTime);
        bool operator != (DateTime &DateTime);

    private:
        void InitByStr(std::string dateTimeStr,std::string formaterStr);
    public:
        ~DateTime(void);
    };




    }
}

CPP文件

  1#include "StdAfx.h"
  2#include "HongYing.h"
  3namespace HongYing
  4{
  5    namespace Object
  6    {
  7        DateTime::DateTime(const time_t seconds)
  8        {
  9            this->seconds = seconds;
 10            this->date = *localtime(&this->seconds);
 11        }
 12        DateTime::DateTime(int year,int month,int day)
 13        {
 14            tm t;
 15            t.tm_year = year-1900;
 16            t.tm_mon = month-1;
 17            t.tm_mday = day;
 18            t.tm_hour = 0;
 19            t.tm_min = 0;
 20            t.tm_sec = 0;
 21            this->seconds = mktime(&t);
 22            this->date = *localtime(&this->seconds);
 23
 24        }
 25        DateTime::DateTime(int year,int month,int day,int hour,int minute,int second)
 26        {
 27            tm t;
 28            t.tm_year = year-1900;
 29            t.tm_mon = month-1;
 30            t.tm_mday = day;
 31            t.tm_hour = hour;
 32            t.tm_min = minute;
 33            t.tm_sec = second;
 34            this->seconds = mktime(&t);
 35            this->date = *localtime(&this->seconds);
 36
 37        }
 38
 39        DateTime::DateTime(std::string datetimeStr) //日期字符串格式 月/日/年 时:分:秒 例:02/03/2008 9:30:20 出错返回 01/01/1970 00:00:00
 40        {
 41            this->InitByStr(datetimeStr,"%d/%d/%d %d:%d:%d");
 42        }
 43        DateTime::DateTime(std::string datetimeStr,std::string formaterStr)
 44        {
 45            this->InitByStr(datetimeStr,formaterStr);
 46        }
 47        DateTime DateTime::Parse(std::string datetimeStr)
 48        {
 49
 50            DateTime datetime(datetimeStr);
 51            return datetime;
 52        }
 53        DateTime DateTime::Parse(const std::string datetimeStr,const std::string formaterStr)
 54        {
 55            DateTime datetime(datetimeStr,formaterStr);
 56            return datetime;
 57        }
 58
 59
 60        void DateTime::InitByStr(std::string dateTimeStr,std::string formaterStr)
 61        {
 62            int year,month,day,hour,minutes,seconds;
 63            sscanf(dateTimeStr.c_str(),formaterStr.c_str(),&year,&month,&day,&hour,&minutes,&seconds);    
 64            if(year <1900) year = 1970;
 65            if(month <0) month = 1;
 66            if(day <0) day = 1;
 67            if(hour <0) hour = 0;
 68            if(minutes <0) minutes = 0;
 69            if(seconds <0) seconds = 0;
 70            tm t;
 71            t.tm_year = year-1900;
 72            t.tm_mon = month-1;
 73            t.tm_mday = day;
 74            t.tm_hour = hour;
 75            t.tm_min = minutes;
 76            t.tm_sec = seconds;
 77            this->seconds = mktime(&t);
 78            this->date = *localtime(&this->seconds);
 79        }
 80        int DateTime::DayOfWeek()
 81        {
 82            return this->date.tm_wday;
 83        }
 84        int DateTime::DayOfYear()
 85        {
 86            return this->date.tm_yday;
 87        }
 88        int DateTime::DaysInMonth(const int year,const int months)
 89        {
 90            return 0;
 91        }
 92
 93        bool DateTime::Equals(const Object *object)
 94        {
 95            DateTime *dateTime = (DateTime *)object;
 96            if(this->seconds == dateTime->seconds)
 97                return true;
 98            return false;
 99        }

        bool DateTime::Equals(const DateTime *dateTime)
        {
            return this->Equals((Object *)dateTime);
        }

        bool DateTime::Equals(const DateTime *value1,const DateTime *value2)
        {
            if(value1->seconds == value2->seconds)
                return true;
            return false;
        }
        int DateTime::GetDay()
        {    
            return this->date.tm_mday;;
        }

        int DateTime::GetHour()
        {
            return this->date.tm_hour;
        }
        int DateTime::GetMinute()
        {
            return this->date.tm_min;
        }
        int DateTime::GetMonth()
        {
            return this->date.tm_mon;
        }

        DateTime DateTime::GetNow()
        {
            DateTime datetime(time(0));
            return datetime;
        }

        int DateTime::GetSecond()
        {
            return this->date.tm_sec;
        }

        int DateTime::GetYear()
        {
            return this->date.tm_year+1900;
        }

        void DateTime::AddYears(const time_t years)
        {
            this->date.tm_year = this->date.tm_year+years;
            this->seconds = mktime(&this->date);
        }
        void DateTime::AddMonths(const time_t months)
        {
            int a  =(int)((this->date.tm_mon+months)/12);
            
            this->date.tm_year = this->date.tm_year+a;
            this->date.tm_mon = this->date.tm_mon+(int)((this->date.tm_mon+months)%12)-1;
            this->seconds = mktime(&this->date);
        }

        void DateTime::AddDays(const time_t days)
        {    
            this->AddHours(days*24);
        }
        void DateTime::AddHours(const time_t hours)
        {
            this->AddMinutes(hours*60);
        }
        void DateTime::AddMinutes(const time_t minutes)
        {
            this->AddSeconds(minutes *60);
        }

        void DateTime::AddSeconds(const time_t seconds)
        {
            this->seconds = this->seconds+seconds;
            this->date = *localtime(&this->seconds);
        }
        void DateTime::AddWeeks(const time_t weeks)
        {
            this->AddDays(weeks*7);
        }


        int DateTime::Compare(const DateTime *t1,const DateTime *t2)
        {
            if( t1->seconds == t2->seconds)
                return 0;
            if(t1->seconds < t2->seconds)
                return -1;
            return 1;

        }


        int DateTime::CompareTo(const Object *value)
        {
            DateTime * dateTime =  (DateTime *)value;
            if( dateTime->seconds == this->seconds)
                return 0;
            if(this->seconds < dateTime->seconds)
                return -1;
            return 1;
        }

        int DateTime::CompareTo(const DateTime *value)
        {
            if(this->seconds == value->seconds)
                return 0;
            if(this->seconds <value->seconds)
                return -1;
            return 1;
        }


        std::string DateTime::ToShortDateString()
        {
            return this->ToString("%Y-%m-%d");
        }

        std::string DateTime::ToString()
        {
            return this->ToString("%Y-%m-%d %H:%M:%S");
        }
        std::string DateTime::ToString(const std::string formaterStr)
        {
            //strftime(s, sizeof(s), "%Y-%m-%d %H:%M:%S", localtime(&t)); 
            char s[256];
            strftime(s, sizeof(s), formaterStr.c_str(), &this->date);
            std::string str(s);
            return str;

        }

        bool DateTime::operator ==( DateTime &dateTime)
        {
            return this->Equals(&dateTime);

        }
        bool DateTime::operator != (DateTime &datetime)
        {
            if(this->seconds != datetime.seconds)
                return true;
            return false;
        }
        bool DateTime::operator > (DateTime &dateTime)
        {
            if(this->seconds > dateTime.seconds)
                return true;
            return false;
        }
        bool DateTime::operator < (DateTime &datetime)
        {
            if(this->seconds <datetime.seconds)
                return true;
            return false;
        }
        bool DateTime::operator >=(DateTime &datetime)
        {
            if(this->seconds >= datetime.seconds)
                return true;
            return false;
        }

        bool DateTime::operator <=(DateTime &datetime)
        {
            if(this->seconds <= datetime.seconds)
                return true;
            return false;
        }

        DateTime::~DateTime(void)
        {

        }

    }

}