QDateTime Class

Documentation des fonctions membres

QDateTime::QDateTime(QDate date, QTime time, const QTimeZone &timeZone, QDateTime::TransitionResolution resolve = TransitionResolution::LegacyBehavior)

Crée un objet `datetime` à partir des données fournies date et time, en utilisant le format de représentation de l'heure décrit à l'adresse timeZone.

Si date est valide et time ne l’est pas, l’heure sera définie sur minuit. Si timeZone n’est pas valide, l’objet datetime sera invalide. Si date et time décrivent un moment proche d’une transition pour timeZone, resolve contrôle la manière dont cette situation est résolue.

[noexcept] QDateTime::QDateTime()

Crée une date-heure nulle, en utilisant par défaut l'heure locale.

Une date-heure nulle n'est pas valide, car sa date et son heure ne sont pas valides.

Voir également isValid(), setMSecsSinceEpoch(), setDate(), setTime() et setTimeZone().

[since 6.5] QDateTime::QDateTime(QDate date, QTime time, QDateTime::TransitionResolution resolve = TransitionResolution::LegacyBehavior)

Crée un objet `datetime` à partir des valeurs ` date ` et ` time` fournies, en utilisant l'heure locale.

Si date est valide et que time ne l’est pas, minuit sera utilisé comme heure. Si date et time décrivent un moment proche d’une transition de l’heure locale, resolve contrôle la manière dont cette situation est résolue.

Cette fonction a été introduite dans Qt 6.5.

[noexcept] QDateTime::QDateTime(const QDateTime &other)

Crée une copie de la date-heure « other ».

[noexcept] QDateTime::QDateTime(QDateTime &&other)

Transfère le contenu de l'objet temporaire « other » (date-heure) vers cet objet et laisse « other » dans un état non spécifié (mais correct).

[noexcept] QDateTime::~QDateTime()

Supprime la date-heure.

QDateTime QDateTime::addDays(qint64 ndays) const

Renvoie un objet ` QDateTime ` contenant une date-heure ` ndays ` jours après la date-heure de cet objet (ou avant si ` ndays ` est négatif).

Si la valeur de ` timeSpec()` est ` Qt::LocalTime ` ou ` Qt::TimeZone ` et que la date et l’heure résultantes se situent pendant l’heure de transition entre l’heure d’hiver et l’heure d’été, le résultat se situera alors juste après cette intervalle, dans le sens du changement. Si le changement a lieu à 2 h du matin et que l’horloge passe à 3 h, le résultat d’une visée comprise entre 2 h et 3 h sera ajusté pour se situer avant 2 h (si ndays < 0) ou après 3 h (dans le cas contraire).

Voir également daysTo(), addMonths(), addYears(), addSecs() et Timezone transitions.

[since 6.4] QDateTime QDateTime::addDuration(std::chrono::milliseconds msecs) const

Renvoie un objet ` QDateTime ` contenant une date-heure ` msecs ` millisecondes après la date-heure de cet objet (ou avant si ` msecs ` est négatif).

Si cette date-heure n'est pas valide, une date-heure non valide sera renvoyée.

Cette fonction a été introduite dans Qt 6.4.

Voir également addMSecs(), msecsTo(), addDays(), addMonths() et addYears().

QDateTime QDateTime::addMSecs(qint64 msecs) const

Renvoie un objet ` QDateTime ` contenant une date-heure ` msecs ` correspondant à un moment situé `milliseconds` après la date-heure de cet objet (ou avant si ` msecs ` est négatif).

Si cette date-heure n'est pas valide, une date-heure non valide sera renvoyée.

Voir également addSecs(), msecsTo(), addDays(), addMonths() et addYears().

QDateTime QDateTime::addMonths(int nmonths) const

Renvoie un objet ` QDateTime ` contenant une date-heure nmonths située x mois après la date-heure de cet objet (ou avant, si ` nmonths ` est négatif).

Si la fonction timeSpec() reçoit les paramètres Qt::LocalTime ou Qt::TimeZone et que la date et l’heure résultantes se situent pendant l’heure de transition entre l’heure d’hiver et l’heure d’été, le résultat se situera juste après cette plage, dans le sens du changement. Si le changement a lieu à 2 h du matin et que l’horloge passe à 3 h, le résultat d’une visée comprise entre 2 h et 3 h sera ajusté pour se situer avant 2 h (si nmonths < 0) ou après 3 h (dans le cas contraire).

