QDate Class

Documentation des fonctions-membres

[constexpr] QDate::QDate()

Crée une date nulle. Les dates nulles ne sont pas valides.

Voir également isNull() et isValid().

Crée un objet ` QDate ` représentant la même date que ` date`. Cela facilite l'interopérabilité entre les classes de calendrier de la bibliothèque standard et les classes de date et d'heure de Qt.

Par exemple :

// 23 April 2012:
QDate date = std::chrono::year_month_day(std::chrono::year(2012),
                                        std::chrono::month(4),
                                        std::chrono::day(23));

// Same, under `using std::chrono` convenience:
QDate dateWithLiterals1 = 23d / April / 2012y;
QDate dateWithLiterals2 = 2012y / April / 23;

// Last day of February 2000
QDate lastDayFeb2020 = 2000y / February / last;

// First Monday of January 2020:
QDate firstMonday = 2020y / January / Monday[0];

// Last Monday of January 2020:
QDate lastMonday = 2020y / January / Monday[last];

Ces fonctions ont été introduites dans Qt 6.4.

QDate::QDate(int y, int m, int d)

Crée une date avec l'année y, le mois m et le jour d.

La date est interprétée selon le calendrier grégorien. Si la date spécifiée n'est pas valide, elle n'est pas définie et la fonction isValid() renvoie false.

Voir également isValid() et QCalendar::dateFromParts().

QDate QDate::addDays(qint64 ndays) const

Renvoie un objet ` QDate ` contenant une date ndays postérieure à la date de cet objet (ou antérieure si ` ndays ` est négative).

Renvoie une date nulle si la date actuelle n'est pas valide ou si la nouvelle date est hors de la plage autorisée.

Voir également addMonths(), addYears() et daysTo().

[since 6.4] QDate QDate::addDuration(std::chrono::days ndays) const

Renvoie un objet ` QDate ` contenant une date ndays postérieure à la date de cet objet (ou antérieure si ` ndays ` est négatif).

Renvoie une date nulle si la date actuelle n’est pas valide ou si la nouvelle date est hors limites.

Cette fonction a été introduite dans Qt 6.4.

Voir également addMonths(), addYears() et daysTo().

QDate QDate::addMonths(int nmonths, QCalendar cal) const

Renvoie un objet ` QDate ` contenant une date nmonths postérieure à la date de cet objet (ou antérieure si ` nmonths ` est négatif).

Utilise cal comme calendrier, s’il est fourni, sinon le calendrier grégorien.

Voir également addDays() et addYears().

QDate QDate::addMonths(int nmonths) const

QDate QDate::addYears(int nyears, QCalendar cal) const

Renvoie un objet ` QDate ` contenant une date nyears postérieure à la date de cet objet (ou antérieure si ` nyears ` est négatif).

Utilise cal comme calendrier, s'il est fourni, sinon le calendrier grégorien.

Voir également addDays() et addMonths().

QDate QDate::addYears(int nyears) const

[static] QDate QDate::currentDate()

Renvoie la date actuelle de l'horloge système.

Voir également QTime::currentTime() et QDateTime::currentDateTime().

int QDate::day(QCalendar cal) const

Renvoie le jour du mois correspondant à cette date.

Utilise le calendrier cal s'il est fourni, sinon le calendrier grégorien (pour lequel la valeur renvoyée est comprise entre 1 et 31). Renvoie 0 si la date n'est pas valide.

Voir également year(), month(), dayOfWeek() et QCalendar::partsFromDate().

int QDate::day() const

int QDate::dayOfWeek(QCalendar cal) const

Renvoie le jour de la semaine (1 = lundi à 7 = dimanche) correspondant à cette date.

Utilise le calendrier cal s'il est fourni, sinon le calendrier grégorien. Renvoie 0 si la date n'est pas valide. Certains calendriers peuvent attribuer une signification particulière (par exemple, des jours intercalaires) aux valeurs supérieures à 7.

