一文读懂Qt信号与槽的机制

已于 2024-02-05 19:27:04 修改
阅读量472 收藏 8
点赞数 10
分类专栏： C++和C语言 文章标签： qt 开发语言
于 2024-01-13 14:08:50 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/YDY5659150/article/details/135566843
版权

        Qt的信号与槽主要是为了对象之间的信号传递，以达到某种交互操作的功能。我按照自己的理解逐步实现这样的效果。

步骤一：

        第一个类（接收者）的成员函数实现某种功能，第二个类（发送者）定义一个对象指针，初始化后达到间接访问类1（接收者)的成员函数。运行后显示：I am a receiver!

#include <iostream>
using namespace std;

class Receiver
{
public:
    void show()
    {
        cout <<"I am a receiver!"<<endl;
    }
};

class Transimiter
{
public:
    Receiver * p_receiver;
};


int main()
{
    Transimiter t1;
    Receiver r1;
    t1.p_receiver=&r1;
    t1.p_receiver->show();
    return 0;
}

步骤二：

        不能把所有的事情都让类的成员函数去处理，因为没有人知道未来会添加哪些功能，所以把接收者中定义的show函数改成一个函数指针会更合理。这样可以在接收者初始化对象的时候赋予具体的函数地址，完成具体的功能。运行结果：

I am a slot_show function!
I am a slot_print function!

#include <iostream>
using namespace std;

class Receiver
{
public:
    void (*fun)();//函数指针
    Receiver(void (*pfun)())
    {
        this->fun=pfun;//函数指针初始化
    }
};

void slot_show()
{
    cout<<"I am a slot_show function!"<<endl;
}
void slot_print()
{
    cout<<"I am a slot_print function!"<<endl;
}

class Transimiter
{
public:
    Receiver * p_receiver;
};


int main()
{
    Transimiter t1;
    Receiver r1(&slot_show);//定义两个不同的接收者对象
    Receiver r2(&slot_print);
    t1.p_receiver=&r1;
    t1.p_receiver->fun();

    t1.p_receiver=&r2;
    t1.p_receiver->fun();
    return 0;
}

步骤三：

        为了解决一个发送者对象和多个接收者对象产生关系的问题，发送者对象应该用一个指针数组保存所有的接收者，我的数组大小为2。程序的运行结果和上面一样。

#include <iostream>
using namespace std;

class Receiver
{
public:
    void (*fun)();//函数指针
    Receiver(void (*pfun)())
    {
        this->fun=pfun;//函数指针初始化
    }
};

void slot_show()
{
    cout<<"I am a slot_show function!"<<endl;
}
void slot_print()
{
    cout<<"I am a slot_print function!"<<endl;
}

class Transimiter
{
public:
    Receiver * p_receiver[2];
};


int main()
{
    Transimiter t1;
    Receiver r1(&slot_show);//定义两个不同的接收者对象
    Receiver r2(&slot_print);
    t1.p_receiver[0]=&r1;
    t1.p_receiver[1]=&r2;
    t1.p_receiver[0]->fun();
    t1.p_receiver[1]->fun();
    return 0;
}

步骤四：

       有关发送者对象的信号发送，应当有一个专门的成员函数集中处理， 所以程序做一点修正，运行结果不变，如下：

#include <iostream>
using namespace std;

class Receiver
{
public:
    void (*fun)();//函数指针
    Receiver(void (*pfun)())
    {
        this->fun=pfun;//函数指针初始化
    }
};

void slot_show()
{
    cout<<"I am a slot_show function!"<<endl;
}
void slot_print()
{
    cout<<"I am a slot_print function!"<<endl;
}

class Transimiter
{
public:
    Receiver * p_receiver[2];
public:
    void send_message()
    {
        this->p_receiver[0]->fun();
        this->p_receiver[1]->fun();
    }
};


int main()
{
    Transimiter t1;
    Receiver r1(&slot_show);//定义两个不同的接收者对象
    Receiver r2(&slot_print);
    t1.p_receiver[0]=&r1;
    t1.p_receiver[1]=&r2;
    t1.send_message();

    return 0;
}

