实现python datetime算法的C++Date类--The C++ Programmming Language

最新推荐文章于 2023-08-12 23:29:03 发布
最新推荐文章于 2023-08-12 23:29:03 发布
阅读量453 收藏 2
点赞数 1
分类专栏： C++ 文章标签： c++ python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43227599/article/details/106964495
版权

根据python datetime实现的C++Date类

文章目录

一、需求

（来自The C++ Programming Language第十章）要求设计一个以1970年1月1日以后的天数来表示日期的日期类，如下图：

在这里插入图片描述
这里借鉴了python标准库datetime的实现方法。datetime的日期是以日期在公历（Gregorian Calendar）中的序号来表示的，也就是“第几天”的意思。例如，1-1-1在公历中是第一天，它的序号就是1。
见Lib/datetime.py:20的注释：The code here calls January 1 of year 1 day number 1.

这里主要学习datetime.py的实现中年月日格式和序号格式互转的方法。

二、年月日格式和序号格式互转方法

2.1 年月日转序号（ymd2ord）

年月日转序号的思想是这样的：日期(year-month-day)的序号是
ordinal=_days_before_year(year)+_days_before_month(month)+day
也就是(1)公元1年起到当前年份的所有整年的天数、(2)本年内本月前所有整月的天数、(3)本月天数，这三者相加。

(2)和(3)的计算很简单。注意闰年的判断条件是所有能被4整除而不能被100整除，或者能被400整除的年份。每4年一个闰年、每100要减去一个闰年、每400年要再增加一个闰年（我们知道这是地球公转周期决定的）。
因此_days_before_year()的实现是这样的：

def _days_before_year(y):
	y = y -1
	return 365*y + y//4 - y//100 + y//400

2.2 序号转年月日（ord2ymd）

2.2.1 年份的确定

给定日期的序号形式ord来确定年份y。
定义三个常量DI400Y, DI100Y, DI4Y，把ord-1(ord-1是序号，ord-1才是距离公历1-1-1的天数)依次对这三个常量取模后当前年份之前的闰年已经全部包含在内，再对365取模，商分别是n400, n100, n4, n1，这时就能基本确定年份y了：

n = ord - 1
n400, n = divmod(n, DI400Y)
n100, n = divmod(n, DI100Y)
n4, n = divmod(n, DI4Y)
n1, n = divmod(n, 365)
y = 400*n400 + 100*n100 + 4*n4 + n1 + 1

但是要注意到DI400Y, DI100Y, DI4Y的关系，这里比较复杂：

DI4Y = 365*4 + 1
DI100Y = 25*DI4Y -1
DI400Y = 4*DI100Y + 1
// 所以 n % DI4Y, n % DI400Y 最大可以取到 4*365 和 4*DI100Y
// 在这种情况下 (n1 == 4 || n100 == 4), n 必然为 0, 日期则是 12月31日
// 由于 n1 **或** n100 多算了一年(显然 n1 和 n100 是不会同时取4的), 年份应该是 y - 1

也就是说这里n1, n100为4其实是不正常的值，毕竟我们已经抛去了4年（或100年）相应的天数。
仔细思考一下，公历日期5-1-1的序号是365*4+2，距离1-1-1的天数是365*4+1。而4-12-31才是序号是365*4+1，距离1-1-1的天数是4*365。我们发现这时候年份确实是要减一的。
因此datetime.py中有这样几句断言：

assert DI400Y == 4 * DI100Y + 1
assert DI100Y == 25 * DI4Y -1
assert DI4Y   == 4 * 365 + 1
if n1 ==  4 or n100 == 4:
	assert n == 0
// 而且根据n1, n100, n4 的值我们可以推导出闰年条件：
leapyear = n1 == 3 and (n4 != 24 || n100 == 3)
assert leapyear == _is_leap(y)
2.2.2 月份和日期的确定

确定月份利用位运算构造了一个线性函数的表达式，使得取值总是正确的月份值或者正好比真正的月份值大一。也是比较精妙的，上官方代码：

# Now the year is correct, and n is the offset from January 1.  We find
# the month via an estimate that's either exact or one too large.
leapyear = n1 == 3 and (n4 != 24 or n100 == 3)
assert leapyear == _is_leap(year)
month = (n + 50) >> 5
// 这里preceding 的意思是所谓猜测的月份值所对应的 “days before month”
preceding = _DAYS_BEFORE_MONTH[month] + (month > 2 and leapyear)
if preceding > n:  # estimate is too large
    month -= 1
    preceding -= _DAYS_IN_MONTH[month] + (month == 2 and leapyear)
n -= preceding
assert 0 <= n < _days_in_month(year, month)