Voir également daysTo(), addDays(), addYears(), addSecs() et Timezone transitions.

QDateTime QDateTime::addSecs(qint64 s) const

Renvoie un objet ` QDateTime ` contenant une date-heure ` s ` secondes après la date-heure de cet objet (ou avant si ` s ` est négatif).

Si cette date-heure n'est pas valide, une date-heure non valide sera renvoyée.

Voir également addMSecs(), secsTo(), addDays(), addMonths() et addYears().

QDateTime QDateTime::addYears(int nyears) const

Renvoie un objet ` QDateTime ` contenant une date-heure nyears située x années après la date-heure de cet objet (ou avant, si ` nyears ` est négatif).

Si la fonction timeSpec() prend pour paramètres Qt::LocalTime ou Qt::TimeZone et que la date et l’heure résultantes se situent dans l’heure de transition entre l’heure d’hiver et l’heure d’été, le résultat se situera juste au-delà de cet intervalle, dans le sens du changement. Si le changement a lieu à 2 h du matin et que l’horloge passe à 3 h, le résultat d’une visée comprise entre 2 h et 3 h sera ajusté pour se situer avant 2 h (si nyears < 0) ou après 3 h (dans le cas contraire).

Voir également daysTo(), addDays(), addMonths(), addSecs() et Timezone transitions.

[static, since 6.5] QDateTime QDateTime::currentDateTime(const QTimeZone &zone)

Renvoie la date et l'heure actuelles de l'horloge système, en utilisant le format de représentation du temps décrit à l'adresse zone. Si zone est omis, c'est l'heure locale qui est utilisée.

Cette fonction a été introduite dans Qt 6.5.

Voir également currentDateTimeUtc(), QDate::currentDate(), QTime::currentTime() et toTimeZone().

[static] QDateTime QDateTime::currentDateTime()

[static] QDateTime QDateTime::currentDateTimeUtc()

Renvoie la date et l'heure actuelles de l'horloge système, exprimées en UTC.

Équivalent à ` currentDateTime(QTimeZone::UTC)`.

Voir également currentDateTime(), QDate::currentDate(), QTime::currentTime() et toTimeZone().

[static noexcept] qint64 QDateTime::currentMSecsSinceEpoch()

Renvoie le nombre actuel de millisecondes écoulées depuis le début de l'année 1970, en UTC.

Ce nombre est similaire à la variable POSIX `time_t`, mais exprimé en millisecondes plutôt qu’en secondes.

Voir également currentDateTime(), currentDateTimeUtc() et toTimeZone().

[static noexcept] qint64 QDateTime::currentSecsSinceEpoch()

Renvoie le nombre de secondes écoulées depuis le début de l'année 1970, en UTC.

Ce nombre est similaire à la variable POSIX `time_t`.

Voir aussi currentMSecsSinceEpoch().

QDate QDateTime::date() const

Renvoie la partie « date » de l'objet `datetime`.

Voir également setDate(), time() et timeRepresentation().

qint64 QDateTime::daysTo(const QDateTime &other) const

Renvoie le nombre de jours entre cette date-heure et la date-heure « other ».

Le nombre de jours est calculé en fonction du nombre de fois où minuit est atteint entre cette date-heure et la date-heure de l'other. Cela signifie qu'un écart de 10 minutes entre 23 h 55 et 0 h 05 le lendemain compte pour un jour.

Si la date-heure « other » est antérieure à la date-heure actuelle, la valeur renvoyée est négative. Si l'une ou l'autre des dates-heures n'est pas valide, la valeur renvoyée est 0.

Exemple :

QDateTime startDate(QDate(2012, 7, 6), QTime(8, 30, 0));
QDateTime endDate(QDate(2012, 7, 7), QTime(16, 30, 0));
qDebug() << "Days from startDate to endDate: " << startDate.daysTo(endDate);

startDate = QDateTime(QDate(2012, 7, 6), QTime(23, 55, 0));
endDate = QDateTime(QDate(2012, 7, 7), QTime(0, 5, 0));
qDebug() << "Days from startDate to endDate: " << startDate.daysTo(endDate);

qSwap(startDate, endDate); // Make endDate before startDate.
qDebug() << "Days from startDate to endDate: " << startDate.daysTo(endDate);

Voir également addDays(), secsTo() et msecsTo().