步骤五：

        上面的程序发送的消息是空的，我用一个整型的数字代表一个合法的消息，程序稍作修改，运行结果如下：

I am a slot_show function!
num:100
I am a slot_print function! 
num:100

#include <iostream>
using namespace std;

class Receiver
{
public:
    void (*fun)(int);//函数指针
    Receiver(void (*pfun)(int))
    {
        this->fun=pfun;//函数指针初始化
    }
};

void slot_show(int num)
{
    cout<<"I am a slot_show function!"<<endl;
    cout<<"num:"<<num<<endl;
}
void slot_print(int num)
{
    cout<<"I am a slot_print function!"<endl;
    cout<<"num:"<<num<<endl;
}

class Transimiter
{
public:
    Receiver * p_receiver[2];
public:
    void send_message(int num)
    {
        this->p_receiver[0]->fun(num);
        this->p_receiver[1]->fun(num);
    }
};


int main()
{
    Transimiter t1;
    Receiver r1(&slot_show);//定义两个不同的接收者对象
    Receiver r2(&slot_print);
    t1.p_receiver[0]=&r1;
    t1.p_receiver[1]=&r2;
    t1.send_message(100);

    return 0;
}

步骤六：

        上面的程序中发送者和接收者之间建立联系的过程不够形象，我用一个函数命名为管道连接，管理对象之间的通信。安全起见，同时把发送者对象里面的指针数组从公用属性改为私有属性。

#include <iostream>
using namespace std;

class Receiver
{
public:
    void (*fun)(int);//函数指针
    Receiver(void (*pfun)(int))
    {
        this->fun=pfun;//函数指针初始化
    }
};

void slot_show(int num)
{
    cout<<"I am a slot_show function!"<<endl;
    cout<<"num:"<<num<<endl;
}
void slot_print(int num)
{
    cout<<"I am a slot_print function!"<<endl;
    cout<<"num:"<<num<<endl;
}

class Transimiter
{
private://成员变量改为私有属性
    Receiver * p_receiver[2];
public:
    void send_message(int num)
    {
        this->p_receiver[0]->fun(num);
        this->p_receiver[1]->fun(num);
    }
    void connect_pipe(Receiver *pR,int num)//建立管道连接
    {
      this->p_receiver[num]=pR;
    }
};


int main()
{
    Transimiter t1;
    Receiver r1(&slot_show);//定义两个不同的接收者对象
    Receiver r2(&slot_print);
    t1.connect_pipe(&r1,0);
    t1.connect_pipe(&r2,1);
    t1.send_message(100);
    return 0;
}

步骤七：

        由于接受者的个数也是不确定的，因此不能把数组写死，于是我采用一个向量vector记录接收者对象的指针，相关的函数或变量做一点点修改，运行结果如下：

I am a slot_show function!
num:100
I am a slot_print function!
num:100
I am a slot_print function!
num:100

#include <iostream>
#include <vector>
using namespace std;

class Receiver
{
public:
    void (*fun)(int);//函数指针
    Receiver(void (*pfun)(int))
    {
        this->fun=pfun;//函数指针初始化
    }
};

void slot_show(int num)
{
    cout<<"I am a slot_show function!"<<endl;
    cout<<"num:"<<num<<endl;
}
void slot_print(int num)
{
    cout<<"I am a slot_print function!"<<endl;
    cout<<"num:"<<num<<endl;
}

class Transimiter
{
private://成员变量改为私有属性
    vector <Receiver*> receiver_v;
public:
    void send_message(int num)
    {
        for(vector <Receiver*>::iterator it=receiver_v.begin();it!=receiver_v.end();it++)//遍历器
        {
            (*it)->fun(num);//(*it)为实际的元素值
        }

    }
    void connect_pipe(Receiver *pR)//建立管道连接
    {
      this->receiver_v.push_back(pR);
    }
};