# Now the year and month are correct, and n is the offset from the
# start of that month:  we're done!
return year, month, n+1

到这里序号转年月日的核心代码就都出现过了，个人感觉最难懂的地方还是在确定年份的地方，有很多细节部分需要仔细思考才能想明白。

最后搬运一下python内置模块datetime的相关代码。

2.3 datetime.py 1~142行 官方代码

datetime.py：

"""Concrete date/time and related types.

See http://www.iana.org/time-zones/repository/tz-link.html for
time zone and DST data sources.
"""

import time as _time
import math as _math

def _cmp(x, y):
    return 0 if x == y else 1 if x > y else -1

MINYEAR = 1
MAXYEAR = 9999
_MAXORDINAL = 3652059  # date.max.toordinal()

# Utility functions, adapted from Python's Demo/classes/Dates.py, which
# also assumes the current Gregorian calendar indefinitely extended in
# both directions.  Difference:  Dates.py calls January 1 of year 0 day
# number 1.  The code here calls January 1 of year 1 day number 1.  This is
# to match the definition of the "proleptic Gregorian" calendar in Dershowitz
# and Reingold's "Calendrical Calculations", where it's the base calendar
# for all computations.  See the book for algorithms for converting between
# proleptic Gregorian ordinals and many other calendar systems.

# -1 is a placeholder for indexing purposes.
_DAYS_IN_MONTH = [-1, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]

_DAYS_BEFORE_MONTH = [-1]  # -1 is a placeholder for indexing purposes.
dbm = 0
for dim in _DAYS_IN_MONTH[1:]:
    _DAYS_BEFORE_MONTH.append(dbm)
    dbm += dim
del dbm, dim

def _is_leap(year):
    "year -> 1 if leap year, else 0."
    return year % 4 == 0 and (year % 100 != 0 or year % 400 == 0)

def _days_before_year(year):
    "year -> number of days before January 1st of year."
    y = year - 1
    return y*365 + y//4 - y//100 + y//400

def _days_in_month(year, month):
    "year, month -> number of days in that month in that year."
    assert 1 <= month <= 12, month
    if month == 2 and _is_leap(year):
        return 29
    return _DAYS_IN_MONTH[month]

def _days_before_month(year, month):
    "year, month -> number of days in year preceding first day of month."
    assert 1 <= month <= 12, 'month must be in 1..12'
    return _DAYS_BEFORE_MONTH[month] + (month > 2 and _is_leap(year))

def _ymd2ord(year, month, day):
    "year, month, day -> ordinal, considering 01-Jan-0001 as day 1."
    assert 1 <= month <= 12, 'month must be in 1..12'
    dim = _days_in_month(year, month)
    assert 1 <= day <= dim, ('day must be in 1..%d' % dim)
    return (_days_before_year(year) +
            _days_before_month(year, month) +
            day)

_DI400Y = _days_before_year(401)    # number of days in 400 years
_DI100Y = _days_before_year(101)    #    "    "   "   " 100   "
_DI4Y   = _days_before_year(5)      #    "    "   "   "   4   "

# A 4-year cycle has an extra leap day over what we'd get from pasting
# together 4 single years.
assert _DI4Y == 4 * 365 + 1

# Similarly, a 400-year cycle has an extra leap day over what we'd get from
# pasting together 4 100-year cycles.
assert _DI400Y == 4 * _DI100Y + 1

# OTOH, a 100-year cycle has one fewer leap day than we'd get from
# pasting together 25 4-year cycles.
assert _DI100Y == 25 * _DI4Y - 1

