Diferencias entre las conexiones basadas en cadenas y las basadas en funtores
Qt ofrece dos formas diferentes de escribir conexiones de señales y ranuras en C++: la sintaxis de conexión basada en cadenas y la sintaxis de conexión basada en functores. Ambas sintaxis tienen sus ventajas e inconvenientes. La tabla siguiente resume sus diferencias.
| Característica | Basada en cadenas | Basada en funtores |
|---|---|---|
| Comprobación de tipos | Realizada en tiempo de ejecución | Se realiza en tiempo de compilación |
| Puede realizar conversiones de tipos implícitas. | No | Sí |
| Puede conectar señales a expresiones lambda. | No | Sí |
| Permite conectar señales a ranuras con más argumentos que la señal (utilizando parámetros por defecto). | Sí | No |
| Permite conectar funciones de C++ a funciones de QML. | Sí | No |
En las siguientes secciones se explican estas diferencias en detalle y se muestra cómo utilizar las características propias de cada sintaxis de conexión.
Comprobación de tipos y conversiones de tipos implícitas
Las conexiones basadas en cadenas realizan la comprobación de tipos comparando cadenas en tiempo de ejecución.
Se aplican las siguientes limitaciones:
| Limitación | Motivo |
|---|---|
| Los errores de conexión solo se pueden detectar una vez que el programa ha comenzado a ejecutarse. | N/A |
| No se pueden realizar conversiones implícitas entre señales y ranuras. | El comparador de cadenas no tiene acceso a la información de tipos de C++, por lo que se basa en la coincidencia exacta de cadenas. |
| No se pueden resolver los typedefs ni los espacios de nombres. |
Por el contrario, el compilador comprueba las conexiones basadas en functores. El compilador detecta los errores en tiempo de compilación, permite las conversiones implícitas entre tipos compatibles y reconoce los diferentes nombres de un mismo tipo.
Por ejemplo, solo se puede utilizar la sintaxis basada en funtores para conectar una señal que transporte un ` int ` a una ranura que acepte un ` double`. Un ` QSlider ` contiene un valor ` int `, mientras que un ` QDoubleSpinBox ` contiene un valor ` double `. El siguiente fragmento de código muestra cómo mantenerlos sincronizados:
auto slider = new QSlider(this);
auto doubleSpinBox = new QDoubleSpinBox(this);
// OK: The compiler can convert an int into a double
connect(slider, &QSlider::valueChanged,
doubleSpinBox, &QDoubleSpinBox::setValue);
// ERROR: The string table doesn't contain conversion information
connect(slider, SIGNAL(valueChanged(int)),
doubleSpinBox, SLOT(setValue(double)));El siguiente ejemplo ilustra la falta de resolución de nombres. QAudioInput::stateChanged() se declara con un argumento de tipo «QAudio::State». Por lo tanto, las conexiones basadas en cadenas también deben especificar «QAudio::State», incluso si "State" ya es visible. Este problema no afecta a las conexiones basadas en functores, ya que los tipos de los argumentos no forman parte de la conexión.
auto audioInput = new QAudioInput(QAudioFormat(), this);
auto widget = new QWidget(this);
// OK
connect(audioInput, SIGNAL(stateChanged(QAudio::State)),
widget, SLOT(show()));
// ERROR: The strings "State" and "QAudio::State" don't match
using namespace QAudio;
connect(audioInput, SIGNAL(stateChanged(State)),
widget, SLOT(show()));
// ...Realización de conexiones a expresiones lambda
La sintaxis de conexión basada en funtores permite conectar señales a expresiones lambda, que son, en la práctica, slots en línea. Esta característica no está disponible con la sintaxis basada en cadenas.
En el siguiente ejemplo, la clase `TextSender` emite una señal ` textCompleted() ` que lleva un parámetro ` QString `. Esta es la declaración de la clase:
class TextSender : public QWidget {
Q_OBJECT
QLineEdit *lineEdit;
QPushButton *button;
signals:
void textCompleted(const QString& text) const;
public:
TextSender(QWidget *parent = nullptr);
};Esta es la conexión que emite « TextSender::textCompleted() » cuando el usuario hace clic en el botón:
TextSender::TextSender(QWidget *parent) : QWidget(parent) {
lineEdit = new QLineEdit(this);
button = new QPushButton("Send", this);
connect(button, &QPushButton::clicked, [=] {
emit textCompleted(lineEdit->text());
});
// ...
}En este ejemplo, la función lambda simplificó la conexión a pesar de que QPushButton::clicked() y TextSender::textCompleted() tienen parámetros incompatibles. Por el contrario, una implementación basada en cadenas requeriría código repetitivo adicional.
Nota: La sintaxis de conexión basada en functores acepta punteros a todas las funciones, incluidas las funciones independientes y las funciones miembro normales. Sin embargo, en aras de la legibilidad, las señales solo deben conectarse a ranuras, expresiones lambda y otras señales.
Conexión de objetos C++ a objetos QML
La sintaxis basada en cadenas permite conectar objetos de C++ a objetos de QML, pero la sintaxis basada en functores no. Esto se debe a que los tipos de QML se resuelven en tiempo de ejecución, por lo que no están disponibles para el compilador de C++.
En el siguiente ejemplo, al hacer clic en el objeto QML, el objeto C++ muestra un mensaje, y viceversa. Este es el tipo QML (en QmlGui.qml):
Rectangle {
width: 100; height: 100
signal qmlSignal(string sentMsg)
function qmlSlot(receivedMsg) {
console.log("QML received: " + receivedMsg)
}
MouseArea {
anchors.fill: parent
onClicked: qmlSignal("Hello from QML!")
}
}Esta es la clase de C++:
class CppGui : public QWidget {
Q_OBJECT
QPushButton*button;
signals:
void cppSignal(const QVariant& sentMsg) const;
public slots:
void cppSlot(const QString& receivedMsg) const {
qDebug() << "C++ received:" << receivedMsg;
}
public:
CppGui(QWidget*parent = nullptr) : QWidget(parent) {
button = new QPushButton("¡Haz clic aquí!", this);
connect(button, &QPushButton::clicked, [=] {
emit cppSignal("¡Hola desde C++!");
});
}
};Este es el código que establece las conexiones entre señales y ranuras:
auto cppObj = new CppGui(this);
auto quickWidget = new QQuickWidget(QUrl("QmlGui.qml"), this);
auto qmlObj = quickWidget->rootObject();
// Connect QML signal to C++ slot
connect(qmlObj, SIGNAL(qmlSignal(QString)),
cppObj, SLOT(cppSlot(QString)));
// Connect C++ signal to QML slot
connect(cppObj, SIGNAL(cppSignal(QVariant)),
qmlObj, SLOT(qmlSlot(QVariant)));Nota: Todas las funciones JavaScript en QML aceptan parámetros de tipo ` var `, que se corresponde con el tipo ` QVariant ` en C++, a menos que utilicen anotaciones de tipo. Consulta «Invocación de métodos QML» para obtener más detalles.
Al hacer clic en el elemento « QPushButton », la consola muestra el mensaje «QML recibió: "¡Hola desde C++!"». Del mismo modo, al hacer clic en el «Rectangle», la consola muestra el mensaje «C++ recibió: "¡Hola desde QML!"».
Consulta Interactuar con objetos QML desde C++ para conocer otras formas de permitir que los objetos C++ interactúen con los objetos QML.
Uso de parámetros por defecto en las ranuras para conectarse a señales con menos parámetros
Por lo general, solo se puede establecer una conexión si el slot tiene el mismo número de argumentos que la señal (o menos) y si todos los tipos de argumentos son compatibles.
La sintaxis de conexión basada en cadenas ofrece una solución alternativa a esta regla: si el slot tiene parámetros por defecto, dichos parámetros pueden omitirse en la señal. Cuando la señal se emite con menos argumentos que el slot, Qt ejecuta el slot utilizando los valores por defecto de los parámetros.
Las conexiones basadas en funtores no admiten esta característica.
Supongamos que hay una clase llamada ` DemoWidget ` con un slot ` printNumber() ` que tiene un argumento por defecto:
public slots:
void printNumber(int number = 42) {
qDebug() << "Lucky number" << number;
}Utilizando una conexión basada en cadenas, DemoWidget::printNumber() se puede conectar a QApplication::aboutToQuit(), aunque esta última no tenga argumentos. La conexión basada en functores producirá un error en tiempo de compilación:
DemoWidget::DemoWidget(QWidget*parent) : QWidget(parent) {
// Correcto: se llamará a printNumber() con un valor por defecto de 42
connect(qApp, SIGNAL(aboutToQuit()),
esto, SLOT(printNumber()));
// ERROR: El compilador requiere argumentos compatibles
connect(qApp, &QCoreApplication::aboutToQuit,
this, &DemoWidget::printNumber);
}Para sortear esta limitación con la sintaxis basada en functores, conecta la señal a una función lambda que llame a la ranura. Consulta la sección anterior, «Realización de conexiones a expresiones lambda».
Selección de señales y ranuras sobrecargadas
Con la sintaxis basada en cadenas, los tipos de los parámetros se especifican de forma explícita. Como resultado, la instancia deseada de una señal o ranura sobrecargada no presenta ambigüedad.
Por el contrario, con la sintaxis basada en functores, hay que especificar explícitamente a qué versión de una señal o ranura sobrecargada se desea conectar.
Por ejemplo, QLCDNumber tiene tres versiones de la ranura « display() »:
QLCDNumber::display(int)QLCDNumber::display(double)QLCDNumber::display(QString)
Para conectar la versión de ` int ` a ` QSlider::valueChanged()`, las dos sintaxis son:
auto slider = new QSlider(this);
auto lcd = new QLCDNumber(this);
// String-based syntax
connect(slider, SIGNAL(valueChanged(int)),
lcd, SLOT(display(int)));
// Functor-based syntax
connect(slider, &QSlider::valueChanged,
lcd, qOverload<int>(&QLCDNumber::display));Para ver ejemplos detallados sobre cómo conectarse a señales y ranuras sobrecargadas utilizando qOverload(), static_cast y lambdas, consulta «Conexión a señales y ranuras sobrecargadas».
Véase también ` qOverload()`.
© 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.