[static] QDateTime QDateTime::fromCFDate(CFDateRef date)

Crée un nouvel objet ` QDateTime ` contenant une copie de l'date` CFDate`.

Voir également toCFDate().

[static] QDateTime QDateTime::fromMSecsSinceEpoch(qint64 msecs, const QTimeZone &timeZone)

Renvoie une date-heure représentant un instant situé à un nombre donné msecs de millisecondes après le début, en UTC, de l'année 1970, tel que défini par timeZone. La représentation par défaut de l'heure est l'heure locale.

Notez qu’il existe des valeurs possibles pour msecs qui se situent en dehors de la plage valide de QDateTime, qu’elles soient négatives ou positives. Le comportement de cette fonction est indéfini pour ces valeurs.

Voir également fromSecsSinceEpoch(), toMSecsSinceEpoch() et setMSecsSinceEpoch().

[static] QDateTime QDateTime::fromMSecsSinceEpoch(qint64 msecs)

[static] QDateTime QDateTime::fromNSDate(const NSDate *date)

Crée un nouvel objet ` QDateTime ` contenant une copie de l'objet `NSDate` ` date`.

Voir également toNSDate().

[static] QDateTime QDateTime::fromSecsSinceEpoch(qint64 secs, const QTimeZone &timeZone)

Renvoie une date-heure représentant un instant situé à secs secondes après le début de l'année 1970, en UTC, tel que défini par timeZone. La représentation par défaut de l'heure est l'heure locale.

Notez qu’il existe des valeurs possibles pour secs qui se situent en dehors de la plage valide définie par QDateTime, qu’elles soient négatives ou positives. Le comportement de cette fonction est indéfini pour ces valeurs.

Voir également fromMSecsSinceEpoch(), toSecsSinceEpoch() et setSecsSinceEpoch().

[static] QDateTime QDateTime::fromSecsSinceEpoch(qint64 secs)

[static, since 6.4] QDateTime QDateTime::fromStdLocalTime(const std::chrono::local_time<std::chrono::milliseconds> &time)

Crée un objet `datetime` dont la date et l'heure correspondent au nombre de millisecondes représenté par ` time`, compté à partir du 1er janvier 1970 à 00:00:00.000, en heure locale (Qt::LocalTime).

Cette fonction a été introduite dans Qt 6.4.

Voir également ` toStdSysMilliseconds()` et ` fromMSecsSinceEpoch()`.

