En esta página

QTime Class

La clase QTime ofrece funciones relacionadas con la hora del reloj. Más información...

Encabezado: #include <QTime>
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 QTime

CategoríaTipos comparables
strongQTime

Funciones públicas

QTime()
QTime(int h, int m, int s = 0, int ms = 0)
QTime addMSecs(int ms) const
QTime addSecs(int s) const
int hour() const
bool isNull() const
bool isValid() const
int minute() const
int msec() const
int msecsSinceStartOfDay() const
int msecsTo(QTime t) const
int second() const
int secsTo(QTime t) const
bool setHMS(int h, int m, int s, int ms = 0)
QString toString(const QString &format) const
QString toString(QStringView format) const
QString toString(Qt::DateFormat format = Qt::TextDate) const

Miembros públicos estáticos

QTime currentTime()
QTime fromMSecsSinceStartOfDay(int msecs)
QTime fromString(const QString &string, const QString &format)
(since 6.0) QTime fromString(QStringView string, QStringView format)
(since 6.0) QTime fromString(QStringView string, Qt::DateFormat format = Qt::TextDate)
(since 6.0) QTime fromString(const QString &string, QStringView format)
QTime fromString(const QString &string, Qt::DateFormat format = Qt::TextDate)
bool isValid(int h, int m, int s, int ms = 0)
bool operator!=(const QTime &lhs, const QTime &rhs)
bool operator<(const QTime &lhs, const QTime &rhs)
QDataStream &operator<<(QDataStream &out, QTime time)
bool operator<=(const QTime &lhs, const QTime &rhs)
bool operator==(const QTime &lhs, const QTime &rhs)
bool operator>(const QTime &lhs, const QTime &rhs)
bool operator>=(const QTime &lhs, const QTime &rhs)
QDataStream &operator>>(QDataStream &in, QTime &time)

Descripción detallada

Un objeto QTime contiene una hora, que puede expresarse como el número de horas, minutos, segundos y milisegundos transcurridos desde la medianoche. Proporciona funciones para comparar horas y para manipular una hora añadiendo un número de milisegundos. Los objetos QTime deben pasarse por valor en lugar de por referencia a const; simplemente empaquetan int.

QTime utiliza el formato de reloj de 24 horas; no tiene en cuenta la distinción entre AM y PM. A diferencia de QDateTime, QTime no tiene en cuenta las zonas horarias ni el horario de verano (DST).

Un objeto QTime se crea normalmente bien indicando explícitamente el número de horas, minutos, segundos y milisegundos, bien utilizando la función estática currentTime(), que crea un objeto QTime que representa la hora local del sistema.

Las funciones hour(), minute(), second() y msec() permiten acceder al número de horas, minutos, segundos y milisegundos de la hora. La función toString() proporciona la misma información en formato textual.

Las funciones ` addSecs()` y ` addMSecs()` proporcionan la hora que se produce un número determinado de segundos o milisegundos después de una hora dada. Del mismo modo, el número de segundos o milisegundos entre dos horas se puede calcular utilizando ` secsTo()` o ` msecsTo()`.

QTime proporciona un conjunto completo de operadores para comparar dos objetos QTime; una hora anterior se considera menor que una posterior; si A.msecsTo(B) es positivo, entonces A < B.

Los objetos QTime también se pueden crear a partir de una representación de texto mediante fromString() y convertir a una representación de cadena mediante toString(). Todas las conversiones hacia y desde formatos de cadena se realizan utilizando la configuración regional de C. Para conversiones localizadas, véase QLocale.

Véase también QDate y QDateTime.

Documentación de las funciones miembro

[constexpr] QTime::QTime()

Crea un objeto de tiempo nulo. Para un tiempo nulo, la función ` isNull()` devuelve ` true ` y la función ` isValid()` devuelve ` false`. Si necesitas un tiempo cero, utiliza `QTime(0, 0)`. Para el inicio de un día, consulta la función ` QDate::startOfDay()`.

Véanse también isNull() y isValid().

QTime::QTime(int h, int m, int s = 0, int ms = 0)

Crea una hora con la hora h, los minutos m, los segundos s y los milisegundos ms.

h debe estar comprendido entre 0 y 23, m y s deben estar comprendidos entre 0 y 59, y ms debe estar comprendido entre 0 y 999.

Véase también isValid().

QTime QTime::addMSecs(int ms) const

Devuelve un objeto ` QTime ` que contiene una hora ` ms ` milisegundos después de la hora de este objeto (o antes, si ` ms ` es negativo).

Ten en cuenta que la hora se reiniciará si pasa de medianoche. Consulta addSecs() para ver un ejemplo.

Devuelve una hora nula si esta hora no es válida.

Véanse también addSecs(), msecsTo() y QDateTime::addMSecs().

QTime QTime::addSecs(int s) const

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

