En esta página

QDateTime Class

La clase QDateTime ofrece funciones relacionadas con la fecha y la hora. Más información...

Encabezado: #include <QDateTime>
CMake: find_package(Qt6 REQUIRED COMPONENTS Core)
target_link_libraries(mytarget PRIVATE Qt6::Core)
qmake: QT += core

Nota: Todas las funciones de esta clase son reentrantes.

Comparaciones de QDateTime

CategoríaTipos comparables
débilQDateTime

Tipos públicos

(since 6.7) enum class TransitionResolution { Reject, RelativeToBefore, RelativeToAfter, PreferBefore, PreferAfter, …, PreferDaylightSaving }
enum class YearRange { First, Last }

Funciones públicas

QDateTime(QDate date, QTime time, const QTimeZone &timeZone, QDateTime::TransitionResolution resolve = TransitionResolution::LegacyBehavior)
QDateTime()
(since 6.5) QDateTime(QDate date, QTime time, QDateTime::TransitionResolution resolve = TransitionResolution::LegacyBehavior)
QDateTime(const QDateTime &other)
QDateTime(QDateTime &&other)
~QDateTime()
QDateTime addDays(qint64 ndays) const
(since 6.4) QDateTime addDuration(std::chrono::milliseconds msecs) const
QDateTime addMSecs(qint64 msecs) const
QDateTime addMonths(int nmonths) const
QDateTime addSecs(qint64 s) const
QDateTime addYears(int nyears) const
QDate date() const
qint64 daysTo(const QDateTime &other) const
bool isDaylightTime() const
bool isNull() const
bool isValid() const
qint64 msecsTo(const QDateTime &other) const
int offsetFromUtc() const
qint64 secsTo(const QDateTime &other) const
void setDate(QDate date, QDateTime::TransitionResolution resolve = TransitionResolution::LegacyBehavior)
void setMSecsSinceEpoch(qint64 msecs)
void setSecsSinceEpoch(qint64 secs)
void setTime(QTime time, QDateTime::TransitionResolution resolve = TransitionResolution::LegacyBehavior)
void setTimeZone(const QTimeZone &toZone, QDateTime::TransitionResolution resolve = TransitionResolution::LegacyBehavior)
void swap(QDateTime &other)
QTime time() const
(since 6.5) QTimeZone timeRepresentation() const
Qt::TimeSpec timeSpec() const
QTimeZone timeZone() const
QString timeZoneAbbreviation() const
CFDateRef toCFDate() const
QDateTime toLocalTime() const
qint64 toMSecsSinceEpoch() const
NSDate *toNSDate() const
QDateTime toOffsetFromUtc(int offsetSeconds) const
qint64 toSecsSinceEpoch() const
(since 6.4) std::chrono::sys_time<std::chrono::milliseconds> toStdSysMilliseconds() const
(since 6.4) std::chrono::sys_seconds toStdSysSeconds() const
QString toString(const QString &format, QCalendar cal) const
QString toString(QStringView format) const
QString toString(Qt::DateFormat format = Qt::TextDate) const
QString toString(const QString &format) const
QString toString(QStringView format, QCalendar cal) const
QDateTime toTimeZone(const QTimeZone &timeZone) const
QDateTime toUTC() const
(since 6.4) QDateTime &operator+=(std::chrono::milliseconds duration)
(since 6.4) QDateTime &operator-=(std::chrono::milliseconds duration)
QDateTime &operator=(const QDateTime &other)

Miembros públicos estáticos

(since 6.5) QDateTime currentDateTime(const QTimeZone &zone)
QDateTime currentDateTime()
QDateTime currentDateTimeUtc()
qint64 currentMSecsSinceEpoch()
qint64 currentSecsSinceEpoch()
QDateTime fromCFDate(CFDateRef date)
QDateTime fromMSecsSinceEpoch(qint64 msecs, const QTimeZone &timeZone)
QDateTime fromMSecsSinceEpoch(qint64 msecs)
QDateTime fromNSDate(const NSDate *date)
QDateTime fromSecsSinceEpoch(qint64 secs, const QTimeZone &timeZone)
QDateTime fromSecsSinceEpoch(qint64 secs)
(since 6.4) QDateTime fromStdLocalTime(const std::chrono::local_time<std::chrono::milliseconds> &time)
(since 6.4) QDateTime fromStdTimePoint(const std::chrono::time_point<Clock, Duration> &time)
(since 6.4) QDateTime fromStdTimePoint(const std::chrono::local_time<std::chrono::milliseconds> &time)
(since 6.4) QDateTime fromStdTimePoint(std::chrono::time_point<std::chrono::system_clock, std::chrono::milliseconds> time)
(since 6.4) QDateTime fromStdZonedTime(const std::chrono::zoned_time<std::chrono::milliseconds, const std::chrono::time_zone *> &time)
QDateTime fromString(const QString &string, const QString &format, int baseYear, QCalendar cal)
(since 6.0) QDateTime fromString(QStringView string, Qt::DateFormat format = Qt::TextDate)
QDateTime fromString(const QString &string, Qt::DateFormat format = Qt::TextDate)
(since 6.0) QDateTime fromString(QStringView string, QStringView format, QCalendar cal)
(since 6.7) QDateTime fromString(QStringView string, QStringView format, int baseYear = QLocale::DefaultTwoDigitBaseYear)
(since 6.0) QDateTime fromString(const QString &string, QStringView format, QCalendar cal)
(since 6.7) QDateTime fromString(const QString &string, QStringView format, int baseYear = QLocale::DefaultTwoDigitBaseYear)
QDateTime fromString(const QString &string, const QString &format, QCalendar cal)
(since 6.7) QDateTime fromString(const QString &string, const QString &format, int baseYear = QLocale::DefaultTwoDigitBaseYear)
(since 6.7) QDateTime fromString(QStringView string, QStringView format, int baseYear, QCalendar cal)
(since 6.0) QDateTime fromString(const QString &string, QStringView format, int baseYear, QCalendar cal)
bool operator!=(const QDateTime &lhs, const QDateTime &rhs)
(since 6.4) QDateTime operator+(const QDateTime &dateTime, std::chrono::milliseconds duration)
(since 6.4) QDateTime operator+(std::chrono::milliseconds duration, const QDateTime &dateTime)
(since 6.4) std::chrono::milliseconds operator-(const QDateTime &lhs, const QDateTime &rhs)
(since 6.4) QDateTime operator-(const QDateTime &dateTime, std::chrono::milliseconds duration)
bool operator<(const QDateTime &lhs, const QDateTime &rhs)
QDataStream &operator<<(QDataStream &out, const QDateTime &dateTime)
bool operator<=(const QDateTime &lhs, const QDateTime &rhs)
bool operator==(const QDateTime &lhs, const QDateTime &rhs)
bool operator>(const QDateTime &lhs, const QDateTime &rhs)
bool operator>=(const QDateTime &lhs, const QDateTime &rhs)
QDataStream &operator>>(QDataStream &in, QDateTime &dateTime)

Descripción detallada

Un objeto QDateTime codifica una fecha del calendario y una hora (una «fecha y hora») de acuerdo con una representación temporal. Combina características de las clases « QDate » y « QTime ». Puede leer la fecha y hora actuales del reloj del sistema. Proporciona funciones para comparar fechas y horas, así como para manipular una fecha y hora añadiendo un número determinado de segundos, días, meses o años.

QDateTime puede describir fechas y horas con respecto a « local time », a « UTC », a una « offset from UTC » especificada o a un « time zone » especificado. Cada una de estas representaciones de tiempo puede encapsularse en una instancia adecuada de la clase « QTimeZone ». Por ejemplo, una zona horaria «Europe/Berlin» aplicará las normas de horario de verano vigentes en Alemania. Por el contrario, un desfase fijo respecto al UTC de +3600 segundos supone una hora por delante del UTC (lo que suele escribirse en notación estándar ISO como «UTC+01:00»), sin complicaciones derivadas del horario de verano. Al utilizar la hora local o una zona horaria especificada, se tienen en cuenta las transiciones de zona horaria (véase below). El método timeSpec() de un objeto QDateTime le indicará cuál de los cuatro tipos de representación de la hora se está utilizando; su método timeRepresentation() proporciona una descripción completa de dicha representación de la hora, en forma de QTimeZone.

Un objeto `QDateTime` se crea normalmente bien especificando explícitamente una fecha y una hora en el constructor, bien utilizando una función estática como ` currentDateTime()` o ` fromMSecsSinceEpoch()`. La fecha y la hora se pueden modificar con ` setDate()` y ` setTime()`. También se puede establecer una fecha y hora utilizando la función ` setMSecsSinceEpoch()` que toma el tiempo, en milisegundos, transcurrido desde el inicio, en UTC, del año 1970. La función ` fromString()` devuelve un `QDateTime`, a partir de una cadena y un formato de fecha utilizado para interpretar la fecha contenida en dicha cadena.