int main()
{
    Transimiter t1;
    Receiver r1(&slot_show);//定义两个不同的接收者对象
    Receiver r2(&slot_print);
    Receiver r3(&slot_print);
    t1.connect_pipe(&r1);
    t1.connect_pipe(&r2);
    t1.connect_pipe(&r3);
    t1.send_message(100);
    return 0;
}

步骤八：

        添加一个断开连接的函数，修改代码如下：

#include <iostream>
#include <vector>
using namespace std;

class Receiver
{
public:
    void (*fun)(int);//函数指针
    Receiver(void (*pfun)(int))
    {
        this->fun=pfun;//函数指针初始化
    }
};

void slot_show(int num)
{
    cout<<"I am a slot_show function!"<<endl;
    cout<<"num:"<<num<<endl;
}
void slot_print(int num)
{
    cout<<"I am a slot_print function!"<<endl;
    cout<<"num:"<<num<<endl;
}

class Transimiter
{
private://成员变量改为私有属性
    vector <Receiver*> receiver_v;
public:
    void send_message(int num)
    {
        for(vector <Receiver*>::iterator it=receiver_v.begin();it!=receiver_v.end();it++)//遍历器
        {
            (*it)->fun(num);//(*it)为实际的元素值
        }

    }
    void connect_pipe(Receiver *pR)//建立管道连接
    {
      this->receiver_v.push_back(pR);
    }
    void disconnect_pipe(Receiver *pR)
    {
        for(vector <Receiver*>::iterator it=receiver_v.begin();it!=receiver_v.end();it++)//遍历器
        {
            if((*it)==pR)
            {
                this->receiver_v.erase(it);
            }
        }


    }
};


int main()
{
    Transimiter t1;
    Receiver r1(&slot_show);//定义两个不同的接收者对象
    Receiver r2(&slot_print);
    Receiver r3(&slot_print);
    t1.connect_pipe(&r1);
    t1.connect_pipe(&r2);
    t1.connect_pipe(&r3);
    t1.send_message(100);

    t1.disconnect_pipe(&r1);
    t1.disconnect_pipe(&r2);
    t1.send_message(100);

    return 0;
}

 步骤九：

        为了增进程序的通用性，使用模板对上述程序进行重新整理，如下：

#include <iostream>
#include <vector>
using namespace std;

template <typename T>
class Receiver
{
public:
    void (*fun)(T);//函数指针
    Receiver(void (*pfun)(T))
    {
        this->fun=pfun;//函数指针初始化
    }
};

template <typename T>
void slot_show(T num)
{
    cout<<"I am a slot_show function!"<<endl;
    cout<<"num:"<<num<<endl;
}

template <typename T>
void slot_print(T num)
{
    cout<<"I am a slot_print function!"<<endl;
    cout<<"num:"<<num<<endl;
}

template <typename T>
class Transimiter
{
private://成员变量改为私有属性
    vector <Receiver<T>*>receiver_v;
public:
    void send_message(T num)
    {
        for(typename vector <Receiver<T>*>::iterator it=receiver_v.begin();it!=receiver_v.end();it++)//遍历器
        {
            (*it)->fun(num);//(*it)为实际的元素值
        }

    }
    void connect_pipe(Receiver<T> *pR)//建立管道连接
    {
      this->receiver_v.push_back(pR);
    }
    void disconnect_pipe(Receiver<T> *pR)
    {
       for(typename vector <Receiver<T>*>::iterator it=receiver_v.begin();it!=receiver_v.end();it++)//遍历器
        {
            if((*it)==pR)
            {
                this->receiver_v.erase(it);
            }
        }
    }
};



int main()
{
    Transimiter <int> t1;
    Receiver <int>r1(&slot_show<int>);//定义两个不同的接收者对象
    Receiver <int>r2(&slot_print<int>);
    t1.connect_pipe(&r1);
    t1.connect_pipe(&r2);
    t1.send_message(100);

    Transimiter <float> t3;
    Receiver <float>r3(&slot_show<float>);//定义两个不同的接收者对象
    Receiver <float>r4(&slot_print<float>);
    t3.connect_pipe(&r3);
    t3.connect_pipe(&r4);
    t3.send_message(100);

    return 0;
}

       