Ten en cuenta que la hora se reiniciará si pasa de medianoche.

Devuelve un tiempo nulo si este tiempo no es válido.

Ejemplo:

QTime n(14, 0, 0);                // n == 14:00:00
QTime t;
t = n.addSecs(70);                // t == 14:01:10
t = n.addSecs(-70);               // t == 13:58:50
t = n.addSecs(10 * 60 * 60 + 5);  // t == 00:00:05
t = n.addSecs(-15 * 60 * 60);     // t == 23:00:00

Véase también addMSecs(), secsTo() y QDateTime::addSecs().

[static] QTime QTime::currentTime()

Devuelve la hora actual según la indica el reloj del sistema.

Ten en cuenta que la precisión depende de la precisión del sistema operativo subyacente; no todos los sistemas ofrecen una precisión de 1 milisegundo.

Además, currentTime() solo aumenta a lo largo de cada día; se reduce en 24 horas cada vez que pasa la medianoche; y, además, es posible que los cambios en este valor no se correspondan con el tiempo transcurrido si se produce un cambio de horario de verano.

Véanse también QDateTime::currentDateTime() y QDateTime::currentDateTimeUtc().

[static constexpr] QTime QTime::fromMSecsSinceStartOfDay(int msecs)

Devuelve una nueva instancia de ` QTime ` con la hora establecida en el número de ` msecs ` transcurridos desde el inicio del día, es decir, desde las 00:00:00.

Si msecs se encuentra fuera del rango válido, se devolverá un valor QTime no válido.

Véase también msecsSinceStartOfDay().

[static] QTime QTime::fromString(const QString &string, const QString &format)

Devuelve el objeto ` QTime ` representado por la cadena ` string`, utilizando el formato ` format ` proporcionado, o una hora no válida si no se puede analizar la cadena.

Estas expresiones pueden utilizarse para el formato:

ExpresiónSalida
hLa hora sin el cero inicial (del 0 al 23 o del 1 al 12 si se muestra AM/PM)
hhLa hora con un cero inicial (de 00 a 23 o de 01 a 12 si se muestra AM/PM)
HLa hora sin el cero inicial (del 0 al 23, incluso con visualización AM/PM)
HHLa hora con un cero inicial (de 00 a 23, incluso con visualización AM/PM)
mLos minutos sin el cero inicial (de 0 a 59)
mmEl minuto con un cero delante (de 00 a 59)
sEl segundo completo, sin ceros iniciales (0 a 59)
ssEl segundo completo, con un cero inicial cuando proceda (de 00 a 59)
z o zzLa parte fraccionaria del segundo, tal y como suele aparecer tras el punto decimal, sin necesidad de ceros a la derecha (0 a 999). Así, « "s.z" » coincide con los segundos que tienen hasta tres dígitos en la parte fraccionaria, lo que proporciona una precisión de milisegundos, sin necesidad de ceros a la derecha. Por ejemplo, « "s.z" » reconocería tanto « "00.250" » como « "0.25" » como representaciones de un tiempo que se encuentra a un cuarto de segundo dentro de su minuto.
zzzParte fraccionaria del segundo de tres dígitos, con precisión de milisegundos, incluyendo ceros a la derecha cuando proceda (de 000 a 999). Por ejemplo, "ss.zzz" rechazaría "0.25", pero reconocería "00.250" como una hora en la que se ha transcurrido un cuarto de segundo del minuto.
AP, A, ap, a, aP o ApTanto «AM», que indica una hora anterior a las 12:00, como «PM» para horas posteriores, se comparan sin distinguir entre mayúsculas y minúsculas.

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 simple que debe coincidir con la entrada, en lugar de marcar el inicio o el final de una secuencia literal. Todos los demás caracteres de la entrada se tratarán como texto literal que debe coincidir con la cadena de entrada. Por ejemplo:

QTime time = QTime::fromString("1mm12car00", "m'mm'hcarss");
// time is 12:01.00

Si no se cumple el formato, se devuelve un valor « QTime » 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 representan 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 sobraran dígitos si cada uno tuviera solo uno), se prefiere una resolución que asigne dígitos adicionales a los campos anteriores a una que los asigne a los campos posteriores, siempre que los datos sigan siendo coherentes. Por ejemplo:

QTime time = QTime::fromString("00:710", "hh:ms"); // 7 mins, 10 secs after midnight

Cualquier campo que no esté representado en el formato se establecerá en cero. Por ejemplo:

QTime time = QTime::fromString("1.30", "m.s");
// time is 00:01:30.000

Nota: Si se desea reconocer formas localizadas de «am» o «pm» (los formatos AP, ap, Ap, aP, A o a), utilice QLocale::system().toTime().

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 copias haya de ella, terminando con un residuo que puede ser una expresión más corta. Así, 'HHHHH' coincidiría con "08088" o "080808" y establecería la hora en las 8; si la cadena de hora contuviera «070809», «coincidiría» pero produciría un resultado incoherente, lo que daría lugar a una hora no válida.

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