QDateTime::currentDateTime() devuelve un QDateTime que expresa la fecha y la hora actuales con respecto a una representación temporal específica, como la hora local (su valor por defecto). QDateTime::currentDateTimeUtc() devuelve un QDateTime que expresa la fecha y la hora actuales con respecto a UTC; es equivalente a QDateTime::currentDateTime(QTimeZone::UTC).

Las funciones date() y time() permiten acceder a las partes de fecha y hora del objeto QDateTime. La función toString() proporciona la misma información en formato textual.

QDateTime proporciona un conjunto completo de operadores para comparar dos objetos QDateTime, donde un valor menor significa una fecha anterior y un valor mayor, una fecha posterior.

Se puede incrementar (o decrementar) una fecha y hora en un número determinado de milisegundos utilizando ` addMSecs()`; en segundos, utilizando ` addSecs()`; o en días, utilizando ` addDays()`. Del mismo modo, se pueden utilizar ` addMonths()` y ` addYears()`. La función daysTo() devuelve el número de días entre dos fechas y horas, secsTo() devuelve el número de segundos entre dos fechas y horas, y msecsTo() devuelve el número de milisegundos entre dos fechas y horas. Estas operaciones tienen en cuenta el horario de verano (DST) y otros cambios de zona horaria, cuando proceda.

Utiliza ` toTimeZone()` para reexpresar una fecha y hora en términos de una representación horaria diferente. Al pasar un objeto ` QTimeZone ` ligero que represente la hora local, el UTC o un desfase fijo respecto al UTC, puedes convertir la fecha y hora para que utilice la representación horaria correspondiente; o bien, puedes pasar una zona horaria completa (cuyo ` timeSpec()` sea ` Qt::TimeZone`) para utilizarla en su lugar.

Observaciones

QDateTime no tiene en cuenta los segundos intercalares.

Todas las conversiones a y desde formatos de cadena se realizan utilizando la configuración regional C. Para conversiones localizadas, consulte QLocale.

No existe el año 0 en el calendario gregoriano. Las fechas de ese año se consideran inválidas. El año -1 es el año «1 antes de Cristo» o «1 antes de la era común». El día anterior al 1 de enero del año 1 d. C. es el 31 de diciembre del año 1 a. C.

El uso de la hora local (por defecto) o de una zona horaria especificada implica la necesidad de resolver cualquier problema relacionado con transitions. Como resultado, las operaciones sobre dichas instancias de QDateTime (incluida, en particular, su creación) pueden resultar más costosas que las equivalentes cuando se utiliza UTC o una diferencia fija con respecto a este.

Rango de fechas válidas

El rango de valores que QDateTime puede representar depende de la implementación del almacenamiento interno. Actualmente, QDateTime se almacena en un qint64 como un valor serial en milisegundos que codifica la fecha y la hora. Esto limita el rango de fechas a unos ±292 millones de años, en comparación con el rango de QDate de ±2.000 millones de años. Se debe tener cuidado al crear un QDateTime con valores extremos para no provocar un desbordamiento del almacenamiento. El rango exacto de valores admitidos varía en función de la representación temporal utilizada.

Uso de zonas horarias

QDateTime utiliza la información de zonas horarias del sistema para determinar la zona horaria local actual y su desfase respecto al UTC. Si el sistema no está configurado correctamente o no está actualizado, QDateTime dará resultados erróneos.

Del mismo modo, QDateTime utiliza la información proporcionada por el sistema para determinar las diferencias horarias de otras zonas horarias respecto al UTC. Si esta información está incompleta o desactualizada, QDateTime dará resultados erróneos. Consulta la documentación de QTimeZone para obtener más detalles.

En los sistemas Unix modernos, esto significa que QDateTime suele disponer de información precisa sobre las transiciones históricas (incluido el horario de verano, véase más abajo) siempre que sea posible. En Windows, donde el sistema no admite datos históricos de zonas horarias, no se mantiene la precisión histórica con respecto a las transiciones de zonas horarias, incluyendo en particular el horario de verano. Sin embargo, compilar Qt con la biblioteca ICU dotará a QTimeZone de la misma base de datos de zonas horarias que se utiliza en Unix.

Cambios de zona horaria

QDateTime tiene en cuenta las transiciones de zona horaria, tanto las transiciones entre la hora estándar y la hora de verano (DST) como las transiciones que se producen cuando una zona cambia su desfase estándar. Por ejemplo, si la transición tiene lugar a las 2:00 y el reloj se adelanta a las 3:00, entonces hay una hora «que falta» desde las 02:00:00 hasta las 02:59:59,999. Esta transición se conoce como «adelanto de primavera» y las horas que se omiten carecen de significado. Cuando la transición se produce en sentido contrario, lo que se conoce como «retroceso de otoño», se repite un intervalo de tiempo, primero en la zona anterior (normalmente horario de verano) y luego en la nueva (normalmente horario estándar), por lo que las horas de este intervalo son ambiguas.

Algunas zonas aplican el horario de verano «invertido», es decir, utilizan el horario estándar en verano y el horario de verano (con una diferencia horaria menor) en invierno. En estas zonas, el cambio de primavera sigue produciéndose en primavera y supone un avance de una hora, pero es una transición para salir del horario de verano, mientras que el cambio de otoño sigue suponiendo un retraso de una hora, pero es una transición hacia el horario de verano.

Al convertir desde una hora UTC (o una hora con un desfase fijo respecto al UTC), siempre se obtiene un resultado válido e inequívoco en cualquier zona horaria. Sin embargo, al combinar una fecha y una hora para formar una fecha y hora, expresadas con respecto a la hora local o a una zona horaria específica, el resultado nominal puede caer en un periodo de transición, lo que lo hace inválido o ambiguo. Los métodos en los que puede darse esta situación admiten un parámetro ` resolve `: este siempre se ignora si la fecha y hora solicitadas son válidas y no ambiguas. Consulta TransitionResolution para conocer las opciones que te permite controlar. Antes de Qt 6.7, se seleccionaba el equivalente a su ` LegacyBehavior `.

En el caso del intervalo omitido por el cambio horario de primavera, interpretar la hora solicitada con cualquiera de los dos desplazamientos da como resultado una hora real en la que se estaba utilizando el otro desplazamiento; por lo tanto, pasar ` TransitionResolution::RelativeToBefore ` para ` resolve ` dará como resultado, en realidad, una hora posterior a la transición, que habría tenido la representación solicitada si la transición no hubiera tenido lugar. Del mismo modo, TransitionResolution::RelativeToAfter para resolve da como resultado una hora anterior a la transición, que habría tenido la representación solicitada si la transición se hubiera producido antes.

Cuando QDateTime realiza operaciones aritméticas, como con `addDay()` o ` addSecs()`, se asegura de producir un resultado válido. Por ejemplo, en un día en el que se adelanta el reloj de 02:00 a 03:00, al sumar un segundo a las 01:59:59 se obtendrá las 03:00:00. Si se suma un día a las 02:30 del día anterior, se obtendrá las 03:30 del día del cambio de hora, mientras que si se resta un día —llamando a addDay(-1) — a las 02:30 del día siguiente, se obtendrá la 01:30 del día del cambio de hora. Mientras que ` addSecs()` proporciona un desplazamiento de tiempo equivalente al número de segundos indicado, ` addDays()` ajusta la fecha y solo modifica la hora si, de lo contrario, se obtendría un resultado inválido. Al aplicar addDays(1) a las 03:00 del día anterior al cambio horario de primavera, simplemente se obtendrá las 03:00 del día del cambio, aunque este último sea solo 23 horas después del primero; pero addSecs(24 * 60 * 60) dará como resultado las 04:00 del día del cambio, ya que eso es 24 horas más tarde. Las transiciones habituales hacen que algunos días tengan una duración de 23 o 25 horas.

Para las fechas y horas que el sistema time_t puede representar (desde el 14 de diciembre de 1901 hasta el 18 de enero de 2038 en sistemas de 32 bits time_t; para el rango completo que QDateTime puede representar si el tipo es de 64 bits), se utilizan las API estándar del sistema para determinar la diferencia horaria de la hora local respecto al UTC. Para las fechas y horas que no gestionan estas API del sistema (lo que podría incluir algunas dentro del rango time_t ), se utiliza QTimeZone::systemTimeZone(), si está disponible, o se hace todo lo posible por estimarla. En cualquier caso, la información sobre el desfase utilizada depende del sistema y puede estar incompleta o, en el caso de fechas pasadas, ser históricamente inexacta. Además, para fechas futuras, los desfases de la zona horaria local y las normas de horario de verano pueden cambiar antes de que llegue dicha fecha.

Transiciones de días completos

Un pequeño número de zonas se ha saltado o ha repetido días enteros como parte del desplazamiento de la línea internacional de cambio de fecha a través de ellas. En estos casos, daysTo() no tendrá en cuenta la duplicación o la laguna, y se limitará a utilizar la diferencia en la fecha del calendario; por el contrario, msecsTo() y secsTo() conocen el intervalo de tiempo real. Del mismo modo, addMSecs() y addSecs() se corresponden directamente con el tiempo transcurrido, mientras que addDays(), addMonths() y addYears() siguen el calendario nominal, salvo en los casos en que el hecho de caer en un salto o una duplicación requiera resolver una ambigüedad o una invalidez debida a dicha duplicación u omisión.

