使用c++函数式编程实现Qt信号槽机制

于 2024-07-04 21:01:43 发布
阅读量250 收藏 4
点赞数 4
文章标签： c++ qt
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43495002/article/details/139992007
版权

问题背景

在下面的代码中，Input输入器 输入数据，希望A和B 接收数据。但使用的赋值，导致in.a和a只是拷贝数据，而不是同一个对象，使得数据不同步。

#include <iostream>
struct A
{
    int age = 32;
};
struct B
{
    int age = 10;
};

struct Input
{
    void fun(int i){
        a.age = i;
        b.age = i;
    }
    A a;
    B b;
};
int main(int argc, char *argv[])
{
    Input in;
    A a;
    B b;
    in.a = a;
    in.b = b;
    in.fun(3);
    std::cout<<a.age<<" "<<b.age<<std::endl;//32 10
    return 0;
}

解决方法1：如下所示，当希望修改in.a的age时能修改到A a的age，需要传指针A，而且还要手动指定in.a = &a

#include <iostream>
struct A
{
    int age = 32;
};
struct Input
{
    void fun(int i){
        a->age = i;
        std::cout<<a->age<<std::endl;
    }
    A* a;
};
int main(int argc, char *argv[])
{
    Input in;
    A a;
    in.a = &a;
    in.fun(4);//4
    return 0;
}

解决方法2：使用function实现回调函数，将fun函数的赋值操作写在回调函数中

#include <iostream>
#include<functional>
struct A
{
    int age = 32;
};
struct Input
{
    void fun(int i){
        callback(i);
    }
    std::function<void(int)> callback;
};
int main(int argc, char *argv[])
{
    Input in;
    A a;
    in.callback = [&a](int i){
        a.age = i;
        std::cout<<a.age<<std::endl;
    };
    in.fun(4);//4
    return 0;
}

方法3：将添加回调函数和执行回调函数抽离出来，实现成Signal信号的形式

#include <iostream>
#include<functional>
#include <vector>
struct Signal
{
    std::vector<std::function<void(int)>> m_callbacks;
    void connect(std::function<void(int i)> callback){
        m_callbacks.push_back(std::move(callback));
    }
    void emit(int i){
        for(auto&& callback: m_callbacks){
            callback(i);
        }
    }
};
struct A
{
    int age = 32;
};
struct Input
{
    void fun(int i){
        on_input.emit(i);
    }
    Signal on_input;
};
int main(int argc, char *argv[])
{
    Input in;
    A a;
    in.on_input.connect([&a](int i){
        a.age = i;
        std::cout<<a.age<<std::endl;
    });
    in.on_input.connect([&a](int i){
        a.age = i;
        std::cout<<a.age<<std::endl;
    });
    in.fun(4);//4
    return 0;
}

4：如果类A需要注册一个退出事件on_exit，有如下实现。但实际上我们并不希望在此信号传递参数int i。

#include <iostream>
#include <functional>
#include <vector>
struct Signal
{
    std::vector<std::function<void(int)>> m_callbacks;
    void connect(std::function<void(int i)> callback){
        m_callbacks.push_back(std::move(callback));
    }
    void emit(int i){
        for(auto&& callback: m_callbacks){
            callback(i);
        }
    }
};
struct A
{   
    void on_input(int i) const {
        std::cout<<"input "<<age<<std::endl;
    }
    void on_exit() const {
        std::cout<<"exit "<<std::endl;
    }
    int age = 32;
};
struct Input
{
    //调用该函数就发出 进入事件和退出事件的信号
    void fun(int i){
        on_input.emit(i);
        on_exit.emit(i);
    }
    Signal on_input;//进入事件
    Signal on_exit;//退出事件
};
int main(int argc, char *argv[])
{
    Input in;
    A a;
    in.on_input.connect([&a](int i){
        a.age = i;
        a.on_input(i);
    });
    in.on_exit.connect([&a](int i){
        a.on_exit();
    });
    in.fun(4);//4
    return 0;
}

5：为了信号更加通用，使用变长模板参数来实现。注意：…在左边表示定义，在右边表示使用

