QC++ / Qt 学习之路

元对象系统与信号槽

理解 moc 原理并掌握信号槽的三种 connect 写法

入门第 18 / 48 章第三篇 · Qt 入门

#为什么 C++ 需要"元对象系统"

信号槽是 Qt 最著名的特性,也是很多人"听说 Qt"的第一印象。它的本质是对象之间的松耦合通信机制:一个对象发生了某件事(发出信号),关心这件事的对象会自动收到通知(执行槽函数),而发信号的一方完全不需要知道谁在听。

信号与槽 Signal & Slot:对象间松耦合通信connect 建立连接,emit 触发信号,元对象系统在中间查表并调用槽函数发送者 Sender(QObject 子类)class Sender : public QObject { Q_OBJECTsignals: void valueChanged(int);};emit valueChanged(42)元对象系统moc 生成元对象代码连接表:signal → slot按对象 + 信号索引查表onValueChanged(int)成员函数槽[=](int v) { ... }Lambda 槽函数connect(sender, &Sender::valueChanged, this, &Widget::onValueChanged);Qt::AutoConnection:默认自动判断直连还是队列跨线程自动转为队列连接 Qt::QueuedConnection:信号被包装成事件,投递到接收者所在线程再执行自定义类型作为跨线程参数时,需先 qRegisterMetaType<T>() 注册
信号槽的连接与分发:emit 之后发生了什么

你可能会问:C++ 不是有函数指针、有 std::function、有虚函数吗?为什么还要另起炉灶?原因是标准 C++ 没有反射——运行时无法查询"这个类有哪些方法""这个方法叫什么名字""参数类型是什么"。而信号槽想要做到"按名字连接"、"跨线程自动投递"、"支持按字符串在运行时动态调用",就必须有一份类的元数据。

Qt 的解决办法是引入元对象系统(Meta-Object System),由三部分组成:

  1. Q_OBJECT 宏:写在类的私有段,声明"我需要元对象能力"。
  2. moc(Meta-Object Compiler):一个预处理器,扫描含 Q_OBJECT 的头文件,生成一份额外的 moc_xxx.cpp,里面是该类的元数据表与信号实现。
  3. QObject 基类:提供 metaObject()、property()、connect() 等运行时接口。

对比:Java 天然支持反射(Class.getMethods()),因此 Swing 的监听器机制直接基于接口与反射实现;Python 更是动态语言,PyQt 的信号槽几乎不需要额外工具。C++ 没有这些,Qt 只好用"代码生成"来补——这就是 moc 存在的原因。理解这一点,你就明白 moc 不是什么黑魔法,它只是一个在编译前运行、帮你写样板代码的工具。

#第一个自定义信号与槽

看一个完整例子:一个"计数器"类,计数变化时发出信号;窗口收到信号后更新标题。

C++
// counter.h
#pragma once
#include <QObject>

class Counter : public QObject
{
    Q_OBJECT          // 必须:启用元对象系统
public:
    explicit Counter(QObject *parent = nullptr) : QObject(parent) {}

    int value() const { return m_value; }

public slots:         // 槽:可以被信号触发,也可以像普通函数一样调用
    void setValue(int v)
    {
        if (v == m_value)
            return;
        m_value = v;
        emit valueChanged(m_value);   // emit 是个空宏,只为可读性
    }
    void reset() { setValue(0); }

signals:              // 信号:只需声明,不用实现(moc 会生成实现)
    void valueChanged(int newValue);

private:
    int m_value = 0;
};
C++
// main.cpp
#include <QApplication>
#include <QPushButton>
#include <QDebug>
#include "counter.h"

int main(int argc, char *argv[])
{
    QApplication app(argc, argv);

    Counter counter;
    QPushButton button("加一");

    // 写法 A:函数指针(Qt 5/6 推荐)
    QObject::connect(&button, &QPushButton::clicked,
                     &counter, [&counter]() {
                         counter.setValue(counter.value() + 1);
                     });

    // 写法 B:函数指针连接信号到槽
    QObject::connect(&counter, &Counter::valueChanged,
                     &counter, [](int v) {
                         qDebug() << "当前值:" << v;
                     });

    button.show();
    return app.exec();
}

对应的 CMake 必须开启 AUTOMOC(上一章已配置),并且头文件必须被 add_executable 收录或被 CMake 扫描到——Qt 6 的 AUTOMOC 会自动扫描目标源文件所在目录的头文件,一般无需手动列出 .h,但如果你的头文件在别的目录,就要显式加上。