Nota: Los días «perdidos» durante un cambio de calendario, como del juliano al gregoriano, no afectan a QDateTime. Aunque los dos calendarios describen las fechas de forma diferente, los días sucesivos a lo largo del cambio se describen mediante instancias consecutivas de QDate, cada una un día más tarde que la anterior, tal y como lo describen cualquiera de los dos calendarios o sus valores toJulianDay(). Por el contrario, una zona que omite o duplica un día está modificando su descripción de la hora, no de la fecha, aunque lo haga por un periodo completo de 24 horas.

Desplazamientos respecto a UTC

Las desviaciones respecto al UTC se miden en segundos al este de Greenwich. El momento descrito por una fecha y hora concretas, como el mediodía de un día determinado, depende de la representación temporal utilizada. Aquellas con una mayor desviación respecto al UTC describen un momento anterior, y aquellas con una menor desviación, un momento posterior, para cualquier combinación dada de fecha y hora.

No existe una restricción explícita en cuanto al valor de una desviación respecto al UTC, pero hay un límite implícito impuesto al utilizar los métodos ` toString()` y ` fromString()`, que emplean el formato ±hh:mm, lo que limita efectivamente el rango a ±99 horas y 59 minutos, y solo a minutos enteros. Tenga en cuenta que, actualmente, ninguna zona horaria tiene un desfase fuera del rango de ±14 horas y que todos los desfases conocidos son múltiplos de cinco minutos. Las zonas horarias históricas tienen un rango más amplio y pueden presentar desfases que incluyen segundos; estos últimos no pueden representarse fielmente en cadenas de caracteres.

Véase también QDate, QTime, QDateTimeEdit y QTimeZone.

Documentación sobre los tipos de miembros

[since 6.7] enum class QDateTime::TransitionResolution

Esta enumeración se utiliza para resolver combinaciones de fecha y hora que se encuentran en Timezone transitions.

Al construir una fecha y hora, especificada en términos de hora local o de una zona horaria que aplica el horario de verano, o al modificarla con setDate(), setTime() o setTimeZone(), los parámetros proporcionados pueden implicar una representación de la hora que o bien carece de significado o bien tiene dos significados en dicha zona. Dichas representaciones de la hora se describen como «en transición». En cualquiera de los dos casos, podemos simplemente devolver una fecha y hora no válidas, para indicar que la operación está mal definida. En el caso ambiguo, podemos, alternativamente, seleccionar una de las dos horas a las que podría referirse. Cuando no tiene sentido, podemos seleccionar una hora a uno u otro lado de ella que pudiera haber sido la pretendida de forma plausible. Por ejemplo, al avanzar desde una hora anterior, podemos seleccionar la hora posterior a la transición que corresponda realmente al intervalo de tiempo especificado desde la hora anterior en cuestión. Las opciones especificadas aquí configuran cómo se lleva a cabo dicha selección.

ConstanteValorDescripción
QDateTime::TransitionResolution::Reject0Considera inválida cualquier hora en una transición. O bien lo es realmente, o bien es ambigua.
QDateTime::TransitionResolution::RelativeToBefore1Selecciona un momento como si se avanzara desde un momento anterior a la transición. Esto interpreta el momento solicitado utilizando el desplazamiento vigente antes de la transición y, si es necesario, convierte el resultado al desplazamiento vigente en el momento resultante.
QDateTime::TransitionResolution::RelativeToAfter2Selecciona un momento como si se retrocediera desde un momento posterior a la transición. Esto interpreta el momento solicitado utilizando el desfase vigente tras la transición y, si es necesario, convierte el resultado al desfase vigente en el momento resultante.
QDateTime::TransitionResolution::PreferBefore3Selecciona un momento anterior a la transición,
QDateTime::TransitionResolution::PreferAfter4Selecciona una hora posterior a la transición.
QDateTime::TransitionResolution::PreferStandard5Selecciona una hora en el lado del horario estándar de la transición.
QDateTime::TransitionResolution::PreferDaylightSaving6Selecciona una hora en el lado del horario de verano de la transición.

Se utiliza una constante adicional, ` LegacyBehavior`, como valor por defecto para los parámetros de `TransitionResolution` en algunos constructores y funciones setter. Se trata de un alias de ` RelativeToBefore`, que implementa un comportamiento que se asemeja en mayor medida al de ` QDateTime ` anterior a Qt 6.7.

En el caso de addDays(), addMonths() o addYears(), el comportamiento es —y (en su mayor parte) era— utilizar RelativeToBefore si se añade un ajuste positivo y RelativeToAfter si se añade un ajuste negativo.

Nota: En las zonas horarias en las que el horario de verano aumenta la diferencia con respecto al UTC en verano (lo que se conoce como «horario de verano positivo»), PreferStandard es un alias de RelativeToAfter y PreferDaylightSaving, de RelativeToBefore. En las zonas horarias en las que el mecanismo del horario de verano supone una disminución de la diferencia con respecto al UTC en invierno (lo que se conoce como «horario de verano negativo»), se aplica lo contrario, siempre que el sistema operativo indique —como ocurre en la mayoría de las plataformas— si una fecha y hora se encuentra en horario de verano o en horario estándar. En algunas plataformas, en las que no se dispone de detalles sobre la transición ni siquiera para las fechas y horas de « Qt::TimeZone », « QTimeZone » se ve obligado a suponer que el lado con menor diferencia con respecto al UTC es la hora estándar, lo que en la práctica supone un horario de verano positivo.

Las siguientes tablas ilustran cómo un constructor de QDateTime resuelve una solicitud para las 02:30 en un día en el que la hora local tiene una transición entre las 02:00 y las 03:00, con una hora estándar nominal (LST) y una hora de verano (LDT) a ambos lados, en los distintos casos posibles. El tipo de transición puede consistir en saltarse una hora o repetirla. El tipo de transición y el valor de un parámetro resolve determinan qué hora real de la fecha dada se selecciona. En primer lugar, el caso habitual de horario de verano positivo, en el que:

Antes de02:00–03:00Despuésresolveseleccionado
LSTsaltarLDTRelativo a antes03:30 LDT
LSTsaltarLDTRelativo a después01:30 LST
LSTsaltarLDTPreferir antes de01:30 LST
LSTsaltarLDTPreferir después03:30 LDT
LSTsaltarLDTPreferir horario estándar01:30 LST
LSTsaltarLDTPreferir horario de verano03:30 LDT
LDTrepetirLSTRelativo a antes02:30 LDT
LDTrepetirLSTRelativo a después02:30 LST
LDTrepetirLSTPreferir antes de02:30 LDT
LDTrepetirLSTPreferir después02:30 LST
LDTrepetirLSTPreferir horario estándar02:30 LST
LDTrepetirLSTPreferir horario de verano02:30 LDT

En segundo lugar, el caso del horario de verano negativo, en el que se utiliza el LDT en invierno y se omite una hora para pasar al LST en verano, para luego recuperar esa hora en la transición de vuelta al invierno:

LDTsaltarLSTEn relación con antes03:30 LST
LDTsaltarLSTRelativo a después01:30 LDT
LDTsaltarLSTPreferir antes de01:30 LDT
LDTsaltarLSTPreferir después03:30 LST
LDTsaltarLSTPreferir horario estándar03:30 LST
LDTsaltarLSTPreferir horario de verano01:30 LDT
LSTrepetirLDTRelativo a antes02:30 LST
LSTrepetirLDTRelativo a después02:30 LDT
LSTrepetirLDTPreferir antes de02:30 LST
LSTrepetirLDTPreferir después02:30 LDT
LSTrepetirLDTPreferir horario estándar02:30 LST
LSTrepetirLDTPreferir horario de verano02:30 LDT

La opción «Rechazar» puede utilizarse para indicar a las API pertinentes de QDateTime que devuelvan un objeto de fecha y hora no válido, de modo que tu código pueda gestionar las transiciones por sí mismo; por ejemplo, avisando al usuario de que la fecha y hora que ha seleccionado se encuentra en un intervalo de transición, para ofrecerle la oportunidad de resolver un conflicto o una ambigüedad. El código que utilice esta función puede encontrar útiles las demás opciones mencionadas anteriormente para determinar la información relevante que utilizar en su propia resolución (o en la del usuario). Si el inicio o el final de la transición, o el momento de la propia transición, es la resolución adecuada, se pueden utilizar las API de transición de QTimeZone para obtener esa información. Se puede determinar si la transición corresponde a un intervalo repetido o omitido utilizando secsTo() para medir el tiempo real transcurrido entre el mediodía del día anterior y el del día siguiente. El resultado será inferior a 48 horas en el caso de un intervalo omitido (como el cambio horario de primavera) y superior a 48 horas en el caso de un intervalo repetido (como el cambio horario de otoño).