[static, since 6.4] template <typename Clock, typename Duration> QDateTime QDateTime::fromStdTimePoint(const std::chrono::time_point<Clock, Duration> &time) requires requires(const std::chrono::time_point<Clock, Duration> &t) { // the clock can be converted to system_clock std::chrono::clock_cast<std::chrono::system_clock>(t); // after the conversion to system_clock, the duration type // we get is convertible to milliseconds requires std::is_convertible_v< system_clock_cast_duration<Clock, Duration>, std::chrono::milliseconds >; }

Crée une date-heure correspondant au même instant que time, en utilisant Qt::UTC comme représentation temporelle.

L'horloge de time doit être compatible avec std::chrono::system_clock; en particulier, une conversion prise en charge par std::chrono::clock_cast doit exister. Après la conversion, le type de durée du résultat doit être convertible en std::chrono::milliseconds.

Si ce n’est pas le cas, l’appelant doit effectuer la conversion d’horloge nécessaire vers std::chrono::system_clock ainsi que la conversion nécessaire du type de durée (cast/round/floor/ceil/...) afin que l’entrée de cette fonction satisfasse aux contraintes ci-dessus.

Cette fonction a été introduite dans Qt 6.4.

Voir également toStdSysMilliseconds() et fromMSecsSinceEpoch().

[static, since 6.4] QDateTime QDateTime::fromStdTimePoint(const std::chrono::local_time<std::chrono::milliseconds> &time)

Crée un objet `datetime` dont la date et l'heure correspondent au nombre de millisecondes représenté par ` time`, compté à partir du 1er janvier 1970 à 00:00:00.000, en heure locale (Qt::LocalTime).

Cette fonction a été introduite dans Qt 6.4.

Voir également toStdSysMilliseconds() et fromMSecsSinceEpoch().

[static, since 6.4] QDateTime QDateTime::fromStdTimePoint(std::chrono::time_point<std::chrono::system_clock, std::chrono::milliseconds> time)

Crée un objet `datetime` représentant le même instant que ` time`, en utilisant ` Qt::UTC ` comme représentation temporelle.

Cette fonction a été introduite dans Qt 6.4.

[static, since 6.4] QDateTime QDateTime::fromStdZonedTime(const std::chrono::zoned_time<std::chrono::milliseconds, const std::chrono::time_zone *> &time)

Crée un objet `datetime` représentant le même instant que ` time`. Le résultat sera exprimé dans le fuseau horaire de ` time`.

Cette fonction a été introduite dans Qt 6.4.

Voir également QTimeZone, toStdSysMilliseconds() et fromMSecsSinceEpoch().

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

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

Utilise l'cal du calendrier si elle est fournie, sinon le calendrier grégorien.

Lorsque format ne spécifie 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. Dans certains cas, d’autres champs peuvent entraîner la sélection du siècle suivant ou précédent, afin d’obtenir un résultat cohérent avec l’ensemble des champs fournis. Voir « QDate::fromString() » pour plus de détails.

Outre les expressions reconnues dans la chaîne de format pour représenter les différentes parties de la date et de l'heure par QDate::fromString() et QTime::fromString(), cette méthode prend en charge :

Si aucun spécificateur de format « t » n’est présent, le fuseau horaire local du système est utilisé. Pour connaître les valeurs par défaut de tous les autres champs, consultez QDate::fromString() et QTime::fromString().

Par exemple :

QDateTime dateTime = QDateTime::fromString("1.30.1", "M.d.s");
// dateTime is January 30 in 1900 at 00:00:01.
dateTime = QDateTime::fromString("12", "yy");
// dateTime is January 1 in 1912 at 00:00:00.

Toute séquence de caractères non vide 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 :

QTime time1 = QTime::fromString("131", "HHh");
// time1 is 13:00:00
QTime time2 = QTime::fromString("1apA", "1amAM");
// time2 is 01:00:00

QDateTime dateTime2 = QDateTime::fromString("M1d1y9800:01:02",
                                            "'M'M'd'd'y'yyhh:mm:ss");
// dateTime is 1 January 1998 00:01:02

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

Lorsque des champs numériques sont juxtaposés, sans séparateurs pour diviser les séquences de chiffres, une ambiguïté peut exister quant à savoir si certains champs, pour lesquels un seul chiffre est autorisé, 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 à celle qui les attribue aux champs suivants, à condition que les données restent cohérentes. Par exemple :

Les expressions qui ne comportent pas de zéros en tête (d, M, h, m, s, z) seront « gourmandes ». Cela signifie qu’elles utiliseront deux chiffres (ou trois, pour z) même si cela les fait sortir de la plage autorisée et/ou laisse trop peu de chiffres pour les autres sections.

QDateTime dateTime = QDateTime::fromString("130", "Mm"); // January, 30 mins

Cela aurait pu donner le 1er janvier à 00:30.00, mais le champ M prendra deux chiffres.

Des champs de l’ string mal spécifiés entraîneront le renvoi d’une valeur « QDateTime » non valide. Seules les dates et heures comprises entre le début de l’année 100 et la fin de l’année 9999 selon l’heure locale sont prises en charge. Notez que les dates et heures proches des limites de cette plage dans d’autres fuseaux horaires, notamment l’UTC, peuvent se situer en dehors de la plage (et donc être considérées comme non valides) en fonction du fuseau horaire local.

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

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

Cette fonction a été introduite dans Qt 6.0.

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

Renvoie l'QDateTime représentée par l'string, en utilisant l'format fournie, ou une date-heure non valide si cela n'est pas possible.

Remarque concernant Qt::TextDate: seuls les noms de mois courts en anglais (par exemple « Jan » sous sa forme abrégée ou « January » sous sa forme complète) sont reconnus.

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

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

Cette fonction a été introduite dans Qt 6.0.

[static, since 6.7] QDateTime QDateTime::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] QDateTime QDateTime::fromString(const QString &string, QStringView format, QCalendar cal)

Cette fonction a été introduite dans Qt 6.0.

[static, since 6.7] QDateTime QDateTime::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] QDateTime QDateTime::fromString(const QString &string, const QString &format, QCalendar cal)

[static, since 6.7] QDateTime QDateTime::fromString(const QString &string, const QString &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.7] QDateTime QDateTime::fromString(QStringView string, QStringView format, int baseYear, QCalendar cal)