#include <iostream>
#include <functional>
#include <vector>
template<class ...T>//定义T
struct Signal
{
    std::vector<std::function<void(T...)>> m_callbacks;//使用T
    void connect(std::function<void(T...)> callback){
        m_callbacks.push_back(std::move(callback));
    }
    void emit(T... t){//使用T， 定义t
        for(auto&& callback: m_callbacks){
            callback(t...);//使用t
        }
    }
};
struct A
{   
    void on_input(int i) const {
        std::cout<<"input "<<age<<std::endl;
    }
    void on_exit() const {
        std::cout<<"exit "<<std::endl;
    }
    int age = 32;
};
struct Input
{
    //调用该函数就发出 进入事件和退出事件的信号
    void fun(int i){
        on_input.emit(i);
        on_exit.emit();
    }
    Signal<int> on_input;//进入事件
    Signal<> on_exit;//退出事件
};
int main(int argc, char *argv[])
{
    Input in;
    A a;
    in.on_input.connect([&a](int i){
        a.age = i;
        a.on_input(i);
    });
    in.on_exit.connect([&a](){
        a.on_exit();
    });
    in.fun(4);//4
    return 0;
}

6：上述代码main函数中connect时传入的lambda表达式，下面在Signal中将其封装为bind方法，并提供对应的connect函数，使其更类似于Qt信号的connect。实际上Qt中是使用字符串来查找匹配的类型名，而这里我们使用模板更加高效

#include <iostream>
#include <functional>
#include <vector>

template<class Self, class MemFn>
auto bind(Self *self, MemFn memfn){//第2个参数为成员函数指针：void(A::*)(int i)，这里使用模板来避免写成该复杂类型
    //调用成员函数指针(a->*memfn)()。如果是普通函数指针，就是(*memfn)()这样调用
    return [self, memfn](auto... t){
        (self->*memfn)(t...);
    };
}

template<class ...T>//定义T
struct Signal
{
    std::vector<std::function<void(T...)>> m_callbacks;//使用T
    void connect(std::function<void(T...)> callback){
        m_callbacks.push_back(std::move(callback));
    }
    //提供一个bind版本的connect，类似qt语法
    template<class Self, class MemFn>
    void connect(Self *self, MemFn memfn){
        m_callbacks.push_back(bind(self, memfn));
    }

    void emit(T... t){//使用T， 定义t
        for(auto&& callback: m_callbacks){
            callback(t...);//使用t
        }
    }
};
struct A
{   
    void on_input(int i){
        age = i;
        std::cout<<"input "<<age<<std::endl;
    }
    void on_exit(std::string s) const {
        std::cout<<"exit "<<s<<std::endl;
    }
    int age = 32;
};
struct Input
{
    //调用该函数就发出 进入事件和退出事件的信号
    void fun(int i){
        on_input.emit(i);
        on_exit.emit("byebye");
    }
    Signal<int> on_input;//进入事件
    Signal<std::string> on_exit;//退出事件
};


int main(int argc, char *argv[])
{
    Input in;
    A a;
    in.on_input.connect(&a, &A::on_input);
    in.on_exit.connect(&a, &A::on_exit);
    in.fun(4);//4
    return 0;
}

下面写了重载函数test_fun作为要connect的函数，此时必须写明要使用哪个函数，因此下面使用static_cast进行转换

void test_fun(int m){
    std::cout<<"int "<<m<<std::endl;
}
void test_fun(std::string m){
    std::cout<<"string "<<m<<std::endl;
}
//function要求必须有唯一的重载，这样必须指定使用哪个
in.on_input.connect(static_cast<void(*)(int)>(test_fun));

7：为了避免connect的对象提前析构，下面代码使用智能指针

template<class Self, class MemFn>
auto bind(Self self, MemFn memfn){
    return [self, memfn](auto... t){
        ((*self).*memfn)(t...);
    };
}

void test2(Input &input){
    auto a = std::make_shared<A>();//使用智能指针而不是A a，避免对象提前析构
    input.on_input.connect(a, &A::on_input);//这里智能指针a发生拷贝
    input.on_exit.connect(a, &A::on_exit);
}

