回调函数实用写法

一、 

#ifndef DATAPROCESS_H
#define DATAPROCESS_H

#include <QObject>
#include <QDebug>
#include <functional>
#include <memory>
#include <iostream>
#include <QThread>
#include <QObject>
#include <QMutex>
#include <QWaitCondition>
#define type 1
typedef std::function<void(int)> Callback;
//using Callback = std::function<void(int)>;
//typedef void(*Callback)(int data) ;
extern QMutex  m_mutex;
//QWaitCondition 是 Qt 中用于线程间同步的类，它可以使一个线程等待，直到其他线程发出信号来通知它继续执行
extern QWaitCondition  m_Available;
extern int m_receiveData;
class DataProcess : public QObject
        #if type
        , public QThread
        #endif
{
    Q_OBJECT
public:
    explicit DataProcess(QObject *parent = nullptr) : QObject(parent)
    {
        m_back = nullptr;
        m_stop = false;
#if type
        start();
#else
        moveToThread(&m_thread); // 将对象移到新的线程
        connect(&m_thread, &QThread::started, this, &DataProcess::Slotprocess);
        m_thread.start(); // 启动线程
#endif
    }

    ~DataProcess()
    {
#if type
        if (isRunning())
        {
            stopThread(); // 结束线程的run()函数执行
            terminate();  // 强制结束
            wait();
        }
#else
        if (m_thread.isRunning())
        {
            stopThread();
            m_thread.quit(); // 退出线程的事件循环
            m_thread.wait(); // 等待线程退出
        }
#endif
    }

    void setCallback(Callback func) { m_back = func; }

    void stopThread()
    {
        QMutexLocker locker(&m_mutex);
        m_stop = true;
    }
#if type
protected:
    void run() Q_DECL_OVERRIDE
    {
        m_stop=false; // 启动线程时令m_stop=false
        while(!m_stop)
        {
            m_mutex.lock();
            m_Available.wait(&m_mutex); // 会先解锁mutex，使其他线程可以使用mutex
            // 在这里执行数据处理逻辑 
            if(m_back!=nullptr)
                m_back(m_receiveData);//发数据

            m_mutex.unlock();
        }
    }
#else
private slots:
    void Slotprocess()
    {
        while (!m_stop)
        {
            m_mutex.lock();
            m_Available.wait(&m_mutex); // 会先解锁mutex，使其他线程可以使用mutex
            // 在这里执行数据处理逻辑
            if(m_back!=nullptr)
                m_back(m_receiveData);

            m_mutex.unlock();
        }
    }
#endif
private:
    Callback m_back;
    bool m_stop;
    QThread m_thread;
};

#endif // DATAPROCESS_H

#include "dataprocess.h"
QMutex  m_mutex; // 互斥量
QWaitCondition  m_Available;
int m_receiveData;

#include "dataprocess.h"
DataProcess  m_dataprocess; // 数据处理类
class CCallback
{
public:
    void setCallback(const Callback& func)
    {
        m_dataprocess.setCallback(func);
    }

    void putData(int datagram)//有数据就执行线程
    {
        m_mutex.lock();
        m_receiveData = datagram;
        m_mutex.unlock();
        m_Available.wakeAll();// 唤醒所有线程，有新数据了
    }
};

class DY
{
public:
    DY()
    {
        m_back = std::make_unique<CCallback>();
        m_back->setCallback([this](int data) { callback(data); });
//        m_back->setCallback(std::bind(&DY::callback, this, std::placeholders::_1));
//        m_back->setCallback(&DY::callback);
    }

    void callback(int data) //接收最终数据
//    static void callback(int data)
    {
        qDebug() << data;
    }

    void setData() //传入原始数据
    {
        int i = 1;
        while (1) {
            m_back->putData(i++);
            std::this_thread::sleep_for(std::chrono::milliseconds(1000));
        }
    }
private:
    std::unique_ptr<CCallback> m_back;
};

int main(int argc, char *argv[])
{
    DY m_dy;
    m_dy.setData();
    return 0;
}

二、  

#include <functional>
#include <QDebug>

typedef std::function<void(const int& data)>  callback;
class Ccall
{
public:
    //    template<typename callback>
    void setInfo(callback call) { call(num); }
private:
    int num = 10;
};

class DY
{
public:
    DY() {
        m_call.setInfo([this](const int& data) { outdata(data); });
//        m_call.setInfo(std::bind(&DY::outdata, this, std::placeholders::_1));
    }
    void outdata(const int& data) {qDebug() << data;}
private:
    Ccall m_call;
};
int main()
{
    DY dy;
    return 0;
}