Qt 学习笔记#

class MyClass : public QObject
{
    Q_OBJECT  // ← 必须放在类声明最前面
public:
    explicit MyClass(QObject* parent = nullptr);
signals:
    void dataReady(const QByteArray& data);
private slots:
    void onTimeout();
};

// 旧式：字符串匹配（不推荐，运行时才报错）
connect(socket, SIGNAL(connected()), this, SLOT(onConnected()));

// 新式：函数指针（推荐，编译期类型检查）
connect(socket, &QTcpSocket::connected, this, &MyClass::onConnected);

// Lambda 作为槽
connect(timer, &QTimer::timeout, [this]() {
    m_retryCount++;
});

class MyWorker : public QObject
{
    Q_OBJECT
signals:
    void progressChanged(int percent);  // 只需声明，MOC 生成实现
    void finished(const QString& result);

public:
    void doWork()
    {
        emit progressChanged(50);  // emit 是空宏，纯标记
        emit finished("Done");
    }
};

// 阻塞 10 秒，界面完全卡死
void onButtonClicked() {
    QThread::sleep(10);
}

// 放到后台线程
void onButtonClicked() {
    QtConcurrent::run([this]() {
        QThread::sleep(10);  // 线程池中执行，界面正常
    });
}

QtHttpResponse request(const QString& method, const QString& url, ...)
{
    QNetworkReply* reply = sendRequest(method, req, body);

    QEventLoop loop;
    QTimer timer;
    timer.setSingleShot(true);

    connect(reply, &QNetworkReply::finished, &loop, &QEventLoop::quit);
    connect(&timer, &QTimer::timeout, &loop, &QEventLoop::quit);

    timer.start(m_timeoutMs);
    loop.exec();  // ← 嵌套事件循环，界面不卡

    if (timer.isActive()) {
        timer.stop();
        return parseReply(reply);
    } else {
        reply->abort();
        return QtHttpResponse{.error = "Request timeout"};
    }
}

// 创建时指定 parent，自动加入对象树
QWidget* central = new QWidget(mainWindow);
QVBoxLayout* layout = new QVBoxLayout(central);
QPushButton* btn = new QPushButton("OK", central);
// mainWindow 析构 → central 析构 → layout 和 btn 自动析构

// 危险：信号槽还在调用栈中，直接 delete 可能崩溃
void onReceived() {
    delete socket;
}

// 安全：延迟到事件循环下一轮删除
void onReceived() {
    socket->deleteLater();
}

QString s1 = "Hello";
QString s2 = QStringLiteral("世界");  // 编译期生成，推荐
QString s3 = QString("%1 + %2 = %3").arg(1).arg(2).arg(3);

s1.length();           // 长度
s1.contains("ell");    // 是否包含
s1.split(",");         // 分割
s1.toUtf8();           // 转 QByteArray

// QByteArray — 二进制数据
QByteArray data("hello");
data.toHex();           // 转十六进制
QString::fromUtf8(data); // → QString

// QVariant — 通用值容器
QVariant v = 42;
v.toInt();    // → 42
v.toString(); // → "42"

// QList / QMap / QHash（隐式共享，Copy-on-Write）
QList<QString> list;
list << "a" << "b" << "c";
QMap<QString, int> map;
map["one"] = 1;

QSettings settings("config/config.ini", QSettings::IniFormat);

settings.beginGroup("database");
settings.setValue("host", "localhost");
settings.setValue("port", 3306);
settings.endGroup();

settings.beginGroup("database");
QString host = settings.value("host", "localhost").toString();
int port = settings.value("port", 3306).toInt();
settings.endGroup();

ConfigManager& config = ConfigManager::instance();
config.initialize("config.ini");

// 简洁的 get/set，类型安全
QString host = config.get("database", "host", "localhost");
int port = config.getInt("database", "port", 3306);
config.set("database", "port", 5432);

// 变更通知（信号）
connect(&config, &ConfigManager::valueChanged,
    [](const QString& group, const QString& key, const QVariant& old, const QVariant& newVal) {
        qDebug() << group << "/" << key << "changed:" << old << "->" << newVal;
    });

// QFile
QFile file("data.txt");
if (file.open(QIODevice::ReadWrite)) {
    file.write("Hello Qt");
    file.seek(0);
    QByteArray data = file.readAll();
    file.close();
}

// QDir
QDir dir("logs");
if (!dir.exists()) dir.mkpath(".");
QStringList files = dir.entryList(QStringList() << "*.log", QDir::Files);

// QFileInfo
QFileInfo info("data.txt");
info.size();
info.absoluteFilePath();

// 应用目录
QString appDir = QCoreApplication::applicationDirPath();
QString configPath = QDir(appDir).filePath("config/config.ini");

class VideoThread : public QThread
{
    Q_OBJECT
public:
    explicit VideoThread(QObject* parent = nullptr)
        : QThread(parent)
    {
        qRegisterMetaType<QImage>("QImage");  // 跨线程信号槽需注册自定义类型
    }
signals:
    void frameReady(const QImage& frame, int channelId);
protected:
    void run() override {
        // run() 在新线程中执行
        while (!m_stop) {
            QImage image = matToQImage(frame);
            emit frameReady(image, m_channelId);  // 跨线程发射信号
        }
    }
};