[static, since 6.0] QTime QTime::fromString(QStringView string, QStringView format)

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

Esta función se introdujo en Qt 6.0.

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

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

Esta función se introdujo en Qt 6.0.

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

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

Esta función se introdujo en Qt 6.0.

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

Devuelve la hora representada en el objeto ` string ` como un objeto ` QTime ` utilizando el objeto ` format ` proporcionado; si esto no es posible, devuelve una hora no válida.

Esta es una función sobrecargada.

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

int QTime::hour() const

Devuelve la parte correspondiente a la hora (de 0 a 23) de la hora.

Devuelve -1 si la hora no es válida.

Véase también minute(), second() y msec().

[constexpr] bool QTime::isNull() const

Devuelve « true » si la hora es nula (es decir, si el objeto ` QTime ` se ha creado mediante el constructor por defecto); en caso contrario, devuelve «false». Una hora nula también se considera una hora no válida.

Véase también isValid().

bool QTime::isValid() const

Devuelve « true » si la hora es válida; en caso contrario, devuelve « false ». Por ejemplo, la hora 23:30:55,746 es válida, pero 24:12:30 no lo es.

Véase también isNull().

[static] bool QTime::isValid(int h, int m, int s, int ms = 0)

Devuelve « true » si la hora especificada es válida; en caso contrario, devuelve «false».

La hora es válida si h está comprendida entre 0 y 23, m y s están comprendidas entre 0 y 59, y ms está comprendida entre 0 y 999.

Ejemplo:

QTime::isValid(21, 10, 30); // returns true
QTime::isValid(22, 5,  62); // returns false

Esta función sobrecarga ` QTime::isValid()`.

int QTime::minute() const

Devuelve la parte correspondiente a los minutos (de 0 a 59) de la hora.

Devuelve -1 si la hora no es válida.

Véase también hour(), second() y msec().

int QTime::msec() const

Devuelve la parte correspondiente a los milisegundos (de 0 a 999) de la hora.

Devuelve -1 si la hora no es válida.

Véase también hour(), minute() y second().

[constexpr] int QTime::msecsSinceStartOfDay() const

Devuelve el número de milisegundos transcurridos desde el inicio del día, es decir, desde las 00:00:00.

Véase también fromMSecsSinceStartOfDay().

int QTime::msecsTo(QTime t) const

Devuelve el número de milisegundos que transcurren desde esta hora hasta t. Si t es anterior a esta hora, el número de milisegundos devuelto es negativo.

Dado que QTime mide el tiempo dentro de un día y hay 86 400 segundos en un día, el resultado siempre está comprendido entre -86 400 000 y 86 400 000 ms.

Devuelve 0 si alguna de las horas no es válida.

Véase también secsTo(), addMSecs() y QDateTime::msecsTo().

int QTime::second() const

Devuelve la segunda parte (de 0 a 59) de la hora.

Devuelve -1 si la hora no es válida.

Véase también hour(), minute() y msec().

int QTime::secsTo(QTime t) const

Devuelve el número de segundos que hay entre esta hora y t. Si t es anterior a esta hora, el número de segundos devuelto es negativo.

Dado que QTime mide el tiempo dentro de un día y hay 86 400 segundos en un día, el resultado siempre está comprendido entre -86 400 y 86 400.

La función `secsTo()` no tiene en cuenta los milisegundos.

Devuelve 0 si alguna de las horas no es válida.

Véase también addSecs() y QDateTime::secsTo().

bool QTime::setHMS(int h, int m, int s, int ms = 0)

Establece la hora en « h », los minutos en « m », los segundos en « s » y los milisegundos en « ms ».

h debe estar comprendido entre 0 y 23, m y s deben estar comprendidos entre 0 y 59, y ms debe estar comprendido entre 0 y 999. Devuelve true si la hora establecida es válida; en caso contrario, devuelve false.

Véase también isValid().

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

QString QTime::toString(QStringView format) const

Devuelve una cadena que representa la hora.

El parámetro « format » determina el formato de la cadena resultante. Si la hora no es válida, se devolverá una cadena vacía.

Se pueden utilizar las siguientes expresiones:

