Tipo personalizado en cola
El ejemplo «Tipo personalizado en cola» muestra cómo enviar tipos personalizados entre subprocesos mediante señales y ranuras en cola.

Descripción general
En este ejemplo, creamos una clase de valor, Block, y la registramos en el sistema de metaobjetos para poder enviar instancias de la misma entre subprocesos utilizando señales y ranuras en cola.
La clase de bloques
La clase ` Block ` proporciona el constructor por defecto, el constructor de copia y un destructor en la sección pública de la clase, tal y como exige el sistema de metaobjetos. La clase describe un rectángulo de color.
class Block
{
public:
Block();
Block(const Block &other);
~Block();
Block(const QRect &rect, const QColor &color);
QColor color() const;
QRect rect() const;
private:
QRect m_rect;
QColor m_color;
};
Q_DECLARE_METATYPE(Block);Aún así, tendremos que registrarla en el sistema de metaobjetos en tiempo de ejecución llamando a la función de plantilla ` qRegisterMetaType()` antes de establecer cualquier conexión de señal-ranura que utilice este tipo. Aunque en este ejemplo no tengamos intención de utilizar el tipo con ` QVariant `, es una buena práctica declarar también el nuevo tipo con ` Q_DECLARE_METATYPE()`.
La implementación de la clase ` Block ` es muy sencilla, por lo que no la incluimos aquí.
La clase Window
Definimos una clase sencilla ` Window ` con una ranura pública que acepta un objeto ` Block `. El resto de la clase se dedica a gestionar la interfaz de usuario y a manejar imágenes.
class Window : public QWidget
{
Q_OBJECT
public:
Window(QWidget *parent = nullptr);
void loadImage(const QImage &image);
public slots:
void addBlock(const Block &block);
private slots:
void loadImage();
void resetUi();
private:
QLabel *label;
QPixmap pixmap;
QPushButton *loadButton;
QPushButton *resetButton;
QString path;
RenderThread *thread;
};La clase ` Window ` también contiene un hilo de trabajo, proporcionado por un objeto ` RenderThread `. Este emitirá señales para enviar objetos ` Block ` a la ranura ` addBlock(Block) ` de la ventana.
Las partes más relevantes de la clase ` Window ` son el constructor y la ranura ` addBlock(Block) `.
El constructor crea un hilo para renderizar imágenes y configura una interfaz de usuario que contiene una etiqueta y dos botones conectados a ranuras de la misma clase.
Window::Window(QWidget *parent)
: QWidget(parent), thread(new RenderThread(this))
{
label = new QLabel(this);
label->setAlignment(Qt::AlignCenter);
loadButton = new QPushButton(tr("&Load image..."), this);
resetButton = new QPushButton(tr("&Stop"), this);
resetButton->setEnabled(false);
connect(loadButton, &QPushButton::clicked,
this, QOverload<>::of(&Window::loadImage));
connect(resetButton, &QPushButton::clicked,
thread, &RenderThread::requestInterruption);
connect(thread, &RenderThread::finished,
this, &Window::resetUi);
connect(thread, &RenderThread::sendBlock,
this, &Window::addBlock);En la última de estas conexiones, conectamos una señal del objeto ` RenderThread ` a la ranura ` addBlock(Block) ` de la ventana.
...
setWindowTitle(tr("Queued Custom Type"));
}El resto del constructor se limita a configurar el diseño de la ventana.
La ranura addBlock(Block) recibe bloques del hilo de renderizado a través de la conexión de señal-ranura establecida en el constructor:
void Window::addBlock(const Block &block)
{
QColor color = block.color();
color.setAlpha(64);
QPainter painter;
painter.begin(&pixmap);
painter.fillRect(block.rect(), color);
painter.end();
label->setPixmap(pixmap);
}Simplemente los dibujamos en la etiqueta a medida que van llegando.
La clase `RenderThread`
La clase ` RenderThread ` procesa una imagen, creando objetos ` Block ` y utilizando la señal ` sendBlock(Block) ` para enviarlos a otros componentes del ejemplo.
class RenderThread : public QThread
{
Q_OBJECT
public:
RenderThread(QObject *parent = nullptr);
~RenderThread();
void processImage(const QImage &image);
signals:
void sendBlock(const Block &block);
protected:
void run();
private:
QImage m_image;
};El constructor y el destructor no se incluyen aquí. Estos se encargan de configurar el estado interno del hilo y de limpiarlo cuando se destruye.
El procesamiento se inicia con la función ` processImage() `, que llama a la reimplementación de la función ` QThread::run()` de la clase ` RenderThread `:
void RenderThread::processImage(const QImage &image)
{
if (image.isNull())
return;
m_image = image;
start();
}
void RenderThread::run()
{
const int size = qMax(m_image.width()/20, m_image.height()/20);
for (int s = size; s > 0; --s) {
for (int c = 0; c < 400; ++c) {Sin entrar en detalles sobre cómo se procesa la imagen, vemos que la señal que contiene un bloque se emite de la forma habitual:
...
const Block block(QRect(x1, y1, x2 - x1 + 1, y2 - y1 + 1),
QColor(red/n, green/n, blue/n));
emit sendBlock(block);
if (isInterruptionRequested())
return;
msleep(10);
}
}
}Cada señal que se emita se pondrá en cola y se enviará posteriormente al slot « addBlock(Block) » de la ventana.
Registro del tipo
En la función ` main() ` del ejemplo, registramos la clase ` Block ` como tipo personalizado en el sistema de metaobjetos llamando a la función de plantilla ` qRegisterMetaType()`:
int main(int argc, char *argv[])
{
QApplication app(argc, argv);
qRegisterMetaType<Block>();
Window window;
window.show();
window.loadImage(createImage(256, 256));
return app.exec();
}Esta llamada se incluye aquí para garantizar que el tipo quede registrado antes de que se establezca cualquier conexión de señal-ranura que lo utilice.
El resto de la función ` main() ` se encarga de establecer una semilla para el generador de números pseudoaleatorios, crear y mostrar la ventana, y establecer una imagen por defecto. Consulta el código fuente para ver la implementación de la función ` createImage() `.
Lecturas recomendadas
Este ejemplo ha mostrado cómo se puede registrar un tipo personalizado en el sistema de metaobjetos para que pueda utilizarse con conexiones de señal-ranura entre subprocesos.
En la práctica, tanto la macro ` Q_DECLARE_METATYPE()` como la función de plantilla ` qRegisterMetaType()` pueden utilizarse para registrar tipos personalizados, pero ` qRegisterMetaType()` solo es necesaria si se necesita realizar comunicación de señales y ranuras o si es preciso crear y destruir objetos del tipo personalizado en tiempo de ejecución.
Puedes encontrar más información sobre el uso de tipos personalizados con Qt en el documento «Creación de tipos personalizados en Qt ».
© 2026 The Qt Company Ltd. Documentation contributions included herein are the copyrights of their respective owners. The documentation provided herein is licensed under the terms of the GNU Free Documentation License version 1.3 as published by the Free Software Foundation. Qt and respective logos are trademarks of The Qt Company Ltd. in Finland and/or other countries worldwide. All other trademarks are property of their respective owners.