Cette fonction a été introduite dans Qt 6.7.

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

Cette fonction a été introduite dans Qt 6.0.

bool QDateTime::isDaylightTime() const

Renvoie une valeur indiquant si cette date-heure se situe pendant la période d'heure d'été.

Si l'Qt::TimeSpec n'est pas Qt::LocalTime ou Qt::TimeZone, la fonction renvoie toujours false.

Voir aussi timeSpec().

bool QDateTime::isNull() const

Renvoie « true » si la date et l'heure sont toutes deux nulles ; sinon, renvoie « false ». Une date-heure nulle n'est pas valide.

Voir également QDate::isNull(), QTime::isNull() et isValid().

bool QDateTime::isValid() const

Renvoie « true » si cette date-heure correspond à un moment précis, sinon « false ».

Une date-heure est valide si sa date et son heure sont toutes deux valides et si le format d'heure utilisé donne un sens valide à leur combinaison. Lorsque la représentation de l’heure correspond à un fuseau horaire spécifique ou à l’heure locale, il peut arriver que, pour certaines dates, le fuseau horaire saute des intervalles dans sa représentation, comme lors d’un changement d’heure d’été où une heure est sautée (généralement pendant une nuit au printemps). Par exemple, si l’heure d’été prend fin à 2 h du matin et que l’horloge passe directement à 3 h, alors les dates-heures comprises entre 02:00:00 et 02:59:59,999 ce jour-là ne sont pas valides.

Voir également QDateTime::YearRange, QDate::isValid() et QTime::isValid().

qint64 QDateTime::msecsTo(const QDateTime &other) const

Renvoie le nombre de millisecondes séparant cette date-heure de la date-heure « other ».

Avant d'effectuer la comparaison, les deux dates/heures sont converties au format « Qt::UTC » afin de garantir l'exactitude du résultat si l'heure d'été (DST) s'applique à l'une des deux dates/heures mais pas à l'autre.

Si la date-heure « other » est antérieure à la présente date-heure, la valeur renvoyée est négative. Renvoie 0 si l’une des deux dates-heures n’est pas valide.

Voir également addMSecs(), daysTo() et QTime::msecsTo().

int QDateTime::offsetFromUtc() const

Renvoie le décalage de cette date-heure par rapport à l'UTC, en secondes.

Le résultat dépend de la fonction ` timeSpec()` :

• Qt::UTC Le décalage est égal à 0.
• Qt::OffsetFromUTC Le décalage correspond à la valeur initialement définie.
• Qt::LocalTime Le décalage de l'heure locale par rapport à l'UTC est renvoyé.
• Qt::TimeZone Le décalage utilisé par le fuseau horaire est renvoyé.

Pour les deux derniers cas, c'est le décalage à cette date et à cette heure qui est renvoyé, en tenant compte du décalage lié à l'heure d'été. Le décalage correspond à la différence entre l’heure locale ou l’heure dans le fuseau horaire donné et l’heure UTC ; il est positif dans les fuseaux horaires en avance sur l’UTC (à l’est du méridien d’origine), et négatif dans ceux en retard sur l’UTC (à l’ouest du méridien d’origine).

Voir également setTimeZone().

qint64 QDateTime::secsTo(const QDateTime &other) const

Renvoie le nombre de secondes entre cette date-heure et la date-heure other.

Avant d’effectuer la comparaison, les deux dates/heures sont converties au format « Qt::UTC » afin de garantir l’exactitude du résultat si l’heure d’été (DST) s’applique à l’une des deux dates/heures mais pas à l’autre.

Si la date-heure « other » est antérieure à cette date-heure, la valeur renvoyée est négative. Renvoie 0 si l'une des deux dates-heures n'est pas valide.

Exemple :

QDateTime now = QDateTime::currentDateTime();
QDateTime xmas(QDate(now.date().year(), 12, 25).startOfDay());
qDebug("There are %d seconds to Christmas", now.secsTo(xmas));

Voir également addSecs(), daysTo() et QTime::secsTo().

void QDateTime::setDate(QDate date, QDateTime::TransitionResolution resolve = TransitionResolution::LegacyBehavior)

Définit la partie « date » de cette date-heure sur date.

Si aucune heure n’est encore définie, elle est fixée à minuit. Si date n’est pas valide, cette QDateTime devient invalide.

