Algorithme pour ajouter ou soustraire des jours à compter d'une date?

Vous n'avez pas vraiment besoin d'un algorithme en tant que tel (au moins pas quelque chose digne de ce nom), de la bibliothèque standard peut faire la plupart des charges lourdes; calendrier des calculs sont notoirement difficiles. Tant que vous n'avez pas besoin de dates antérieures à 1900, puis:

#include <ctime>

//Adjust date by a number of days +/-
void DatePlusDays( struct tm* date, int days )
{
    const time_t ONE_DAY = 24 * 60 * 60 ;

    //Seconds since start of epoch
    time_t date_seconds = mktime( date ) + (days * ONE_DAY) ;

    //Update caller's date
    //Use localtime because mktime converts to UTC so may change date
    *date = *localtime( &date_seconds ) ; ;
}

Exemple d'utilisation:

#include <iostream>

int main()
{
    struct tm date = { 0, 0, 12 } ;  //nominal time midday (arbitrary).
    int year = 2010 ;
    int month = 2 ;  //February
    int day = 26 ;   //26th

    //Set up the date structure
    date.tm_year = year - 1900 ;
    date.tm_mon = month - 1 ;  //note: zero indexed
    date.tm_mday = day ;       //note: not zero indexed

    //Date, less 100 days
    DatePlusDays( &date, -100 ) ; 

    //Show time/date using default formatting
    std::cout << asctime( &date ) << std::endl ;
}

OriginalL'auteur Clifford

Voici une esquisse d'une approche très simple. Pour des raisons de simplicité d'idées, je vais supposer que d, le nombre de jours à ajouter, est positif. Il est facile d'étendre le ci-dessous pour les cas où d est négatif.

Soit d est de moins de 365 ou d est supérieure ou égale à 365.

Si d est inférieure à 365:

m = 1;
while(d > numberOfDaysInMonth(m, y)) {
    d -= numberOfDaysInMonth(m, y);
    m++;
}
return date with year = y, month = m, day = d;

Si d est supérieure à 365:

while(d >= 365) {
    d -= 365;
    if(isLeapYear(y)) {
        d -= 1;
    }
    y++;
}
//now use the case where d is less than 365

Sinon, vous pouvez exprimer la date, disons, Julian forme et puis suffit d'ajouter à la Julian forme et la conversion de format ymd.

OriginalL'auteur jason

Essayer cette fonction. Il calcule correctement les additions ou les soustractions. dateTime argument doit être au format UTC.

tm* dateTimeAdd(const tm* const dateTime, const int& days, const int& hours, const int& mins, const int& secs) {
    tm* newTime = new tm;
    memcpy(newTime, dateTime, sizeof(tm));

    newTime->tm_mday += days;
    newTime->tm_hour += hours;
    newTime->tm_min += mins;
    newTime->tm_sec += secs;        

    time_t nt_seconds = mktime(newTime) - timezone;
    delete newTime;

    return gmtime(&nt_seconds);
}

Et il y a des exemple d'utilisation:

time_t t = time(NULL);
tm* utc = gmtime(&t);
tm* newUtc = dateTimeAdd(utc, -5, 0, 0, 0); //subtract 5 days

OriginalL'auteur Eldar Agalarov

Je sais que c'est une très vieille question, mais c'est intéressant, et quand il s'agit de travailler avec des dates et des heures. J'ai donc pensé à partager un bout de code qui permet de calculer la nouvelle date sans l'aide de tous intégré des fonctionnalités en C++.

#include <iostream>
#include <string>
using namespace std;
class Date {
public:
Date(size_t year, size_t month, size_t day):m_year(year), m_month(month), m_day(day) {}
~Date() {}
//Add specified number of days to date
Date operator + (size_t days) const;
//Subtract specified number of days from date
Date operator - (size_t days) const;
size_t Year()  { return m_year; }
size_t Month() { return m_month; }
size_t Day()   { return m_day; }
string DateStr();
private:
//Leap year check 
inline bool LeapYear(int year) const
{ return year % 4 == 0 && (year % 100 != 0 || year % 400 == 0); }
//Holds all max days in a general year
static const int MaxDayInMonth[13];
//Private members
size_t m_year;
size_t m_month;
size_t m_day;   
};
//Define MaxDayInMonth
const int Date::MaxDayInMonth[13] = {0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
//===========================================================================================
///Add specified number of days to date
Date Date::operator + (size_t days) const {
//Maximum days in the month
int nMaxDays(MaxDayInMonth[m_month] + (m_month == 2 && LeapYear(m_year) ? 1 : 0));
//Initialize the Year, Month, Days
int nYear(m_year);
int nMonth(m_month);
int nDays(m_day + days);
//Iterate till it becomes a valid day of a month
while (nDays > nMaxDays) {
//Subtract the max number of days of current month
nDays -= nMaxDays;
//Advance to next month
++nMonth;
//Falls on to next year?
if (nMonth > 12) {
nMonth = 1; //January
++nYear;    //Next year
}
//Update the max days of the new month
nMaxDays = MaxDayInMonth[nMonth] + (nMonth == 2 && LeapYear(nYear) ? 1 : 0);
}
//Construct date
return Date(nYear, nMonth, nDays);
}
//===========================================================================================
///Subtract specified number of days from date
Date Date::operator - (size_t days) const {
//Falls within the same month?
if (0 < (m_day - days)) {
return Date(m_year, m_month, m_day - days);
}
//Start from this year
int nYear(m_year);
//Start from specified days and go back to first day of this month
int nDays(days);
nDays -= m_day;
//Start from previous month and check if it falls on to previous year
int nMonth(m_month - 1);
if (nMonth < 1) {
nMonth = 12; //December
--nYear;     //Previous year
}
//Maximum days in the current month
int nDaysInMonth = MaxDayInMonth[nMonth] + (nMonth == 2 && LeapYear(nYear) ? 1 : 0);
//Iterate till it becomes a valid day of a month
while (nDays >= 0) {
//Subtract the max number of days of current month
nDays -= nDaysInMonth;
//Falls on to previous month?
if (nDays > 0) {
//Go to previous month
--nMonth;
//Falls on to previous year?
if (nMonth < 1) {
nMonth = 12; //December
--nYear;     //Previous year
}
}
//Update the max days of the new month
nDaysInMonth = MaxDayInMonth[nMonth] + (nMonth == 2 && LeapYear(nYear) ? 1 : 0);
}
//Construct date
return Date(nYear, nMonth, (0 < nDays ? nDays : -nDays));
}
//===========================================================================================
///Get the date string in yyyy/mm/dd format
string Date::DateStr() {
return to_string(m_year) 
+ string("/")
+ string(m_month < 10 ? string("0") + to_string(m_month) : to_string(m_month))
+ string("/")
+ string(m_day < 10 ? string("0") + to_string(m_day) : to_string(m_day)); 
}
int main() {
//Add n days to a date
cout << Date(2017, 6, 25).DateStr() << " + 10 days = "
<< (Date(2017, 6, 25) /* Given Date */ + 10 /* Days to add */).DateStr() << endl;
//Subtract n days from a date
cout << Date(2017, 6, 25).DateStr() << " - 10 days = "
<< (Date(2017, 6, 25) /* Given Date */ - 10 /* Days to subract */).DateStr() << endl;
return 0;
}
Output
2017/06/25 + 10 days = 2017/07/05
2017/06/25 - 10 days = 2017/06/15

OriginalL'auteur SajithP