ExpresiónSalida
hLa hora sin el cero inicial (del 0 al 23 o del 1 al 12 si se muestra en formato AM/PM)
hhLa hora con un cero inicial (del 00 al 23 o del 01 al 12 si se muestra AM/PM)
HLa hora sin el cero inicial (del 0 al 23, incluso con visualización AM/PM)
HHLa hora con un cero inicial (de 00 a 23, incluso con indicación de AM/PM)
mLos minutos sin el cero inicial (del 0 al 59)
mmEl minuto con un cero delante (de 00 a 59)
sEl segundo completo, sin ceros iniciales (de 0 a 59)
ssEl segundo completo, con un cero inicial cuando proceda (de 00 a 59)
z o zzLa parte fraccionaria del segundo, que va después del punto decimal, sin ceros a la derecha. Así, « "s.z" » devuelve los segundos con la máxima precisión disponible (en milisegundos) sin ceros a la derecha (de 0 a 999). Por ejemplo, « "s.z" » daría como resultado « "0.25" » para un tiempo de un cuarto de segundo dentro de un minuto.
zzzLa parte fraccionaria del segundo, con precisión de milisegundos, incluyendo ceros finales cuando proceda (de 000 a 999). Por ejemplo, "ss.zzz" generaría "00.250" para un tiempo de un cuarto de segundo dentro de un minuto.
AP o AUtiliza el formato AM/PM. A/AP se sustituirá por «AM» o «PM». En las versiones localizadas (solo relevante para QLocale::toString()), el texto adecuado para la configuración regional se convierte a mayúsculas.
ap o aUtiliza el formato am/pm. « a/ap » se sustituirá por «am» o «pm». En las versiones localizadas (solo relevante para QLocale::toString()), el texto correspondiente a la configuración regional se convierte a minúsculas.
aP o ApUtiliza el formato AM/PM (desde la versión 6.3). aP/Ap se sustituirá por «AM» o «PM». En los formularios localizados (solo relevante para QLocale::toString()), se utiliza el texto adecuado para la configuración regional (devuelto por QLocale::amText() o QLocale::pmText()) sin cambiar las mayúsculas y minúsculas.
tLa abreviatura de la zona horaria (por ejemplo, «CEST»). Ten en cuenta que las abreviaturas de las zonas horarias no son únicas. En concreto, fromString() no puede analizar esto.
ttLa diferencia horaria respecto al UTC, sin dos puntos entre las horas y los minutos (por ejemplo, «+0200»).
tttLa diferencia horaria con respecto al UTC, con dos puntos entre las horas y los minutos (por ejemplo, «+02:00»).
ttttEl nombre de la zona horaria, tal y como lo proporciona la función ` QTimeZone::displayName()` con el tipo ` QTimeZone::LongName `. Esto puede depender del sistema operativo que se utilice. Si no se dispone de dicho nombre, se puede utilizar el identificador IANA de la zona (como «Europe/Berlin»). Es posible que no indique si la fecha y hora correspondían al horario de verano o al horario estándar, lo que puede dar lugar a ambigüedad si la fecha y hora se sitúan en una hora que se repite debido a una transición entre ambos.

Nota: Para obtener formas localizadas de AM o PM (los formatos AP, ap, A, a, aP o Ap ) o de representaciones de zonas horarias (los formatos t ), utilice QLocale::system().toString().

Cuando no se pueda determinar la zona horaria o no haya disponible ninguna representación adecuada de la misma, se pueden omitir los formularios t para representarla. Consulte QTimeZone::displayName() para obtener más detalles sobre cuándo devuelve una cadena vacía.

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., «hhmm»), pero deben utilizarse con precaución, ya que las cadenas resultantes no siempre son legibles de forma fiable (p. ej., si «Hm» produce «212», podría significar tanto 02:12 como 21:02).

Ejemplos de cadenas de formato (suponiendo que el QTime sea 14:13:09.042)

FormatoResultado
hh:mm:ss.zzz14:13:09.042
h:m:s ap2:13:9 p. m.
H:m:s a14:13:9 p. m.

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 leerá 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í, « 'HHHHH' » para la hora 08:00 contribuirá con « "08088" » a la salida.

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

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

Devuelve la hora como una cadena de caracteres. El parámetro format determina el formato de la cadena.

Si format es Qt::TextDate, el formato de la cadena es HH:mm:ss; por ejemplo, 1 segundo antes de la medianoche sería «23:59:59».

Si 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, expresada como HH:mm:ss. Para incluir milisegundos en la fecha ISO 8601, utiliza el format Qt::ISODateWithMs , que corresponde a HH:mm:ss.zzz.

Si el parámetro « format » es « Qt::RFC2822Date », la cadena se formatea de acuerdo con el estándar RFC 2822. Un ejemplo de este formato es «23:59:20».

Si la hora no es válida, se devolverá una cadena vacía.

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

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

Elementos no miembros relacionados

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

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

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

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

QDataStream &operator<<(QDataStream &out, QTime time)

Escribe en time para ver la retransmisión en out.

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

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

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

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

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

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

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

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

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

QDataStream &operator>>(QDataStream &in, QTime &time)

Lee un valor de tiempo del flujo « in » y lo almacena en el objeto « time » indicado.

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.