Si date et time() décrivent un moment proche d’une transition pour la représentation temporelle de cette date-heure, resolve contrôle la manière dont cette situation est résolue.

Voir également date(), setTime() et setTimeZone().

void QDateTime::setMSecsSinceEpoch(qint64 msecs)

Définit la date-heure de manière à représenter un instant situé à un nombre donné, msecs, de millisecondes après le début, en UTC, de l'année 1970.

Sur les systèmes ne prenant pas en charge les fuseaux horaires, cette fonction se comportera comme si l'heure locale était Qt::UTC.

Notez que le fait de passer la valeur minimale de qint64 (std::numeric_limits<qint64>::min()) à msecs entraînera un comportement indéfini.

Voir également setSecsSinceEpoch(), toMSecsSinceEpoch() et fromMSecsSinceEpoch().

void QDateTime::setSecsSinceEpoch(qint64 secs)

Définit la date et l'heure de manière à représenter un instant situé à un nombre donné, secs, de secondes après le début de l'année 1970, en UTC.

Sur les systèmes ne prenant pas en charge les fuseaux horaires, cette fonction se comporte comme si l'heure locale était Qt::UTC.

Voir également setMSecsSinceEpoch(), toSecsSinceEpoch() et fromSecsSinceEpoch().

void QDateTime::setTime(QTime time, QDateTime::TransitionResolution resolve = TransitionResolution::LegacyBehavior)

Définit la partie « heure » de cette date-heure sur time. Si time n'est pas valide, cette fonction la définit sur minuit. Il est donc possible d'effacer toute heure définie dans une QDateTime en la remettant à la valeur par défaut QTime:

QDateTime dt = QDateTime::currentDateTime();
dt.setTime(QTime());

Si date() et time décrivent un moment proche d’une transition pour la représentation temporelle de cette date-heure, resolve contrôle la manière dont cette situation est résolue.

Voir également time(), setDate() et setTimeZone().

void QDateTime::setTimeZone(const QTimeZone &toZone, QDateTime::TransitionResolution resolve = TransitionResolution::LegacyBehavior)

Définit le fuseau horaire utilisé pour cette date-heure sur toZone.

La date-heure peut se référer à un moment différent. Elle utilise la représentation temporelle de toZone, ce qui peut modifier la signification de ses méthodes inchangées date() et time().

Si toZone n'est pas valide, alors la date-heure sera invalide. Dans le cas contraire, la valeur de timeSpec() de cette date-heure après l'appel correspondra à celle de toZone.timeSpec().

Si date() et time() décrivent un moment proche d’une transition pour toZone, resolve contrôle la manière dont cette situation est résolue.

Voir également timeRepresentation(), timeZone() et Qt::TimeSpec.

[noexcept] void QDateTime::swap(QDateTime &other)

Permute cette date-heure avec celle de other. Cette opération est très rapide et ne rencontre jamais d'échec.

QTime QDateTime::time() const

Renvoie la partie « heure » de la date-heure.

Voir également setTime(), date() et timeRepresentation().

[since 6.5] QTimeZone QDateTime::timeRepresentation() const

Renvoie un objet « QTimeZone » indiquant comment cette date-heure représente le temps.

L'timeSpec() de l'QTimeZone renvoyé coïncidera avec celui de cette date-heure ; s'il n'est pas Qt::TimeZone, alors l'QTimeZone renvoyé est une représentation de l'heure. Lorsque leur timeSpec() est Qt::OffsetFromUTC, la fonction fixedSecondsAheadOfUtc() de l'QTimeZone renvoyé fournit le décalage. Lorsque timeSpec() est Qt::TimeZone, l'objet QTimeZone lui-même constitue la représentation complète de ce fuseau horaire.

Cette fonction a été introduite dans Qt 6.5.

Voir également timeZone(), setTimeZone() et QTimeZone::asBackendZone().

Qt::TimeSpec QDateTime::timeSpec() const

Renvoie la spécification temporelle de la date-heure.

Cela classe sa représentation temporelle comme heure locale, UTC, un décalage fixe par rapport à l'UTC (sans indiquer ce décalage) ou un fuseau horaire (sans donner les détails de ce fuseau horaire). Équivalent à ` timeRepresentation().timeSpec()`.

Voir également setTimeZone(), timeRepresentation(), date() et time().

QTimeZone QDateTime::timeZone() const