class Worker : public QObject {
    Q_OBJECT
public slots:
    void doWork() {
        // 在 worker 线程中执行
        emit resultReady(result);
    }
signals:
    void resultReady(const QString& result);
};

QThread* thread = new QThread;
Worker* worker = new Worker;
worker->moveToThread(thread);

connect(thread, &QThread::started, worker, &Worker::doWork);
connect(worker, &Worker::resultReady, [](const QString& result) {
    qDebug() << "Result:" << result;
});
connect(thread, &QThread::finished, worker, &QObject::deleteLater);
thread->start();

// 跨线程信号槽（AutoConnection 自动变 QueuedConnection）
connect(worker, &Worker::resultReady, this, &MainWindow::onResult);

// QMetaObject::invokeMethod 投递任务到指定线程
QMetaObject::invokeMethod(this, [this]() {
    label->setText("Updated from thread");  // 在主线程执行
}, Qt::QueuedConnection);

QMutex mutex;
void threadSafeFunction() {
    QMutexLocker locker(&mutex);  // RAII，构造加锁析构解锁
    // 临界区
}

class QtTask : public QRunnable {
public:
    using Callback = std::function<void()>;
    explicit QtTask(Callback cb) : m_callback(std::move(cb)) {
        setAutoDelete(true);  // 执行完自动 delete
    }
    void run() override { if (m_callback) m_callback(); }
};

// 线程池
QThreadPool* pool = new QThreadPool(this);
pool->setMaxThreadCount(QThread::idealThreadCount());  // CPU 核心数
pool->start(new QtTask([]() { /* 后台任务 */ }));
pool->waitForDone();

// 在线程池中运行
QFuture<QString> future = QtConcurrent::run([]() -> QString {
    QThread::sleep(2);
    return "Done";
});

// 非阻塞监控
QFutureWatcher<QString>* watcher = new QFutureWatcher<QString>;
connect(watcher, &QFutureWatcher<QString>::finished, [=]() {
    qDebug() << "Result:" << watcher->result();
    watcher->deleteLater();
});
watcher->setFuture(future);

template<typename ResultType>
static ResultType execute(std::function<ResultType()> task, ...)
{
    QFuture<ResultType> future = QtConcurrent::run(task);
    QEventLoop loop;
    QFutureWatcher<ResultType> watcher;
    connect(&watcher, &QFutureWatcher<ResultType>::finished, &loop, &QEventLoop::quit);
    watcher.setFuture(future);
    loop.exec();  // ← 界面不卡，事件循环继续运转
    return future.result();
}

class QtTcpClient : public QObject
{
    Q_OBJECT
public:
    explicit QtTcpClient(QObject* parent = nullptr)
        : QObject(parent), m_socket(new QTcpSocket(this))
    {
        connect(m_socket, &QTcpSocket::connected, this, &QtTcpClient::connected);
        connect(m_socket, &QTcpSocket::readyRead, this, &QtTcpClient::onReadyRead);
    }
    void connectToHost(const QString& host, quint16 port) {
        m_socket->connectToHost(host, port);
    }
    qint64 send(const QByteArray& data) { return m_socket->write(data); }
signals:
    void connected();
    void dataReceived(const QByteArray& data);
private slots:
    void onReadyRead() {
        QByteArray data = m_socket->readAll();
        if (!data.isEmpty()) emit dataReceived(data);
    }
};

class QtTcpServer : public QObject
{
    Q_OBJECT
public:
    explicit QtTcpServer(QObject* parent = nullptr)
        : QObject(parent), m_server(new QTcpServer(this))
    {
        connect(m_server, &QTcpServer::newConnection, this, &QtTcpServer::onNewConnection);
    }
    bool listen(quint16 port) { return m_server->listen(QHostAddress::Any, port); }
    void broadcast(const QByteArray& data) {
        for (auto conn : m_connections) conn->send(data);
    }
private slots:
    void onNewConnection() {
        while (m_server->hasPendingConnections()) {
            QTcpSocket* socket = m_server->nextPendingConnection();
            auto conn = new QtTcpConnection(socket, this);
            m_connections.append(conn);
            connect(conn, &QtTcpConnection::disconnected, [this, conn]() {
                m_connections.removeOne(conn);
                conn->deleteLater();
            });
            emit newConnection(conn);
        }
    }
};

class QtUdpServer : public QObject
{
    Q_OBJECT
public:
    explicit QtUdpServer(QObject* parent = nullptr)
        : QObject(parent), m_socket(new QUdpSocket(this))
    {
        connect(m_socket, &QUdpSocket::readyRead, this, &QtUdpServer::onReadyRead);
    }
    bool start(quint16 port) { return m_socket->bind(QHostAddress::Any, port); }
    qint64 sendTo(const QHostAddress& addr, quint16 port, const QByteArray& data) {
        return m_socket->writeDatagram(data, addr, port);
    }
signals:
    void dataReceived(const QHostAddress& sender, quint16 port, const QByteArray& data);
private slots:
    void onReadyRead() {
        while (m_socket->hasPendingDatagrams()) {
            QByteArray datagram;
            datagram.resize(m_socket->pendingDatagramSize());
            QHostAddress addr; quint16 port;
            m_socket->readDatagram(datagram.data(), datagram.size(), &addr, &port);
            emit dataReceived(addr, port, datagram);
        }
    }
};