Nota: Cuando se especifica una resolución distinta de «Reject», se devuelve un objeto ` QDateTime ` válido, si es posible. Si la fecha y hora solicitadas se encuentran en un intervalo omitido, la fecha y hora devueltas no tendrán el valor de ` time()` solicitado —o, en algunos casos, el de ` date()`, si se ha omitido un día completo—. Por lo tanto, puedes detectar cuándo se produce un intervalo sin datos comparando date() y time() con lo que se solicitó.

Relación con otros programas de gestión de fechas y horas

Las API de fecha y hora del lenguaje de programación Python cuentan con un parámetro « fold » que se corresponde con « RelativeToBefore » (fold = True) y « RelativeToAfter » (fold = False).

La propuesta Temporal, destinada a sustituir a Date de JavaScript, ofrece cuatro opciones sobre cómo resolver una transición, como valor para el parámetro disambiguation. Su opción 'reject' lanza una excepción, lo que se corresponde aproximadamente con que Reject produzca un resultado no válido. Sus opciones 'earlier' y 'later' se corresponden con PreferBefore y PreferAfter. Su opción 'compatible' se corresponde con RelativeToBefore (y con fold = True de Python).

Esta enumeración se introdujo en Qt 6.7.

Véase también Timezone transitions.

enum class QDateTime::YearRange

Este tipo enumerado describe el intervalo de años (según el calendario gregoriano) que puede representar un QDateTime:

ConstanteValorDescripción
QDateTime::YearRange::First-292275056Las últimas partes de este año son representables
QDateTime::YearRange::Last+292278994Las partes iniciales de este año son representables

Las primeras y últimas fechas y horas exactas representables se encuentran dentro de estos años y dependen de la función ` timeRepresentation()` utilizada. Se pueden determinar pasando los valores adecuados a ` fromMSecsSinceEpoch()`.

Todas las fechas que se encuentren estrictamente entre estos dos años también son representables. Sin embargo, hay que tener en cuenta que el calendario gregoriano no tiene año cero.

Nota: QDate puede describir fechas en un rango de años más amplio. Para la mayoría de los casos, esto supone poca diferencia, ya que el rango de años que admite QDateTime alcanza los 292 millones de años a ambos lados de 1970.

Véase también isValid() y QDate.

Documentación de las funciones de miembro

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

Crea un objeto de fecha y hora con los valores proporcionados en date y time, utilizando la representación de la hora descrita en timeZone.

Si date es válido y time no lo es, la hora se establecerá a medianoche. Si timeZone no es válido, el objeto de fecha y hora no será válido. Si date y time describen un momento cercano a una transición para timeZone, resolve controla cómo se resuelve esa situación.

Nota: Antes de Qt 6.7, la versión de esta función carecía del parámetro « resolve », por lo que no tenía forma de resolver las ambigüedades relacionadas con las transiciones.

[noexcept] QDateTime::QDateTime()

Crea una fecha y hora nulas, utilizando, en principio, la hora local.

Una fecha y hora nula no es válida, ya que tanto la fecha como la hora son inválidas.

Véase también isValid(), setMSecsSinceEpoch(), setDate(), setTime() y setTimeZone().

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

Crea un objeto de fecha y hora con los valores proporcionados en « date » y « time », utilizando la hora local.

Si date es válido y time no lo es, se utilizará la medianoche como hora. Si date y time describen un momento cercano a una transición de la hora local, resolve controla cómo se resuelve esa situación.

Nota: Antes de Qt 6.7, la versión de esta función carecía del parámetro « resolve », por lo que no tenía forma de resolver las ambigüedades relacionadas con las transiciones.

Se trata de una función sobrecargada.

Esta función se introdujo en Qt 6.5.

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

Crea una copia del objeto de fecha y hora « other ».

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

Traslada el contenido de la fecha y hora temporal other a este objeto y deja other en un estado no especificado (pero correcto).

[noexcept] QDateTime::~QDateTime()

Elimina la fecha y hora.

QDateTime QDateTime::addDays(qint64 ndays) const

Devuelve un objeto ` QDateTime ` que contiene una fecha y hora ` ndays ` días después de la fecha y hora de este objeto (o antes si ` ndays ` es negativo).

Si el valor de ` timeSpec()` es ` Qt::LocalTime ` o ` Qt::TimeZone ` y la fecha y hora resultantes se sitúan en la hora de transición del horario estándar al horario de verano, el resultado se situará justo más allá de ese intervalo, en la dirección del cambio. Si la transición se produce a las 2:00 y el reloj se adelanta a las 3:00, el resultado de fijar un intervalo entre las 2:00 y las 3:00 se ajustará para que se sitúe antes de las 2:00 (si ndays < 0) o después de las 3:00 (en caso contrario).

Véase también daysTo(), addMonths(), addYears(), addSecs() y Timezone transitions.

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

Devuelve un objeto ` QDateTime ` que contiene una fecha y hora ` msecs ` milisegundos posteriores a la fecha y hora de este objeto (o anteriores si ` msecs ` es negativo).

Si esta fecha y hora no es válida, se devolverá una fecha y hora no válida.

Nota: Sumar duraciones expresadas en std::chrono::months o std::chrono::years no da el mismo resultado que se obtiene al utilizar addMonths() o addYears(). Las primeras son duraciones fijas, calculadas en relación con el año solar; las segundas utilizan las definiciones de meses y años del calendario gregoriano.

Esta función se introdujo en Qt 6.4.

Véanse también addMSecs(), msecsTo(), addDays(), addMonths() y addYears().

QDateTime QDateTime::addMSecs(qint64 msecs) const

Devuelve un objeto ` QDateTime ` que contiene una fecha y hora ` msecs ` milisegundos posteriores a la fecha y hora de este objeto (o anteriores si ` msecs ` es negativo).

Si esta fecha y hora no es válida, se devolverá una fecha y hora no válida.

Véanse también addSecs(), msecsTo(), addDays(), addMonths() y addYears().

QDateTime QDateTime::addMonths(int nmonths) const

Devuelve un objeto ` QDateTime ` que contiene una fecha y hora ` nmonths ` meses después de la fecha y hora de este objeto (o antes, si ` nmonths ` es negativo).

Si el valor de timeSpec() es Qt::LocalTime o Qt::TimeZone y la fecha y hora resultantes se sitúan en la hora de transición de la hora estándar a la hora de verano, el resultado se situará justo más allá de este intervalo, en la dirección del cambio. Si la transición se produce a las 2:00 y el reloj se adelanta a las 3:00, el resultado de fijar un intervalo entre las 2:00 y las 3:00 se ajustará para que se sitúe antes de las 2:00 (si nmonths < 0) o después de las 3:00 (en caso contrario).

Véase también daysTo(), addDays(), addYears(), addSecs() y Timezone transitions.

QDateTime QDateTime::addSecs(qint64 s) const

Devuelve un objeto ` QDateTime ` que contiene una fecha y hora ` s ` segundos después de la fecha y hora de este objeto (o antes si ` s ` es negativo).

Si esta fecha y hora no es válida, se devolverá una fecha y hora no válida.

Véase también addMSecs(), secsTo(), addDays(), addMonths() y addYears().

QDateTime QDateTime::addYears(int nyears) const

Devuelve un objeto ` QDateTime ` que contiene una fecha y hora ` nyears ` años posterior a la fecha y hora de este objeto (o anterior si ` nyears ` es negativo).

Si el timeSpec() es Qt::LocalTime o Qt::TimeZone y la fecha y hora resultantes se sitúan en la hora de transición de la hora estándar a la hora de verano, el resultado se situará justo más allá de este intervalo, en la dirección del cambio. Si la transición se produce a las 2:00 y el reloj se adelanta a las 3:00, el resultado de fijar un intervalo entre las 2:00 y las 3:00 se ajustará para que se sitúe antes de las 2:00 (si nyears < 0) o después de las 3:00 (en caso contrario).

Véase también daysTo(), addDays(), addMonths(), addSecs() y Timezone transitions.

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

Devuelve la fecha y hora actuales del reloj del sistema, utilizando el formato de hora descrito en zone. Si se omite zone, se utiliza la hora local.

Esta función se introdujo en Qt 6.5.

Véase también currentDateTimeUtc(), QDate::currentDate(), QTime::currentTime() y toTimeZone().

[static] QDateTime QDateTime::currentDateTime()

Esta función sobrecarga la función « QDateTime::currentDateTime()».

[static] QDateTime QDateTime::currentDateTimeUtc()

Devuelve la fecha y hora actuales del reloj del sistema, expresadas en formato UTC.

Equivalente a ` currentDateTime(QTimeZone::UTC)`.

Véase también currentDateTime(), QDate::currentDate(), QTime::currentTime() y toTimeZone().

[static noexcept] qint64 QDateTime::currentMSecsSinceEpoch()

Devuelve el número actual de milisegundos transcurridos desde el inicio, en UTC, del año 1970.

Este número es similar a la variable time_t de POSIX, pero expresado en milisegundos en lugar de segundos.