def _ord2ymd(n):
    "ordinal -> (year, month, day), considering 01-Jan-0001 as day 1."

    # n is a 1-based index, starting at 1-Jan-1.  The pattern of leap years
    # repeats exactly every 400 years.  The basic strategy is to find the
    # closest 400-year boundary at or before n, then work with the offset
    # from that boundary to n.  Life is much clearer if we subtract 1 from
    # n first -- then the values of n at 400-year boundaries are exactly
    # those divisible by _DI400Y:
    #
    #     D  M   Y            n              n-1
    #     -- --- ----        ----------     ----------------
    #     31 Dec -400        -_DI400Y       -_DI400Y -1
    #      1 Jan -399         -_DI400Y +1   -_DI400Y      400-year boundary
    #     ...
    #     30 Dec  000        -1             -2
    #     31 Dec  000         0             -1
    #      1 Jan  001         1              0            400-year boundary
    #      2 Jan  001         2              1
    #      3 Jan  001         3              2
    #     ...
    #     31 Dec  400         _DI400Y        _DI400Y -1
    #      1 Jan  401         _DI400Y +1     _DI400Y      400-year boundary
    n -= 1
    n400, n = divmod(n, _DI400Y)
    year = n400 * 400 + 1   # ..., -399, 1, 401, ...

    # Now n is the (non-negative) offset, in days, from January 1 of year, to
    # the desired date.  Now compute how many 100-year cycles precede n.
    # Note that it's possible for n100 to equal 4!  In that case 4 full
    # 100-year cycles precede the desired day, which implies the desired
    # day is December 31 at the end of a 400-year cycle.
    n100, n = divmod(n, _DI100Y)

    # Now compute how many 4-year cycles precede it.
    n4, n = divmod(n, _DI4Y)

    # And now how many single years.  Again n1 can be 4, and again meaning
    # that the desired day is December 31 at the end of the 4-year cycle.
    n1, n = divmod(n, 365)

    year += n100 * 100 + n4 * 4 + n1
    if n1 == 4 or n100 == 4:
        assert n == 0
        return year-1, 12, 31

    # Now the year is correct, and n is the offset from January 1.  We find
    # the month via an estimate that's either exact or one too large.
    leapyear = n1 == 3 and (n4 != 24 or n100 == 3)
    assert leapyear == _is_leap(year)
    month = (n + 50) >> 5
    preceding = _DAYS_BEFORE_MONTH[month] + (month > 2 and leapyear)
    if preceding > n:  # estimate is too large
        month -= 1
        preceding -= _DAYS_IN_MONTH[month] + (month == 2 and leapyear)
    n -= preceding
    assert 0 <= n < _days_in_month(year, month)

    # Now the year and month are correct, and n is the offset from the
    # start of that month:  we're done!
    return year, month, n+1

三、我的C++ Date class

借鉴python datetime.py中的思想，要求Date class只存储一个日期距离公历1970-1-1（默认日期，default date）的天数，只要设置一个静态成员变量offset来存default date距离公元1-1-1的天数即可，而普通成员变量ordinal存一个日期距离公历1970-1-1的天数。

实现原理和datetime.py几乎一模一样，也作为对所学方法的巩固，这里就直接上代码了：
Date.h：

#ifndef DATE_H_
#define DATE_H_

# include <iostream>
using std::string;

class Date
{
	int ord;
	// default date
	static int offset, Y, M, D;

	friend int daysBeforeYear(int);
	friend int daysBeforeMonth(int, int);
	friend void ord2ymd(int, int&, int&, int&);
public:
	static int DI400Y, DI100Y, DI4Y;
	static int Days_in_month[13], Days_before_month[13];
	enum Month {Jan=1, Feb, Mar, Apr, May, Jun, Jul, Aug, Sep, Oct, Nov, Dec};
	Date(int, int, int);
	void set_default(int, int, int);
	string string_rep() const;
	void char_rep(char s[]) const;
	int day() const;
	int month() const;
	int year() const;
	int ordinal() const;
	Date& add_day(int);
	Date& add_month(int);
	Date& add_year(int);
};

#endif /* DATE_H_ */

Date.cpp：

/*
 * Date.cpp
 *
 *  Created on: 2020年6月11日
 *      Author: 18488
 */
# include <iostream>
# include <sstream>
# include "Date.h"

using std::string;
using std::ostringstream;
using std::cout;
using std::endl;

int Date::DI4Y = 365*4 +1;
int Date::DI100Y = 25*DI4Y -1;
int Date::DI400Y = 4*DI100Y +1;
int Date::Days_in_month[] = 	{0, 31, 28, 31, 30,  31,  30,  31,  31,  30,  31,  30,  31};
int Date::Days_before_month[] = {0,  0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334};
int Date::Y = 1970, Date::M = 1, Date::D = 1;