几个关键点:

  • Q_OBJECT 必须写在类的声明里,且该类必须(直接或间接)继承 QObject,且必须是继承列表中的第一个。
  • signals 段下的函数不需要你实现,moc 会生成。你写了实现反而会报"重复定义"。
  • emit 其实是空宏(#define emit,展开后什么都没有),它纯粹是为了让读代码的人一眼看出"这里在发信号"。写不写都一样。
  • 信号是 public 的(在 Qt 的语义里 signals 段默认 public),任何人都 emit?实际上 Qt 把 signals 声明为 protected 的信号只能由该类自己发出,这是 Qt 6 的一个改进——Qt 6 中信号是 public 的但 Qt 建议遵守封装;在 Qt 5 中 signals 是 protected。

#关于 private 段与 Q_OBJECT

Q_OBJECT 展开后包含若干成员函数声明,通常写在类开头(默认 private 区)。如果你的类开头就是 public:,那么 Q_OBJECT 里的成员会变成 public,一般无害,但约定俗成写在最前面。

#connect 的三种写法

#写法一:函数指针(推荐)

C++
QObject::connect(sender, &SenderClass::signalName,
                 receiver, &ReceiverClass::slotName);

// 参数可以"少"但不能"多":槽的参数个数 ≤ 信号的参数个数,且类型必须兼容
connect(&counter, &Counter::valueChanged, this, &MyWindow::onValueChanged);
// void onValueChanged(int v);       // OK
// void onValueChanged();            // OK,忽略参数
// void onValueChanged(QString s);   // 编译错误,类型不匹配

优点:编译期检查。

#写法二:Lambda 表达式(最灵活)

C++
connect(&counter, &Counter::valueChanged,
        this, [this](int v) {          // 第三个参数是"上下文对象",用于自动断开
            m_label->setText(QString::number(v));
            qDebug() << "收到:" << v;
        });

Lambda 写法在 Qt 5 引入,是现在最常用的形式。它有三到四个参数,第三个(上例的 this)被称为上下文对象(context object):当这个对象被销毁时,连接自动失效,避免 Lambda 捕获了已析构的对象。这个参数强烈建议不要省略——如果写成三参数版本 connect(sender, &S::sig, lambda),Lambda 会在 sender 存活期间一直有效,捕获的 this 可能已经悬空。

对比:Web 前端里 element.addEventListener('click', () => {...}) 也是注册回调,但 JS 的箭头函数靠闭包捕获变量,且没有自动解绑——你必须手动 removeEventListener,否则就是内存泄漏。Qt 的"上下文对象"机制相当于帮你自动 removeEventListener,这是 Qt 在资源管理上更省心的体现。Java Swing 的 addActionListener 同样需要手动 removeActionListener。

#写法三:旧式字符串宏(不推荐,但要认识)

C++
// Qt 4 风格,Qt 5/6 仍然支持,但不要用在新代码里
connect(&counter, SIGNAL(valueChanged(int)),
        this, SLOT(onValueChanged(int)));

这种写法用 SIGNAL() / SLOT() 宏把函数签名转成字符串,在运行时按名字查找。问题很明显:拼错名字、参数类型写错,编译器一声不吭,只在运行时输出一行警告 "QObject::connect: No such signal ...",然后功能静默失效——这是 Qt 4 时代最难查的 bug 来源之一。

它唯一的优势是支持运行时动态连接(名字是运行时拼出来的字符串),某些插件化、脚本化场景还会用到。日常开发请一律用写法一或写法二。

Qt 5 提示:三种写法在 Qt 5 中都可用,行为一致。Qt 6 依然保留字符串写法,但官方已标记为"不推荐"。另外 Qt 6 中 QObject::connect 的重载做了清理,部分 Qt 5 里能编译的模糊调用在 Qt 6 中需要显式转换。

#disconnect:断开连接

C++
// 断开某个 sender 的所有连接
disconnect(&counter, nullptr, nullptr, nullptr);

// 断开特定信号与特定接收者
disconnect(&counter, &Counter::valueChanged, this, nullptr);

// 断开 sender 发出的某个信号的所有连接
disconnect(&counter, &Counter::valueChanged, nullptr, nullptr);

// connect 返回 QMetaObject::Connection,保存它可精确断开某一条
QMetaObject::Connection conn = connect(&counter, &Counter::valueChanged, ...);
// ...
disconnect(conn);

还有一个很实用的技巧:临时阻塞而非断开。用 QSignalBlocker(RAII 风格)可以在作用域内屏蔽某个对象的所有信号,常用于"程序设置控件值时不想触发其信号"的场景:

C++
{
    QSignalBlocker blocker(m_spinBox);   // 进入作用域,信号被屏蔽
    m_spinBox->setValue(100);            // 不会触发 valueChanged
}                                        // 出作用域,自动恢复

这比 Tkinter 里的手动 remove + re-add 回调优雅得多,也避免了忘记恢复的 bug。

#信号槽的线程安全

这是信号槽最强大的地方:Qt 的 connect 有一个第五个参数 Qt::ConnectionType,默认值为 Qt::AutoConnection:

  • Qt::DirectConnection:信号发出的瞬间,在发送者线程里同步调用槽函数。等价于普通函数调用。
  • Qt::QueuedConnection:把调用请求包装成一个事件,投递到接收者所在线程的事件队列,等接收者线程的事件循环下次取事件时才执行。异步。
  • Qt::BlockingQueuedConnection:同上,但发送者线程会阻塞等待槽执行完毕。注意:发送者与接收者若在同一线程会死锁。
  • Qt::AutoConnection(默认):Qt 自动判断——如果发送者与接收者在同一线程,用 Direct;不同线程,用 Queued。

正是这个默认行为,让 Qt 的跨线程通信变得极其简单:工作线程 emit 一个信号,主线程(GUI 线程)里的槽就会安全地被执行,你不需要自己加锁、不需要自己写消息队列。

C++
// 工作线程只管发信号,UI 更新自动回到主线程
void Worker::doWork() {
    for (int i = 0; i <= 100; ++i) {
        emit progress(i);        // AutoConnection → 跨线程 → Queued
    }
    emit finished();
}

必须强调一条铁律:所有界面控件的操作都必须在主线程(也叫 GUI 线程,即创建 QApplication 的那个线程)进行。工作线程直接调用 label->setText() 是未定义行为,可能崩溃也可能侥幸没事——一定要通过信号槽或 QMetaObject::invokeMethod 切回主线程。

对比:Java Swing 有严格规定——只有 EDT 能碰组件,其他线程必须用 SwingUtilities.invokeLater();Android 同样只允许主线程更新 UI。Qt 的机制与之等价,但因为信号槽的自动队列投递,语法上你感受不到"切换线程"这件事,写起来自然得多。代价是:你必须清楚哪些对象"活在"哪个线程(QObject::thread() 可以查询)。

#与观察者模式、回调的对比

如果你学过设计模式,会发现信号槽就是观察者模式(Observer)的一种实现。对比一下:

维度经典观察者(Java/GoF)Qt 信号槽
接口约束观察者必须实现统一接口(如 Observer.update())槽可以是任意签名的成员函数或 Lambda,无接口约束
注册方式subject.addObserver(this),通常需要手动移除connect(),对象销毁时自动断开
通知粒度通常一个 update(),靠参数区分事件一个信号对应一种事件,类型安全
跨线程需自己实现同步内建 QueuedConnection
参数传递通常需要定义事件类直接传任意(已注册元类型的)参数

与普通回调函数(std::function、JS 的 callback)相比,信号槽的独特之处是:多对多——一个信号可以连多个槽,一个槽可以被多个信号触发,且双方互不持有对方的引用,生命周期由 Qt 托管。这避免了 C++ 里最头疼的"回调捕获了已析构对象"的问题。

#小结

  • 元对象系统 = Q_OBJECT 宏 + moc 预处理器 + QObject 基类;moc 生成元数据与信号实现,是 C++ 缺乏反射的补偿方案。
  • signals 段只声明不实现;emit 是空宏;槽就是普通成员函数,可直接调用。
  • connect 三种写法:函数指针(编译期检查,推荐)、Lambda(灵活,务必传上下文对象)、字符串宏(Qt 4 遗留,勿用)。
  • QSignalBlocker 用于临时屏蔽信号;disconnect 或保存 QMetaObject::Connection 可精确断开。
  • 默认 Qt::AutoConnection 使跨线程通信自动变为队列投递;界面操作必须留在主线程。

#练习

  1. 编写一个 TemperatureSensor 类,带 temperatureChanged(double) 信号和 setTemperature(double) 槽;用三种 connect 写法各连接一次并观察输出顺序(提示:信号发出时,槽按连接顺序依次执行)。
  2. 写一个窗口,含一个输入框和一个按钮,点击按钮时发出自定义信号 textSubmitted(QString),窗口的槽把它显示在标签上。要求用函数指针写法。
  3. 故意把信号参数写成 (int) 而槽写成 (QString),分别用函数指针写法和字符串写法,对比两者的报错时机(一个编译期、一个运行期)。
  4. 用 QThread 或 QtConcurrent 起一个工作线程,循环 emit progress(int) 更新主线程的 QProgressBar;尝试把连接类型改成 Qt::DirectConnection,观察并解释发生了什么。
我的学习笔记笔记总览
笔记保存在本机浏览器(localStorage),换设备或清理缓存会丢失;重要内容请点「导出全部笔记」存成 .md 文件。