Renvoie le fuseau horaire de la date-heure.

Le résultat est identique à celui de la méthode ` timeRepresentation().asBackendZone()`. Dans tous les cas, la méthode ` timeSpec()` du résultat renvoie ` Qt::TimeZone`.

Lorsque timeSpec() est Qt::LocalTime, le résultat indique l'heure locale au moment où cette méthode a été appelée. Il ne tiendra pas compte des modifications ultérieures apportées au fuseau horaire du système, même si l'QDateTime à partir de laquelle il a été obtenu en tient compte.

Voir également timeRepresentation(), setTimeZone(), Qt::TimeSpec et QTimeZone::asBackendZone().

QString QDateTime::timeZoneAbbreviation() const

Renvoie l'abréviation du fuseau horaire correspondant à cette date-heure.

La chaîne renvoyée dépend de la fonction timeSpec() :

• Pour Qt::UTC, elle est « UTC ».
• Pour Qt::OffsetFromUTC, elle se présente sous la forme « UTC±00:00 ».
• Pour Qt::LocalTime, le système hôte est interrogé.
• Pour Qt::TimeZone, l’objet QTimeZone associé est interrogé.

Voir également timeSpec() et QTimeZone::abbreviation().

CFDateRef QDateTime::toCFDate() const

Crée un objet CFDate à partir d'un objet ` QDateTime`.

L'appelant est propriétaire de l'objet CFDate et est chargé de le libérer.

Voir également fromCFDate().

QDateTime QDateTime::toLocalTime() const

Renvoie une copie de cette date-heure convertie à l'heure locale.

Le résultat représente le même instant que cette date-heure et est égal à celle-ci.

Exemple :

QDateTime UTC(QDateTime::currentDateTimeUtc());
QDateTime local(UTC.toLocalTime());
qDebug() << "UTC time is:" << UTC;
qDebug() << "Local time is:" << local;
qDebug() << "No difference between times:" << UTC.secsTo(local);

Voir également toTimeZone(), toUTC() et toOffsetFromUtc().

qint64 QDateTime::toMSecsSinceEpoch() const

Renvoie la date et l'heure sous la forme d'un nombre de millisecondes écoulées depuis le début de l'année 1970, en UTC.

Sur les systèmes ne prenant pas en charge les fuseaux horaires, cette fonction se comporte comme si l'heure locale était Qt::UTC.

Le comportement de cette fonction est indéfini si la date-heure stockée dans cet objet n’est pas valide. Cependant, pour toutes les dates valides, cette fonction renvoie une valeur unique.

Voir également toSecsSinceEpoch(), setMSecsSinceEpoch() et fromMSecsSinceEpoch().

NSDate *QDateTime::toNSDate() const

Crée un objet NSDate à partir d’une instance de ` QDateTime`.

L'objet NSDate est libéré automatiquement.

Voir aussi fromNSDate().

QDateTime QDateTime::toOffsetFromUtc(int offsetSeconds) const

Renvoie une copie de cette date-heure convertie au format Qt::OffsetFromUTC avec l'offsetSeconds spécifiée. Équivalent à toTimeZone(QTimeZone::fromSecondsAheadOfUtc(offsetSeconds)).

Si l'offsetSeconds est égal à 0, une date-heure UTC sera renvoyée.

Le résultat représente le même instant que cette date-heure et lui est égal.

Voir également offsetFromUtc() et toTimeZone().

qint64 QDateTime::toSecsSinceEpoch() const

Renvoie la date et l'heure sous forme de nombre de secondes écoulées depuis le début de l'année 1970, en UTC.

Sur les systèmes ne prenant pas en charge les fuseaux horaires, cette fonction se comporte comme si l'heure locale était Qt::UTC.

Le comportement de cette fonction est indéfini si la date-heure stockée dans cet objet n’est pas valide. Cependant, pour toutes les dates valides, cette fonction renvoie une valeur unique.

Voir également toMSecsSinceEpoch(), fromSecsSinceEpoch() et setSecsSinceEpoch().

[since 6.4] std::chrono::sys_time<std::chrono::milliseconds> QDateTime::toStdSysMilliseconds() const

Convertit cet objet `datetime` en un instant équivalent exprimé en millisecondes, en utilisant ` std::chrono::system_clock ` comme horloge.

Cette fonction a été introduite dans Qt 6.4.