古楼望月
关注
  • 10
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据可视化
weixin_48995695的博客
01-09 6972
excel提供了商业标准的可视化内容，但总显笨拙。也不希望excel形成垄断，到时候坐地起价。程序员的求知天性，也要求随心所欲得设计，总希望是设置参数而不是选项，是调用函数而不是下拉列表框。自由是要付出代价的，就像到地摊上淘A货，或者自已起炉灶。 总会用种种问题，不能显示中文，代码页不同，不能调整大小。众多的媒体推送，看着眼花缭乱。一看就会，一做就废。都成股市里的庄家，套路满满。听话就有糖吃的时代一去不复返。 Matplotlib 默认情况不支持中文，我们可以使用以下简单的方法来解决。这里我们使用思源黑体
一文读懂SIP与SOC封装技术
01-19
除了既有的封测大厂积极扩大SiP制造产能外，晶圆代工业者与IC基板厂也竞相投入此一技术，以满足市场需求。 　早前，苹果发布了的apple watch手表，里面用到SIP封装芯片，从尺寸和性能上为新手表增色不少。而...
一文带你读懂PyQt：用Python做出与C++一样的GUI界面应用程序
热门推荐
老猿Python
05-09 7万+
本文介绍了Python的图形化界面应用开发工具PyQt的功能和开发框架，通过PyQt的这些重要的工具、功能和框架机制，开发人员可以设计对应的GUI图形化界面、定义不同部件的操作及响应、捕获部件或应用的消息以及实现界面显示组件和数据存储组件的联动，从而构造完整的应用程序框架，最后提供了老猿实现的一些PyQt开发程序的界面来说明PyQt不同部件的界面风格。 通过以上内容的介绍，有助于对PyQt或Qt不了解的初学者提了解PyQt的基本开发框架、应用界面风格。
【1】一文读懂PyQt简介和环境搭建
bug_love的博客
12-05 977
一文读懂PyQt简介和环境搭建。
一文带你通俗理解23种软件设计模式（推荐收藏，适合小白学习，附带C++例程完整源码）
翟天保的博客
04-20 4万+
一文带你通俗理解23种软件设计模式（推荐收藏，适合小白学习，附带C++例程完整源码）
一文读懂深度学习与机器学习的差异
01-27
机器学习和深度学习变得越来越火。突然之间，不管是了解的还是不了解的，所有人都在谈论机器学习和深度学习。无论你是否主动关注过数据科学，你应该已经听说过这两个名词了。为了展示他们的火热程度，我在...
一文读懂接近传感器
01-19
　在转换为电气信号的检测方式中，包括利用电磁感应引起的检测对象的金属体中产生的涡电流的方式、捕测体的接近引起的电气信号的容量变化的方式、利石和引导开关的方式。由感应型、静电容量型、超声波型、光电型、...
一文读懂磁传感器
01-19
磁传感器磁传感器是一种把磁场、电流、应力应变、温度、光等外界因素引起的敏感元件磁性能变化转换成电信号，以这种方式来检测相应物理量的器件。用于感测速度、运动和方向，应用领域包括汽车、无线和消费电子、军事...
Qt QLineEdit详解
希望能帮助大家，希望大家多多支持，你们的支持是我前进的动力。
04-29 570
QLineEdit是一个单行文本编辑器。行编辑允许用户使用一组有用的编辑功能输入和编辑单行纯文本，包括撤消和重做、剪切和粘贴以及拖放。通过更改行编辑的echoMode，它也可以用作“只写”字段，用于密码等输入。文本的长度可以限制为maxLength，文本可以使用validator或inputMask进行任意约束，也可以同时使用这两种方法。在同一行编辑的validator和inputMask之间切换时，最好清除validator或输入mask，以防止出现未定义的行为。
【Qt】信号与槽
最新发布
m0_66599463的博客
04-30 653
1、信号和槽的概述 1.1 信号的本质 1.2 槽的本质 2、信号和槽的使用 2.1 连接信号的槽 click和clicked 2.2 第二种自定义创建槽函数的方式 3、自定义信号和槽 3.1 ⾃定义信号函数书写规范 3.2 带参数得槽和函数 4、信号与槽的连接方式 4.1 一对一 4.2 一对多 4.3 多对一 5、信号和槽的其他说明 5.1 信号与槽的断开 5.2 Qt4 版本信号与槽的连接 5.3 使⽤ Lambda 表达式定义槽函数 5.4 信号与槽的优缺点
qt——窗口置灰不可操作
qq_43287763的博客
04-24 581
虽然`setEnabled(false)`会自动让大多数控件看起来是灰色的，但有时你可能需要更明显的视觉效果，或者要自定义非标准控件的视觉表现。在Qt中实现一个窗口（或窗口中的特定部分）置灰并不可操作，通常涉及到两个概念：禁用窗口的交互功能以及视觉上的置灰效果。如果你希望整个窗口都不可交互，可以简单地使用`QWidget`的`setEnabled(false)`方法。这将禁用窗口及其所有子控件的交互能力。这段代码将在窗口的内容上绘制一个半透明的灰色矩形，从而给用户一种窗口被禁用的视觉印象。
Qt ： 在QTreeWidget中添加自定义右键菜单
Mr.Sugarcane
04-25 282
QTreeWidget 添加自定义右键菜单
【Qt】error LNK2001: 无法解析的外部符号
paxlhhh
04-26 262
error LNK2001: 无法解析的外部符号 "__declspec(dllimport)以这种为前缀的基本上跟库相关的，说明无法正常调用库，一般是路径有问题。查看该文件所在的pro文件里，发现只添加了。
【QT进阶】Qt线程与并发之QtConcurrent的简单介绍
LF__plus的博客
04-25 929
【QT进阶】Qt线程与并发之QtConcurrent的简单介绍
《QT实用小工具·四十一》无边框窗口
cs1395293598的博客
04-25 323
该项目实现了无边框窗口效果
Qt:学习笔记一
weixin_45930573的博客
04-25 1219
/槽函数，可以写到public slots，也可以写到public全局下//返回值void，需要声明，也需要实现//可以有参数，可以发生重载signals://自定义信号，写到signals下//返回值是void，只需要声明，不需要实现//可以有参数，可以重载qDebug() << "请老师吃饭";//QString->char * 先转成QByteArray (.toUtf8() ) 再转char * ()
【Qt之·路径获取】
m0_66203017的博客
04-30 116
在进行Qt开发时，经常需要获取文件的路径，如图片、音频、配置文件等。路径的获取可以通过直接指定绝对路径或者使用相对路径的方式来实现。本篇博客将介绍如何在Qt中获取文件路径的方法。总之，在进行Qt开发中，获取文件路径是一个常见的操作，根据具体需求选择合适的方法获取文件路径能够更加方便地进行文件的读取、写入、显示等操作。
C# 和 Qt 相比的一些优势
super_Dev_OP的博客
04-30 233
以下是 C# 和 Qt 相比的一些优势。C# 与 Visual Studio 等强大的 IDE 紧密集成，提供了高效的开发体验，包括代码分析、调试工具和丰富的插件生态系统。C# 作为 .NET 框架的主要语言之一，能够充分利用 .NET 生态系统中的大量库和工具，这为开发者提供了强大的支持9。C# 是一种现代的、类型安全的面向对象编程语言，它提供了丰富的语言特性，如LINQ、异步编程、扩展方法等7。作为微软主导的语言，C# 得到了广泛的企业支持和持续的发展，有着稳定的未来和明确的发展方向。
一文读懂MADDPG算法
09-29
一文读懂MADDPG算法的文章介绍了MADDPG算法的基本原理和应用。MADDPG代表多智能体深度确定性策略梯度算法，是一种用于协同多智能体决策的强化学习算法。该算法通过维护一个actor-critic结构的网络，每个智能体都有...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值