bool isLeapYear(int year) {
	return (year %4 == 0 && year % 100 != 0) || (year % 400 == 0);
}
int daysBeforeYear(int year) {
	-- year;
	return 365*year + year/4 + year/400 - year/100;
}
int daysBeforeMonth(int year, int month) {
	return Date::Days_before_month[month] + (int)(isLeapYear(year) && month > 2);
}
int ymd2ord(int y, int m, int d) {
	return daysBeforeYear(y) + daysBeforeMonth(y, m) + d;
}
int Date::offset = ymd2ord(1970,1,1) -1;
void ord2ymd(int ord, int& y, int& m, int& d) {
	int n = ord + Date::offset-1;
//	cout <<"n = " <<n <<endl;
	int n400 = n/Date::DI400Y; n = n%Date::DI400Y;
	int n100 = n/Date::DI100Y; n = n%Date::DI100Y;
	int n4   = n/Date::DI4Y;   n = n%Date::DI4Y;
	int n1   = n/365;          n = n%365;
	y = 400*n400 + 100*n100 + 4*n4 + n1 + 1;
	if ((n1 == 4 || n100 == 4) && n == 0) {
		-- y; m = 12; d = 31; return;
	}
	m = (n+50) >> 5;
	int preceding = daysBeforeMonth(y,m);
	if (preceding > n) {
		-- m;
		preceding -= Date::Days_in_month[m] + (int)(isLeapYear(y) && m == 2);
	}
//	cout <<"preceding = " <<preceding <<" n = " <<n <<endl;
//	cout <<"year: " <<y <<"Leapyear: " <<isLeapYear(y) <<"offset :" <<Date::offset <<endl;
	d = n - preceding +1;
}
void Date::set_default(int y, int m, int d) {
	Y = y; M = m; D = d;
	offset = ymd2ord(y,m,d) -1;
}
Date::Date(int y, int m, int d) {
	ord = ymd2ord(y,m,d) - offset;
}
string Date::string_rep() const{
	int y, m, d;
	ord2ymd(ord, y, m, d);
	ostringstream out;
	out <<y <<"-" <<m <<"-" <<d;
	return out.str();
}
void Date::char_rep(char s[]) const {
	int y, m, d;
	ord2ymd(ord, y, m, d);
	sprintf(s, "%d-%d-%d", y, m, d);
}
int Date::day() const {
	int y,m,d;
	ord2ymd(ord, y,m,d);
	return d;
}
int Date::month() const {
	int y,m,d;
	ord2ymd(ord, y,m,d);
	return m;
}
int Date::year() const {
	int y,m,d;
	ord2ymd(ord, y,m,d);
	return y;
}
int Date::ordinal() const {
//	return ord;
	return ord + offset;
}
Date& Date::add_day(int n) {
	ord += n;
	return *this;
}
Date& Date::add_month(int n) {
	int y, m, d;
	ord2ymd(ord, y,m,d);
	y += n/12; m += n;
	ord = ymd2ord(y, m, d) - offset;
	return *this;
}
Date& Date::add_year(int n) {
	int y,m,d;
	ord2ymd(ord, y,m,d);
	y += n;
	ord = ymd2ord(y, m, d) - offset;
	return *this;
}
weixin_43227599
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
python设计一个date类_各位大佬，请教c++编程。（1）设计一个日期类（TDate）并派生出TNormalDate、...
weixin_39846378的博客
12-03 156
展开全部其实，要逼自己很简单，两条路任你32313133353236313431303231363533e59b9ee7ad9431333365653238选。就业选择就业，学东西一定是最快的。如果不够快，就想想你的梦想、你的工资、你的奖金吧。虽然AI行业充满了“爱与理想”，但我们不得不承认，跟随这股AI潮，很多人主要还是冲着高薪去的。不用再花家里钱，还可以边学AI边赚大钱，听起来简直美梦一桩。不...
datetime.h
01-29
因为项目需要，写了一个c++的获取与系统时间 返回字符串（是std::string)精确到6位毫秒形式 搞点积分备着以后用
C++实现日期类
Python_programer的博客
05-21 374
初步学习了类和对象后，为了能学以致用，我想用类和对象实现一个日期类，能实现日期的一些计算方法！ 1.功能 1）日期的大小判断 2）日期变化的日期加减天数 3）计算两个日期间隔天数 4）日期变化的日期加减天数 2.实现代码 我把接口的声明和类的定义放在了Date1.h文件里： #pragma once #include<iostream> using std::cout; using...
C/C++语言实现给定日期计算该日期与当前日期的相差天数
qq_39540537的博客
09-29 997
#include <stdio.h> #include <time.h> #include<math.h> #define TRUE 1 #define FALSE 0 size_t StringToDatetime(char *str) { time_t ocurtime; char buffer[80]; struct tm tm_; int year, month, day; sscanf(str,"%d-%d-%d", .
C++入门级练手项目——日期类的计算
Britney_dark的博客
05-22 865
只要付出真心去对待对方就可以了。
C++详解实现日期类的运算（默认成员函数的综合运用）
weixin_41446512的博客
07-22 575
1.头文件 要点： （1）声明成员函数与成员变量 （2）针对Date类，构造函数需要自己写，系统不会进行处理，析构函数、拷贝构造函数与赋值重载可以不用写 （3）构造函数的声明与函数，缺省值只能写一处，下面代码中，构造函数的缺省值已经存在，则在函数中不能再存在 （4）前置++与后置++的声明不一样，后置++会多一个int形参，这个形参没有作用，只是为了区分 （5）运算符重载的&：参考拷贝构造函数中的讲解要点 #include<iostream> using namespace std;
测量程序编制 - python 60格式化输出：datetime模块（date类-函数）.pptx
05-10
Python的datetime模块是一个非常强大的工具，它包含了处理日期和时间的各种功能。在讲解date类时，我们关注几个关键函数：isocalendar(), isoformat(), weekday(), isoweekday(), strftime()以及fromtimestamp()。 ...
Python库 | django-datetime-widget-fa-0.10.0.zip
05-25
资源分类：Python库 所属语言：Python 资源全名：django-datetime-widget-fa-0.10.0.zip 资源来源：官方 安装方法：https://lanzao.blog.csdn.net/article/details/101784059
System-Date-and-Time.rar_DATE system_Time_c++Date
09-24
在编程领域，尤其是在C#和C++中处理系统日期和时间是常见的需求。本文将深入探讨如何使用这两种语言来获取和操作系统日期与时间。首先，让我们从C#开始。 在C#中，`System.DateTime`是用于表示日期和时间的基本类。...
2021-python-3.8.8-amd64-安装包.rar
08-30
标题 "2021-python-3.8.8-amd64-安装包.rar" 提供的信息表明，这是一个包含Python编程语言的安装程序的压缩文件，适用于64位（AMD64）架构的计算机系统。Python 3.8.8是这个安装包对应的版本号，意味着它是最新的...
05-python-datetime模块-SQL数据库-对象关系映射-函数进阶
02-09
这个模块提供了处理日期和时间的功能，包括日期（date）、时间（time）、日期时间（datetime）和时区（tzinfo）等类。例如，你可以创建一个日期对象表示当前日期：`import datetime; today = datetime.date.today()`...
C++ 日期和时间的相关函数
汉阳Hann's Home
01-28 4008
C++ 标准库没有提供所谓的日期类型，头文件ctime提供了继承于C 语言的日期和时间的结构和函数。
【C++】日期计算器(类class)
最新发布
qq_63231615的博客
08-12 81
【代码】【C++】日期计算器。
C/C++ 日期 & 时间 函数总结
前人栽树，后人乘凉。
03-31 2042
和。类型 clock_t、size_t 和 time_t 能够把系统时间和日期表示为某种整数。
时间日期类
vlucky_long的博客
09-09 498
1、Date类 Date类的概述：Date 代表了一个特定的时间，精确到毫秒 Date类构造方法： 方法名 说明 public Date() 分配一个 Date对象，并初始化，以便它代表它被分配的时间，精确到毫秒 public Date(long date) 分配一个 Date对象，并将其初始化为表示从标准基准时间起指定的毫秒数 示例代码： public class DateDemo01 { public static void main(String[] args) {
c++与python 数据类型对应
jacke121的专栏
11-14 9091
c++与python 数据类型对应
python转c++语言_C++和Python的数据类型的相互转换
weixin_39874269的博客
11-26 3174
我们都知道，Python本身呢是一门动态语言，变量的类型是在运行时才会被确定的，所以PythonCalc.py脚本中的Add方法呢不仅仅可以满足int型数据相加，同样也能支持其他类型的相加，既然是这样，那在示例工程中的PyInvoker中就没必要也不可能为每一种数据类型都建立一个函数来完成加法功能，所以这里就分享下使用C++的泛型函数，泛型类和泛型特化来完成相应功能。在PyInvoker这个类里建...
Jython和JyNI的研究
java131313的专栏
01-14 8921
Linux Mint Debian Edition13(64) Environment Sunjdk1.7 Python2.7.3 Jython2.7b1 JyNI.alpha.2 编译JyNI.alpha.2是出错（系统库不兼容） In file included from /usr/include/string.h:159:0,                 
python 自动生成C++代码 （代码生成器）
weixin_33862041的博客
07-25 1925
python 代码自动生成的方法 （代码生成器） 遇到的问题 工作中遇到这么一个事，需要写很多C++的底层数据库类，但这些类大同小异，无非是增删改查，如果人工来写代码，既费力又容易出错；而借用python的代码自动生成，可以轻松搞定； （类比JAVA中的Hibernate自动生成的数据库底层操作代码） 下面介绍使用python字符串替换的方法； Python字符串替换的几种方法 1...
python中datetime在c++中代码
05-24
在C++中，可以使用C++11引入的std::chrono库来实现类似于Python中datetime的日期和时间操作。以下是一个简单的示例代码： ```c++ #include #include int main() { // 获取当前时间 auto now = std::chrono::...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值