Voir également ` fromStdTimePoint()` et ` toMSecsSinceEpoch()`.

[since 6.4] std::chrono::sys_seconds QDateTime::toStdSysSeconds() const

Convertit cet objet « datetime » en un instant équivalent exprimé en secondes, en utilisant std::chrono::system_clock comme horloge.

Cette fonction a été introduite dans Qt 6.4.

Voir également ` fromStdTimePoint()` et ` toSecsSinceEpoch()`.

Renvoie la date et l'heure sous forme de chaîne de caractères. Le paramètre « format » détermine le format de la chaîne de résultat. 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é. Voir QTime::toString() et QDate::toString() pour connaître les spécificateurs pris en charge respectivement pour l’heure et la date dans le paramètre format.

Toute séquence non vide de caractères placée 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 sortie, au lieu de marquer le début ou la fin d’une séquence littérale. 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'QDateTime e soit le 21 mai 2001 à 14 h 13 min 09,120 s) :

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

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

QString QDateTime::toString(QStringView format) const

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

Renvoie la date-heure sous forme de chaîne de caractères selon le format format.

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

Si l’ format 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, prenant la forme yyyy-MM-ddTHH:mm:ss[Z|±HH:mm], en fonction de l’ timeSpec() de l’ QDateTime. Si l’ timeSpec() est Qt::UTC, Z sera ajouté à la chaîne ; si l’ timeSpec() est Qt::OffsetFromUTC, le décalage en heures et minutes par rapport à l’UTC sera ajouté à la chaîne. Pour inclure les millisecondes dans la date au format ISO 8601, utilisez la fonction format Qt::ISODateWithMs , qui correspond à yyyy-MM-ddTHH:mm:ss.zzz[Z|±HH:mm].

Si l’ format est Qt::RFC2822Date, la chaîne est formatée conformément à la norme RFC 2822.

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

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

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

QDateTime QDateTime::toTimeZone(const QTimeZone &timeZone) const

Renvoie une copie de cette date-heure convertie au format « timeZone » spécifié.

Le résultat représente le même instant que cette date-heure et est égal à celle-ci.

Le résultat décrit l'instant selon la représentation temporelle d'timeZone. Par exemple :

QDateTime local(QDateTime::currentDateTime());
QDateTime UTC(local.toTimeZone(QTimeZone::UTC));
qDebug() << "Local time is:" << local;
qDebug() << "UTC time is:" << UTC;
qDebug() << "No difference between times represented:" << local.secsTo(UTC);

Si timeZone n'est pas valide, la date-heure sera invalide. Sinon, la méthode timeSpec() de la date-heure renvoyée correspondra à timeZone.timeSpec().

Voir également timeRepresentation(), toLocalTime(), toUTC() et toOffsetFromUtc().

QDateTime QDateTime::toUTC() const

Renvoie une copie de cette date-heure convertie en UTC.

Le résultat représente le même instant que cette date-heure et est égal à celle-ci.

Exemple :

QDateTime local(QDateTime::currentDateTime());
QDateTime UTC(local.toUTC());
qDebug() << "Local time is:" << local;
qDebug() << "UTC time is:" << UTC;
qDebug() << "No difference between times:" << local.secsTo(UTC);

Voir également toTimeZone(), toLocalTime() et toOffsetFromUtc().

[since 6.4] QDateTime &QDateTime::operator+=(std::chrono::milliseconds duration)

Modifie cet objet « datetime » en y ajoutant l'duration spécifiée.

L'objet mis à jour sera postérieur si duration est positif, ou antérieur s’il est négatif. Renvoie une référence à cet objet datetime.

Si cet objet datetime n'est pas valide, cette fonction n'a aucun effet.

Cette fonction a été introduite dans Qt 6.4.

Voir également addMSecs().

[since 6.4] QDateTime &QDateTime::operator-=(std::chrono::milliseconds duration)

Modifie cet objet « datetime » en soustrayant l'duration e indiquée.

L'objet mis à jour sera antérieur si duration est positif, ou postérieur s'il est négatif. Renvoie une référence à cet objet datetime.

Si cet objet datetime n'est pas valide, cette fonction n'a aucun effet.

Cette fonction a été introduite dans Qt 6.4.

Voir également addMSecs.

[noexcept] QDateTime &QDateTime::operator=(const QDateTime &other)

Copie la date-heure de other dans cette variable et renvoie cette copie.