QObject Class
La clase QObject es la clase base de todos los objetos de Qt. Más información...
Nota: Todas las funciones de esta clase son reentrantes.
Nota: Estas funciones también son seguras para subprocesos:
- connect(const QObject *sender, const char *signal, const QObject *receiver, const char *method, Qt::ConnectionType type)
- connect(const QObject *sender, const char *signal, const char *method, Qt::ConnectionType type) const
- connect(const QObject *sender, PointerToMemberFunction signal, const QObject *receiver, PointerToMemberFunction method, Qt::ConnectionType type)
- connect(const QObject *sender, PointerToMemberFunction signal, Functor functor)
- connect(const QObject *emisor, PointerToMemberFunction señal, const QObject *contexto, Functor functor, Qt::ConnectionType tipo)
- disconnect(const QObject *emisor, const char *señal, const QObject *receptor, const char *método)
- disconnect(const char *señal, const QObject *receptor, const char *método) const
- disconnect(const QObject *sender, PointerToMemberFunction signal, const QObject *receiver, PointerToMemberFunction method)
- deleteLater()
Propiedades
- objectName : QString
Funciones públicas
| QObject(QObject *parent = nullptr) | |
| virtual | ~QObject() |
| QBindable<QString> | bindableObjectName() |
| bool | blockSignals(bool block) |
| const QObjectList & | children() const |
| QMetaObject::Connection | connect(const QObject *sender, const char *signal, const char *method, Qt::ConnectionType type = Qt::AutoConnection) const |
| bool | disconnect(const QObject *receiver, const char *method = nullptr) const |
| bool | disconnect(const char *signal = nullptr, const QObject *receiver = nullptr, const char *method = nullptr) const |
| void | dumpObjectInfo() const |
| void | dumpObjectTree() const |
| QList<QByteArray> | dynamicPropertyNames() const |
| virtual bool | event(QEvent *e) |
| virtual bool | eventFilter(QObject *watched, QEvent *event) |
| T | findChild(QAnyStringView name, Qt::FindChildOptions options = Qt::FindChildrenRecursively) const |
(since 6.7) T | findChild(Qt::FindChildOptions options = Qt::FindChildrenRecursively) const |
| QList<T> | findChildren(QAnyStringView name, Qt::FindChildOptions options = Qt::FindChildrenRecursively) const |
(since 6.3) QList<T> | findChildren(Qt::FindChildOptions options = Qt::FindChildrenRecursively) const |
| QList<T> | findChildren(const QRegularExpression &re, Qt::FindChildOptions options = Qt::FindChildrenRecursively) const |
| bool | inherits(const char *className) const |
| void | installEventFilter(QObject *filterObj) |
(since 6.11) bool | isQmlExposed() const |
(since 6.4) bool | isQuickItemType() const |
| bool | isWidgetType() const |
| bool | isWindowType() const |
| void | killTimer(int id) |
(since 6.8) void | killTimer(Qt::TimerId id) |
| virtual const QMetaObject * | metaObject() const |
| bool | moveToThread(QThread *targetThread) |
| QString | objectName() const |
| QObject * | parent() const |
| QVariant | property(const char *name) const |
| void | removeEventFilter(QObject *obj) |
| void | setObjectName(const QString &name) |
(since 6.4) void | setObjectName(QAnyStringView name) |
| void | setParent(QObject *parent) |
| bool | setProperty(const char *name, const QVariant &value) |
(since 6.6) bool | setProperty(const char *name, QVariant &&value) |
| bool | signalsBlocked() const |
| int | startTimer(int interval, Qt::TimerType timerType = Qt::CoarseTimer) |
| int | startTimer(std::chrono::nanoseconds interval, Qt::TimerType timerType = Qt::CoarseTimer) |
| QThread * | thread() const |
Ranuras públicas
| void | deleteLater() |
Señales
| void | destroyed(QObject *obj = nullptr) |
| void | objectNameChanged(const QString &objectName) |
Miembros públicos estáticos
| QMetaObject::Connection | connect(const QObject *sender, const QMetaMethod &signal, const QObject *receiver, const QMetaMethod &method, Qt::ConnectionType type = Qt::AutoConnection) |
| QMetaObject::Connection | connect(const QObject *sender, const char *signal, const QObject *receiver, const char *method, Qt::ConnectionType type = Qt::AutoConnection) |
| QMetaObject::Connection | connect(const QObject *sender, PointerToMemberFunction signal, Functor functor) |
| QMetaObject::Connection | connect(const QObject *sender, PointerToMemberFunction signal, const QObject *context, Functor functor, Qt::ConnectionType type = Qt::AutoConnection) |
| QMetaObject::Connection | connect(const QObject *sender, PointerToMemberFunction signal, const QObject *receiver, PointerToMemberFunction method, Qt::ConnectionType type = Qt::AutoConnection) |
(since 6.12) bool | disconnect(QMetaObject::Connection &connection) |
(since 6.12) bool | disconnect(QMetaObject::Connection &&connection) |
| bool | disconnect(const QMetaObject::Connection &connection) |
| bool | disconnect(const QObject *sender, const QMetaMethod &signal, const QObject *receiver, const QMetaMethod &method) |
| bool | disconnect(const QObject *sender, const char *signal, const QObject *receiver, const char *method) |
| bool | disconnect(const QObject *sender, PointerToMemberFunction signal, const QObject *receiver, PointerToMemberFunction method) |
| const QMetaObject | staticMetaObject |
| QString | tr(const char *sourceText, const char *disambiguation = nullptr, int n = -1) |
Funciones protegidas
| virtual void | childEvent(QChildEvent *event) |
| virtual void | connectNotify(const QMetaMethod &signal) |
| virtual void | customEvent(QEvent *event) |
| virtual void | disconnectNotify(const QMetaMethod &signal) |
| bool | isSignalConnected(const QMetaMethod &signal) const |
| int | receivers(const char *signal) const |
| QObject * | sender() const |
| int | senderSignalIndex() const |
| virtual void | timerEvent(QTimerEvent *event) |
Personas no afiliadas relacionadas
| QObjectList | |
(since 6.8) enum class | TimerId { Invalid } |
| T | qobject_cast(QObject *object) |
| T | qobject_cast(const QObject *object) |
Macros
(since 6.7) | QT_NO_CONTEXTLESS_CONNECT |
(since 6.12) | QT_NO_DISCONNECT_CONST_CONNECTION |
| QT_NO_NARROWING_CONVERSIONS_IN_CONNECT | |
| Q_CLASSINFO(Name, Value) | |
| Q_EMIT | |
| Q_ENUM(...) | |
| Q_ENUM_NS(...) | |
| Q_FLAG(...) | |
| Q_FLAG_NS(...) | |
| Q_GADGET | |
(since 6.3) | Q_GADGET_EXPORT(EXPORT_MACRO) |
| Q_INTERFACES(...) | |
| Q_INVOKABLE | |
(since 6.0) | Q_MOC_INCLUDE |
| Q_NAMESPACE | |
| Q_NAMESPACE_EXPORT(EXPORT_MACRO) | |
| Q_OBJECT | |
| Q_PROPERTY(...) | |
| Q_REVISION | |
| Q_SET_OBJECT_NAME(Object) | |
| Q_SIGNAL | |
| Q_SIGNALS | |
| Q_SLOT | |
| Q_SLOTS |
Descripción detallada
QObject es el núcleo del modelo de objetos de Qt. La característica principal de este modelo es un mecanismo muy potente para la comunicación fluida entre objetos, denominado «señales y ranuras». Se puede conectar una señal a una ranura mediante ` connect()` y romper la conexión con ` disconnect()`. Para evitar bucles de notificación interminables, se pueden bloquear temporalmente las señales con ` blockSignals()`. Las funciones protegidas ` connectNotify()` y ` disconnectNotify()` permiten realizar un seguimiento de las conexiones.
Los QObjects se organizan en árboles de objetos. Cuando se crea un QObject con otro objeto como padre, el objeto se añade automáticamente a la lista children() del padre. El padre asume la propiedad del objeto; es decir, eliminará automáticamente a sus hijos en su destructor. Se puede buscar un objeto por nombre y, opcionalmente, por tipo utilizando findChild() o findChildren().
Cada objeto tiene un método ` objectName()` y su nombre de clase se puede obtener mediante el correspondiente ` metaObject()` (véase ` QMetaObject::className()`). Se puede determinar si la clase del objeto hereda de otra clase en la jerarquía de herencia de `QObject` utilizando la función ` inherits()`.
Cuando se elimina un objeto, este emite una señal ` destroyed()`. Se puede capturar esta señal para evitar referencias colgantes a objetos `QObject`.
Los QObjects pueden recibir eventos a través de ` event()` y filtrar los eventos de otros objetos. Consulte ` installEventFilter()` y ` eventFilter()` para obtener más detalles. Se puede reimplementar un controlador de conveniencia, ` childEvent()`, para capturar eventos de los objetos hijos.
Por último, pero no por ello menos importante, QObject proporciona el soporte básico para temporizadores en Qt; consulta QChronoTimer para obtener información sobre el soporte de alto nivel para temporizadores.
Ten en cuenta que la macro Q_OBJECT es obligatoria para cualquier objeto que implemente señales, ranuras o propiedades. También es necesario ejecutar el Meta-Object Compiler sobre el archivo fuente. Recomendamos encarecidamente el uso de esta macro en todas las subclases de QObject, independientemente de si utilizan o no señales, ranuras y propiedades, ya que, de no hacerlo, algunas funciones podrían mostrar un comportamiento anómalo.
Todos los widgets de Qt heredan de QObject. La función de conveniencia isWidgetType() devuelve si un objeto es realmente un widget. Es mucho más rápida que qobject_cast<QWidget *>(obj) u obj->inherits(«QWidget »).
Algunas funciones de QObject, por ejemplo, children(), devuelven un QObjectList. QObjectList es un typedef para QList<QObject *>.
Afinidad de subprocesos
Se dice que una instancia de QObject tiene afinidad de hilo, o que reside en un hilo determinado. Cuando un QObject recibe un queued signal o un evento publicado, el slot o el controlador de eventos se ejecutará en el hilo en el que reside el objeto.
Nota: Si un QObject no tiene afinidad de hilo (es decir, si thread() devuelve cero), o si reside en un hilo que no tiene ningún bucle de eventos en ejecución, entonces no puede recibir señales en cola ni eventos publicados.
Por defecto, un QObject reside en el hilo en el que se crea. La afinidad de hilo de un objeto se puede consultar mediante thread() y modificarse mediante moveToThread().
Todos los QObjects deben residir en el mismo hilo que su padre. Por consiguiente:
- setParent() fallará si los dos QObjects implicados residen en hilos diferentes.
- Cuando un QObject se traslada a otro hilo, todos sus hijos se trasladarán automáticamente también.
- moveToThread() fallará si el QObject tiene un padre.
- Si los QObjects se crean dentro de ` QThread::run()`, no pueden convertirse en hijos del objeto ` QThread `, ya que ` QThread ` no se encuentra en el hilo que llama a ` QThread::run()`.
Nota: Las variables miembrode un QObject no se convierten automáticamente en sus hijos. La relación padre-hijo debe establecerse bien pasando un puntero a la función constructor del hijo, bien llamando a setParent(). Sin este paso, las variables miembro del objeto permanecerán en el hilo anterior cuando se llame a moveToThread().
Sin constructor de copia ni operador de asignación
QObject no tiene ni constructor de copia ni operador de asignación. Esto es a propósito. En realidad, están declarados, pero en una sección « private » con la macro « Q_DISABLE_COPY()». De hecho, todas las clases de Qt derivadas de QObject (directa o indirectamente) utilizan esta macro para declarar como privados su constructor de copia y su operador de asignación. El razonamiento se explica en el apartado «Identidad frente a valor » de la página «Modelo de objetos de Qt».
La principal consecuencia es que debes utilizar punteros a QObject (o a tu subclase de QObject) en aquellos casos en los que, de otro modo, podrías sentirte tentado a utilizar tu subclase de QObject como un valor. Por ejemplo, sin un constructor de copia, no puedes utilizar una subclase de QObject como valor para almacenarlo en una de las clases contenedor. Debes almacenar punteros.
Conexión automática
El sistema de metaobjetos de Qt proporciona un mecanismo para conectar automáticamente señales y ranuras entre subclases de QObject y sus descendientes. Siempre que los objetos se definan con nombres adecuados y las ranuras sigan una convención de nomenclatura sencilla, esta conexión puede realizarse en tiempo de ejecución mediante la función QMetaObject::connectSlotsByName().
uic genera código que invoca esta función para permitir que se realice la conexión automática entre los widgets de los formularios creados con Qt Widgets Designer. Encontrarás más información sobre el uso de la conexión automática con Qt Widgets Designer se ofrece en la sección «Uso de un archivo UI de Qt Widgets Designer en su aplicación» del Qt Widgets Designer manual.
Propiedades dinámicas
Las propiedades dinámicas se pueden añadir y eliminar de las instancias de QObject en tiempo de ejecución. No es necesario declararlas en tiempo de compilación, pero ofrecen las mismas ventajas que las propiedades estáticas y se manipulan mediante la misma API: se utiliza property() para leerlas y setProperty() para escribirlas.
Las propiedades dinámicas son compatibles con Qt Widgets Designer, y tanto los Qt Widgets estándar como los formularios creados por el usuario pueden dotarse de propiedades dinámicas.
Internacionalización (I18n)
Todas las subclases de QObject son compatibles con las funciones de traducción de Qt, lo que permite traducir la interfaz de usuario de una aplicación a diferentes idiomas.
Para que el texto visible para el usuario sea traducible, debe incluirse entre llamadas a la función tr(). Esto se explica con detalle en el documento «Escritura de código fuente para la traducción ».
Véase también QMetaObject, QPointer, QObjectCleanupHandler, Q_DISABLE_COPY() y «Árboles de objetos y propiedad».
Documentación sobre propiedades
[bindable] objectName : QString
Nota: Esta propiedad admite enlaces de tipo « QProperty ».
Esta propiedad contiene el nombre de este objeto
Puedes buscar un objeto por su nombre (y tipo) utilizando findChild(). Puedes buscar un conjunto de objetos con findChildren().
qDebug("MyClass::setPrecision(): (%s) precisión no válida %f",
qPrintable(objectName()), newPrecision);Por defecto, esta propiedad contiene una cadena vacía.
Funciones de acceso:
| QString | objectName() const |
| void | setObjectName(const QString &name) |
| void | setObjectName(QAnyStringView name) |
Señal de notificador:
| void | objectNameChanged(const QString &objectName) | [see note below] |
Nota: Se trata de una señal privada. Se puede utilizar en conexiones de señales, pero el usuario no puede emitirla.
Véase también metaObject() y QMetaObject::className().
Documentación de funciones miembro
[explicit invokable] QObject::QObject(QObject *parent = nullptr)
Crea un objeto cuyo objeto padre es parent.
El objeto padre de un objeto puede considerarse como el propietario de este. Por ejemplo, un dialog box es el objeto padre de los botones OK y Cancel que contiene.
El destructor de un objeto padre destruye todos los objetos hijos.
Al establecer parent en nullptr se crea un objeto sin padre. Si el objeto es un widget, se convertirá en una ventana de nivel superior.
Nota: Esta función se puede invocar a través del sistema de metaobjetos y desde QML. Véase Q_INVOKABLE.
Véase también parent(), findChild() y findChildren().
[virtual noexcept] QObject::~QObject()
Destruye el objeto y elimina todos sus objetos secundarios.
Todas las señales hacia y desde el objeto se desconectan automáticamente, y cualquier evento pendiente para el objeto se elimina de la cola de eventos. Sin embargo, suele ser más seguro utilizar ` deleteLater()` en lugar de eliminar directamente una subclase de ` QObject `.
Advertencia: Se eliminantodos los objetos hijos. Si alguno de estos objetos se encuentra en la pila o es global, tarde o temprano tu programa se bloqueará. No recomendamos mantener punteros a objetos hijos desde fuera del objeto padre. Si aún así lo haces, la señal ` destroyed()` te ofrece la oportunidad de detectar cuándo se destruye un objeto.
Advertencia: Eliminar un ` QObject ` mientras está gestionando un evento que se le ha entregado puede provocar un fallo del sistema. No debes eliminar el ` QObject ` directamente si se encuentra en un hilo distinto al que se está ejecutando actualmente. Utiliza en su lugar ` deleteLater()`, lo que hará que el bucle de eventos elimine el objeto una vez que se le hayan entregado todos los eventos pendientes.
Véase también deleteLater().
[noexcept] bool QObject::blockSignals(bool block)
Si ` block ` es verdadero, se bloquean las señales emitidas por este objeto (es decir, la emisión de una señal no activará nada que esté conectado a ella). Si ` block ` es falso, no se producirá dicho bloqueo.
El valor de retorno es el valor anterior de signalsBlocked().
Ten en cuenta que la señal destroyed() se emitirá incluso si se han bloqueado las señales de este objeto.
Las señales emitidas mientras se está bloqueado no se almacenan en el búfer.
Véanse también signalsBlocked() y QSignalBlocker.
[virtual protected] void QObject::childEvent(QChildEvent *event)
Este controlador de eventos puede reimplementarse en una subclase para recibir eventos de los elementos secundarios. El evento se pasa en el parámetro « event ».
QEvent::ChildAdded Los eventos ` QEvent::ChildRemoved ` se envían a los objetos cuando se añaden o se eliminan elementos secundarios. En ambos casos, solo se puede dar por hecho que el elemento secundario es un ` QObject`, o, si ` isWidgetType()` devuelve ` true`, un ` QWidget`. (Esto se debe a que, en el caso de ` ChildAdded `, el elemento secundario aún no está completamente construido, y en el caso de ` ChildRemoved `, es posible que ya haya sido destruido).
QEvent::ChildPolished Los eventos se envían a los widgets cuando se pulen los hijos o cuando se añaden hijos pulidos. Si recibes un evento de hijo pulido, la construcción del hijo suele estar completada. Sin embargo, esto no está garantizado, y pueden entregarse múltiples eventos de pulido durante la ejecución del constructor de un widget.
Por cada widget hijo, recibirás un evento « ChildAdded », cero o más eventos « ChildPolished » y un evento « ChildRemoved ».
El evento « ChildPolished » se omite si un widget hijo se elimina inmediatamente después de añadirse. Si un widget hijo se pulimenta varias veces durante su construcción y destrucción, es posible que reciba varios eventos «child polished» para el mismo widget hijo, cada vez con una tabla virtual diferente.
Véase también event().
const QObjectList &QObject::children() const
Devuelve una lista de objetos hijos. La clase ` QObjectList ` se define en el archivo de cabecera ` <QObject> ` de la siguiente manera:
typedef QList<QObject*> QObjectList;El primer hijo añadido es el objeto ` first ` de la lista y el último hijo añadido es el objeto ` last ` de la lista; es decir, los nuevos hijos se añaden al final.
Ten en cuenta que el orden de la lista cambia cuando los elementos secundarios de ` QWidget ` son ` raised ` o ` lowered`. Un widget que se eleva pasa a ser el último objeto de la lista, y un widget que se baja pasa a ser el primer objeto de la lista.
Véanse también findChild(), findChildren(), parent() y setParent().
[static] QMetaObject::Connection QObject::connect(const QObject *sender, const QMetaMethod &signal, const QObject *receiver, const QMetaMethod &method, Qt::ConnectionType type = Qt::AutoConnection)
Crea una conexión entre el objeto ` type ` especificado, procedente del objeto ` signal ` del objeto ` sender `, y el objeto ` method ` del objeto ` receiver `. Devuelve un identificador de la conexión que se puede utilizar para desconectarla más adelante.
El identificador de conexión no será válido si no se puede establecer la conexión, por ejemplo, si los parámetros no son válidos. Se puede comprobar si el objeto QMetaObject::Connection es válido convirtiéndolo a un valor booleano.
Esta función funciona de la misma manera que connect(const QObject *sender, const char *signal, const QObject *receiver, const char *method, Qt::ConnectionType type), pero utiliza QMetaMethod para especificar la señal y el método.
Véase también connect(const QObject *sender, const char *signal, const QObject *receiver, const char *method, Qt::ConnectionType type).
[static] QMetaObject::Connection QObject::connect(const QObject *sender, const char *signal, const QObject *receiver, const char *method, Qt::ConnectionType type = Qt::AutoConnection)
Crea una conexión entre el type especificado, procedente del signal del objeto sender, y el method del objeto receiver. Devuelve un identificador de la conexión que puede utilizarse para desconectarla más adelante.
Debes utilizar las macros SIGNAL() y SLOT() al especificar signal y method, por ejemplo:
QLabel *label = new QLabel;
QScrollBar *scrollBar = new QScrollBar;
QObject::connect(scrollBar, SIGNAL(valueChanged(int)),
label, SLOT(setNum(int)));Este ejemplo garantiza que la etiqueta muestre siempre el valor actual de la barra de desplazamiento. Ten en cuenta que los parámetros de señales y ranuras no deben contener nombres de variables, sino únicamente el tipo. Por ejemplo, lo siguiente no funcionaría y devolvería «false»:
// WRONG
QObject::connect(scrollBar, SIGNAL(valueChanged(int value)),
label, SLOT(setNum(int value)));Una señal también se puede conectar a otra señal:
class MyWidget : public QWidget
{
Q_OBJECT
public:
MyWidget();
signals:
void buttonClicked();
private:
QPushButton *myButton;
};
MyWidget::MyWidget()
{
myButton = new QPushButton(this);
connect(myButton, SIGNAL(clicked()),
this, SIGNAL(buttonClicked()));
}En este ejemplo, el constructor MyWidget transmite una señal desde una variable miembro privada y la pone a disposición con un nombre relacionado con MyWidget.
Una señal puede conectarse a muchas ranuras y señales. Se pueden conectar muchas señales a una misma ranura.
Si una señal está conectada a varias ranuras, estas se activan en el mismo orden en que se realizaron las conexiones, cuando se emite la señal.
La función devuelve un ` QMetaObject::Connection ` que representa un identificador de conexión si conecta correctamente la señal al slot. El identificador de conexión no será válido si no se puede establecer la conexión; por ejemplo, si ` QObject ` no puede verificar la existencia de ` signal ` o ` method`, o si sus firmas no son compatibles. Puedes comprobar si el identificador es válido convirtiéndolo a un tipo `bool`.
Por defecto, se emite una señal por cada conexión que se establezca; se emiten dos señales en caso de conexiones duplicadas. Puedes interrumpir todas estas conexiones con una sola llamada a ` disconnect()`. Si pasas el ` Qt::UniqueConnection ` ` type`, la conexión solo se establecerá si no es un duplicado. Si ya existe un duplicado (la misma señal exacta a la misma ranura exacta en los mismos objetos), la conexión fallará y `connect` devolverá un ` QMetaObject::Connection` no válido.
Nota: Las conexiones únicas (Qt ::UniqueConnections) no funcionan con lambda, funciones que no son de miembro ni functores; solo se aplican a la conexión con funciones de miembro.
El parámetro opcional ` type ` describe el tipo de conexión que se va a establecer. En concreto, determina si una señal concreta se envía a una ranura de forma inmediata o si se pone en cola para su envío más adelante. Si la señal se pone en cola, los parámetros deben ser de tipos conocidos por el sistema de metaobjetos de Qt, ya que Qt necesita copiar los argumentos para almacenarlos en un evento en segundo plano. Si intentas utilizar una conexión en cola y recibes el mensaje de error
QObject::connect: Cannot queue arguments of type 'MyType'
(Make sure 'MyType' is registered using qRegisterMetaType().)llama a qRegisterMetaType() para registrar el tipo de datos antes de establecer la conexión.
Nota: Esta función es segura para subprocesos.
Véase también disconnect(), sender(), qRegisterMetaType(), Q_DECLARE_METATYPE() y Diferencias entre conexiones basadas en cadenas y basadas en functores.
[static] template <typename PointerToMemberFunction, typename Functor> QMetaObject::Connection QObject::connect(const QObject *sender, PointerToMemberFunction signal, Functor functor)
Crea una conexión desde ` signal ` en un objeto ` sender ` hasta ` functor`, y devuelve un identificador de la conexión
La señal debe ser una función declarada como señal en el encabezado. La función de ranura puede ser cualquier función o functor que se pueda conectar a la señal. Una función de ranura se puede conectar a una señal determinada si la señal tiene al menos tantos argumentos como la función de ranura. Debe existir una conversión implícita entre los tipos de los argumentos correspondientes de la señal y la ranura.
Ejemplo:
void someFunction();
//...
void someOtherFunction()
{
QPushButton *button = new QPushButton;
QObject::connect(button, &QPushButton::clicked, someFunction);
}También se pueden utilizar expresiones lambda:
QByteArray page = "...";
QTcpSocket *socket = new QTcpSocket;
socket->connectToHost("qt-project.org", 80);
QObject::connect(socket, &QTcpSocket::connected, [=] () {
socket->write("GET " + page + "\r\n");
});La conexión se desconectará automáticamente si se destruye el emisor. Sin embargo, hay que asegurarse de que cualquier objeto utilizado dentro del functor siga activo cuando se emita la señal.
Por este motivo, se recomienda utilizar la sobrecarga de connect() que también toma un QObject como receptor/contexto. Es posible desactivar el uso de la sobrecarga sin contexto definiendo la macro QT_NO_CONTEXTLESS_CONNECT.
Las funciones sobrecargadas se pueden resolver con la ayuda de ` qOverload`.
Esta función sobrecarga ` QObject::connect()`.
Nota: Esta función es segura para subprocesos.
QMetaObject::Connection QObject::connect(const QObject *sender, const char *signal, const char *method, Qt::ConnectionType type = Qt::AutoConnection) const
Conecta ` signal ` del objeto ` sender ` con ` method` de este objeto.
Equivalente a connect(sender, signal, this, method, type).
Cada conexión que se establece emite una señal, por lo que las conexiones duplicadas emiten dos señales. Se puede romper una conexión utilizando disconnect().
Esta función sobrecarga QObject::connect().
Nota: Esta función es segura para subprocesos.
Véase también ` disconnect()`.
[static] template <typename PointerToMemberFunction, typename Functor> QMetaObject::Connection QObject::connect(const QObject *sender, PointerToMemberFunction signal, const QObject *context, Functor functor, Qt::ConnectionType type = Qt::AutoConnection)
Crea una conexión de un objeto ` type ` determinado, procedente de ` signal ` en ` sender `, a ` functor ` para colocarla en un bucle de eventos específico de ` context`, y devuelve un identificador de la conexión.
Nota: Las conexionesQt ::UniqueConnections no funcionan con lambda, funciones que no son de miembro ni functores; solo se aplican a la conexión con funciones de miembro.
La señal debe ser una función declarada como señal en el encabezado. La función de ranura puede ser cualquier función o functor que se pueda conectar a la señal. Una función de ranura se puede conectar a una señal determinada si la señal tiene al menos tantos argumentos como la función de ranura. Debe existir una conversión implícita entre los tipos de los argumentos correspondientes en la señal y la ranura.
Ejemplo:
void someFunction();
//...
void someOtherFunction()
{
QPushButton *button = new QPushButton;
QObject::connect(button, &QPushButton::clicked, this, someFunction, Qt::QueuedConnection);
}También se pueden utilizar expresiones lambda:
QByteArray page = "...";
QTcpSocket *socket = new QTcpSocket;
socket->connectToHost("qt-project.org", 80);
QObject::connect(socket, &QTcpSocket::connected, this, [=] () {
socket->write("GET " + page + "\r\n");
}, Qt::AutoConnection);La conexión se desconectará automáticamente si se destruye el emisor o el contexto. Sin embargo, debes asegurarte de que cualquier objeto utilizado dentro del functor siga activo cuando se emita la señal.
Las funciones sobrecargadas pueden resolverse con la ayuda de ` qOverload`.
Esta función sobrecarga QObject::connect().
Nota: Esta función es segura para subprocesos.
[static] template <typename PointerToMemberFunction> QMetaObject::Connection QObject::connect(const QObject *sender, PointerToMemberFunction signal, const QObject *receiver, PointerToMemberFunction method, Qt::ConnectionType type = Qt::AutoConnection)
Crea una conexión entre la señal « type » especificada, procedente de la « signal » del objeto « sender », y la « method » del objeto « receiver ». Devuelve un identificador de la conexión que se puede utilizar para desconectarla posteriormente.
La señal debe ser una función declarada como señal en el encabezado. La función de ranura puede ser cualquier función miembro que se pueda conectar a la señal. Una ranura se puede conectar a una señal determinada si la señal tiene al menos tantos argumentos como la ranura y existe una conversión implícita entre los tipos de los argumentos correspondientes en la señal y en la ranura.
Ejemplo:
QLabel *label = new QLabel;
QLineEdit *lineEdit = new QLineEdit;
QObject::connect(lineEdit, &QLineEdit::textChanged,
label, &QLabel::setText);Este ejemplo garantiza que la etiqueta muestre siempre el texto actual del campo de edición de línea.
Una señal puede conectarse a muchas ranuras y señales. Se pueden conectar muchas señales a una misma ranura.
Si una señal está conectada a varias ranuras, estas se activan en el mismo orden en que se realizó la conexión, cuando se emite la señal
La función devuelve un identificador de conexión si conecta correctamente la señal al slot. El identificador de conexión no será válido si no puede crear la conexión; por ejemplo, si QObject no puede verificar la existencia de signal (si no se ha declarado como señal). Puedes comprobar si QMetaObject::Connection es válido convirtiéndolo a un valor booleano.
Por defecto, se emite una señal por cada conexión que se establezca; se emiten dos señales en caso de conexiones duplicadas. Se pueden interrumpir todas estas conexiones con una sola llamada a ` disconnect()`. Si se pasa el Qt::UniqueConnection type , la conexión solo se establecerá si no es un duplicado. Si ya existe un duplicado (la misma señal exactamente en el mismo slot de los mismos objetos), la conexión fallará y connect devolverá un QMetaObject::Connection no válido.
El parámetro opcional type describe el tipo de conexión que se va a establecer. En concreto, determina si una señal concreta se entrega a una ranura de forma inmediata o si se pone en cola para su entrega en un momento posterior. Si la señal se pone en cola, los parámetros deben ser de tipos conocidos por el sistema de metaobjetos de Qt, ya que Qt necesita copiar los argumentos para almacenarlos en un evento en segundo plano. Si intentas utilizar una conexión en cola y recibes el mensaje de error
QObject::connect: Cannot queue arguments of type 'MyType'
(Make sure 'MyType' is registered using qRegisterMetaType().)asegúrate de declarar el tipo de argumento con Q_DECLARE_METATYPE
Las funciones sobrecargadas se pueden resolver con la ayuda de qOverload.
Esta función sobrecarga QObject::connect().
Nota: Esta función es segura para subprocesos.
Véase también Diferencias entre conexiones basadas en cadenas y basadas en functores.
[virtual protected] void QObject::connectNotify(const QMetaMethod &signal)
Esta función virtual se invoca cuando se ha conectado algo a « signal » en este objeto.
Si quieres comparar « signal » con una señal específica, puedes utilizar « QMetaMethod::fromSignal()» de la siguiente manera:
if (signal == QMetaMethod::fromSignal(&MyObject::valueChanged)) {
// signal is valueChanged
}Advertencia: Esta función incumple el principio de modularidad de la programación orientada a objetos. Sin embargo, puede resultar útil cuando sea necesario realizar una operación costosa solo si hay algo conectado a una señal.
Advertencia: Esta función se invoca desde el hilo que realiza la conexión, que puede ser un hilo diferente al hilo en el que reside este objeto. Esta función también puede invocarse con un mutex interno de ` QObject ` bloqueado. Por lo tanto, no está permitido volver a entrar en ninguna de las funciones de ` QObject `, incluida ` isSignalConnected()`, desde tu reimplementación. Si bloquea un mutex en su reimplementación, asegúrese de no llamar a funciones de QObject con ese mutex bloqueado en otros lugares, ya que se produciría un interbloqueo.
Véase también connect() y disconnectNotify().
[virtual protected] void QObject::customEvent(QEvent *event)
Este controlador de eventos se puede reimplementar en una subclase para recibir eventos personalizados. Los eventos personalizados son eventos definidos por el usuario cuyo valor de tipo es al menos tan grande como el elemento QEvent::User de la enumeración QEvent::Type, y suelen ser una subclase de QEvent. El evento se pasa en el parámetro event.
Véase también event() y QEvent.
[slot] void QObject::deleteLater()
Programa la eliminación de este objeto.
El objeto se eliminará cuando el control vuelva al bucle de eventos. Si el bucle de eventos no se está ejecutando cuando se llama a esta función (por ejemplo, si se llama a `deleteLater()` sobre un objeto antes de ` QCoreApplication::exec()`), el objeto se eliminará una vez que se inicie el bucle de eventos. Si se invoca a `deleteLater()` después de que el bucle de eventos principal se haya detenido, el objeto no se eliminará. Si se invoca a `deleteLater()` sobre un objeto que reside en un hilo sin un bucle de eventos en ejecución, el objeto se destruirá cuando finalice el hilo.
Un patrón habitual al utilizar un « QObject » de trabajo en un « QThread » consiste en conectar la señal « finished() » del hilo a la ranura « deleteLater() » del « » de trabajo para garantizar que se elimine de forma segura:
Ten en cuenta que entrar y salir de un nuevo bucle de eventos (por ejemplo, al abrir un cuadro de diálogo modal) no provocará la eliminación diferida; para que el objeto se elimine, el control debe volver al bucle de eventos desde el que se llamó a `deleteLater()`. Esto no se aplica a los objetos eliminados mientras aún se estaba ejecutando un bucle de eventos anidado anterior: el bucle de eventos de Qt eliminará esos objetos tan pronto como comience el nuevo bucle de eventos anidado.
En situaciones en las que Qt no controla el distribuidor de eventos a través de, por ejemplo, ` QCoreApplication::exec()` o ` QEventLoop::exec()`, las eliminaciones diferidas no se procesarán automáticamente. Para garantizar la eliminación diferida en este caso, se puede utilizar la siguiente solución alternativa:
const auto *eventDispatcher = QThread::currentThread()->eventDispatcher();
QObject::connect(eventDispatcher, &QAbstractEventDispatcher::aboutToBlock,
QThread::currentThread(), []{
if (QThread::currentThread()->loopLevel() == 0)
QCoreApplication::sendPostedEvents(nullptr, QEvent::DeferredDelete);
}
);Nota: Esta función es segura para subprocesos.
Véase también destroyed() y QPointer.
[signal] void QObject::destroyed(QObject *obj = nullptr)
Esta señal se emite inmediatamente antes de que se destruya el objeto obj, una vez que se haya notificado a todas las instancias de QPointer, y no se puede bloquear.
Todos los hijos del objeto se destruyen inmediatamente después de que se emita esta señal.
Véase también deleteLater() y QPointer.
[static, since 6.12] bool QObject::disconnect(QMetaObject::Connection &connection)
[static, since 6.12] bool QObject::disconnect(QMetaObject::Connection &&connection)
Desconectar una conexión.
Si connection es invalid o ya se ha desconectado, no haga nada y devuelva false.
Nota: En las versiones de Qt anteriores a la 6.12, esta función solo aceptaba como parámetro ` const-&`.
Estas funciones se introdujeron en Qt 6.12.
Véase también connect().
[static] bool QObject::disconnect(const QMetaObject::Connection &connection)
Desconecta connection y lo restablece a invalid.
Si connection no es válido o ya se ha desconectado, no hace nada y devuelve false.
Nota: Es posible que lasfuturas versiones de Qt solo acepten aquí objetos no const.
Véase también QT_NO_DISCONNECT_CONST_CONNECTION y connect().
[static] bool QObject::disconnect(const QObject *sender, const QMetaMethod &signal, const QObject *receiver, const QMetaMethod &method)
Desconecta signal en el objeto sender de method en el objeto receiver. Devuelve true si la conexión se interrumpe correctamente; en caso contrario, devuelve false.
Esta función ofrece las mismas posibilidades que disconnect(const QObject *sender, const char *signal, const QObject *receiver, const char *method), pero utiliza QMetaMethod para representar la señal y el método que se va a desconectar.
Además, esta función devuelve «false» y no desconecta ninguna señal ni ranura si:
- signal no es un miembro de la clase emisora ni de ninguna de sus clases padre.
- method no es miembro de la clase receptora ni de ninguna de sus clases padre.
- signal la instancia no representa una señal.
Nota: Utiliza la misma sintaxis, ya sea mediante un puntero a una función miembro o basada en cadenas, utilizando las macros SIGNAL y SLOT, en las llamadas a connect() y a la correspondiente disconnect().
Para evitar discrepancias, almacene el identificador de conexión devuelto por connect() y utilícelo en la llamada a disconnect().
Nota: Si se desconecta un ` queued connection `, es posible que los eventos ya programados se sigan entregando, lo que provocaría que se llamara al receptor después de que la conexión se haya desconectado.
Se puede utilizar `QMetaMethod()` como comodín en el sentido de «cualquier señal» o «cualquier ranura en el objeto receptor». Del mismo modo, se puede utilizar ` nullptr ` para ` receiver ` en el sentido de «cualquier objeto receptor». En este caso, el método también debería ser `QMetaMethod()`. El parámetro ` sender ` nunca debería ser ` nullptr`.
Nota: Al desconectar todas las conexiones de señal-ranura, también se desconectará la señal QObject::destroyed() si está conectada. Hacerlo puede afectar negativamente a las clases que dependen de esta señal para liberar recursos. Se recomienda desconectar únicamente las señales específicas que hayan sido conectadas por el código de la aplicación.
Véase también disconnect(const QObject *sender, const char *signal, const QObject *receiver, const char *method).
[static] bool QObject::disconnect(const QObject *sender, const char *signal, const QObject *receiver, const char *method)
Desconecta « signal » en el objeto « sender » de « method » en el objeto « receiver ». Devuelve « true » si la conexión se interrumpe correctamente; en caso contrario, devuelve « false ».
Una conexión de señal-ranura se elimina cuando se destruye cualquiera de los objetos implicados.
La función disconnect() se suele utilizar de tres formas, tal y como muestran los siguientes ejemplos.
- Desconectar todo lo que esté conectado a las señales de un objeto:
QObject::disconnect(myObject, nullptr, nullptr, nullptr);equivalente a la función sobrecargada no estática
myObject->disconnect(); - Desconectar todo lo que esté conectado a una señal específica:
QObject::disconnect(myObject, SIGNAL(mySignal()), nullptr, nullptr);equivalente a la función sobrecargada no estática
myObject->disconnect(SIGNAL(mySignal())); - Desconectar un receptor específico:
QObject::disconnect(myObject, nullptr, myReceiver, nullptr);equivalente a la función sobrecargada no estática
myObject->disconnect(myReceiver);
Nota: Utiliza la misma sintaxis, ya sea mediante un puntero a una función miembro o basada en cadenas utilizando las macros SIGNAL y SLOT, en las llamadas a connect() y a la correspondiente disconnect().
Para evitar discrepancias, almacena el identificador de conexión devuelto por connect() y utilízalo en la llamada a disconnect().
Nota: Si se desconecta un ` queued connection `, es posible que los eventos ya programados se sigan entregando, lo que provocaría que se llamara al receptor después de que la conexión se haya desconectado.
nullptr se puede utilizar como comodín, lo que significa «cualquier señal», «cualquier objeto receptor» o «cualquier ranura del objeto receptor», respectivamente.
sender nunca puede ser nullptr. (No se pueden desconectar señales de más de un objeto en una sola llamada.)
Si signal es nullptr, desconecta receiver y method de cualquier señal. De lo contrario, solo se desconecta la señal especificada.
Si receiver es nullptr, desconecta todo lo que esté conectado a signal. Si no es así, las ranuras de los objetos distintos de receiver no se desconectan.
Si method es nullptr, se desconecta todo lo que esté conectado a receiver. De lo contrario, solo se desconectarán las ranuras denominadas method, y el resto de ranuras permanecerán intactas. El method debe ser nullptr si se omite receiver, por lo que no es posible desconectar una ranura con un nombre específico en todos los objetos.
Nota: Al desconectar todas las conexiones de señal-ranura, también se desconectará la señal QObject::destroyed() si está conectada. Hacerlo puede afectar negativamente a las clases que dependen de esta señal para liberar recursos. Se recomienda desconectar únicamente las señales específicas que hayan sido conectadas por el código de la aplicación.
Nota: Esta función es segura para subprocesos.
Véase también connect().
bool QObject::disconnect(const QObject *receiver, const char *method = nullptr) const
Desconecta todas las señales de este objeto de method en receiver.
Nota: Utiliza la misma sintaxis, ya sea mediante un puntero a una función miembro o basada en cadenas, utilizando las macros SIGNAL y SLOT, tanto en las llamadas a connect() como en las correspondientes a disconnect().
Para evitar discrepancias, almacena el identificador de conexión devuelto por connect() y utilízalo en la llamada a disconnect().
Nota: Si se desconecta un ` queued connection `, es posible que los eventos ya programados se sigan entregando, lo que provocaría que se llamara al receptor después de que la conexión se haya desconectado.
Una conexión de señal-ranura se elimina cuando se destruye cualquiera de los objetos implicados.
Esta función sobrecarga QObject::disconnect().
bool QObject::disconnect(const char *signal = nullptr, const QObject *receiver = nullptr, const char *method = nullptr) const
Desconecta signal de method de receiver.
Nota: Utiliza la misma sintaxis, ya sea mediante un puntero a una función miembro o basada en cadenas utilizando las macros SIGNAL y SLOT, en las llamadas a connect() y a la función disconnect() correspondiente.
Para evitar discrepancias, almacena el identificador de conexión devuelto por connect() y utilízalo en la llamada a disconnect().
Nota: Si se desconecta una queued connection, es posible que los eventos ya programados se sigan entregando, lo que provocaría que se llamara al receptor después de que la conexión se haya desconectado.
Una conexión de señal-ranura se elimina cuando se destruye cualquiera de los objetos implicados.
Nota: Al desconectar todas las conexiones de señal-ranura, también se desconectará la señal QObject::destroyed() si está conectada. Hacerlo puede afectar negativamente a las clases que dependen de esta señal para liberar recursos. Se recomienda desconectar únicamente las señales específicas que hayan sido conectadas por el código de la aplicación.
Esta función sobrecarga QObject::disconnect().
Nota: Esta función es segura para subprocesos.
[static] template <typename PointerToMemberFunction> bool QObject::disconnect(const QObject *sender, PointerToMemberFunction signal, const QObject *receiver, PointerToMemberFunction method)
Desconecta signal en el objeto sender de method en el objeto receiver. Devuelve true si la conexión se interrumpe correctamente; en caso contrario, devuelve false.
Una conexión de señal-ranura se elimina cuando se destruye cualquiera de los objetos implicados.
La función disconnect() se suele utilizar de tres formas, tal y como muestran los siguientes ejemplos.
- Desconectar todo lo que esté conectado a las señales de un objeto:
QObject::disconnect(myObject, nullptr, nullptr, nullptr); - Desconectar todo lo conectado a una señal específica:
QObject::disconnect(myObject, &MyObject::mySignal, nullptr, nullptr); - Desconectar un receptor específico:
QObject::disconnect(myObject, nullptr, myReceiver, nullptr); - Desconectar una conexión de una señal concreta a una ranura concreta:
nullptr puede utilizarse como comodín, lo que significa «cualquier señal», «cualquier objeto receptor» o «cualquier ranura del objeto receptor», respectivamente.
La expresión « sender » nunca puede ser « nullptr ». (No se pueden desconectar señales de más de un objeto en una sola llamada).
Si signal es nullptr, desconecta receiver y method de cualquier señal. De lo contrario, solo se desconecta la señal especificada.
Si receiver es nullptr, desconecta todo lo que esté conectado a signal. Si no es así, solo se desconectan las ranuras del receptor especificado. La función disconnect() con un receiver distinto de nulo también desconecta las funciones de ranura que estaban conectadas con receiver como su objeto de contexto.
Si method es nullptr, desconecta todo lo que esté conectado a receiver. De lo contrario, solo se desconectarán las ranuras denominadas method, y el resto de ranuras permanecerán intactas. El method debe ser nullptr si se omite receiver, por lo que no es posible desconectar una ranura con un nombre específico en todos los objetos.
Nota: Noes posible utilizar esta sobrecarga para desconectar señales conectadas a functores o expresiones lambda. Esto se debe a que no es posible compararlas. En su lugar, utilice la sobrecarga que toma un QMetaObject::Connection.
Nota: A menos que ` method ` sea ` nullptr`, esta función tampoco romperá las conexiones que se hayan establecido utilizando la versión basada en cadenas de ` connect()`. Para romper dichas conexiones, utiliza la sobrecarga correspondiente basada en cadenas de `disconnect()`.
Esta función sobrecarga QObject::disconnect().
Nota: Esta función es segura para subprocesos.
Véase también connect().
[virtual protected] void QObject::disconnectNotify(const QMetaMethod &signal)
Esta función virtual se invoca cuando se ha desconectado algo de signal en este objeto.
Consulte « connectNotify()» para ver un ejemplo de cómo comparar « signal » con una señal específica.
Si todas las señales se han desconectado de este objeto (por ejemplo, si el argumento «signal» de disconnect() era nullptr), disconnectNotify() solo se invoca una vez, y el objeto signal será un QMetaMethod no válido (QMetaMethod::isValid() devuelve false).
Advertencia: Esta función incumple el principio de modularidad de la programación orientada a objetos. Sin embargo, podría resultar útil para optimizar el acceso a recursos costosos.
Advertencia: Esta función se invoca desde el hilo que realiza la desconexión, que puede ser un hilo distinto del hilo en el que reside este objeto. Esta función también puede invocarse con un mutex interno de QObject bloqueado. Por lo tanto, no está permitido volver a entrar en ninguna de las funciones de QObject, incluida isSignalConnected(), desde tu reimplementación. Si bloquea un mutex en su reimplementación, asegúrese de no llamar a funciones de QObject con ese mutex bloqueado en otros lugares, ya que se produciría un interbloqueo.
Véase también disconnect() y connectNotify().
void QObject::dumpObjectInfo() const
Muestra información sobre las conexiones de señales, etc., de este objeto en la salida de depuración.
Nota: Antes de Qt 5.9, esta función no era const.
Véase también dumpObjectTree().
void QObject::dumpObjectTree() const
Muestra un árbol de elementos hijos en la salida de depuración.
Nota: Antes de Qt 5.9, esta función no era const.
Véase también dumpObjectInfo().
QList<QByteArray> QObject::dynamicPropertyNames() const
Devuelve los nombres de todas las propiedades que se han añadido dinámicamente al objeto mediante la función ` setProperty()`.
[virtual] bool QObject::event(QEvent *e)
Esta función virtual recibe eventos de un objeto y debe devolver «true» si se ha reconocido y procesado el evento « e ».
La función event() se puede reimplementar para personalizar el comportamiento de un objeto.
Asegúrate de llamar a la implementación de la clase de eventos principal para todos los eventos que no hayas gestionado.
Ejemplo:
class MyClass : public QWidget
{
Q_OBJECT
public:
MyClass(QWidget *parent = nullptr);
~MyClass();
bool event(QEvent* ev) override
{
if (ev->type() == QEvent::PolishRequest) {
// overwrite handling of PolishRequest if any
doThings();
return true;
} else if (ev->type() == QEvent::Show) {
// complement handling of Show if any
doThings2();
QWidget::event(ev);
return true;
}
// Make sure the rest of events are handled
return QWidget::event(ev);
}
};Véase también installEventFilter(), timerEvent(), QCoreApplication::sendEvent() y QCoreApplication::postEvent().
[virtual] bool QObject::eventFilter(QObject *watched, QEvent *event)
Filtra los eventos si este objeto se ha instalado como filtro de eventos para el objeto « watched ».
En tu reimplementación de esta función, si deseas excluir el evento « event », es decir, impedir que se siga gestionando, devuelve «true»; de lo contrario, devuelve «false».
Ejemplo:
class MainWindow : public QMainWindow
{
public:
MainWindow();
protected:
bool eventFilter(QObject*obj, QEvent*ev) override;
private:
QTextEdit*textEdit;
};
MainWindow::MainWindow()
{
textEdit = new QTextEdit;
setCentralWidget(textEdit);
textEdit->installEventFilter(this);
}
bool MainWindow::eventFilter(QObject*obj, QEvent*event)
{
if (obj== textEdit) {
if (event->type()== QEvent::KeyPress) {
QKeyEvent*keyEvent = static_cast<QKeyEvent*>(event);
qDebug() << "Ate key press" << keyEvent->key();
return true;
} else {
return false;
}
} else {
// pasa el evento a la clase padre
return QMainWindow::eventFilter(obj, event);
}
}Obsérvese en el ejemplo anterior que los eventos no gestionados se pasan a la función eventFilter() de la clase base, ya que esta podría haber reimplementado eventFilter() para sus propios fines internos.
Algunos eventos, como QEvent::ShortcutOverride, deben aceptarse explícitamente (llamando a accept() sobre ellos) para evitar su propagación.
Advertencia: Si eliminas el objeto receptor en esta función, asegúrate de devolver «true». De lo contrario, Qt reenviará el evento al objeto eliminado y el programa podría bloquearse.
Véase también installEventFilter().
template <typename T> T QObject::findChild(QAnyStringView name, Qt::FindChildOptions options = Qt::FindChildrenRecursively) const
Devuelve el hijo de este objeto que se puede convertir al tipo T y que se denomina « name », o « nullptr » si no existe tal objeto. Un argumento « name » nulo hace que se busquen todos los objetos. Un argumento « name » vacío y no nulo solo busca objetos cuyo « objectName » esté vacío. La búsqueda se realiza de forma recursiva, a menos que « options » especifique la opción «FindDirectChildrenOnly».
Si hay más de un hijo que coincida con la búsqueda, se devuelve el antepasado más directo. Si hay varios antepasados más directos, se devolverá el primer hijo de children(). En ese caso, es mejor utilizar findChildren() para obtener la lista completa de todos los hijos.
Este ejemplo devuelve un hijo QPushButton de parentWidget denominado "button1", aunque el botón no sea un hijo directo del padre:
QPushButton *button = parentWidget->findChild<QPushButton *>("button1");Este ejemplo devuelve un elemento « QListWidget » hijo de parentWidget:
QListWidget *list = parentWidget->findChild<QListWidget *>();Este ejemplo devuelve un elemento hijo QPushButton de parentWidget (su padre directo) llamado "button1":
QPushButton *button = parentWidget->findChild<QPushButton *>("button1", Qt::FindDirectChildrenOnly);Este ejemplo devuelve un elemento secundario de tipo « QListWidget » de « parentWidget », su padre directo:
QListWidget *list = parentWidget->findChild<QListWidget *>(Qt::FindDirectChildrenOnly);Nota: En las versiones de Qt anteriores a la 6.7, esta función tomaba name como QString, no como QAnyStringView.
Véase también findChildren().
[since 6.7] template <typename T> T QObject::findChild(Qt::FindChildOptions options = Qt::FindChildrenRecursively) const
Devuelve el hijo de este objeto que se puede convertir al tipo T, o ` nullptr ` si no existe tal objeto. La búsqueda se realiza de forma recursiva, a menos que ` options ` especifique la opción `FindDirectChildrenOnly`.
Si hay más de un descendiente que coincide con la búsqueda, se devuelve el antepasado más directo. Si hay varios antepasados más directos, se devolverá el primer descendiente de children(). En ese caso, es mejor utilizar findChildren() para obtener la lista completa de todos los descendientes.
Esta es una función sobrecargada.
Esta función se introdujo en Qt 6.7.
Véase también findChildren().
template <typename T> QList<T> QObject::findChildren(QAnyStringView name, Qt::FindChildOptions options = Qt::FindChildrenRecursively) const
Devuelve todos los hijos de este objeto con el name dado que puedan convertirse al tipo T, o una lista vacía si no existen tales objetos. Un argumento name nulo hace que se seleccionen todos los objetos, mientras que uno vacío solo selecciona aquellos cuyo objectName esté vacío. La búsqueda se realiza de forma recursiva, a menos que options especifique la opción FindDirectChildrenOnly.
El siguiente ejemplo muestra cómo encontrar una lista de elementos hijos QWidgetde la parentWidget especificada denominada widgetname:
Este ejemplo devuelve todos los « QPushButton» que son hijos de « parentWidget »:
QList<QPushButton *> allPButtons = parentWidget->findChildren<QPushButton *>();Este ejemplo devuelve todos los QPushButtonque son hijos directos de parentWidget:
QList<QPushButton *> childButtons = parentWidget.findChildren<QPushButton *>(Qt::FindDirectChildrenOnly);Nota: En las versiones de Qt anteriores a la 6.7, esta función tomaba name como QString, no como QAnyStringView.
Véase también findChild().
[since 6.3] template <typename T> QList<T> QObject::findChildren(Qt::FindChildOptions options = Qt::FindChildrenRecursively) const
Devuelve todos los elementos secundarios de este objeto que puedan convertirse al tipo T, o una lista vacía si no hay ningún objeto de ese tipo. La búsqueda se realiza de forma recursiva, a menos que options especifique la opción FindDirectChildrenOnly.
Esta es una función sobrecargada.
Esta función se introdujo en Qt 6.3.
Véase también findChild().
template <typename T> QList<T> QObject::findChildren(const QRegularExpression &re, Qt::FindChildOptions options = Qt::FindChildrenRecursively) const
Devuelve los hijos de este objeto que pueden convertirse al tipo T y cuyos nombres coinciden con la expresión regular re, o una lista vacía si no existen tales objetos. La búsqueda se realiza de forma recursiva, a menos que options especifique la opción FindDirectChildrenOnly.
Esta función sobrecarga la función QObject::findChildren().
bool QObject::inherits(const char *className) const
Devuelve « true » si este objeto es una instancia de una clase que hereda de « className » o de una subclase de « QObject » que hereda de « className »; en caso contrario, devuelve « false ».
Se considera que una clase se hereda a sí misma.
Ejemplo:
QTimer *timer = new QTimer; // QTimer inherits QObject
timer->inherits("QTimer"); // returns true
timer->inherits("QObject"); // returns true
timer->inherits("QAbstractButton"); // returns false
// QVBoxLayout inherits QObject and QLayoutItem
QVBoxLayout *layout = new QVBoxLayout;
layout->inherits("QObject"); // returns true
layout->inherits("QLayoutItem"); // returns true (even though QLayoutItem is not a QObject)Si necesitas determinar si un objeto es una instancia de una clase concreta con el fin de realizar un casting, considera utilizar en su lugar qobject_cast<Type *>(object).
Véase también metaObject() y qobject_cast().
void QObject::installEventFilter(QObject *filterObj)
Instala un filtro de eventos « filterObj » en este objeto. Por ejemplo:
monitoredObj->installEventFilter(filterObj);Un filtro de eventos es un objeto que recibe todos los eventos que se envían a este objeto. El filtro puede detener el evento o reenviarlo a este objeto. El filtro de eventos filterObj recibe eventos a través de su función eventFilter(). La función eventFilter() debe devolver «true» si el evento debe filtrarse (es decir, detenerse); en caso contrario, debe devolver «false».
Si hay varios filtros de eventos instalados en un mismo objeto, se activa primero el filtro que se instaló en último lugar.
Si ya se ha instalado « filterObj » para este objeto, esta función lo reordena para que actúe como si se hubiera instalado en último lugar.
A continuación se muestra una clase « KeyPressEater » que intercepta las pulsaciones de teclas de los objetos que supervisa:
class KeyPressEater : public QObject
{
Q_OBJECT
public:
KeyPressEater(QObject*parent = nullptr) : QObject(parent) {}
//...
protected:
bool eventFilter(QObject*obj, QEvent*event) override;
};
bool KeyPressEater::eventFilter(QObject*obj, QEvent*event)
{
if (event->type()== QEvent::KeyPress) {
QKeyEvent*keyEvent = static_cast<QKeyEvent*>(event);
qDebug("Ate key press %d", keyEvent->key());
return true;
} else {
// procesamiento estándar de eventos
return QObject::eventFilter(obj, event);
}
}Y así es como se instala en dos widgets:
KeyPressEater *keyPressEater = new KeyPressEater(this);
QPushButton *pushButton = new QPushButton(this);
QListView *listView = new QListView(this);
pushButton->installEventFilter(keyPressEater);
listView->installEventFilter(keyPressEater);La clase ` QShortcut `, por ejemplo, utiliza esta técnica para interceptar las pulsaciones de teclas de acceso rápido.
Advertencia: si eliminas el objeto receptor en tu función ` eventFilter()`, asegúrate de devolver `true`. Si devuelves `false`, Qt enviará el evento al objeto eliminado y el programa se bloqueará.
Ten en cuenta que el objeto de filtrado debe estar en el mismo hilo que este objeto. Si filterObj se encuentra en un hilo diferente, esta función no hace nada. Si filterObj o este objeto se trasladan a un hilo diferente tras llamar a esta función, el filtro de eventos no se activará hasta que ambos objetos vuelvan a tener la misma afinidad de hilo ( no se elimina).
Véase también removeEventFilter(), eventFilter() y event().
[noexcept, since 6.11] bool QObject::isQmlExposed() const
Devuelve si el objeto ha sido creado por el motor QML o si la propiedad se ha establecido explícitamente mediante ` QJSEngine::setObjectOwnership()`.
Esta función se introdujo en Qt 6.11.
[since 6.4] bool QObject::isQuickItemType() const
Devuelve true si el objeto es un QQuickItem; en caso contrario, devuelve false.
Llamar a esta función equivale a llamar a ` inherits("QQuickItem")`, salvo que es mucho más rápida.
Esta función se introdujo en Qt 6.4.
[protected] bool QObject::isSignalConnected(const QMetaMethod &signal) const
Devuelve ` true ` si el ` signal ` está conectado al menos a un receptor; en caso contrario, devuelve ` false`.
signal Debe ser un miembro de señal de este objeto; de lo contrario, el comportamiento es indefinido.
static const QMetaMethod valueChangedSignal = QMetaMethod::fromSignal(&MyObject::valueChanged);
if (QObject::isSignalConnected(valueChangedSignal)) {
QByteArray data;
data = get_the_value(); // expensive operation
emit valueChanged(data);
}Como ilustra el fragmento de código anterior, puedes utilizar esta función para evitar operaciones costosas o emitir una señal que nadie escuche.
Advertencia: En una aplicación multihilo, no se garantiza que las llamadas consecutivas a esta función produzcan los mismos resultados.
Advertencia: Esta función incumple el principio de modularidad de la programación orientada a objetos. En concreto, esta función no debe llamarse desde una reimplementación de ` connectNotify()` o ` disconnectNotify()`, ya que estas podrían ser llamadas desde cualquier hilo.
Véase también receivers().
bool QObject::isWidgetType() const
Devuelve ` true ` si el objeto es un widget; en caso contrario, devuelve ` false`.
Llamar a esta función equivale a llamar a ` inherits("QWidget")`, salvo que es mucho más rápida.
bool QObject::isWindowType() const
Devuelve ` true ` si el objeto es una ventana; en caso contrario, devuelve ` false`.
Llamar a esta función equivale a llamar a ` inherits("QWindow")`, salvo que es mucho más rápida.
void QObject::killTimer(int id)
Detiene el temporizador con el identificador de temporizador, ` id`.
El identificador del temporizador es el que devuelve la función startTimer() al iniciar un evento del temporizador.
Véanse también timerEvent() y startTimer().
[since 6.8] void QObject::killTimer(Qt::TimerId id)
Esta es una función sobrecargada.
Esta función se introdujo en Qt 6.8.
[virtual] const QMetaObject *QObject::metaObject() const
Devuelve un puntero al metaobjeto de este objeto.
Un metaobjeto contiene información sobre una clase que hereda de ` QObject`, por ejemplo, el nombre de la clase, el nombre de la superclase, las propiedades, las señales y las ranuras. Toda subclase de ` QObject ` que contenga la macro ` Q_OBJECT ` tendrá un metaobjeto.
La información del metaobjeto es necesaria para el mecanismo de conexión de señales y ranuras y para el sistema de propiedades. La función inherits() también utiliza el metaobjeto.
Si no dispones de un puntero a una instancia real del objeto, pero aún así deseas acceder al metobjeto de una clase, puedes utilizar staticMetaObject.
Ejemplo:
QObject *obj = new QPushButton;
obj->metaObject()->className(); // returns "QPushButton"
QPushButton::staticMetaObject.className(); // returns "QPushButton"Véase también staticMetaObject.
bool QObject::moveToThread(QThread *targetThread)
Cambia la afinidad de subproceso de este objeto y de sus hijos, y devuelve ` true ` si la operación se realiza correctamente. El objeto no se puede mover si tiene un padre. El procesamiento de eventos continuará en el ` targetThread`.
Para mover un objeto al hilo principal, utiliza ` QApplication::instance()` para obtener un puntero a la aplicación actual y, a continuación, utiliza ` QApplication::thread()` para obtener el hilo en el que se encuentra la aplicación. Por ejemplo:
myObject->moveToThread(QApplication::instance()->thread());Si targetThread es nullptr, se detiene todo el procesamiento de eventos para este objeto y sus hijos, ya que dejan de estar asociados a ningún hilo.
Ten en cuenta que todos los temporizadores activos del objeto se reiniciarán. Los temporizadores se detienen primero en el hilo actual y se reinician (con el mismo intervalo) en el ` targetThread`. Como resultado, mover constantemente un objeto entre hilos puede posponer los eventos de los temporizadores indefinidamente.
Se envía un evento « QEvent::ThreadChange » a este objeto justo antes de que se cambie la afinidad del hilo. Puede gestionar este evento para realizar cualquier procesamiento especial. Tenga en cuenta que cualquier evento nuevo que se envíe a este objeto se gestionará en el « targetThread », siempre que no esté en « nullptr »: cuando está en « nullptr », no puede producirse ningún procesamiento de eventos para este objeto ni para sus hijos, ya que ya no están asociados a ningún hilo.
Advertencia: Esta función no es segura para subprocesos; el subproceso actual debe coincidir con la afinidad de subproceso actual. En otras palabras, esta función solo puede «empujar» un objeto desde el subproceso actual a otro subproceso, pero no puede «tirar» de un objeto desde cualquier subproceso arbitrario hacia el subproceso actual. Sin embargo, hay una excepción a esta regla: los objetos sin afinidad de hilo pueden «trasladarse» al hilo actual.
En las versiones de Qt anteriores a la 6.7, esta función no tenía valor de retorno (void).
Véase también thread().
[private signal] void QObject::objectNameChanged(const QString &objectName)
Esta señal se emite después de que se haya cambiado el nombre del objeto. El nuevo nombre del objeto se pasa como « objectName ».
Nota: Se trata de una señal privada. Se puede utilizar en conexiones de señales, pero el usuario no puede emitirla.
Nota: Señalde notificación para la propiedad objectName.
Véase también ` QObject::objectName`.
QObject *QObject::parent() const
Devuelve un puntero al objeto padre.
Véase también setParent() y children().
QVariant QObject::property(const char *name) const
Devuelve el valor de la propiedad ` name ` del objeto.
Si no existe dicha propiedad, la variante devuelta no es válida.
La información sobre todas las propiedades disponibles se proporciona a través de las funciones metaObject() y dynamicPropertyNames().
Véanse también setProperty(), QVariant::isValid(), metaObject() y dynamicPropertyNames().
[protected] int QObject::receivers(const char *signal) const
Devuelve el número de receptores conectados a la interfaz de red « signal ».
Dado que tanto las ranuras como las señales pueden utilizarse como receptores de señales, y que las mismas conexiones pueden realizarse varias veces, el número de receptores es igual al número de conexiones realizadas desde esta señal.
Al llamar a esta función, puedes utilizar la macro ` SIGNAL() ` para pasar una señal específica:
if (receivers(SIGNAL(valueChanged(QByteArray))) > 0) {
QByteArray data;
get_the_value(&data); // expensive operation
emit valueChanged(data);
}Como ilustra el fragmento de código anterior, puedes utilizar esta función para evitar operaciones costosas o emitir una señal que nadie escuche.
Advertencia: En una aplicación multihilo, no se garantiza que las llamadas consecutivas a esta función produzcan los mismos resultados.
Advertencia: Esta función incumple el principio de modularidad de la programación orientada a objetos. En concreto, esta función no debe invocarse desde una reimplementación de ` connectNotify()` o ` disconnectNotify()`, ya que estas podrían ser invocadas desde cualquier hilo.
Véase también isSignalConnected().
void QObject::removeEventFilter(QObject *obj)
Elimina un objeto de filtro de eventos obj de este objeto. La solicitud se ignora si dicho filtro de eventos no se ha instalado.
Todos los filtros de eventos de este objeto se eliminan automáticamente cuando se destruye dicho objeto.
Siempre es seguro eliminar un filtro de eventos, incluso durante su activación (es decir, desde la función eventFilter()).
Véase también installEventFilter(), eventFilter() y event().
[protected] QObject *QObject::sender() const
Devuelve un puntero al objeto que envió la señal, si se invoca en una ranura activada por una señal; en caso contrario, devuelve un nullptr. El puntero solo es válido durante la ejecución de la ranura que invoca esta función desde el contexto de hilo de este objeto.
El puntero devuelto por esta función deja de ser válido si se destruye el emisor o si la ranura se desconecta de la señal del emisor.
Advertencia: Esta función incumple el principio de modularidad de la programación orientada a objetos. Sin embargo, poder acceder al emisor puede resultar útil cuando hay muchas señales conectadas a una misma ranura.
Advertencia: Como se ha mencionado anteriormente, el valor de retorno de esta función no es válido cuando la ranura se invoca mediante un ` Qt::DirectConnection ` desde un hilo distinto al de este objeto. No utilices esta función en este tipo de situaciones.
Véase también ` senderSignalIndex()`.
[protected] int QObject::senderSignalIndex() const
Devuelve el índice del metamétodo de la señal que ha llamado a la ranura que se está ejecutando actualmente, que es un miembro de la clase devuelta por sender(). Si se llama fuera de una ranura activada por una señal, se devuelve -1.
En el caso de las señales con parámetros por defecto, esta función siempre devolverá el índice con todos los parámetros, independientemente de cuál se haya utilizado con connect(). Por ejemplo, la señal destroyed(QObject *obj = \nullptr) tendrá dos índices diferentes (con y sin el parámetro), pero esta función siempre devolverá el índice con un parámetro. Esto no se aplica cuando se sobrecargan señales con parámetros diferentes.
Advertencia: Esta función incumple el principio de modularidad de la programación orientada a objetos. Sin embargo, poder acceder al índice de la señal puede resultar útil cuando hay muchas señales conectadas a una misma ranura.
Advertencia: El valor de retorno de esta función no es válido cuando se invoca la ranura mediante un ` Qt::DirectConnection ` desde un hilo distinto al hilo de este objeto. No utilices esta función en este tipo de situaciones.
Véase también sender(), QMetaObject::indexOfSignal() y QMetaObject::method().
void QObject::setObjectName(const QString &name)
Establece el nombre del objeto como « name ».
Nota: Funciónde asignación para la propiedad « objectName ».
Véase también objectName().
[since 6.4] void QObject::setObjectName(QAnyStringView name)
Nota: Funciónde asignación para la propiedad « objectName ».
Se trata de una función sobrecargada.
Esta función se introdujo en Qt 6.4.
void QObject::setParent(QObject *parent)
Convierte el objeto en un elemento secundario de parent.
Véase también parent() y children().
bool QObject::setProperty(const char *name, const QVariant &value)
Establece el valor de la propiedad « name » del objeto en « value ».
Si la propiedad está definida en la clase mediante ` Q_PROPERTY `, se devuelve `true` si la operación se realiza correctamente y `false` en caso contrario. Si la propiedad no está definida mediante ` Q_PROPERTY` y, por lo tanto, no aparece en el metaobjeto, se añade como propiedad dinámica y se devuelve `false`.
La información sobre todas las propiedades disponibles se proporciona a través de ` metaObject()` y ` dynamicPropertyNames()`.
Las propiedades dinámicas se pueden consultar de nuevo mediante property() y se pueden eliminar estableciendo el valor de la propiedad en un QVariant no válido. Al cambiar el valor de una propiedad dinámica, se envía un QDynamicPropertyChangeEvent al objeto.
Nota: Las propiedades dinámicas que comienzan por «_q_» están reservadas para fines internos.
Véase también property(), metaObject(), dynamicPropertyNames() y QMetaProperty::write().
[since 6.6] bool QObject::setProperty(const char *name, QVariant &&value)
Esta función sobrescribe ` QObject::setProperty`.
Esta función se introdujo en Qt 6.6.
[noexcept] bool QObject::signalsBlocked() const
Devuelve « true » si las señales están bloqueadas; en caso contrario, devuelve « false ».
Las señales no están bloqueadas de forma predeterminada.
Véase también ` blockSignals()` y ` QSignalBlocker`.
int QObject::startTimer(int interval, Qt::TimerType timerType = Qt::CoarseTimer)
Esta es una función sobrecargada que iniciará un temporizador de tipo timerType y un tiempo de espera de interval milisegundos. Esto equivale a llamar a:
startTimer(std::chrono::milliseconds{interval}, timerType);A partir de Qt 6.10, establecer un intervalo negativo dará lugar a una advertencia en tiempo de ejecución y el valor se restablecerá a 1 ms. Antes de Qt 6.10, un temporizador de Qt permitía establecer un intervalo negativo, pero se comportaba de forma impredecible (por ejemplo, detenía el temporizador si estaba en marcha o no lo iniciaba en absoluto).
Véase también timerEvent(), killTimer(), QChronoTimer y QBasicTimer.
int QObject::startTimer(std::chrono::nanoseconds interval, Qt::TimerType timerType = Qt::CoarseTimer)
Inicia un temporizador y devuelve un identificador del mismo, o devuelve cero si no ha podido iniciarlo.
Se producirá un evento del temporizador cada interval hasta que se llame a killTimer(). Si interval es igual a std::chrono::duration::zero(), el evento del temporizador se producirá cada vez que el control vuelva al bucle de eventos, es decir, cuando no haya más eventos del sistema de ventanas nativo que procesar.
A partir de Qt 6.10, establecer un intervalo negativo provocará una advertencia en tiempo de ejecución y el valor se restablecerá a 1 ms. Antes de Qt 6.10, un temporizador Qt permitía establecer un intervalo negativo, pero se comportaba de forma impredecible (por ejemplo, detenía el temporizador si estaba en marcha o no lo iniciaba en absoluto).
La función virtual ` timerEvent()` se invoca con la clase de parámetro de evento ` QTimerEvent ` cuando se produce un evento del temporizador. Reimplementa esta función para obtener los eventos del temporizador.
Si hay varios temporizadores en ejecución, el método QTimerEvent::id() puede utilizarse para averiguar qué temporizador se ha activado.
Ejemplo:
class MyObject : public QObject
{
Q_OBJECT
public:
MyObject(QObject*parent = nullptr);
Q_SIGNALS:
void valueChanged();
protected:
void timerEvent(QTimerEvent*event) override;
};
MyObject::MyObject(QObject*parent)
: QObject(parent)
{
using namespace std::chrono_literals;
startTimer(50 ms);
startTimer(5 s);
startTimer(10 min);
startTimer(1 h);
}
void MyObject::timerEvent(QTimerEvent*event)
{
qDebug() << "Timer ID:" << event->id();
}Ten en cuenta que la precisión del temporizador depende del sistema operativo y del hardware subyacentes.
El argumento ` timerType ` permite personalizar la precisión del temporizador. Consulte Qt::TimerType para obtener información sobre los diferentes tipos de temporizadores. La mayoría de las plataformas admiten una precisión de 20 milisegundos; algunas ofrecen una mayor precisión. Si Qt no puede generar el número solicitado de eventos del temporizador, descartará algunos de forma silenciosa.
Las clases ` QTimer ` y ` QChronoTimer ` proporcionan una interfaz de programación de alto nivel con temporizadores de un solo disparo y señales de temporizador en lugar de eventos. También existe la clase ` QBasicTimer `, que es más ligera que ` QChronoTimer `, pero menos engorrosa que el uso directo de los identificadores de temporizador.
Nota: A partir de Qt 6.8, el tipo de ` interval ` es ` std::chrono::nanoseconds`; anteriormente era ` std::chrono::milliseconds`. Este cambio es compatible con versiones anteriores de Qt.
Nota: En Qt 6.8, se modificó el método ` QObject ` para que utilizara ` Qt::TimerId ` a la hora de representar los identificadores de temporizador. Este método convierte ` TimerId ` a `int` por motivos de compatibilidad con versiones anteriores; no obstante, puedes utilizar ` Qt::TimerId ` para comprobar el valor devuelto por este método, por ejemplo:
QObject *obj;
//...
const auto id = Qt::TimerId {obj->startTimer(100ms)};
if (id != Qt::TimerId::Invalid)
{
// The timer has been started successfully
}Esta es una función sobrecargada.
Véase también timerEvent(), killTimer(), QChronoTimer y QBasicTimer.
QThread *QObject::thread() const
Devuelve el hilo en el que se encuentra el objeto.
Véase también moveToThread().
[virtual protected] void QObject::timerEvent(QTimerEvent *event)
Este controlador de eventos se puede reimplementar en una subclase para recibir eventos del temporizador del objeto.
QChronoTimer Proporciona interfaces de nivel superior para la funcionalidad del temporizador, así como información más general sobre los temporizadores. El evento del temporizador se pasa en el parámetro event.
Véase también startTimer(), killTimer() y event().
[static] QString QObject::tr(const char *sourceText, const char *disambiguation = nullptr, int n = -1)
Devuelve una versión traducida de sourceText, basada opcionalmente en una cadena de disambiguation y en el valor de n para las cadenas que contengan plurales; en caso contrario, devuelve QString::fromUtf8(sourceText) si no hay disponible ninguna cadena traducida adecuada.
Ejemplo:
void SpreadSheet::setupMenuBar()
{
QMenu *fileMenu = menuBar()->addMenu(tr("&File"));
...Si se utiliza el mismo « sourceText » en diferentes roles dentro del mismo contexto, se puede pasar una cadena identificativa adicional en « disambiguation » (por defecto, «nullptr »).
Ejemplo:
MyWindow::MyWindow()
{
QLabel *senderLabel = new QLabel(tr("Name:"));
QLabel *recipientLabel = new QLabel(tr("Name:", "recipient"));
...Consulte «Escritura de código fuente para la traducción» para obtener una descripción detallada de los mecanismos de traducción de Qt en general, y la sección «Desambiguación de texto idéntico» para obtener información sobre la desambiguación.
Advertencia: Este método solo es reentrante si todos los traductores están instalados antes de llamarlo. No se admite la instalación o eliminación de traductores mientras se realizan traducciones. Hacerlo probablemente provocará fallos del sistema u otros comportamientos indeseados.
Véase también ` QCoreApplication::translate()` e «Internacionalización con Qt».
Documentación de las variables de miembro
const QMetaObject QObject::staticMetaObject
Esta variable almacena el metaobjeto de la clase.
Un metaobjeto contiene información sobre una clase que hereda de QObject, por ejemplo, el nombre de la clase, el nombre de la superclase, las propiedades, las señales y las ranuras. Toda clase que contenga la macro Q_OBJECT también tendrá un metaobjeto.
La información del metaobjeto es necesaria para el mecanismo de conexión de señales y ranuras y para el sistema de propiedades. La función ` inherits()` también utiliza el metaobjeto.
Si dispones de un puntero a un objeto, puedes utilizar metaObject() para recuperar el metaobjeto asociado a dicho objeto.
Ejemplo:
QPushButton::staticMetaObject.className(); // returns "QPushButton"
QObject *obj = new QPushButton;
obj->metaObject()->className(); // returns "QPushButton"Véase también ` metaObject()`.
Elementos no miembros relacionados
QObjectList
Sinónimo de « QList » <QObject *>.
[since 6.8] enum class TimerId
Se utiliza para representar identificadores de temporizador (por ejemplo, QTimer y QChronoTimer). El tipo subyacente es int. Puedes utilizar qToUnderlying() para convertir Qt::TimerId en int.
| Constante | Valor | Descripción |
|---|---|---|
QObject::TimerId::Invalid | 0 | Representa un identificador de temporizador sin operación; su uso depende del contexto; por ejemplo, este es el valor devuelto por ` QObject::startTimer()` para indicar que no se ha podido iniciar un temporizador; mientras que ` QChronoTimer::id()` devuelve este valor cuando el temporizador está inactivo, es decir, ` timer.isActive() ` devuelve ` false`. |
Esta enumeración se introdujo en Qt 6.8.
Véase también QTimer::id(), QChronoTimer::id() y QObject::startTimer().
template <typename T> T qobject_cast(QObject *object)
template <typename T> T qobject_cast(const QObject *object)
Devuelve el objeto ` object ` convertido al tipo `T` si dicho objeto es de tipo `T` (o de una subclase); en caso contrario, devuelve ` nullptr`. Si ` object ` es ` nullptr `, también devolverá ` nullptr`.
La clase T debe heredar (directa o indirectamente) de QObject y estar declarada con la macro Q_OBJECT.
Se considera que una clase se hereda a sí misma.
Ejemplo:
QObject *obj = new QTimer; // QTimer inherits QObject
QTimer *timer = qobject_cast<QTimer *>(obj);
// timer == (QObject *)obj
QAbstractButton *button = qobject_cast<QAbstractButton *>(obj);
// button == nullptrLa función qobject_cast() se comporta de forma similar a la función estándar de C++ dynamic_cast(), con la ventaja de que no requiere compatibilidad con RTTI y funciona más allá de los límites de las bibliotecas dinámicas.
qobject_cast() también se puede utilizar junto con interfaces.
Advertencia: Si T no se declara con la macro ` Q_OBJECT `, el valor de retorno de esta función es indefinido.
Véase también QObject::inherits().
Documentación de la macro
[since 6.7] QT_NO_CONTEXTLESS_CONNECT
Al definir esta macro se desactivará la sobrecarga de ` QObject::connect()` que conecta una señal a un functor, sin especificar además un ` QObject ` como objeto receptor/contexto (es decir, la sobrecarga de tres argumentos de ` QObject::connect()`).
El uso de la sobrecarga sin contexto es propenso a errores, ya que es fácil conectar funtores que dependen de algún estado local del extremo receptor. Si dicho estado local se destruye, la conexión no se desconecta automáticamente.
Además, estas conexiones son siempre conexiones directas, lo que puede causar problemas en entornos multihilo (por ejemplo, si la señal se emite desde otro hilo).
Esta macro se introdujo en Qt 6.7.
Véase también QObject::connect y Qt::ConnectionType.
[since 6.12] QT_NO_DISCONNECT_CONST_CONNECTION
Desactiva la sobrecarga « const & » de ` QObject::disconnect()` para obligar a quienes la invocan a pasar objetos no const.
Es preferible pasar objetos no const, ya que pueden reiniciarse inmediatamente, lo que permite liberar recursos antes. Las diferentes versiones de Qt gestionan la sobrecarga `const` de forma distinta. En versiones anteriores de Qt, llamar a la sobrecarga `const` con una `Connection` declarada originalmente como ` const ` podía provocar un comportamiento indefinido. Las versiones actuales de Qt son seguras en este sentido, pero es posible que en futuras versiones de Qt se elimine la sobrecarga `const` o que esta retrase la liberación de recursos hasta que el objeto `Connection` sea reasignado o destruido.
El paso de objetos no const evita todos los problemas mencionados anteriormente.
El código que se compila con esta macro activada también se compila (y no provoca un comportamiento indefinido) sin la macro activada, y en todas las versiones de Qt a partir de la 5.0.
Esta macro se introdujo en Qt 6.12.
QT_NO_NARROWING_CONVERSIONS_IN_CONNECT
La definición de esta macro desactivará las conversiones de reducción de precisión y de números de coma flotante a enteros entre los argumentos que transporta una señal y los que acepta una ranura, cuando la señal y la ranura estén conectadas mediante la sintaxis basada en PMF.
Véase también QObject::connect.
Q_CLASSINFO(Name, Value)
Esta macro asocia información adicional a la clase, a la que se puede acceder mediante la función ` QObject::metaObject()`. La información adicional adopta la forma de una cadena « Name » y una cadena literal « Value ».
Ejemplo:
class MyClass : public QObject
{
Q_OBJECT
Q_CLASSINFO("Author", "Pierre Gendron")
Q_CLASSINFO("URL", "http://www.my-organization.qc.ca")
public:
//...
};Qt utiliza la macro en Qt D-Bus y Qt Qml los módulos. Por ejemplo, al definir ` QML Object Types ` en C++, se puede designar una propiedad como la predeterminada:
Q_CLASSINFO("DefaultProperty", "content")Véase también QMetaObject::classInfo(), Uso de adaptadores de Qt D-Bus y Definición de tipos QML desde C++.
Q_EMIT
Utiliza esta macro para sustituir la palabra clave « emit » destinada a emitir señales, cuando desees utilizar las señales y ranuras de Qt con un mecanismo de señales y ranuras de terceros.
La macro se utiliza normalmente cuando se especifica « no_keywords » con la variable « CONFIG » en el archivo « .pro », pero puede utilizarse incluso cuando no se especifica « no_keywords ».
Q_ENUM(...)
Esta macro registra un tipo de enumeración en el sistema de metaobjetos. Debe colocarse después de la declaración de la enumeración en una clase que contenga la macro « Q_OBJECT », « Q_GADGET » o « Q_GADGET_EXPORT ». Para los espacios de nombres, utilice en su lugar « Q_ENUM_NS()».
Por ejemplo:
class MyClass : public QObject
{
Q_OBJECT
public:
MyClass(QObject *parent = nullptr);
~MyClass();
enum Priority { High, Low, VeryHigh, VeryLow };
Q_ENUM(Priority)
void setPriority(Priority priority);
Priority priority() const;
};Las enumeraciones declaradas con Q_ENUM tienen su QMetaEnum registrado en el QMetaObject que las engloba. También se puede utilizar QMetaEnum::fromType() para obtener el QMetaEnum.
Las enumeraciones registradas se registran automáticamente también en el sistema de metatipos de Qt, lo que hace que QMetaType las reconozca sin necesidad de utilizar Q_DECLARE_METATYPE(). Esto habilita funciones útiles; por ejemplo, si se utilizan en un QVariant, se pueden convertir en cadenas de caracteres. Del mismo modo, al pasarlas a QDebug se mostrarán sus nombres.
Véase también el sistema de propiedades de Qt.
Q_ENUM_NS(...)
Esta macro registra un tipo de enumeración en el sistema de metaobjetos. Debe colocarse después de la declaración de la enumeración en un espacio de nombres que cuente con la macro Q_NAMESPACE. Es equivalente a Q_ENUM, pero en un espacio de nombres.
Las enumeraciones declaradas con Q_ENUM_NS tienen su QMetaEnum registrado en el QMetaObject que las engloba. También se puede utilizar QMetaEnum::fromType() para obtener el QMetaEnum.
Las enumeraciones registradas se registran automáticamente también en el sistema de metatipos de Qt, lo que hace que sean reconocidas por QMetaType sin necesidad de utilizar Q_DECLARE_METATYPE(). Esto habilita funciones útiles; por ejemplo, si se utilizan en un QVariant, se pueden convertir en cadenas. Del mismo modo, al pasarlas a QDebug se mostrarán sus nombres.
Véase también el sistema de propiedades de Qt.
Q_FLAG(...)
Esta macro registra una única enumeración « flags type » en el sistema de metaobjetos. Se suele utilizar en la definición de una clase para declarar que los valores de una enumeración determinada pueden utilizarse como indicadores y combinarse mediante el operador OR bit a bit. Para los espacios de nombres, utilice en su lugar « Q_FLAG_NS()».
La macro debe colocarse después de la declaración de la enumeración. La declaración del tipo de indicadores se realiza mediante la macro Q_DECLARE_FLAGS().
Por ejemplo, en QItemSelectionModel, el indicador SelectionFlags se declara de la siguiente manera:
class Q_CORE_EXPORT QItemSelectionModel : public QObject
{
Q_OBJECT
...
public:
enum SelectionFlag {
NoUpdate = 0x0000,
Clear = 0x0001,
Select = 0x0002,
Deselect = 0x0004,
Toggle = 0x0008,
Current = 0x0010,
Rows = 0x0020,
Columns = 0x0040,
SelectCurrent = Select | Current,
ToggleCurrent = Toggle | Current,
ClearAndSelect = Clear | Select
};
Q_DECLARE_FLAGS(SelectionFlags, SelectionFlag)
Q_FLAG(SelectionFlags)
};Nota: La macro Q_FLAG se encarga de registrar los valores de cada indicador en el sistema de metaobjetos, por lo que no es necesario utilizar Q_ENUM() además de esta macro.
Véase también el sistema de propiedades de Qt.
Q_FLAG_NS(...)
Esta macro registra una única enumeración « flags type » en el sistema de metaobjetos. Se utiliza en un espacio de nombres que contenga la macro « Q_NAMESPACE », para declarar que los valores de una enumeración determinada pueden utilizarse como indicadores y combinarse mediante el operador OR bit a bit. Es equivalente a « Q_FLAG », pero en un espacio de nombres.
La macro debe colocarse después de la declaración de la enumeración.
Nota: La macro Q_FLAG_NS se encarga de registrar los valores de los indicadores individuales en el sistema de metobjetos, por lo que no es necesario utilizar Q_ENUM_NS() además de esta macro.
Véase también el sistema de propiedades de Qt.
Q_GADGET
La macro Q_GADGET es una versión más ligera de la macro Q_OBJECT para aquellas clases que no heredan de QObject pero que, aun así, desean utilizar algunas de las capacidades de reflexión que ofrece QMetaObject.
Nota: La expansiónde esta macro termina con un especificador de acceso « private:». Si declaras miembros inmediatamente después de esta macro, dichos miembros también serán privados. Para añadir miembros públicos (o protegidos) justo después de la macro, utiliza un especificador de acceso « public: » (o « protected: »).
Los Q_GADGET pueden tener Q_ENUM, Q_PROPERTY y Q_INVOKABLE, pero no pueden tener señales ni ranuras.
Q_GADGET pone a disposición un miembro de clase, staticMetaObject. staticMetaObject es de tipo QMetaObject y proporciona acceso a las enumeraciones declaradas con Q_ENUM.
Véase también Q_GADGET_EXPORT.
[since 6.3] Q_GADGET_EXPORT(EXPORT_MACRO)
La macro `Q_GADGET_EXPORT` funciona exactamente igual que la macro ` Q_GADGET `. Sin embargo, la variable ` staticMetaObject ` que se pone a disposición (véase Q_GADGET) se declara con el calificador ` EXPORT_MACRO ` proporcionado. Esto resulta útil si es necesario exportar el objeto desde una biblioteca dinámica, pero la clase que lo contiene en su conjunto no debe exportarse (por ejemplo, porque está compuesta principalmente por funciones en línea).
Nota: La expansiónde esta macro termina con un especificador de acceso « private ». Si declaras miembros inmediatamente después de esta macro, dichos miembros también serán privados. Para añadir miembros públicos (o protegidos) justo después de la macro, utiliza un especificador de acceso « public: » (o « protected: »).
Por ejemplo:
class Point {
Q_GADGET_EXPORT(EXPORT_MACRO)
Q_PROPERTY(int x MEMBER x)
Q_PROPERTY(int y MEMBER y)
~~~Esta macro se introdujo en Qt 6.3.
Véase también « Q_GADGET » y «Creación de bibliotecas compartidas».
Q_INTERFACES(...)
Esta macro indica a Qt qué interfaces implementa la clase. Se utiliza al implementar complementos.
Véase también Q_DECLARE_INTERFACE(), Q_PLUGIN_METADATA() y Cómo crear complementos de Qt.
Q_INVOKABLE
Aplica esta macro a las declaraciones de funciones miembro para permitir que se invoque a ellas a través del sistema de metaobjetos. La macro se escribe antes del tipo de retorno, tal y como se muestra en el siguiente ejemplo:
class Window : public QWidget
{
Q_OBJECT
public:
Window();
void normalMethod();
Q_INVOKABLE void invokableMethod();
};La función ` invokableMethod() ` se marca con `Q_INVOKABLE`, lo que hace que se registre en el sistema de metaobjetos y permite invocarla mediante ` QMetaObject::invokeMethod()`. Dado que la función ` normalMethod() ` no está registrada de esta forma, no se puede invocar mediante ` QMetaObject::invokeMethod()`.
Si una función miembro invocable devuelve un puntero a un ` QObject ` o a una subclase de ` QObject ` y se invoca desde QML, se aplican normas especiales de propiedad. Para obtener más información, consulte «Conversión de tipos de datos entre QML y C++ ».
[since 6.0] Q_MOC_INCLUDE
La macro Q_MOC_INCLUDE se puede utilizar tanto dentro como fuera de una clase, y le indica al Meta-Object Compiler que añada una inclusión.
// Put this in your code and the generated code will include this header.
Q_MOC_INCLUDE("myheader.h")Esto resulta útil si los tipos que utilizas como propiedades o como argumentos de señales y ranuras se declaran de forma anticipada.
Esta macro se introdujo en Qt 6.0.
Q_NAMESPACE
La macro Q_NAMESPACE se puede utilizar para añadir capacidades de QMetaObject a un espacio de nombres.
Los Q_NAMESPACE pueden tener Q_CLASSINFO, Q_ENUM_NS, Q_FLAG_NS, pero no pueden tener Q_ENUM, Q_FLAG, Q_PROPERTY, Q_INVOKABLE, señales ni ranuras.
Q_NAMESPACE pone a disposición una variable externa, staticMetaObject. staticMetaObject es de tipo QMetaObject y proporciona acceso a las enumeraciones declaradas con Q_ENUM_NS/Q_FLAG_NS.
Por ejemplo:
namespace test {
Q_NAMESPACE
...Véase también Q_NAMESPACE_EXPORT.
Q_NAMESPACE_EXPORT(EXPORT_MACRO)
La macro Q_NAMESPACE_EXPORT se puede utilizar para añadir capacidades de « QMetaObject » a un espacio de nombres.
Funciona exactamente igual que la macro « Q_NAMESPACE ». Sin embargo, la variable externa « staticMetaObject » que se define en el espacio de nombres se declara con el calificador « EXPORT_MACRO » proporcionado. Esto resulta útil si es necesario exportar el objeto desde una biblioteca dinámica.
Por ejemplo:
namespace test {
Q_NAMESPACE_EXPORT(EXPORT_MACRO)
...Véase también Q_NAMESPACE y Creación de bibliotecas compartidas.
Q_OBJECT
La macro Q_OBJECT se utiliza para habilitar las funciones de metaobjetos, como las propiedades dinámicas, las señales y las ranuras.
Puedes añadir la macro Q_OBJECT a cualquier sección de la definición de una clase que declare sus propias señales y ranuras o que utilice otros servicios proporcionados por el sistema de metaobjetos de Qt.
Nota: La expansiónde esta macro termina con un especificador de acceso « private:». Si se declaran miembros inmediatamente después de esta macro, dichos miembros también serán privados. Para añadir miembros públicos (o protegidos) justo después de la macro, utilice un especificador de acceso « public: » (o « protected: »).
Ejemplo:
#include <QObject>
class Counter : public QObject
{
Q_OBJECT
// Note. The Q_OBJECT macro starts a private section.
// To declare public members, use the 'public:' access modifier.
public:
Counter() { m_value = 0; }
int value() const { return m_value; }
public slots:
void setValue(int value);
signals:
void valueChanged(int newValue);
private:
int m_value;
};Nota: Esta macro requiere que la clase sea una subclase de ` QObject`. Utiliza ` Q_GADGET ` o ` Q_GADGET_EXPORT ` en lugar de `Q_OBJECT` para habilitar el soporte del sistema de metobjetos para las enumeraciones en una clase que no sea una subclase de ` QObject `.
Véase también Sistema de metaobjetos, Señales y ranuras, y Sistema de propiedades de Qt.
Q_PROPERTY(...)
Esta macro se utiliza para declarar propiedades en clases que heredan de ` QObject`. Las propiedades se comportan como miembros de datos de clase, pero cuentan con características adicionales a las que se puede acceder a través del sistema de metaobjetos.
Q_PROPERTY(type name
(READ getFunction [WRITE setFunction] |
MEMBER memberName [(READ getFunction | WRITE setFunction)])
[RESET resetFunction]
[NOTIFY notifySignal]
[REVISION int | REVISION(int[, int])]
[DESIGNABLE bool]
[SCRIPTABLE bool]
[STORED bool]
[USER bool]
[BINDABLE bindableProperty]
[CONSTANT]
[FINAL]
[VIRTUAL]
[OVERRIDE]
[REQUIRED])Son obligatorios el nombre y el tipo de la propiedad, así como la función ` READ `. El tipo puede ser cualquiera de los admitidos por ` QVariant`, o bien un tipo definido por el usuario. Los demás elementos son opcionales, aunque es habitual incluir una función ` WRITE `. Los atributos tienen el valor predeterminado «true», excepto ` USER`, cuyo valor predeterminado es «false».
Por ejemplo:
Q_PROPERTY(QString title READ title WRITE setTitle USER true)Para obtener más detalles sobre cómo utilizar esta macro, así como un ejemplo más detallado de su uso, consulta la explicación sobre el sistema de propiedades de Qt.
Véase también el sistema de propiedades de Qt.
Q_REVISION
Aplica esta macro a las declaraciones de funciones miembro para etiquetarlas con un número de revisión en el sistema de metaobjetos. La macro se escribe antes del tipo de retorno, tal y como se muestra en el siguiente ejemplo:
class Window : public QWidget
{
Q_OBJECT
Q_PROPERTY(int normalProperty READ normalProperty)
Q_PROPERTY(int newProperty READ newProperty REVISION(2, 1))
public:
Window();
int normalProperty();
int newProperty();
public slots:
void normalMethod();
Q_REVISION(2, 1) void newMethod();
};Esto resulta útil cuando se utiliza el sistema de metaobjetos para exponer dinámicamente objetos a otra API, ya que permite ajustarse a la versión esperada por las distintas versiones de dicha API. Consideremos el siguiente ejemplo simplificado:
Window window;
int expectedRevision = 0;
const QMetaObject *windowMetaObject = window.metaObject();
for (int i=0; i < windowMetaObject->methodCount(); i++)
if (windowMetaObject->method(i).revision() <= expectedRevision)
exposeMethod(windowMetaObject->method(i));
for (int i=0; i < windowMetaObject->propertyCount(); i++)
if (windowMetaObject->property(i).revision() <= expectedRevision)
exposeProperty(windowMetaObject->property(i));Utilizando la misma clase `Window` que en el ejemplo anterior, las propiedades `newProperty` y `newMethod` solo se expondrían en este código cuando la versión esperada fuera ` 2.1 ` o superior.
Dado que se considera que todos los métodos pertenecen a la revisión 0 si no están etiquetados, una etiqueta de Q_REVISION(0) o Q_REVISION(0, 0) no es válida y se ignora.
Se pueden pasar uno o dos parámetros enteros a ` Q_REVISION`. Si se pasa un parámetro, este denota únicamente la versión menor. Esto significa que la versión mayor no está especificada. Si se pasan dos, el primer parámetro es la versión mayor y el segundo, la versión menor.
El propio sistema de metaobjetos no utiliza esta etiqueta. Actualmente, solo la utiliza el módulo QtQml.
Para una etiqueta de cadena más genérica, véase QMetaMethod::tag()
Véase también QMetaMethod::revision().
Q_SET_OBJECT_NAME(Object)
Esta macro asigna a Object el «objeto» objectName.
No importa si ` Object ` es un puntero o no, la macro lo determina por sí misma.
Véase también QObject::objectName().
Q_SIGNAL
Esta es una macro adicional que te permite marcar una única función como señal. Puede resultar muy útil, sobre todo cuando se utiliza un analizador de código fuente de terceros que no reconoce los grupos « signals » o « Q_SIGNALS ».
Utiliza esta macro para sustituir la palabra clave signals en las declaraciones de clase, cuando desees utilizar las señales y ranuras de Qt con un mecanismo de señales y ranuras de terceros.
La macro se utiliza normalmente cuando se especifica « no_keywords » junto con la variable « CONFIG » en el archivo « .pro », pero puede utilizarse incluso cuando no se especifica « no_keywords ».
Q_SIGNALS
Utiliza esta macro para sustituir la palabra clave « signals » en las declaraciones de clases, cuando desees utilizar las señales y ranuras de Qt con un mecanismo de señales y ranuras de terceros.
La macro se utiliza normalmente cuando se especifica ` no_keywords ` junto con la variable ` CONFIG ` en el archivo ` .pro `, pero puede utilizarse incluso cuando no se especifica ` no_keywords `.
Q_SLOT
Esta es una macro adicional que te permite marcar una única función como slot. Puede resultar muy útil, sobre todo cuando utilizas un analizador de código fuente de terceros que no reconoce los grupos « slots » o « Q_SLOTS ».
Utiliza esta macro para sustituir la palabra clave « slots » en las declaraciones de clase, cuando desees utilizar las señales y ranuras de Qt con un mecanismo de señales y ranuras de terceros.
La macro se utiliza normalmente cuando se especifica « no_keywords » junto con la variable « CONFIG » en el archivo « .pro », pero puede utilizarse incluso cuando no se especifica « no_keywords ».
Q_SLOTS
Utiliza esta macro para sustituir la palabra clave « slots » en las declaraciones de clases, cuando desees utilizar las señales y ranuras de Qt con un mecanismo de señales y ranuras de terceros.
La macro se utiliza normalmente cuando se especifica « no_keywords » con la variable « CONFIG » en el archivo « .pro », pero puede utilizarse incluso cuando no se especifica « no_keywords ».
© 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.