Voir également day(), dayOfYear(), QCalendar::dayOfWeek() et Qt::DayOfWeek.

int QDate::dayOfWeek() const

int QDate::dayOfYear(QCalendar cal) const

Renvoie le jour de l'année (1 pour le premier jour) correspondant à cette date.

Utilise cal comme calendrier s'il est fourni, sinon le calendrier grégorien. Renvoie 0 si la date ou le premier jour de l'année correspondante n'est pas valide.

Voir également day(), dayOfWeek() et QCalendar::daysInYear().

int QDate::dayOfYear() const

int QDate::daysInMonth(QCalendar cal) const

Renvoie le nombre de jours du mois correspondant à cette date.

Utilise le calendrier cal s'il est fourni, sinon le calendrier grégorien (pour lequel le résultat varie entre 28 et 31). Renvoie 0 si la date n'est pas valide.

Voir également day(), daysInYear(), QCalendar::daysInMonth(), QCalendar::maximumDaysInMonth() et QCalendar::minimumDaysInMonth().

int QDate::daysInMonth() const

int QDate::daysInYear(QCalendar cal) const

Renvoie le nombre de jours de l'année correspondant à cette date.

Utilise le calendrier cal s'il est fourni, sinon le calendrier grégorien (pour lequel le résultat est 365 ou 366). Renvoie 0 si la date n'est pas valide.

Voir également day(), daysInMonth(), QCalendar::daysInYear() et QCalendar::maximumMonthsInYear().

int QDate::daysInYear() const

qint64 QDate::daysTo(QDate d) const

Renvoie le nombre de jours entre la date actuelle et d.

Cela équivaut à d.toJulianDay() - toJulianDay(). Le résultat est négatif si d est antérieure à cette date. Renvoie 0 si l'une des deux dates n'est pas valide.

Exemple :

QDate d1(1995, 5, 17);  // May 17, 1995
QDate d2(1995, 5, 20);  // May 20, 1995
d1.daysTo(d2);          // returns 3
d2.daysTo(d1);          // returns -3

Voir aussi addDays().

QDateTime QDate::endOfDay(const QTimeZone &zone) const

Renvoie l'heure de fin de la journée.

Le moment où une journée se termine dépend de la manière dont l'heure est définie : chaque journée commence et se termine plus tôt pour les personnes situées dans des fuseaux horaires plus à l'ouest, et plus tard pour celles situées dans des fuseaux horaires plus à l'est. La représentation de l'heure à utiliser peut être spécifiée à l'aide d'un paramètre facultatif « time zone ». La représentation par défaut est l'heure locale du système.

En général, la fin de la journée correspond à une milliseconde avant minuit, soit 24 h 00 : cependant, si un changement de fuseau horaire fait que la date donnée saute ce moment (par exemple, un passage à l’heure d’été qui saute 23 h 00 et l’heure suivante), c’est l’heure la plus tardive effective de la journée qui est renvoyée. Cela ne peut se produire que lorsque la représentation temporelle est un fuseau horaire ou l’heure locale.

Lorsque zone a un timeSpec() de type Qt::OffsetFromUTC ou Qt::UTC, la représentation de l'heure ne comporte aucune transition ; la fin de la journée est donc QTime(23, 59, 59, 999).

Dans le cas rare où une date serait entièrement ignorée (ce qui se produit lorsqu’un fuseau horaire situé à l’est de la ligne de changement de date passe à l’ouest de celle-ci), le résultat renvoyé sera invalide. Le fait de passer un fuseau horaire invalide tel que zone produira également un résultat invalide, tout comme les dates se terminant en dehors de la plage représentable par QDateTime.

Voir également startOfDay().

[since 6.5] QDateTime QDate::endOfDay() const

Cette fonction a été introduite dans Qt 6.5.

[static constexpr] QDate QDate::fromJulianDay(qint64 jd)

Convertit le jour julien jd en QDate.

Voir aussi toJulianDay().

[static constexpr noexcept, since 6.4] QDate QDate::fromStdSysDays(const std::chrono::sys_days &days)