int main(int argc, char *argv[])
{
    Input in;
    test2(in);
    in.fun(3);
    return 0;
}

如果是connect lambda表达式，注意按值捕获，否则智能指针和a对象都会提前析构掉

void test2(Input &input){
    auto a = std::make_shared<A>();
    input.on_input.connect([a](int i){//注意按值捕获a
        return a->on_input(i);
    });
}
爬虫大佬
关注
C++与Qt中回调函数的两种实现方法
热土程序园，利他愉己~
04-09 1605
回调函数的应用场合 事件驱动编程：在图形用户界面（GUI）编程中，用户的每一个动作，如点击按钮、移动鼠标等，都可能会触发一个事件。这些事件常常通过回调函数来处理。例如，当用户点击一个按钮时，你可能希望执行一个特定的函数。 异步编程：在网络编程或者其他需要异步处理的场景中，当一个长时间的操作（如网络请求）完成时，你可能希望执行某个函数。这个函数可以通过回调来指定。 定时器：某些编程环境允许你设置定时器，当定时器到期时执行一个函数。这个函数就是通过回调来指定的。
c++ 实现 Qt 信号槽机制
一个老菜鸟的学习分享
04-10 713
来自 https://gitee.com/jiang_xu_hui/tan-meta-object TanMetaObject 介绍 80行代码实现Qt信号槽机制。 去除无用行估计也就40行。 使用说明 仿Qt的信号槽，本来打算用c++20的概念和约束来写，但是国内根本没有普及c++20，最后还是用了c++11. main.cpp内有使用的例子。 TanMetaObject.h #include <vector> #include <utility> template<t
js自定义数组高阶函数
qt的博客
11-30 172
// 高阶函数 -- 函数作为参数 // 模拟foreach function forEach(array,fn){ for(let i=0; i<array.length; i++){ fn(array[i]) } } // 测试 let arr = [1,2,3,4,6]; forEach(arr, function(item) { console.log(item) }) // filter function filter(array, fn){
通俗易懂解释函数式编程
ThatWeKnow
01-09 573
所谓函数式编程，是指代码中每一块都是不可变的（immutable），都由纯函数（pure function）的形式组成。这里的纯函数，是指函数本身相互独立、互不影响，对于相同的输入，总会有相同的输出，没有任何副作用[就算传进来一个引用也不会改变这个引用，而是新创建一个返回]。 map\reduce\filter\sorted map，对列表中每一个元素按照传入函数做运算。 reduce，对列表中两个元素按照传入函数做合并运算，如求1-5累加，reduce(lambda x,y:x+y, range(1,6)
【Qt】一篇全面的信号和槽函数机制总结
木牛的博客
03-05 1119
​ 在Qt框架下，信号发出分为两种：​ 1、【每个类预定义的信号】：这些信号何时发出可以通过查看官方文档获知。​ 2、【自定义的信号】：这些信号的发出由开发人员自行定义。（2-2）信号的处理​ 当一个信号发出时，连接到它的槽函数通常会立即执行，就像一个普通函数调用一样。在这种情况下，信号和槽函数机制是完全独立于GUI事件循环的，并不会干扰GUI的事件循环。
c++实现Qt信号槽机制
canon20070904的博客
02-05 2256
信号槽机制的原理 使用c++实现简单的信号槽机制 代码实现
Qt核心机制、Qt元对象系统、Qt信号槽原理
02-27
- 除了传统的函数式信号和槽，Qt 5 引入了基于 C++11 样式的方法签名的信号和槽，提高了代码的可读性。 3. **属性系统**： - 属性系统允许在运行时设置和获取对象的属性值。每个属性都有对应的 getter 和 setter ...
C++ - 使用标准库实现事件和委托，信号和槽机制
最新发布
10-17
在C++中，我们可以使用`std::function`和`std::bind`来实现信号和槽机制。`std::function`可以存储任何可调用对象（如函数、成员函数、Lambda表达式），而`std::bind`则可以绑定函数对象到特定的参数，使其成为可...
qt的信号槽机制的例子
09-19
通过以上解释，我们可以看到Qt的信号槽机制是如何为构建复杂的、响应式的用户界面提供强大支持的。它是Qt框架的核心部分，使得开发人员能够专注于业务逻辑，而不必担心底层的事件处理细节。理解和熟练使用信号槽机制...
QT中信号槽的概念及使用
qq_59938293的博客
12-24 1324
QT中信号槽的概念及使用一万字详解，信息量还是很大的，建议收藏。
03 Qt信号槽使用及其原理.zip
11-02
这个“03 Qt信号槽使用及其原理”资料包专注于讲解Qt的核心特性之一——信号与槽机制。这一机制是Qt设计模式的核心，它允许程序员在类之间建立连接，使得当一个对象的某个事件发生时，可以自动触发另一个对象的相应...
c++模拟qt信号槽机制
weixin_43246170的博客
04-10 1458
qt的信号槽原理：moc元对象编译器翻译头文件成moc文件，实现头文件中的信号的函数体和申明信号、槽的索引，加上一个qt_static_metacall的函数等等，然后在connect中的QObjectConnectionListVector的容器中添加这样的一个结构体，通过信号索引找到从容器中找到这个结构体，然后从结构体中拿到回调函数，就能找到槽函数。 结构体： QScopedPointer<QObjectPrivate::Connection> c(new QObjectPrivate::C
C++实现自己的QT信号槽
lhy321456的博客
08-05 647
C++模拟实现QT信号槽 为了看着更像QT的信号槽，我们也定义一个QObject的父类。 class QObject { public: QObject* self() { return this; } //获取信号的发送者 std::function<QObject* (void)> _sender; }; 信号的接收者 class Slot :public QObject { public: Slot() {} public: //槽函数1 //如需多个参
函数式编程介绍
热门推荐
Mr.Phoebe的专栏
01-19 3万+
历史来源 讲述历史来源，不喜欢的可以跳过。但是我个人认为这对理解有帮助。 在计算机的世界中，有两位巨擘对问题的可计算性做了模型化描述[4]。 一位是阿兰.图灵（Alan Turing），他提出的图灵机。计算机系的各种学科中都充斥着这个概念，假设有一个纸带和一个打孔机，然后有一套指令，能够控制打孔机在纸带上移动、能够读取当前位置是否打了孔、能够在当前位置打一个孔，这就是一个图灵机，假设一个问题
函数式编程思想及其解释器的实现
Cyandev
03-30 2398
前言 函数表达式在Excel中有着非常重要的作用，excel的公式就是一种基于函数的表达式，但公式中支持诸如“+”、“-”等运算符。纯函数表达式应该只包含函数和参数。遵循这种思想我们可以将数学上的中缀表达式”(56-9)*3+1/6”使用函数的方式来表示： ADD(MULTIPLY(MINUS(56,9),3),DIVIDE(1,6)) 即每一种运算符都可以抽象为一个函数（比较类似于前缀表达
C++泛化设计与函数式编程
qt187904的博客
02-05 1010
本篇有关C++函数式编程的弹性设计。 C++支持五种编程形式,过程,面向对象,函数式,泛型,元编程。 本篇不过多介绍C++语法,希望各位对于函数式编程的知识 标准库function(调用形式) lambda表达式 函数 函数指针 bind参数绑定 重载了函数调用运算符的类 有基本的认识与了解。 ...
函数式编程很难，这正是你要学习它的原因
gdapenny的专栏
05-09 466
函数式编程很难，这正是你要学习它的原因 作者: Dave Fayram  来源: 外刊IT评论  发布时间: 2012-07-31 12:13  阅读: 16440 次  推荐: 14   原文链接   [收藏]   　　英文原文：Functional Programming Is Hard,That's Why It's Good 　　很奇怪不是，很少有
响应式编程和函数式编程
知至智
10-10 1522
响应式编程：Rx家族 函数式编程：JS、Scala、Erlang等
Qt编程基础：信号与槽机制详解
"Qt的对象模型和信号槽机制是Qt编程的核心特性，由诺基亚官方提供的Qt教育培训材料详细阐述了这一概念。这个机制允许程序员以动态、松散耦合的方式响应事件和状态变化，实现对象间的通信。" 在Qt框架中，信号...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值