class QtHttpClient : public QObject
{
    Q_OBJECT
public:
    explicit QtHttpClient(QObject* parent = nullptr)
        : QObject(parent), m_manager(new QNetworkAccessManager(this)), m_timeoutMs(30000) {}

    // 同步 GET（QEventLoop 等待）
    QtHttpResponse get(const QString& url, const QMap<QString, QString>& headers = {}) {
        return request("GET", url, QByteArray(), headers);
    }
    // 异步 GET（回调）
    void getAsync(const QString& url, HttpCallback callback, ...) {
        requestAsync("GET", url, QByteArray(), callback, headers);
    }
};

class QtWebSocketClient : public QObject
{
    Q_OBJECT
public:
    explicit QtWebSocketClient(QObject* parent = nullptr)
        : QObject(parent), m_socket(new QWebSocket(..., this))
    {
        connect(m_socket, &QWebSocket::connected, this, &QtWebSocketClient::connected);
        connect(m_socket, &QWebSocket::textMessageReceived, this, &QtWebSocketClient::messageReceived);
    }
    void connectToServer(const QString& url) { m_socket->open(QUrl(url)); }
    qint64 send(const QString& msg) { return m_socket->sendTextMessage(msg); }
signals:
    void connected();
    void messageReceived(const QString& message);
};

// 垂直布局
QVBoxLayout* vLayout = new QVBoxLayout(parent);
vLayout->addWidget(button1);
vLayout->addStretch();  // 弹性空间

// 水平布局
QHBoxLayout* hLayout = new QHBoxLayout;
hLayout->addWidget(label);
hLayout->addWidget(inputField);

// 网格布局
QGridLayout* grid = new QGridLayout;
grid->addWidget(label1, 0, 0);  // row=0, col=0
grid->addWidget(input1, 0, 1);

// 嵌套
QVBoxLayout* main = new QVBoxLayout(window);
main->addLayout(hLayout);
main->addLayout(grid);

class MyWidget : public QWidget {
protected:
    void mousePressEvent(QMouseEvent* event) override {
        if (event->button() == Qt::LeftButton)
            qDebug() << "Left click at" << event->pos();
        QWidget::mousePressEvent(event);  // 调用基类保持默认行为
    }
    void keyPressEvent(QKeyEvent* event) override {
        if (event->key() == Qt::Key_Escape) close();
        else QWidget::keyPressEvent(event);
    }
    void resizeEvent(QResizeEvent* event) override {
        QWidget::resizeEvent(event);
        repositionOverlays();
    }
};

textEdit->installEventFilter(this);  // 监听 textEdit 的事件

bool MyWindow::eventFilter(QObject* watched, QEvent* event) {
    if (watched == textEdit && event->type() == QEvent::KeyPress) {
        // 拦截特定按键
        return true;  // true = 事件被过滤
    }
    return QWidget::eventFilter(watched, event);
}

void MyWidget::paintEvent(QPaintEvent*) {
    QPainter painter(this);
    painter.setRenderHint(QPainter::Antialiasing);

    painter.setPen(QPen(Qt::blue, 2));
    painter.setBrush(QBrush(Qt::red));
    painter.drawRect(10, 10, 100, 50);

    painter.setPen(Qt::white);
    painter.setFont(QFont("Arial", 14));
    painter.drawText(rect(), Qt::AlignCenter, "Hello Qt");

    QImage image("photo.jpg");
    painter.drawImage(50, 50, image.scaled(200, 200, Qt::KeepAspectRatio));
}

// 全局样式
qApp->setStyleSheet(
    "QPushButton { background-color: #4CAF50; color: white; border: none; padding: 8px 16px; border-radius: 4px; }"
    "QPushButton:hover { background-color: #45a049; }"
    "QPushButton:pressed { background-color: #3d8b40; }"
);

// 单个控件
label->setStyleSheet("background: rgba(0,0,0,150); color: #fff; font-size: 12px;");

// 周期定时器
QTimer* timer = new QTimer(this);
timer->setInterval(1000);
connect(timer, &QTimer::timeout, [this]() { qDebug() << "Tick"; });
timer->start();

// 单次定时器
QTimer::singleShot(3000, [this]() { qDebug() << "3s later"; });

timer->stop();

// 简单用法
QStandardItemModel* model = new QStandardItemModel(this);
model->setHorizontalHeaderLabels({"Name", "Age"});
model->appendRow({new QStandardItem("Alice"), new QStandardItem("25")});

QTableView* view = new QTableView;
view->setModel(model);

#ifdef Q_OS_WIN
    args << "-n" << "1" << "-w" << QString::number(timeoutMs) << host;
#else
    args << "-c" << "1" << "-W" << QString::number(timeoutMs / 1000) << host;
#endif