精华内容
下载资源
问答
  • 信号和槽是Qt编程的一个重要部分。这个机制可以在对象之间彼此并不了解的情况下将它们的行为联系起来。在前几个例子中,我们已经连接了信号和槽,声明了控件自己的信号和槽,并实现了槽函数,发送了自己的信号。现在...

    信号和槽是Qt编程的一个重要部分。这个机制可以在对象之间彼此并不了解的情况下将它们的行为联系起来。在前几个例子中,我们已经连接了信号和槽,声明了控件自己的信号和槽,并实现了槽函数,发送了自己的信号。现在来更深入了解这个机制。

    槽和普通的c++成员函数很像。它们可以是虚函数(virtual),也可被重载(overload),可以是公有的(public),保护的(protective),也可是私有的(private),它们可以象任何c++成员函数一样被直接调用,可以传递任何类型的参数。不同在于一个槽函数能和一个信号相连接,只要信号发出了,这个槽函数就会自动被调用。

    connect函数语法如下:
    connect(sender, SIGNAL(signal), receiver, SLOT(slot));
    sender和receiver是QObject对象指针,signal和slot是不带参数的函数原型。SIGNALE()和SLOT()宏的作用是把他们的参数转换成字符串。

    在目前有的例子中,我们已经连接了不同的信号和槽。实际使用中还要考虑如下一些规则:
    1、一个信号可以连接到多个槽:
    connect(slider, SIGNAL(valueChanged(int)),spinBox, SLOT(setValue(int)));
    connect(slider, SIGNAL(valueChanged(int)),this, SLOT(updateStatusBarIndicator(int)));
    当信号发出后,槽函数都会被调用,但是调用的顺序是随机的,不确定的。

    2、多个信号可以连接到同一个槽
    connect(lcd, SIGNAL(overflow()), this, SLOT(handleMathError()));
    connect(calculator, SIGNAL(divisionByZero()),this, SLOT(handleMathError()));
    任何一个信号发出,槽函数都会执行。

    3、一个信号可以和另一个信号相连
    connect(lineEdit, SIGNAL(textChanged(const QString &)),
                  this, SIGNAL(updateRecord(const QString &)));
     第一个信号发出后,第二个信号也同时发送。除此之外,信号与信号的连接和信号与槽连接相同。
     
    4、连接可以被删除
    disconnect(lcd, SIGNAL(overflow()),this, SLOT(handleMathError()));
    这个函数很少使用,因为当一个对象被删除后,Qt自动删除这个对象的所有连接。

    信号和槽函数必须有着相同的参数类型及顺序,这样信号和槽函数才能成功连接:
    connect(ftp, SIGNAL(rawCommandReply(int, const QString &)),this, SLOT(processReply(int, const QString &)));
    如果信号里的参数个数多于槽函数的参数,多余的参数被忽略:
    connect(ftp, SIGNAL(rawCommandReply(int, const QString &)),this, SLOT(checkErrorCode(int)));
    如果参速类型不匹配,或者信号和槽不存在,应用程序在debug状态下时,Qt会在运行期间给出警告。如果信号和槽连接时包含了参数的名字,Qt也将会给出警告。
    以前我们列举的例子中都是控件的信号和槽。但是信号和槽机制在QObject中就实现了,可以实现在任何从QObject继承的子类中。
    class Employee : public QObject
    {
        Q_OBJECT
    public:
        Employee() { mySalary = 0; }
        int salary() const { return mySalary; }
    public slots:
        void setSalary(int newSalary);
    signals:
        void salaryChanged(int newSalary);
    private:
        int mySalary;
    };
    void Employee::setSalary(int newSalary)
    {
        if (newSalary != mySalary) {
            mySalary = newSalary;
            emit salaryChanged(mySalary);
        }
    }
    注意,只有newSalary != mySalary时才发出salaryChanged()信号,这样避免了死循环的出现。

    ×××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××
    Qt的元对象(Meta-Object)系统
    Qt的一个最主要的成功是对C++扩展,即把彼此独立的软件模块连接起来,而模块间彼此不需要知道相连模块的任何细节。
    这个机制就是Meta-Object系统,它提供了两个关键的用途:信号和槽和introspection(内省)。introspection功能允许程序员在程序运行时得到QObject它子类的“元信息(meta-information)”,这对实现信号和槽是很必要的,包括全部信号和槽的列表,和类的名字。这个机制还提供了属性(在Qt Designer中使用)和文本翻译(国际化)支持。它们构成了QSA(Qt Script for Application)的基础。

    标准C++不提供Qt meta-object系统所需的动态meta-information。为解决该问题,Qt提供了一个独立的工具moc,它通过C++函数来解析Q_OBJECT宏类定义而获得信息。moc是用纯c++实现的,因此元对象系统可以使用在任何C++编译器中。

    这个机制工作过程如下:
    Q_OBJECT宏声明了一些QObject子类中必须实现的内省函数:metaObject(),TR(),qt_metacall()等。
    Qt的moc工具会实现Q_OBJECT宏声明的函数和所有的信号。
    QObject成员函数例如connect()和disconnect()使用这些内省函数实现信号和槽的连接。
    以上这些是通过qmake,moc和QObject自动处理的,程序员通常不用考虑它们。如果你感到对此好奇,可以查看QMetaObject类文档和moc生成的c++源文件。

    展开全文
  • QT signal & slot 定义及用法 .

    千次阅读 2013-09-03 15:49:12
    信号和槽是Qt编程的一个重要部分。这个机制可以在对象之间彼此并不了解的情况下将它们的行为联系起来。在前几个例子中,我们已经连接了信号和槽,声明了控件自己的信号和槽,并实现了槽函数,发送了自己的信号。现在...

    来源: http://blog.csdn.net/kaffeel/article/details/5568954

     

    信号和槽是Qt编程的一个重要部分。这个机制可以在对象之间彼此并不了解的情况下将它们的行为联系起来。在前几个例子中,我们已经连接了信号和槽,声明了控件自己的信号和槽,并实现了槽函数,发送了自己的信号。现在来更深入了解这个机制。

    槽和普通的c++成员函数很像。它们可以是虚函数(virtual),也可被重载(overload),可以是公有的(public),保护的(protective),也可是私有的(private),它们可以象任何c++成员函数一样被直接调用,可以传递任何类型的参数。不同在于一个槽函数能和一个信号相连接,只要信号发出了,这个槽函数就会自动被调用。

    connect函数语法如下:
    connect(sender, SIGNAL(signal), receiver, SLOT(slot));
    sender和receiver是QObject对象指针,signal和slot是不带参数的函数原型。SIGNALE()和SLOT()宏的作用是把他们的参数转换成字符串。

    在目前有的例子中,我们已经连接了不同的信号和槽。实际使用中还要考虑如下一些规则:
    1、一个信号可以连接到多个槽:
    connect(slider, SIGNAL(valueChanged(int)),spinBox, SLOT(setValue(int)));
    connect(slider, SIGNAL(valueChanged(int)),this, SLOT(updateStatusBarIndicator(int)));
    当信号发出后,槽函数都会被调用,但是调用的顺序是随机的,不确定的。

    2、多个信号可以连接到同一个槽
    connect(lcd, SIGNAL(overflow()), this, SLOT(handleMathError()));
    connect(calculator, SIGNAL(divisionByZero()),this, SLOT(handleMathError()));
    任何一个信号发出,槽函数都会执行。

    3、一个信号可以和另一个信号相连
    connect(lineEdit, SIGNAL(textChanged(const QString &)),
                  this, SIGNAL(updateRecord(const QString &)));
     第一个信号发出后,第二个信号也同时发送。除此之外,信号与信号的连接和信号与槽连接相同。
     
    4、连接可以被删除
    disconnect(lcd, SIGNAL(overflow()),this, SLOT(handleMathError()));
    这个函数很少使用,因为当一个对象被删除后,Qt自动删除这个对象的所有连接。

    信号和槽函数必须有着相同的参数类型及顺序,这样信号和槽函数才能成功连接:
    connect(ftp, SIGNAL(rawCommandReply(int, const QString &)),this, SLOT(processReply(int, const QString &)));
    如果信号里的参数个数多于槽函数的参数,多余的参数被忽略:
    connect(ftp, SIGNAL(rawCommandReply(int, const QString &)),this, SLOT(checkErrorCode(int)));
    如果参速类型不匹配,或者信号和槽不存在,应用程序在debug状态下时,Qt会在运行期间给出警告。如果信号和槽连接时包含了参数的名字,Qt也将会给出警告。
    以前我们列举的例子中都是控件的信号和槽。但是信号和槽机制在QObject中就实现了,可以实现在任何从QObject继承的子类中。
    class Employee : public QObject
    {
        Q_OBJECT
    public:
        Employee() { mySalary = 0; }
        int salary() const { return mySalary; }
    public slots:
        void setSalary(int newSalary);
    signals:
        void salaryChanged(int newSalary);
    private:
        int mySalary;
    };
    void Employee::setSalary(int newSalary)
    {
        if (newSalary != mySalary) {
            mySalary = newSalary;
            emit salaryChanged(mySalary);
        }
    }
    注意,只有newSalary != mySalary时才发出salaryChanged()信号,这样避免了死循环的出现。

    ×××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××
    Qt的元对象(Meta-Object)系统
    Qt的一个最主要的成功是对C++扩展,即把彼此独立的软件模块连接起来,而模块间彼此不需要知道相连模块的任何细节。
    这个机制就是Meta-Object系统,它提供了两个关键的用途:信号和槽和introspection(内省)。introspection功能允许程序员在程序运行时得到QObject它子类的“元信息(meta-information)”,这对实现信号和槽是很必要的,包括全部信号和槽的列表,和类的名字。这个机制还提供了属性(在Qt Designer中使用)和文本翻译(国际化)支持。它们构成了QSA(Qt Script for Application)的基础。

    标准C++不提供Qt meta-object系统所需的动态meta-information。为解决该问题,Qt提供了一个独立的工具moc,它通过C++函数来解析Q_OBJECT宏类定义而获得信息。moc是用纯c++实现的,因此元对象系统可以使用在任何C++编译器中。

    这个机制工作过程如下:
    Q_OBJECT宏声明了一些QObject子类中必须实现的内省函数:metaObject(),TR(),qt_metacall()等。
    Qt的moc工具会实现Q_OBJECT宏声明的函数和所有的信号。
    QObject成员函数例如connect()和disconnect()使用这些内省函数实现信号和槽的连接。
    以上这些是通过qmake,moc和QObject自动处理的,程序员通常不用考虑它们。如果你感到对此好奇,可以查看QMetaObject类文档和moc生成的c++源文件。

     

    展开全文
  • Qt signal slot 实现机制

    千次阅读 2011-04-02 19:56:00
    <br />今天被问到一个问题,如下:Qt的signal slot的实现机制。 现在整理一下: 概述 信号和槽机制是QT的核心机制,要精通QT编程就必须对信号和槽有所了解。信号和槽是一种高级接口,应用于...

    今天被问到一个问题,如下:Qt的signal slot的实现机制。

    现在整理一下:

    概述

    信号和槽机制是QT的核心机制,要精通QT编程就必须对信号和槽有所了解。信号和槽是一种高级接口,应用于对象之间的通信,它是QT的核心特性,也是QT区别于其它工具包的重要地方。信号和槽是QT自行定义的一种通信机制,它独立于标准的C/C++语言,因此要正确的处理信号和槽,必须借助一个称为moc(Meta Object Compiler)的QT工具,该工具是一个C++预处理程序,它为高层次的事件处理自动生成所需要的附加代码。

    在我们所熟知的很多GUI工具包中,窗口小部件(widget)都有一个回调函数用于响应它们能触发的每个动作,这个回调函数通常是一个指向某个函数的指针。但是,在QT中信号和槽取代了这些凌乱的函数指针,使得我们编写这些通信程序更为简洁明了。 信号和槽能携带任意数量和任意类型的参数,他们是类型完全安全的,不会像回调函数那样产生core dumps。

    所有从QObject或其子类(例如Qwidget)派生的类都能够包含信号和槽。当对象改变其状态时,信号就由该对象发射(emit)出去,这就是对象所要做的全部事情,它不知道另一端是谁在接收这个信号。这就是真正的信息封装,它确保对象被当作一个真正的软件组件来使用。槽用于接收信号,但它们是普通的对象成员函数。一个槽并不知道是否有任何信号与自己相连接。而且,对象并不了解具体的通信机制。

    你可以将很多信号与单个的槽进行连接,也可以将单个的信号与很多的槽进行连接,甚至于将一个信号与另外一个信号相连接也是可能的,这时无论第一个信号什么时候发射系统都将立刻发射第二个信号。总之,信号与槽构造了一个强大的部件编程机制。

    信号

    当某个信号对其客户或所有者发生的内部状态发生改变,信号被一个对象发射。只有 定义过这个信号的类及其派生类能够发射这个信号。当一个信号被发射时,与其相关联的槽将被立刻执行,就象一个正常的函数调用一样。信号-槽机制完全独立于任何GUI事件循环。只有当所有的槽返回以后发射函数(emit)才返回。 如果存在多个槽与某个信号相关联,那么,当这个信号被发射时,这些槽将会一个接一个地 执行,但是它们执行的顺序将会是随机的、不确定的,我们不能人为地指定哪个先执行、哪 个后执行。

    信号的声明是在头文件中进行的,QT的signals关键字指出进入了信号声明区,随后即可 声明自己的信号。例如,下面定义了三个信号:

    signals: 
       void mySignal();
       void mySignal(int x);
       void mySignalParam(int x,int y);


    在上面的定义中,signals是QT的关键字,而非C/C++的。接下来的一行void mySignal() 定义了信号mySignal,这个信号没有携带参数;接下来的一行void mySignal(int x)定义 了重名信号mySignal,但是它携带一个整形参数,这有点类似于C++中的虚函数。从形式上 讲信号的声明与普通的C++函数是一样的,但是信号却没有函数体定义,另外,信号的返回 类型都是void,不要指望能从信号返回什么有用信息。

    信号由moc自动产生,它们不应该在.cpp文件中实现。

    槽是普通的C++成员函数,可以被正常调用,它们唯一的特殊性就是很多信号可以与其相关联。当与其关联的信号被发射时,这个槽就会被调用。槽可以有参数,但槽的参数不能有缺省值。

    既然槽是普通的成员函数,因此与其它的函数一样,它们也有存取权限。槽的存取权限决定了谁能够与其相关联。同普通的C++成员函数一样,槽函数也分为三种类型,即public slots、private slots和protected slots。

    public slots:在这个区内声明的槽意味着任何对象都可将信号与之相连接。这对于组件编程非常有用,你可以创建彼此互不了解的对象,将它们的信号与槽进行连接以便信息能够正确的传递。 
    protected slots:在这个区内声明的槽意味着当前类及其子类可以将信号与之相连接。这适用于那些槽,它们是类实现的一部分,但是其界面接口却面向外部。 
    private slots:在这个区内声明的槽意味着只有类自己可以将信号与之相连接。这适用于联系非常紧密的类。 
    槽也能够声明为虚函数,这也是非常有用的。

    槽的声明也是在头文件中进行的。例如,下面声明了三个槽:

           public slots:
       void mySlot();
       void mySlot(int x);
       void mySignalParam(int x,int y);


    信号与槽的关联

    通过调用QObject对象的connect函数来将某个对象的信号与另外一个对象的槽函数相关联,这样当发射者发射信号时,接收者的槽函数将被调用。该函数的定义如下:

           bool QObject::connect ( const QObject * sender, const char * signal, 
       const QObject * receiver, const char * member ) [static]

    这个函数的作用就是将发射者sender对象中的信号signal与接收者receiver中的member槽函数联系起来。当指定信号signal时必须使用QT的宏SIGNAL(),当指定槽函数时必须使用宏SLOT()。如果发射者与接收者属于同一个对象的话,那么在connect调用中接收者参数可以省略。

    例如,下面定义了两个对象:标签对象label和滚动条对象scroll,并将valueChanged()信号与标签对象的setNum()相关联,另外信号还携带了一个整形参数,这样标签总是显示滚动条所处位置的值。

           QLabel     *label = new QLabel;
        QScrollBar *scroll = new QScrollBar;
        QObject::connect( scroll, SIGNAL(valueChanged(int)),
                          label, SLOT(setNum(int)) );

    一个信号甚至能够与另一个信号相关联,看下面的例子:

           class MyWidget : public QWidget
        {
        public:
            MyWidget();
        ...
        signals:
            void aSignal();
        ...
        private:
        ...
            QPushButton *aButton;
        };
        MyWidget::MyWidget()
        {
            aButton = new QPushButton( this );
            connect( aButton, SIGNAL(clicked()), SIGNAL(aSignal()) );
        }

    在上面的构造函数中,MyWidget创建了一个私有的按钮aButton,按钮的单击事件产生的信号clicked()与另外一个信号aSignal()进行了关联。这样一来,当信号clicked()被发射时,信号aSignal()也接着被发射。当然,你也可以直接将单击事件与某个私有的槽函数相关联,然后在槽中发射aSignal()信号,这样的话似乎有点多余。

    当信号与槽没有必要继续保持关联时,我们可以使用disconnect函数来断开连接。其定义如下:

           bool QObject::disconnect ( const QObject * sender, const char * signal, 
       const Object * receiver, const char * member ) [static]

    这个函数断开发射者中的信号与接收者中的槽函数之间的关联。

    有三种情况必须使用disconnect()函数:

    断开与某个对象相关联的任何对象。这似乎有点不可理解,事实上,当我们在某个对象中定义了一个或者多个信号,这些信号与另外若干个对象中的槽相关联,如果我们要切断这些关联的话,就可以利用这个方法,非常之简洁。

    disconnect( myObject, 0, 0, 0 )
    或者
    myObject->disconnect()

    断开与某个特定信号的任何关联。

    disconnect( myObject, SIGNAL(mySignal()), 0, 0 )
    或者
    myObject->disconnect( SIGNAL(mySignal()) )

    断开两个对象之间的关联。

    disconnect( myObject, 0, myReceiver, 0 )
    或者
    myObject->disconnect( myReceiver )

    在disconnect函数中0可以用作一个通配符,分别表示发射者、任何信号、任何接收对象、接收对象中的任何槽函数。但是发射者sender不能为0,其它三个参数的值可以等于0。

    应注意的问题

    信号与槽机制是比较灵活的,但有些局限性我们必须了解,这样在实际的使用过程中做到有的放矢,避免产生一些错误。下面就介绍一下这方面的情况。

    1.信号与槽的效率是非常高的,但是同真正的回调函数比较起来,由于增加了灵活性,因此在速度上还是有所损失,当然这种损失相对来说是比较小的,通过在一台i586-133的机器上测试是10微秒(运行Linux),可见这种机制所提供的简洁性、灵活性还是值得的。但如果我们要追求高效率的话,比如在实时系统中就要尽可能的少用这种机制。

    2.信号与槽机制与普通函数的调用一样,如果使用不当的话,在程序执行时也有可能产生死循环。因此,在定义槽函数时一定要注意避免间接形成无限循环,即在槽中再次发射所接收到的同样信号。例如,在前面给出的例子中如果在mySlot()槽函数中加上语句emit mySignal()即可形成死循环。

    3.如果一个信号与多个槽相联系的话,那么,当这个信号被发射时,与之相关的槽被激活的顺序将是随机的。

    4. 宏定义不能用在signal和slot的参数中。

    既然moc工具不扩展#define,因此,在signals和slots中携带参数的宏就不能正确地工作,如果不带参数是可以的。例如,下面的例子中将带有参数的宏SIGNEDNESS(a)作为信号的参数是不合语法的:

           #ifdef ultrix
        #define SIGNEDNESS(a) unsigned a
        #else
        #define SIGNEDNESS(a) a
        #endif
        class Whatever : public QObject 
        {
        [...]
        signals:
            void someSignal( SIGNEDNESS(a) );
        [...]
        };


    5. 构造函数不能用在signals或者slots声明区域内。

    的确,将一个构造函数放在signals或者slots区内有点不可理解,无论如何,不能将它们放在private slots、protected slots或者public slots区内。下面的用法是不合语法要求的:

           class SomeClass : public QObject 
        {
            Q_OBJECT
        public slots:
            SomeClass( QObject *parent, const char *name )
                : QObject( parent, name ) {} // 在槽声明区内声明构造函数不合语法
        [...]
        };


    6. 函数指针不能作为信号或槽的参数。

    例如,下面的例子中将void (*applyFunction)(QList*, void*)作为参数是不合语法的:

           class someClass : public QObject 
        {
            Q_OBJECT
        [...]
        public slots:
            void apply(void (*applyFunction)(QList*, void*), char*); // 不合语法
        };


    你可以采用下面的方法绕过这个限制:

            typedef void (*ApplyFunctionType)(QList*, void*);
        class someClass : public QObject 
        {
            Q_OBJECT
        [...]
        public slots:
            void apply( ApplyFunctionType, char *);
        };


    7.信号与槽不能有缺省参数。

    既然signal->slot绑定是发生在运行时刻,那么,从概念上讲使用缺省参数是困难的。下面的用法是不合理的:

           class SomeClass : public QObject 
        {
            Q_OBJECT
        public slots:
            void someSlot(int x=100); // 将x的缺省值定义成100,在槽函数声明中使用是错误的
        };


    8.信号与槽也不能携带模板类参数。

    如果将信号、槽声明为模板类参数的话,即使moc工具不报告错误,也不可能得到预期的结果。 例如,下面的例子中当信号发射时,槽函数不会被正确调用:

           [...]
       public slots:
           void MyWidget::setLocation (pair<int,int> location);
       [...]
       public signals:
           void MyObject::moved (pair<int,int> location);


    但是,你可以使用typedef语句来绕过这个限制。如下所示:

           typedef pair<int,int> IntPair; 
       [...]
       public slots:
           void MyWidget::setLocation (IntPair location);
       [...]
       public signals:
           void MyObject::moved (IntPair location);


    这样使用的话,你就可以得到正确的结果。

    9.嵌套的类不能位于信号或槽区域内,也不能有信号或者槽。

    例如,下面的例子中,在class B中声明槽b()是不合语法的,在信号区内声明槽b()也是不合语法的。

           class A 
        {
            Q_OBJECT
        public:
            class B 
        {
            public slots:   // 在嵌套类中声明槽不合语法
                void b();
            [....]
            };
        signals:
            class B 
        {
            // 在信号区内声明嵌套类不合语法
            void b();
            [....]
            }:
        };


    10.友元声明不能位于信号或者槽声明区内。

    相反,它们应该在普通C++的private、protected或者public区内进行声明。下面的例子是不合语法规范的:

           class someClass : public QObject 
        {
            Q_OBJECT
        [...]
        signals: //信号定义区
            friend class ClassTemplate; // 此处定义不合语法
        };

     


    本文来自CSDN博客,转载请标明出处:http://blog.csdn.net/nicholas4856/archive/2010/06/18/5678625.aspx

    展开全文
  • Qtslot和signal

    2017-02-23 19:30:32
    1) 信号的定义必须在signals:保留字下,并且不需要实现 ...1)信号和槽,是QT的拓展,所以实现信号和槽的类,必须是QObject的子类 2)实现信号和槽的类,必须以宏Q_OBJECT开始 3)连接信号和槽,要用到SIGNAL和S

    1)信号的定义必须在signals保留字下,并且不需要实现
    2)槽的定义必须在slots:保留字下,需要实现
    3)信号和槽通过QObject::connect函数连接
    4)当信号被触发时,槽函数被调用

    需要注意的是:
    1)信号和槽,是QT的拓展,所以实现信号和槽的类,必须是QObject的子类
    2)实现信号和槽的类,必须以宏Q_OBJECT开始
    3)连接信号和槽,要用到SIGNAL和SLOT宏,转换函数为字符串
    4)一个信号可以和多个槽连接,槽函数调用的顺序是不确定的
    5)多个信号可以同时连接一个槽
    6)信号可以连接信号,形成信号传导
    7)信号和槽的参数应该一样多,而且类型必须相同
    8)信号和槽都可以重载
    9)信号和槽都可以有默认参数
    10)槽函数可以像普通函数一样被调用
    11)在槽函数中,调用sender可以获得信号调用者

    总结下:
    一个类:QObject
    三个宏:Q_OBJECT SIGNAL SLOT
    三个保留字:signals, slots, emit

    展开全文
  • Qt之emit、signals、slot的使用

    万次阅读 多人点赞 2017-12-28 00:07:07
    参考:https://www.ibm.com/developerworks/cn/linux/guitoolkit/qt/signal-slot/index.html 信号和槽机制是 QT 的核心机制,要精通 QT 编程就必须对信号和槽有所了解。...信号和槽是 QT 自行定义的一种通信机制,...
  • Qt中的signal和slot

    2014-07-09 23:31:47
    Qt中的signal和slot
  • Qtslot和singnal的本质

    2020-09-10 22:58:05
    Qtslot的signal是一种对象之间的通信方式,在讲这个之前,要讲一下Qt的元对象系统 Qt的元对象系统 Meta Object System Qt的元对象系统 Meta Object System 主要是分成这个几个部分 (1)所有的类都是QObject的...
  • QTslot,signal,emit讲解

    千次阅读 2018-08-22 18:27:29
    Qt中的类库有接近一半是从基类QObject上继承下来,信号与反应槽(signals/slot)机制就是用来在QObject类或其子类间通讯的方法。作为一种通用的处理机制,信号与反应槽非常灵活,可以携带任意数量的参数,参数的类型...
  • 信号和槽是Qt编程的一个重要部分。这个机制可以在对象之间彼此并不了解的情况下将它们的行为联系起来。在前几个例子中,我们已经连接了信号和槽,声明了控件自己的信号和槽,并实现了槽函数,发送了自己的信号。现在...
  • Qt入门-connect, SIGNAL, SLOT

    千次阅读 2012-07-19 16:36:12
    QT中,事件处理信号叫做SIGNAL,事件处理函数叫做SLOT,两者关联函数是QOjbect::connect。 示例: connect(sender, SIGNAL(signal), receiver, SLOT(slot)); sender: 指触发的控件。 signel:sender中定义...
  • Qt信号与槽宏定义

    2019-01-21 21:25:13
    1 信号与槽的宏定义 METHOD,SLOT,SIGNAL宏前面对应的是字符串数字; #的意思是字符串拼接; METHOD,SLOT,SIGNAL宏实则就是加了前缀的字符串。 define METHOD(a) "...先定义信号槽使用的宏SIGNAL与SLOT; ...
  • Java实现Qt的SIGNAL-SLOT机制

    千次阅读 2012-06-04 22:41:32
    SIGNAL-SLOTQt的一大特色,使用起来十分方便。在传统的AWT和Swing编程中,我们都是为要在 监听的对象上添加Listener监听器。被监听对象中保存有Listener的列表,当相关事件发生时,被监听 对象会通知所有...
  • QT Signal/Slot机制介绍

    千次阅读 2013-09-17 15:43:51
    注:本文转载自:http://www.ibm.com/developerworks/cn/linux/guitoolkit/qt/signal-slot/#author1 简介: 信号与槽作为 QT 的核心机制在 QT 编程中有着广泛的应用,本文介绍了信号与槽的一些基本概念、元对象工具...
  • Qt error: no such slot

    2012-10-28 12:31:29
    最近在使用Qt 的过程中,时常会遇到这样的错误:no such slot 经过整理后发现注要是以下几点错误: 1、自己定义的类开始处没有 Q_OBJECT 2、没有定义slot函数: 3、连接的slot函数出现了书写错误
  • 大家都知道C++虚函数的机制,对于基类定义为虚函数的地方,子类如果覆写,在基类指针或者引用来指向子类的时候会实现动态绑定。  但如果指针去调用非虚函数,这个时候会调用C++的静态绑定,去判断当前的指针是什么...
  • Qt运行时候提取错误: Object::connect: No such slot ButtonDialog::buttonClicked() int ButtonDialog.cpp:17 Object::connect: No such slot ButtonDialog::buttonToggled() in ButtonDialog.cpp:18 错误...
  • QT不同线程间signal-slot机制的值传递 signal-slot机制是QT核心,也是QT解决线程之间通信的一大亮点。深刻理解其两大特性: (1)loosely coupled sender与receiver互不关心,一个signal可以被多个slot获取,...
  • Qt_4——SignalSlot

    2010-12-03 11:49:00
    因为上一篇我们讲到了信号和槽的概念,所以今天我单独拿出一个信号和槽的程序来加深大家对它的理解,就让我们开始对SignalSlot的旅程吧:)用Qt Creator新建一个Qt C++ Project→Mobile Qt Application,命名为...
  • Qt中的Signal和Slot机制

    2009-11-07 19:50:00
    Qt中,Signal和Slot被用于不同对象之间的通信。Signal和Slot机制与传统的Callback类似,它实际上是对传统的Callback机制进行封装,使得对象之间的通信更... 如果在类中定义了Signal和Slot,那么,在创建两个对象之后,
  • 一般情况下都是使用dialog后,结果用信号传回父窗口。 这次是将数据传递近dialog操作,考虑模态和非模态情况,原理是一样的。 SIGNAL部分:header 先声明...SLOT部分:也是先声明一个槽函数 private slots: void info_
  • QT的signal和slot的理解

    千次阅读 2010-11-11 16:25:00
    我们知道标准c++中的消息机制是... QT中的signal和slot机制,也是这个目的。所有从QObject派生的类都可以包含signal和slot。signal相当于定义了该对象(类)能产生哪种事件(比如可以被click,可以resize等),而不必
  • Qt 定义信号 signals 和 槽 slots

    万次阅读 2014-06-13 08:50:12
    2、signals区域的函数必须是void类型,而且这些信号函数没有函数体,也就是说不可以自己定义这些信号函数,你只要声明它就够了,其它不用管,Qt内部自己弄。 3、宏定义和函数指针不能用于信号和槽的参数,信号和...
  • QT中将SIGNAL定义为信号名(字符串)前面加上2,SLOT定义为方法名(字符串)前面加上1 也就是说,只要在运行时使用signal名字前面加上2,slot名字前面加上1即可。 例如: 已有信号和槽的定义: signals: ...
  • 当前接到一个QT项目开发任务,开始QT学习历程! 在经历了一个多月时间,把安装配置QT的Linux开发环境、整理原有源码... Slot)是QT的基础和独有特点,有了信号与槽的编程机制,在 Qt 中处理界面各个组件的交互操作...
  • QT no such slot...

    2017-09-25 14:32:03
    今天在改一个继承自QObject的class,这个class中自然要使用些slot,之前就使用了,今天又往里加了两个signal,编译通过,运行时报“Object::connect: No suchslot”错,当然可以继续运行,只是signal的connect没有...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 12,224
精华内容 4,889
关键字:

qtslot定义