Véanse también currentDateTime(), currentDateTimeUtc() y toTimeZone().

[static noexcept] qint64 QDateTime::currentSecsSinceEpoch()

Devuelve el número de segundos transcurridos desde el inicio, en UTC, del año 1970.

Este número es similar a la variable time_t de POSIX.

Véase también currentMSecsSinceEpoch().

QDate QDateTime::date() const

Devuelve la parte correspondiente a la fecha del objeto «datetime».

Véase también setDate(), time() y timeRepresentation().

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

Devuelve el número de días que hay entre esta fecha y hora y la fecha y hora « other ».

El número de días se calcula como el número de veces que se alcanza la medianoche entre esta fecha y hora y la fecha y hora other. Esto significa que una diferencia de 10 minutos entre las 23:55 y las 0:05 del día siguiente cuenta como un día.

Si la fecha y hora « other » es anterior a esta fecha y hora, el valor devuelto es negativo. Si alguna de las dos fechas y horas no es válida, el valor es 0.

Ejemplo:

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));
fechaFin = 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);

Véase también addDays(), secsTo() y msecsTo().

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

Crea un nuevo objeto ` QDateTime ` que contiene una copia del objeto `CFDate` date.

Véase también toCFDate().

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

Devuelve una fecha y hora que representa un momento situado a un número dado msecs de milisegundos después del inicio, en UTC, del año 1970, tal y como se especifica en timeZone. La representación de la hora por defecto es la hora local.

Tenga en cuenta que existen valores posibles para msecs que se encuentran fuera del rango válido de QDateTime, tanto negativos como positivos. El comportamiento de esta función es indefinido para dichos valores.

Véanse también fromSecsSinceEpoch(), toMSecsSinceEpoch() y setMSecsSinceEpoch().

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

Esta función sobrecarga la función « QDateTime::fromMSecsSinceEpoch()».

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

Crea un nuevo objeto ` QDateTime ` que contiene una copia del objeto `NSDate` ` date`.

Véase también toNSDate().

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

Devuelve una fecha y hora que representa un momento situado a un número dado secs de segundos después del inicio, en UTC, del año 1970, tal y como se especifica en timeZone. La representación predeterminada de la hora es la hora local.

Tenga en cuenta que existen valores posibles para secs que se encuentran fuera del rango válido de QDateTime, tanto negativos como positivos. El comportamiento de esta función es indefinido para dichos valores.

Véanse también fromMSecsSinceEpoch(), toSecsSinceEpoch() y setSecsSinceEpoch().

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

Esta función sobrecarga la función « QDateTime::fromSecsSinceEpoch()».

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

Crea un objeto «datetime» cuya fecha y hora corresponden al número de milisegundos representado por time, contados desde el 1 de enero de 1970 a las 00:00:00.000 en hora local (Qt::LocalTime).

Nota: Esta función requiere C++20.

Esta función se introdujo en Qt 6.4.