Renvoie une date au format « QDate » days jours après le 1er janvier 1970 (l'époque UNIX). Si days est négatif, la date renvoyée sera antérieure à l'époque.

Cette fonction a été introduite dans Qt 6.4.

Voir également toStdSysDays().

[static] QDate QDate::fromString(const QString &string, const QString &format, int baseYear, QCalendar cal)

Renvoie l'QDate représentée par la chaîne « string », en utilisant le format de date « format » fourni, ou une date non valide si la chaîne ne peut pas être analysée.

Utilise le calendrier cal s’il est fourni, sinon le calendrier grégorien. Les plages de valeurs indiquées dans les descriptions de format ci-dessous s’appliquent à ce dernier ; elles peuvent être différentes pour d’autres calendriers.

Les expressions suivantes peuvent être utilisées pour le format :

Toute séquence non vide de caractères placée entre guillemets simples sera également traitée (une fois les guillemets supprimés) comme du texte et ne sera pas interprétée comme une expression. Deux guillemets simples consécutifs («''») sont interprétés comme un guillemet simple devant être trouvé dans l’entrée, plutôt que comme le début ou la fin d’une séquence littérale. Tous les autres caractères de l’entrée seront traités comme du texte littéral devant être trouvé dans la chaîne d’entrée. Par exemple :

QDate date = QDate::fromString("1MM12car2003", "d'MM'MMcaryyyy");
// date is 1 December 2003

Si le format n’est pas respecté, une erreur « QDate » est renvoyée.

Lorsque des champs numériques sont juxtaposés, sans séparateur pour interrompre les séquences de chiffres, une ambiguïté peut exister quant à savoir si certains champs pouvant comporter un seul chiffre utilisent deux chiffres (car la valeur à représenter est supérieure à 9). Lorsque l’attribution de deux chiffres à un tel champ en laisserait trop peu pour les autres champs, et que la lecture à un seul chiffre est cohérente avec les autres champs, cette ambiguïté peut être résolue. Dans le cas contraire (lorsque plusieurs champs peuvent comporter un seul chiffre et qu’il resterait des chiffres inutilisés si chacun n’en recevait qu’un), une résolution attribuant des chiffres supplémentaires aux champs précédents est préférée à une solution les attribuant aux champs suivants, à condition que les données restent cohérentes. Par exemple :

QDate date = QDate::fromString("130", "Md"); // Janary 30

Pour tout champ qui n’est pas représenté dans le format, les valeurs par défaut suivantes sont utilisées :

Lorsque format ne précise que les deux derniers chiffres d'une année, les 100 années commençant par baseYear sont les premières prises en compte. Avant la version 6.7, il n’existait pas de paramètre « baseYear » et l’année 1900 était toujours utilisée. C’est la valeur par défaut pour « baseYear », qui sélectionne une année comprise entre cette date et 1999. En passant 1976 comme « baseYear », on sélectionnera par exemple une année comprise entre 1976 et 2075. Lorsque le format inclut également le mois, le jour (du mois) et le jour de la semaine, ces informations suffisent à déterminer le siècle. Dans ce cas, une date correspondante est sélectionnée dans le siècle le plus proche de celui indiqué par « baseYear », la priorité étant donnée aux dates les plus récentes. Voir QCalendar::matchCenturyToWeekday() et Date ambiguities pour plus de détails.

Les exemples suivants illustrent les valeurs par défaut :

QDate::fromString("1.30", "M.d");           // January 30 1900
QDate::fromString("20000110", "yyyyMMdd");  // January 10, 2000
QDate::fromString("20000110", "yyyyMd");    // January 10, 2000

Ambiguïtés liées aux dates

Les différentes cultures utilisent des formats de date variés et, par conséquent, les utilisateurs peuvent confondre l'ordre dans lequel les champs de date doivent être renseignés. Par exemple, "Wed 28-Nov-01" peut signifier soit le 1er novembre 2028, soit le 28 novembre 2001 (ces deux dates tombant toutes deux un mercredi). En utilisant le format "ddd yy-MMM-dd", la date sera interprétée dans le premier sens, tandis qu’avec "ddd dd-MMM-yy", ce sera dans le second. Cependant, l’intention de l’utilisateur peut dépendre de la façon dont il écrit habituellement les dates, plutôt que du format attendu par le code.

L’exemple examiné ci-dessus a confondu le jour du mois et une année à deux chiffres. Une confusion similaire peut survenir en cas d’inversion du mois et du jour du mois, lorsque les deux sont exprimés sous forme de chiffres. Dans ces cas, l’ajout d’un champ indiquant le jour de la semaine dans le format de date peut apporter une certaine redondance, susceptible d’aider à détecter ce type d’erreurs. Cependant, comme dans l’exemple ci-dessus, cette méthode n’est pas toujours efficace : l’inversion de deux champs (ou de leur signification) peut produire des dates correspondant au même jour de la semaine.

L’inclusion d’un jour de la semaine dans le format peut également permettre de déterminer le siècle d’une date spécifiée en utilisant uniquement les deux derniers chiffres de son année. Malheureusement, lorsqu’elle est combinée à une date dans laquelle l’utilisateur (ou une autre source de données) a interverti deux des champs, cette résolution peut conduire à trouver une date qui correspond certes à la lecture du format, mais qui n’est pas celle voulue par son auteur. De même, si l’utilisateur se trompe simplement sur le jour de la semaine, dans une date par ailleurs correcte, cela peut aboutir à une date appartenant à un autre siècle. Dans chaque cas, le fait de trouver une date d’un autre siècle peut transformer une date saisie de manière erronée en une date radicalement différente.

La meilleure façon d’éviter les ambiguïtés de date consiste à utiliser des années à quatre chiffres et des mois spécifiés par leur nom (qu’il soit complet ou abrégé), idéalement recueillis via des conventions d’interface utilisateur qui indiquent très clairement à l’utilisateur quelle partie de la date il sélectionne. L’inclusion d’un jour de la semaine peut également aider en permettant de vérifier la cohérence des données. Lorsque les données proviennent de l’utilisateur, dans un format défini par les paramètres régionaux qu’il a sélectionnés, il est préférable d’utiliser un format long, car les formats courts ont davantage tendance à utiliser des années à deux chiffres. Bien sûr, il n’est pas toujours possible de contrôler le format : les données peuvent par exemple provenir d’une source que vous ne maîtrisez pas.

En raison de ces sources potentielles de confusion, en particulier lorsque vous ne pouvez pas être certain qu’un format sans ambiguïté est utilisé, il est important de vérifier que le résultat de la lecture d’une chaîne en tant que date est non seulement valide, mais aussi raisonnable au regard de l’usage pour lequel elle a été fournie. Si le résultat se situe en dehors d’une plage de valeurs raisonnables, il peut être utile de demander à l’utilisateur de confirmer sa sélection de date, en affichant la date lue à partir de la chaîne au format long, qui inclut le nom du mois et l’année à quatre chiffres, afin de lui permettre de repérer plus facilement d’éventuelles erreurs.

Voir également toString(), QDateTime::fromString(), QTime::fromString() et QLocale::toDate().

[static, since 6.0] QDate QDate::fromString(QStringView string, Qt::DateFormat format = Qt::TextDate)

Cette fonction a été introduite dans Qt 6.0.

[static] QDate QDate::fromString(const QString &string, Qt::DateFormat format = Qt::TextDate)

Renvoie l'QDate représentée par la chaîne « string », en utilisant la format fournie, ou une date non valide si la chaîne ne peut pas être analysée.

Remarque concernant Qt::TextDate: seuls les noms de mois en anglais (par exemple « Jan » en abrégé ou « January » en complet) sont reconnus.

Voir également toString() et QLocale::toDate().

[static, since 6.0] QDate QDate::fromString(QStringView string, QStringView format, QCalendar cal)

Cette fonction a été introduite dans Qt 6.0.

[static, since 6.7] QDate QDate::fromString(QStringView string, QStringView format, int baseYear = QLocale::DefaultTwoDigitBaseYear)

Utilise un objet ` QCalendar` construit par défaut.

Cette fonction a été introduite dans Qt 6.7.

[static, since 6.0] QDate QDate::fromString(const QString &string, QStringView format, QCalendar cal)

Cette fonction a été introduite dans Qt 6.0.

[static, since 6.7] QDate QDate::fromString(const QString &string, QStringView format, int baseYear = QLocale::DefaultTwoDigitBaseYear)

Utilise un objet ` QCalendar` construit par défaut.

Cette fonction a été introduite dans Qt 6.7.

[static] QDate QDate::fromString(const QString &string, const QString &format, QCalendar cal)

[static, since 6.7] QDate QDate::fromString(const QString &string, const QString &format, int baseYear = QLocale::DefaultTwoDigitBaseYear)

Utilise une instance d'QCalendar créée par défaut.

Cette fonction a été introduite dans Qt 6.7.

[static, since 6.7] QDate QDate::fromString(QStringView string, QStringView format, int baseYear, QCalendar cal)

Cette fonction a été introduite dans Qt 6.7.

[static, since 6.0] QDate QDate::fromString(const QString &string, QStringView format, int baseYear, QCalendar cal)

Cette fonction a été introduite dans Qt 6.0.

void QDate::getDate(int *year, int *month, int *day) const

Extrait l'année, le mois et le jour de la date, puis les attribue respectivement à *year, *month et *day. Les pointeurs peuvent être nuls.

Renvoie 0 si la date n'est pas valide.

Voir également year(), month(), day(), isValid() et QCalendar::partsFromDate().

[static] bool QDate::isLeapYear(int year)

Renvoie true si l'year spécifiée correspond à une année bissextile dans le calendrier grégorien ; sinon, renvoie false.

Voir également QCalendar::isLeapYear().

[constexpr] bool QDate::isNull() const

Renvoie « true » si la date est nulle ; sinon, renvoie « false ». Une date nulle n'est pas valide.

Voir également isValid().

[constexpr] bool QDate::isValid() const

Renvoie « true » si cette date est valide ; sinon, renvoie « false ».

Voir également isNull() et QCalendar::isDateValid().

[static] bool QDate::isValid(int year, int month, int day)

Renvoie « true » si la date spécifiée (year, month et day) est valide dans le calendrier grégorien ; sinon, renvoie « false ».

Exemple :

QDate::isValid(2002, 5, 17);  // true
QDate::isValid(2002, 2, 30);  // false (Feb 30 does not exist)
QDate::isValid(2004, 2, 29);  // true (2004 is a leap year)
QDate::isValid(2000, 2, 29);  // true (2000 is a leap year)
QDate::isValid(2006, 2, 29);  // false (2006 is not a leap year)
QDate::isValid(2100, 2, 29);  // false (2100 is not a leap year)
QDate::isValid(1202, 6, 6);   // true (even though 1202 is pre-Gregorian)

Voir également isNull(), setDate() et QCalendar::isDateValid().

int QDate::month(QCalendar cal) const

Renvoie le numéro du mois correspondant à la date.

Numérote les mois de l’année en commençant par 1 pour le premier. Utilise le calendrier « cal » s’il est fourni, sinon le calendrier grégorien, pour lequel la numérotation des mois est la suivante :

• 1 = « janvier »
• 2 = « février »
• 3 = « mars »
• 4 = « avril »
• 5 = « mai »
• 6 = « juin »
• 7 = « juillet »
• 8 = « août »
• 9 = « septembre »
• 10 = « octobre »
• 11 = « novembre »
• 12 = « décembre »

Renvoie 0 si la date n'est pas valide. Notez que certains calendriers peuvent comporter plus de 12 mois certaines années.

Voir également year(), day() et QCalendar::partsFromDate().

int QDate::month() const

bool QDate::setDate(int year, int month, int day)

Définit cette valeur pour représenter la date, selon le calendrier grégorien, à partir des nombres fournis : year, month et day. Renvoie « true » si la date obtenue est valide ; dans le cas contraire, cette valeur est définie pour représenter une date non valide et renvoie « false ».

Voir également isValid() et QCalendar::dateFromParts().

bool QDate::setDate(int year, int month, int day, QCalendar cal)

Définit cette variable pour qu'elle représente la date, dans le calendrier spécifié cal, avec les valeurs indiquées pour year, month et day. Renvoie « true » si la date obtenue est valide ; dans le cas contraire, elle définit cette variable pour qu'elle représente une date non valide et renvoie « false ».

Voir également isValid() et QCalendar::dateFromParts().

QDateTime QDate::startOfDay(const QTimeZone &zone) const

Renvoie l'instant de début de la journée.

Le moment où commence une journée dépend de la manière dont l'heure est décrite : chaque journée commence et se termine plus tôt pour les personnes situées dans des fuseaux horaires plus à l'ouest, et plus tard pour celles situées dans des fuseaux horaires plus à l'est. La représentation de l'heure à utiliser peut être spécifiée par un paramètre optionnel ` zone`. La représentation par défaut est l'heure locale du système.

En général, le début de la journée correspond à minuit, soit 00:00 ; toutefois, si un changement de fuseau horaire fait que la date donnée ne correspond pas à minuit (par exemple, lors du passage à l’heure d’été qui fait sauter la première heure de la journée), c’est l’heure la plus précoce effective de la journée qui est renvoyée. Ce cas ne peut se produire que lorsque la représentation de l’heure correspond à un fuseau horaire ou à l’heure locale.

Lorsque ` zone ` a un `timeSpec()` de type ` Qt::OffsetFromUTC ` ou ` Qt::UTC`, la représentation de l’heure ne comporte pas de transitions ; le début de la journée est donc ` QTime` (0, 0).

Dans le cas rare où une date aurait été entièrement sautée (ce qui se produit lorsqu’un fuseau horaire situé à l’est de la ligne de changement de date passe à l’ouest de celle-ci), le résultat renvoyé sera invalide. Le fait de passer un fuseau horaire invalide comme paramètre à ` zone ` produira également un résultat invalide, tout comme les dates dont le début se situe en dehors de la plage représentable par ` QDateTime`.

Voir également endOfDay().

[since 6.5] QDateTime QDate::startOfDay() const

Cette fonction a été introduite dans Qt 6.5.

[constexpr] qint64 QDate::toJulianDay() const

Convertit la date en jour julien.

Voir aussi fromJulianDay().

[constexpr noexcept] std::chrono::sys_days QDate::toStdSysDays() const

Renvoie le nombre de jours entre le 1er janvier 1970 (l'époque UNIX) et cette date, représenté sous la forme d'un objet ` std::chrono::sys_days `. Si cette date est antérieure à l'époque, le nombre de jours sera négatif.

Voir également ` fromStdSysDays()` et ` daysTo()`.

Renvoie la date sous forme de chaîne de caractères. Le paramètre « format » détermine le format de la chaîne de caractères résultante. Si « cal » est fourni, il détermine le calendrier utilisé pour représenter la date ; par défaut, c'est le calendrier grégorien. Avant Qt 5.14, le paramètre « cal » n'existait pas et le calendrier grégorien était toujours utilisé.

Les expressions suivantes peuvent être utilisées dans le paramètre format:

Toute séquence non vide de caractères entre guillemets simples sera incluse telle quelle dans la chaîne de sortie (sans les guillemets), même si elle contient des caractères de mise en forme. Deux guillemets simples consécutifs («''») sont remplacés par un seul guillemet simple dans la chaîne de sortie, plutôt que de marquer le début ou la fin d'une séquence à reproduire à l'identique. Tous les autres caractères de la chaîne de format sont inclus tels quels dans la chaîne de sortie.

Les formats sans séparateurs (par exemple « ddMM ») sont pris en charge mais doivent être utilisés avec précaution, car les chaînes résultantes ne sont pas toujours lisibles de manière fiable (par exemple, si « dM » produit « 212 », cela pourrait signifier soit le 2 décembre, soit le 21 février).

Exemples de chaînes de format (en supposant que l’ QDate e soit le 20 juillet 1969) :

Si la date-heure n'est pas valide, une chaîne vide sera renvoyée.

Voir également fromString(), QDateTime::toString(), QTime::toString() et QLocale::toString().

QString QDate::toString(QStringView format) const

QString QDate::toString(Qt::DateFormat format = Qt::TextDate) const

Renvoie la date sous forme de chaîne de caractères. Le paramètre ` format ` détermine le format de cette chaîne.

Si l'format est Qt::TextDate, la chaîne est formatée de manière par défaut. Les noms des jours et des mois seront en anglais. Un exemple de ce formatage est « Sat May 20 1995 ». Pour le formatage localisé, voir QLocale::toString().

Si l’ format e est Qt::ISODate, le format de la chaîne correspond à la spécification étendue ISO 8601 pour la représentation des dates et des heures, sous la forme aaaa-MM-jj, où aaaa est l’année, MM est le mois de l’année (compris entre 01 et 12), et dd le jour du mois compris entre 01 et 31.

Si l'format e est Qt::RFC2822Date, la chaîne est formatée de manière compatible avec la norme RFC 2822. Un exemple de ce format est « 20 mai 1995 ».

Si la date n’est pas valide, une chaîne vide sera renvoyée.

Voir également fromString() et QLocale::toString().

QString QDate::toString(const QString &format) const

int QDate::weekNumber(int *yearNumber = nullptr) const

Renvoie le numéro de semaine selon la norme ISO 8601 (de 1 à 53).

Renvoie 0 si la date n’est pas valide. Sinon, renvoie le numéro de semaine correspondant à la date. Si ` yearNumber ` n’est pas défini sur ` nullptr ` (valeur par défaut), stocke l’année au format *yearNumber.

Conformément à la norme ISO 8601, chaque semaine est attribuée à l’année à laquelle appartiennent la plupart de ses jours, selon le calendrier grégorien. La semaine ISO 8601 commençant le lundi, il s’agit de l’année au cours de laquelle tombe le jeudi de cette semaine. La plupart des années comptent 52 semaines, mais certaines en comptent 53.

Voir également isValid().

int QDate::year(QCalendar cal) const

Renvoie l'année correspondant à cette date.

Utilise le calendrier spécifié par ` cal `, s'il est fourni, sinon le calendrier grégorien.

Renvoie 0 si la date n'est pas valide. Pour certains calendriers, les dates antérieures à leur première année peuvent toutes être invalides.

Si vous utilisez un calendrier comportant une année 0, vérifiez à l’aide de ` isValid()` si la valeur renvoyée est 0. Ces calendriers utilisent des numéros d’années négatifs de manière évidente : l’année 1 est précédée de l’année 0, elle-même précédée de l’année -1, et ainsi de suite.

Certains calendriers, bien qu’ils ne comportent pas d’année 0, utilisent une numérotation conventionnelle des années antérieures à leur première année, en comptant à rebours à partir de 1. Par exemple, dans le calendrier grégorien proleptique, les années successives antérieures à l’an 1 de notre ère (la première année) sont désignées par 1 av. J.-C., 2 av. J.-C., 3 av. J.-C., et ainsi de suite. Dans ces calendriers, les nombres d'années négatifs sont utilisés pour désigner ces années antérieures à l'an 1, -1 indiquant l'année précédant l'an 1.

Voir également month(), day(), QCalendar::hasYearZero(), QCalendar::isProleptic() et QCalendar::partsFromDate().

int QDate::year() const