Véanse también ` toStdSysMilliseconds()` y ` 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 >; }

Crea una fecha y hora que representa el mismo momento que time, utilizando Qt::UTC como representación temporal.

El reloj de time debe ser compatible con std::chrono::system_clock; en concreto, debe existir una conversión admitida por std::chrono::clock_cast. Tras la conversión, el tipo de duración del resultado debe ser convertible a std::chrono::milliseconds.

Si no es así, el llamante debe realizar la conversión de reloj necesaria hacia std::chrono::system_clock y la conversión necesaria del tipo de duración (conversión explícita/redondeo/redondeo por defecto/redondeo al alza/...) para que la entrada a esta función cumpla las restricciones anteriores.

Nota: Esta función requiere C++20.

Esta función se introdujo en Qt 6.4.

Véase también toStdSysMilliseconds() y fromMSecsSinceEpoch().

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

Crea un objeto «datetime» cuya fecha y hora corresponden al número de milisegundos representado por time, contado desde el 1 de enero de 1970 a las 00:00:00.000 en hora local (Qt::LocalTime).

Nota: Esta función requiere C++20.

Esta función se introdujo en Qt 6.4.

Véase también toStdSysMilliseconds() y fromMSecsSinceEpoch().

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

Crea un objeto `datetime` que representa el mismo instante que ` time`, utilizando ` Qt::UTC ` como representación temporal.

Esta función sobrecarga QDateTime::fromStdTimePoint().

Esta función se introdujo en Qt 6.4.

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

Crea un objeto de fecha y hora que representa el mismo momento que time. El resultado se expresará en la zona horaria de time.

Nota: Esta función requiere C++20.

Esta función se introdujo en Qt 6.4.

Véase también QTimeZone, toStdSysMilliseconds() y fromMSecsSinceEpoch().

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

Devuelve el objeto « QDateTime » representado por la cadena « string », utilizando el formato « format » indicado, o una fecha y hora no válidas si no se puede analizar la cadena.

Utiliza el calendario cal si se proporciona; de lo contrario, utiliza el calendario gregoriano.

Cuando format solo especifica los dos últimos dígitos de un año, se consideran en primer lugar los 100 años que comienzan en baseYear. Antes de la versión 6.7 no existía el parámetro « baseYear » y siempre se utilizaba el año 1900. Este es el valor por defecto para « baseYear », que selecciona un año desde entonces hasta 1999. En algunos casos, otros campos pueden dar lugar a que se seleccione el siglo siguiente o el anterior, para obtener un resultado coherente con todos los campos proporcionados. Consulte « QDate::fromString()» para obtener más detalles.

Además de las expresiones reconocidas en la cadena de formato para representar partes de la fecha y la hora, mediante QDate::fromString() y QTime::fromString(), este método admite:

ExpresiónSalida
tla zona horaria (diferencia horaria, nombre, «Z» o diferencia horaria con el prefijo «UTC»)
ttla zona horaria en formato de desfase sin dos puntos entre las horas y los minutos (por ejemplo, «+0200»)
tttla zona horaria en formato de desfase con dos puntos entre las horas y los minutos (por ejemplo, «+02:00»)
ttttel nombre de la zona horaria, ya sea el que devuelve QTimeZone::displayName() para QTimeZone::LongName o el identificador IANA de la zona (por ejemplo, «Europe/Berlin»). Los nombres reconocidos son los que figuran en QTimeZone, lo cual puede depender del sistema operativo utilizado.

Si no se incluye el especificador de formato «t», se utiliza la zona horaria local del sistema. Para conocer los valores por defecto de todos los demás campos, consulte QDate::fromString() y QTime::fromString().

Por ejemplo:

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.

Cualquier secuencia de caracteres no vacía entre comillas simples también se tratará (una vez eliminadas las comillas) como texto y no se interpretará como expresiones. Dos comillas simples consecutivas («''») se interpretan como una sola comilla que debe coincidir con la entrada, en lugar de marcar el inicio o el final de una secuencia literal. El resto de caracteres de la entrada se tratarán como texto literal que debe coincidir con la cadena de entrada. Por ejemplo:

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 no se cumple el formato, se devuelve un valor « QDateTime » no válido.

Cuando los campos numéricos están yuxtapuestos, sin separadores que dividan las secuencias de dígitos, puede haber ambigüedad en cuanto a si algunos campos que pueden tener un solo dígito utilizan dos dígitos (debido a que el valor que deben representar es superior a 9). Cuando asignar dos dígitos a dicho campo dejaría muy pocos para otros campos, y la lectura de un solo dígito es coherente con los demás campos, esta ambigüedad puede resolverse. En caso contrario (cuando se permite que más de un campo tenga solo un dígito y quedaran dígitos de sobra si cada uno recibiera solo uno), se prefiere una resolución que asigne dígitos adicionales a los campos anteriores frente a una que los asigne a los campos posteriores, siempre que los datos sigan siendo coherentes. Por ejemplo:

Las expresiones que no tienen ceros iniciales (d, M, h, m, s, z) serán «codiciosas». Esto significa que utilizarán dos dígitos (o tres, en el caso de z) incluso si ello las sitúa fuera del rango y/o deja muy pocos dígitos para otras secciones.

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

Esto podría haber significado el 1 de enero a las 00:30.00, pero la «M» ocupará dos dígitos.

Los campos especificados incorrectamente en el objeto « string » provocarán que se devuelva un objeto « QDateTime » no válido. Solo se admiten fechas y horas comprendidas entre el inicio del año 100 y el final del año 9999 según la hora local. Ten en cuenta que las fechas y horas cercanas a los extremos de este rango en otras zonas horarias, incluyendo especialmente UTC, pueden quedar fuera del rango (y, por lo tanto, ser consideradas no válidas) dependiendo de la zona horaria local.

Nota: Los nombresde los días y meses, así como los indicadores AM/PM, deben proporcionarse en inglés (configuración regional C). Si se desea que se reconozcan los nombres de los meses y días localizados o las formas localizadas de AM/PM, utilice QLocale::system().toDateTime().

Nota: Si un carácter de formato se repite más veces que la expresión más larga de la tabla anterior que lo utiliza, esta parte del formato se interpretará como varias expresiones sin separador entre ellas; la más larga de las anteriores, posiblemente repetida tantas veces como haya copias de la misma, terminando con un resto que puede ser una expresión más corta. Así, 'tttttt' coincidiría con "Europe/BerlinEurope/Berlin" y establecería la zona horaria en la de Berlín; si la cadena de fecha y hora contuviera «Europe/BerlinZ», «coincidiría», pero produciría un resultado incoherente, lo que daría lugar a una fecha y hora no válidas.

Véase también toString(), QDate::fromString(), QTime::fromString() y QLocale::toDateTime().

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

Esta función sobrescribe la función « QDateTime::fromString()».

Esta función se introdujo en Qt 6.0.

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

Devuelve el objeto « QDateTime » representado por « string », utilizando el « format » proporcionado, o una fecha y hora no válida si esto no es posible.

Nota sobre Qt::TextDate: solo se reconocen los nombres abreviados de los meses en inglés (por ejemplo, «Jan» en su forma abreviada o «January» en su forma completa).

Esta es una función sobrecargada.

Véanse también toString() y QLocale::toDateTime().

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

Esta función sobrescribe la función « QDateTime::fromString()».

Esta función se introdujo en Qt 6.0.

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

Utiliza un objeto ` QCalendar` creado con el constructor por defecto.

Esta función sobrecarga QDateTime::fromString().

Esta función se introdujo en Qt 6.7.

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

Esta función sobrecarga ` QDateTime::fromString()`.

Esta función se introdujo en Qt 6.0.

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

Utiliza un objeto ` QCalendar` creado con el constructor por defecto.

Esta función sobreescribe QDateTime::fromString().

Esta función se introdujo en Qt 6.7.

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

Esta función sobrecarga la función « QDateTime::fromString()».

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

Utiliza un objeto ` QCalendar` creado con el constructor por defecto.

Esta función sobrecarga QDateTime::fromString().

Esta función se introdujo en Qt 6.7.

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

Esta función sobrescribe la función « QDateTime::fromString()».

Esta función se introdujo en Qt 6.7.

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

Esta función sobrescribe la función « QDateTime::fromString()».

Esta función se introdujo en Qt 6.0.

bool QDateTime::isDaylightTime() const

Devuelve un valor si esta fecha y hora se encuentra dentro del horario de verano.

Si la función « Qt::TimeSpec » no es « Qt::LocalTime » o « Qt::TimeZone », siempre devolverá «false».

Véase también timeSpec().

bool QDateTime::isNull() const

Devuelve true si tanto la fecha como la hora son nulas; en caso contrario, devuelve false. Una fecha y hora nulas no son válidas.

Véase también QDate::isNull(), QTime::isNull() y isValid().

bool QDateTime::isValid() const

Devuelve « true » si esta fecha y hora representan un momento concreto; en caso contrario, devuelve « false ».

Una fecha y hora son válidas si tanto la fecha como la hora son válidas y la representación temporal utilizada da un significado válido a su combinación. Cuando la representación de la hora corresponde a un huso horario específico o a la hora local, puede haber momentos en algunas fechas en los que el huso horario omita una hora en su representación, como cuando el cambio al horario de verano omite una hora (normalmente durante una noche de primavera). Por ejemplo, si el horario de verano termina a las 2:00 h y el reloj se adelanta a las 3:00 h, las fechas y horas comprendidas entre las 02:00:00 y las 02:59:59,999 de ese día no son válidas.

Véase también QDateTime::YearRange, QDate::isValid() y QTime::isValid().

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

Devuelve el número de milisegundos que hay entre esta fecha y hora y la fecha y hora other.

Antes de realizar la comparación, ambas fechas y horas se convierten a « Qt::UTC » para garantizar que el resultado sea correcto en caso de que se aplique el horario de verano (DST) a una de las dos fechas y horas, pero no a la otra.

Si la fecha y hora de « other » es anterior a esta fecha y hora, el valor devuelto es negativo. Devuelve 0 si alguna de las dos fechas y horas no es válida.

Véase también addMSecs(), daysTo() y QTime::msecsTo().

int QDateTime::offsetFromUtc() const

Devuelve el desfase de esta fecha y hora respecto al UTC, expresado en segundos.

El resultado depende de timeSpec():

  • Qt::UTC La diferencia horaria es 0.
  • Qt::OffsetFromUTC La diferencia es el valor establecido originalmente.
  • Qt::LocalTime Se devuelve el desfase de la hora local respecto al UTC.
  • Qt::TimeZone Se devuelve la diferencia horaria utilizada por la zona horaria.

En los dos últimos casos, se devolverá la diferencia en esta fecha y hora, teniendo en cuenta la diferencia por horario de verano. La diferencia horaria es la diferencia entre la hora local o la hora en la zona horaria dada y la hora UTC; es positiva en las zonas horarias que van por delante de la UTC (al este del meridiano principal) y negativa en aquellas que van por detrás de la UTC (al oeste del meridiano principal).

Véase también setTimeZone().

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

Devuelve el número de segundos que hay entre esta fecha y hora y la fecha y hora « other ».

Antes de realizar la comparación, ambas fechas y horas se convierten a « Qt::UTC » para garantizar que el resultado sea correcto en caso de que se aplique el horario de verano (DST) a una de ellas, pero no a la otra.

Si la fecha y hora « other » es anterior a esta fecha y hora, el valor devuelto es negativo. Devuelve 0 si alguna de las dos fechas y horas no es válida.

Ejemplo:

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

Véase también addSecs(), daysTo() y QTime::secsTo().

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

Establece la parte de fecha de esta fecha y hora en date.

Si aún no se ha establecido ninguna hora, se establece a medianoche. Si date no es válido, este QDateTime deja de ser válido.

Si date y time() describen un momento cercano a una transición en la representación horaria de esta fecha y hora, resolve controla cómo se resuelve esa situación.

Nota: Antes de Qt 6.7, la versión de esta función carecía del parámetro resolve, por lo que no tenía forma de resolver las ambigüedades relacionadas con las transiciones.

Véase también date(), setTime() y setTimeZone().

void QDateTime::setMSecsSinceEpoch(qint64 msecs)

Establece la fecha y hora para que represente un momento situado a un número determinado — msecs — de milisegundos después del inicio, en UTC, del año 1970.

En sistemas que no admiten zonas horarias, esta función se comportará como si la hora local fuera Qt::UTC.

Ten en cuenta que pasar el mínimo de qint64 (std::numeric_limits<qint64>::min()) a msecs dará lugar a un comportamiento indefinido.

Véanse también setSecsSinceEpoch(), toMSecsSinceEpoch() y fromMSecsSinceEpoch().

void QDateTime::setSecsSinceEpoch(qint64 secs)

Establece la fecha y hora para que represente un momento situado a un número determinado — secs — de segundos después del inicio, en UTC, del año 1970.

En sistemas que no admiten zonas horarias, esta función se comportará como si la hora local fuera Qt::UTC.

Véase también setMSecsSinceEpoch(), toSecsSinceEpoch() y fromSecsSinceEpoch().

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

Establece la parte de hora de esta fecha y hora en time. Si time no es válido, esta función lo establece en medianoche. Por lo tanto, es posible borrar cualquier hora establecida en un QDateTime estableciéndola en un valor por defecto QTime:

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

Si date() y time describen un momento cercano a una transición para la representación temporal de esta fecha y hora, resolve controla cómo se resuelve esa situación.

Nota: Antes de Qt 6.7, la versión de esta función carecía del parámetro resolve, por lo que no tenía forma de resolver las ambigüedades relacionadas con las transiciones.

Véase también time(), setDate() y setTimeZone().

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

Establece la zona horaria utilizada en esta fecha y hora en toZone.

La fecha y hora puede referirse a un momento diferente. Utiliza la representación de la hora de toZone, lo que puede alterar el significado de sus funciones date() y time(), que no han sufrido cambios.

Si toZone no es válida, la fecha y hora tampoco lo serán. De lo contrario, el valor de timeSpec() de esta fecha y hora tras la llamada coincidirá con el de toZone.timeSpec()().

Si date() y time() describen un momento cercano a una transición para toZone, resolve controla cómo se resuelve esa situación.

Nota: Antes de Qt 6.7, la versión de esta función carecía del parámetro resolve, por lo que no había forma de resolver las ambigüedades relacionadas con las transiciones.

Véase también timeRepresentation(), timeZone() y Qt::TimeSpec.

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

Cambia esta fecha y hora por other. Esta operación es muy rápida y nunca falla.

QTime QDateTime::time() const

Devuelve la parte correspondiente a la hora del objeto «datetime».

Véase también setTime(), date() y timeRepresentation().

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

Devuelve un objeto ` QTimeZone ` que identifica cómo esta fecha y hora representa el tiempo.

El objeto ` timeSpec()` del ` QTimeZone ` devuelto coincidirá con el de esta fecha y hora; si no es ` Qt::TimeZone `, entonces el ` QTimeZone ` devuelto es una representación de la hora. Cuando su ` timeSpec()` es ` Qt::OffsetFromUTC`, la función `fixedSecondsAheadOfUtc()` del ` QTimeZone` devuelto proporciona el desfase. Cuando ` timeSpec()` es ` Qt::TimeZone`, el propio objeto ` QTimeZone ` es la representación completa de esa zona horaria.

Esta función se introdujo en Qt 6.5.

Véase también timeZone(), setTimeZone() y QTimeZone::asBackendZone().

Qt::TimeSpec QDateTime::timeSpec() const

Devuelve la especificación de hora del objeto «datetime».

Esto clasifica su representación horaria como hora local, UTC, un desfase fijo respecto al UTC (sin indicar el desfase) o una zona horaria (sin proporcionar los detalles de dicha zona horaria). Equivalente a timeRepresentation().timeSpec().

Véase también setTimeZone(), timeRepresentation(), date() y time().

QTimeZone QDateTime::timeZone() const

Devuelve la zona horaria de la fecha y hora.

El resultado es el mismo que el de ` timeRepresentation().asBackendZone()`. En todos los casos, la función ` timeSpec()` del resultado es ` Qt::TimeZone`.

Cuando timeSpec() es Qt::LocalTime, el resultado describirá la hora local en el momento en que se llamó a este método. No reflejará los cambios posteriores en la zona horaria del sistema, incluso cuando el QDateTime del que se obtuvo sí lo haga.

Véase también timeRepresentation(), setTimeZone(), Qt::TimeSpec y QTimeZone::asBackendZone().

QString QDateTime::timeZoneAbbreviation() const

Devuelve la abreviatura de la zona horaria correspondiente a esta fecha y hora.

La cadena devuelta depende de timeSpec():

Nota: No se garantiza quela abreviatura sea única; es decir, diferentes zonas horarias pueden tener la misma abreviatura. Para Qt::LocalTime y Qt::TimeZone, cuando la devuelve el sistema anfitrión, la abreviatura puede estar localizada.

Véase también timeSpec() y QTimeZone::abbreviation().

CFDateRef QDateTime::toCFDate() const

Crea un objeto CFDate a partir de un objeto ` QDateTime`.

El llamante es el propietario del objeto CFDate y es responsable de liberarlo.

Véase también fromCFDate().

QDateTime QDateTime::toLocalTime() const

Devuelve una copia de esta fecha y hora convertida a la hora local.

El resultado representa el mismo momento en el tiempo que esta fecha y hora, y es igual a ella.

Ejemplo:

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);

Véase también toTimeZone(), toUTC() y toOffsetFromUtc().

qint64 QDateTime::toMSecsSinceEpoch() const

Devuelve la fecha y hora como un número de milisegundos transcurridos desde el inicio del año 1970, en UTC.

En sistemas que no admiten zonas horarias, esta función se comportará como si la hora local fuera Qt::UTC.

El comportamiento de esta función es indefinido si la fecha y hora almacenadas en este objeto no son válidas. Sin embargo, para todas las fechas válidas, esta función devuelve un valor único.

Véase también toSecsSinceEpoch(), setMSecsSinceEpoch() y fromMSecsSinceEpoch().

NSDate *QDateTime::toNSDate() const

Crea un objeto `NSDate` a partir de un objeto ` QDateTime`.

El objeto NSDate se libera automáticamente.

Véase también fromNSDate().

QDateTime QDateTime::toOffsetFromUtc(int offsetSeconds) const

Devuelve una copia de esta fecha y hora convertida a una especificación de Qt::OffsetFromUTC con el offsetSeconds indicado. Equivalente a toTimeZone(QTimeZone::fromSecondsAheadOfUtc(offsetSeconds)).

Si el valor de ` offsetSeconds ` es igual a 0, se devolverá una fecha y hora en UTC.

El resultado representa el mismo momento en el tiempo que esta fecha y hora, y es igual a ella.

Véase también offsetFromUtc() y toTimeZone().

qint64 QDateTime::toSecsSinceEpoch() const

Devuelve la fecha y hora como un número de segundos transcurridos desde el inicio, en UTC, del año 1970.

En sistemas que no admiten zonas horarias, esta función se comportará como si la hora local fuera Qt::UTC.

El comportamiento de esta función es indefinido si la fecha y hora almacenadas en este objeto no son válidas. Sin embargo, para todas las fechas válidas, esta función devuelve un valor único.

Véase también toMSecsSinceEpoch(), fromSecsSinceEpoch() y setSecsSinceEpoch().

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

Convierte este objeto de fecha y hora en el instante de tiempo equivalente expresado en milisegundos, utilizando std::chrono::system_clock como reloj.

Nota: Esta función requiere C++20.

Esta función se introdujo en Qt 6.4.

Véase también ` fromStdTimePoint()` y ` toMSecsSinceEpoch()`.

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

Convierte este objeto de fecha y hora en el momento equivalente expresado en segundos, utilizando std::chrono::system_clock como reloj.

Nota: Esta función requiere C++20.

Esta función se introdujo en Qt 6.4.

Véase también ` fromStdTimePoint()` y ` toSecsSinceEpoch()`.

QString QDateTime::toString(const QString &format, QCalendar cal) const

QString QDateTime::toString(QStringView format, QCalendar cal) const

Devuelve la fecha y hora como una cadena. El parámetro « format » determina el formato de la cadena resultante. Si se especifica « cal », este determina el calendario utilizado para representar la fecha; por defecto, se utiliza el calendario gregoriano. Antes de Qt 5.14, no existía el parámetro « cal » y siempre se utilizaba el calendario gregoriano. Consulte QTime::toString() y QDate::toString() para conocer los especificadores admitidos para la hora y la fecha, respectivamente, en el parámetro format.

Cualquier secuencia de caracteres no vacía entre comillas simples se incluirá tal cual en la cadena de salida (sin las comillas), incluso si contiene caracteres de formato. Dos comillas simples consecutivas («''») se sustituyen por una sola comilla simple en la salida, en lugar de marcar el inicio o el final de una secuencia tal cual. Todos los demás caracteres de la cadena de formato se incluyen tal cual en la cadena de salida.

Se admiten formatos sin separadores (p. ej., «ddMM»), pero deben utilizarse con precaución, ya que las cadenas resultantes no siempre son legibles de forma fiable (p. ej., si «dM» produce «212», podría significar tanto el 2 de diciembre como el 21 de febrero).

Ejemplos de cadenas de formato (suponiendo que el « QDateTime » sea el 21 de mayo de 2001 a las 14:13:09.120):

FormatoResultado
dd.MM.aaaa21.05.2001
ddd MMMM d aaaaMartes, 21 de mayo de 01
hh:mm:ss.zzz14:13:09.120
hh:mm:ss.z14:13:09.12
h:m:s ap2:13:9 p. m.

Si la fecha y hora no son válidas, se devolverá una cadena vacía.

Nota: Los nombresde los días y los meses, así como los indicadores AM/PM, se proporcionan en inglés (configuración regional C). Para obtener los nombres de los meses y los días localizados, así como las formas localizadas de AM/PM, utiliza QLocale::system().toDateTime().

Véase también fromString(), QDate::toString(), QTime::toString() y QLocale::toString().

QString QDateTime::toString(QStringView format) const

Esta función sobrecarga la función « QDateTime::toString()».

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

Devuelve la fecha y hora como una cadena con el formato especificado en el parámetro « format ».

Si el format es Qt::TextDate, la cadena se formatea de forma predeterminada. Los nombres de los días y los meses aparecerán en inglés. Un ejemplo de este formato es «Wed May 20 03:40:13 1998». Para obtener información sobre el formato localizado, consulta QLocale::toString().

Si el parámetro « format » es « Qt::ISODate », el formato de la cadena se ajusta a la especificación ampliada de la norma ISO 8601 para la representación de fechas y horas, adoptando la forma «yyyy-MM-ddTHH:mm:ss[Z|±HH:mm]», dependiendo del valor de « timeSpec » () de « QDateTime ». Si el valor de « timeSpec » () es « Qt::UTC », se añadirá «Z» a la cadena; si el valor de « timeSpec » () es « Qt::OffsetFromUTC », se añadirá a la cadena la diferencia en horas y minutos respecto al UTC. Para incluir milisegundos en la fecha ISO 8601, utiliza el formato « format » Qt::ISODateWithMs, que se corresponde con yyyy-MM-ddTHH:mm:ss.zzz[Z|±HH:mm].

Si el format es Qt::RFC2822Date, la cadena se formatea según la norma RFC 2822.

Si la fecha y hora no son válidas, se devolverá una cadena vacía.

Advertencia: El formato Qt::ISODate solo es válido para años comprendidos entre 0 y 9999.

Esta función sobrescribe la función QDateTime::toString().

Véase también fromString(), QDate::toString(), QTime::toString() y QLocale::toString().

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

Esta función sobrecarga la función « QDateTime::toString()».

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

Devuelve una copia de esta fecha y hora convertida al formato « timeZone » especificado.

El resultado representa el mismo momento en el tiempo que esta fecha y hora, y es igual a ella.

El resultado describe el momento en el tiempo según la representación temporal de timeZone. Por ejemplo:

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 no es válido, la fecha y hora tampoco lo serán. De lo contrario, la función timeSpec() de la fecha y hora devuelta coincidirá con timeZone.timeSpec().

Véase también timeRepresentation(), toLocalTime(), toUTC() y toOffsetFromUtc().

QDateTime QDateTime::toUTC() const

Devuelve una copia de esta fecha y hora convertida a UTC.

El resultado representa el mismo momento en el tiempo que esta fecha y hora, y es igual a ella.

Ejemplo:

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);

Véase también toTimeZone(), toLocalTime() y toOffsetFromUtc().

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

Modifica este objeto de fecha y hora añadiendo el valor dado de « duration ».

El objeto actualizado será posterior si « duration » es positivo, o anterior si es negativo. Devuelve una referencia a este objeto de fecha y hora.

Si este objeto de fecha y hora no es válido, esta función no tiene ningún efecto.

Esta función se introdujo en Qt 6.4.

Véase también ` addMSecs()`.

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

Modifica este objeto de fecha y hora restándole el valor dado ` duration`.

El objeto actualizado será anterior si duration es positivo, o posterior si es negativo. Devuelve una referencia a este objeto de fecha y hora.

Si este objeto de fecha y hora no es válido, esta función no tiene ningún efecto.

Esta función se introdujo en Qt 6.4.

Véase también addMSecs.

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

Copia la fecha y hora de « other » en esta variable y devuelve dicha copia.

Relacionado: No miembros

[noexcept] bool operator!=(const QDateTime &lhs, const QDateTime &rhs)

Devuelve ` true ` si ` lhs ` es diferente de ` rhs`; en caso contrario, devuelve ` false`.

Dos fechas y horas que utilicen representaciones de tiempo diferentes pueden tener desplazamientos distintos respecto al UTC. En este caso, pueden resultar equivalentes en la comparación aunque sus valores de date() y time() difieran, siempre que dicha diferencia coincida con la diferencia en el desplazamiento respecto al UTC. Si sus valores de date() y time() coinciden, la que presente un mayor desplazamiento respecto al UTC es menor (más temprana) que la que presente un menor desplazamiento. Como resultado, las fechas y horas solo están ordenadas de forma débil.

Desde la versión 5.14, todas las fechas y horas no válidas son equivalentes y menores que todas las fechas y horas válidas.

Véase también operator==().

[since 6.4] QDateTime operator+(const QDateTime &dateTime, std::chrono::milliseconds duration)

[since 6.4] QDateTime operator+(std::chrono::milliseconds duration, const QDateTime &dateTime)

Devuelve un objeto ` QDateTime ` que contiene una fecha y hora ` duration ` milisegundos después de ` dateTime ` (o antes si ` duration ` es negativo).

Si dateTime no es válido, se devolverá una fecha y hora no válida.

Estas funciones se introdujeron en Qt 6.4.

Véase también addMSecs().

[since 6.4] std::chrono::milliseconds operator-(const QDateTime &lhs, const QDateTime &rhs)

Devuelve el tiempo, en milisegundos, transcurrido desde lhs hasta rhs.

Si lhs es anterior a rhs, el resultado será negativo. Devuelve 0 ms si alguna de las fechas y horas no es válida.

Esta función se introdujo en Qt 6.4.

Véase también msecsTo().

[since 6.4] QDateTime operator-(const QDateTime &dateTime, std::chrono::milliseconds duration)

Devuelve un objeto ` QDateTime ` que contiene una fecha y hora ` duration ` milisegundos antes que ` dateTime ` (o después, si ` duration ` es negativo).

Si dateTime no es válido, se devolverá una fecha y hora no válida.

Esta función se introdujo en Qt 6.4.

Véase también addMSecs().

[noexcept] bool operator<(const QDateTime &lhs, const QDateTime &rhs)

Devuelve ` true ` si ` lhs ` es anterior a ` rhs`; en caso contrario, devuelve ` false`.

Dos fechas y horas que utilicen representaciones de tiempo diferentes pueden tener desviaciones distintas respecto al UTC. En este caso, pueden resultar equivalentes en la comparación aunque sus valores de date() y time() difieran, siempre que dicha diferencia coincida con la diferencia en la desviación respecto al UTC. Si sus valores de date() y time() coinciden, la que tenga una mayor desviación respecto al UTC es menor (anterior) que la que tenga una menor desviación. Como resultado, las fechas y horas solo están ordenadas de forma débil.

Desde la versión 5.14, todas las fechas y horas no válidas son equivalentes y menores que todas las fechas y horas válidas.

Véase también operator==().

QDataStream &operator<<(QDataStream &out, const QDateTime &dateTime)

Escribe un ` dateTime ` en el flujo ` out `.

Véase también «Serialización detipos de datos de Qt».

[noexcept] bool operator<=(const QDateTime &lhs, const QDateTime &rhs)

Devuelve ` true ` si ` lhs ` es anterior o igual a ` rhs`; en caso contrario, devuelve ` false`.

Dos fechas y horas que utilicen representaciones de tiempo diferentes pueden tener desplazamientos distintos respecto al UTC. En este caso, pueden considerarse equivalentes aunque sus valores de ` date()` y ` time()` difieran, si dicha diferencia coincide con la diferencia en el desplazamiento respecto al UTC. Si sus valores de ` date() ` y ` time() ` coinciden, la que tenga un mayor desplazamiento respecto al UTC es menor (más temprana) que la que tenga un menor desplazamiento. Como resultado, las fechas y horas solo están ordenadas de forma débil.

Desde la versión 5.14, todas las fechas y horas no válidas son equivalentes y menores que todas las fechas y horas válidas.

Véase también operator==().

[noexcept] bool operator==(const QDateTime &lhs, const QDateTime &rhs)

Devuelve ` true ` si ` lhs ` representa el mismo momento en el tiempo que ` rhs`; en caso contrario, devuelve ` false`.

Dos fechas y horas que utilicen representaciones de tiempo diferentes pueden tener desviaciones distintas respecto al UTC. En este caso, pueden resultar equivalentes en la comparación aunque sus valores de date() y time() difieran, si dicha diferencia coincide con la diferencia en la desviación respecto al UTC. Si sus valores de date() y time() coinciden, la que tenga una mayor desviación respecto al UTC es menor (más temprana) que la que tenga una menor desviación. Como resultado, las fechas y horas solo están ordenadas de forma débil.

Desde la versión 5.14, todas las fechas y horas no válidas son equivalentes y menores que todas las fechas y horas válidas.

Véase también operator!=(), operator<(), operator<=(), operator>() y operator>=().

[noexcept] bool operator>(const QDateTime &lhs, const QDateTime &rhs)

Devuelve ` true ` si ` lhs ` es posterior a ` rhs`; en caso contrario, devuelve ` false`.

Dos fechas y horas que utilicen representaciones de tiempo diferentes pueden tener desviaciones distintas respecto al UTC. En este caso, pueden resultar equivalentes en la comparación aunque sus valores de date() y time() difieran, si dicha diferencia coincide con la diferencia en la desviación respecto al UTC. Si sus valores de date() y time() coinciden, la que presente una mayor desviación respecto al UTC es menor (más temprana) que la que presente una menor desviación. Como resultado, las fechas y horas solo están ordenadas de forma débil.

Desde la versión 5.14, todas las fechas y horas no válidas son equivalentes y menores que todas las fechas y horas válidas.

Véase también operator==().

[noexcept] bool operator>=(const QDateTime &lhs, const QDateTime &rhs)

Devuelve ` true ` si ` lhs ` es posterior o igual a ` rhs`; en caso contrario, devuelve ` false`.

Dos fechas y horas que utilicen representaciones de tiempo diferentes pueden tener desplazamientos distintos respecto al UTC. En este caso, pueden resultar equivalentes en la comparación aunque sus valores de ` date()` y ` time()` difieran, si dicha diferencia coincide con la diferencia en el desplazamiento respecto al UTC. Si sus valores de ` date() ` y ` time() ` coinciden, la que tenga un mayor desplazamiento respecto al UTC es menor (más temprana) que la que tenga un menor desplazamiento. Como resultado, las fechas y horas solo están ordenadas de forma débil.

Desde la versión 5.14, todas las fechas y horas no válidas son equivalentes y menores que todas las fechas y horas válidas.

Véase también operator==().

QDataStream &operator>>(QDataStream &in, QDateTime &dateTime)

Lee una fecha y hora del flujo « in » y la almacena en « dateTime ».

Véase también «Serialización detipos de datos de Qt».

© 2026 The Qt Company Ltd. Documentation contributions included herein are the copyrights of their respective owners. The documentation provided herein is licensed under the terms of the GNU Free Documentation License version 1.3 as published by the Free Software Foundation. Qt and respective logos are trademarks of The Qt Company Ltd. in Finland and/or other countries worldwide. All other trademarks are property of their respective owners.