C++ 如何覆盖qt中的信号？

我有一个问题，如何覆盖Qt中的信号

我重新定义了

QCheckBox（）

并更改了

stateChanged

信号

该项目正在进行中。它不会在“应用程序输出”错误或“插槽未连接的信号”消息中输出

但它没有链接到插槽。我不知道怎么了

---

此代码适用于：

  connect(test_checkbox[i], SIGNAL(stateChanged(int)), two_cl , SLOT(run_NEW())); 

除了数字之外，我还需要发出字符串：

  connect(test_checkbox[i], SIGNAL(stateChanged(int, QString)), two_cl , SLOT(run_NEW(int, QString)));  

---

覆盖QCheckBox

h

这就是挑战所在

h

\ifndef主窗口
#定义主窗口
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括“mydimascheckbox.h”
名称空间用户界面{
类主窗口；
}
类主窗口：公共QMainWindow
{
Q_对象
int glob_i；
int glob_流；
int向量_schet；
公众：
显式主窗口（QWidget*parent=0）；
~main窗口（）；
公众时段：
无效开始发送（bool）；
专用插槽：
单击按钮时无效（）；
私人：
Ui:：MainWindow*Ui；
QThread*thread=新的QThread（）；
QVector_线程；
QList test_复选框；
MyDimasCheckBox*复选框=新建MyDimasCheckBox（）；
QWidget*checkBoxWidget=新的QWidget（）；
QHBoxLayout*layoutCheckBox=新的QHBoxLayout（checkBoxWidget）；
};
类NewsThread:publicqthread
{
Q_对象
公众时段：
void run_NEW（）；
无效运行（int，QString）；
信号：
void otprawka（int）；
};
#endif//main窗口

.cpp

#包括“mainwindow.h”
#包括“ui_main window.h”
主窗口：：主窗口（QWidget*父窗口）：
QMainWindow（父级），
用户界面（新用户界面：：主窗口）
{
glob_i=0；
全球流量=0；
向量_schet=0；
用户界面->设置用户界面（此）；
}
MainWindow:：~MainWindow（）
{
删除用户界面；
test_checkbox.clear（）；
}
void主窗口：：在按钮上单击（）
{
glob_i++；
checkBoxWidget=新的QWidget（）；
复选框=新建MyDimasCheckBox（）；
layoutCheckBox=新的QHBoxLayout（checkBoxWidget）；
test_checkbox.append（复选框）；
连接（复选框，信号（切换（bool）），此，插槽（开始发送（bool））；
复选框->设置文本（QString:：number（glob_i））；
layoutCheckBox->addWidget（复选框）；
layoutCheckBox->setAlignment（Qt:：AlignCenter）；
layoutCheckBox->setContentsMargins（0,0,0,0）；
ui->tW_测试->插入行（ui->tW_测试->行计数（））；
ui->tW_测试->setCellWidget（ui->tW_测试->行计数（）-1，1，checkBoxWidget）；
qDebug（）您不能用子类中的另一个信号替换信号。但是，您可以用自连接插槽中的原始信号发出附加信号：

class MyDimasCheckBox : public QCheckBox
{
    Q_OBJECT
public:
    MyDimasCheckBox(QWidget *parent =0);
    ~MyDimasCheckBox();

    QString stroka;
private slots:
    // Emits the new signal
    void doEmitStateChanged(int i);

signals:
    void stateChanged(int, QString);
};

MyDimasCheckBox::MyDimasCheckBox(QWidget *parent) : QCheckBox(parent) {
    // Connect original signal to slot 
    connect(this, SIGNAL(stateChanged(int)), this, SLOT(doEmitStateChanged(int)));
}

void MyDimasCheckBox::doEmitStateChanged(int i) { 
    emit stateChanged(i, stroka); 
}

使用新的连接语法，您可以省略插槽并使用lambda：

connect(this, qOverload<int>(&QCheckBox::stateChanged), 
        // "this" context-object for QThread-Affinity
        this, [=](int i) { emit this->stateChanged(i, this->stroka); });

connect（这个，qOverload（&QCheckBox:：stateChanged），
//QThread关联的“this”上下文对象
这个，[=]（inti）{emit this->stateChanged（i，this->stroka）；}）；
覆盖信号是一种不好的做法[1]：

带有重写信号的API很难使用、意外且容易出现错误。更糟糕的是，Qt甚至允许您用非信号重写信号，反之亦然

好吧，让我们在这里再做一次。你在
MyDimasCheckBox
构造函数中发出新信号，然后在构造复选框后调用
connect
。因此信号正确发出，但此时它没有连接到任何东西，因此不会发生任何情况。从技术上讲，它不是一个替换，只是添加一个新信号w使用相同的名称和不同的签名。请注意，您不能使用具有相同信号名称的新连接语法。@BeardBeaver真的吗？我没有尝试过，但我希望它可以正常工作，只要您使用类似或合适的
静态\u cast
@BeardBeaver的方法消除歧义，它只是在Qt 5.7之前很难看。是的，确实可以，我完全忘记了这一点，你在哪里连接？
QObject:：connect:没有这样的插槽NewsThread:：doEmitStateChanged（int）
。如果你在使用我的代码，这是不可能的，因为我从未使用过
NewsThread
#ifndef MAINWINDOW_H
#define MAINWINDOW_H

#include <QMainWindow>
#include <QCheckBox>
#include <QHBoxLayout>
#include <QDebug>

#include <QThread>

#include <QCoreApplication>
#include <iostream>
#include <vector>

#include "mydimascheckbox.h"

namespace Ui {
class MainWindow;
}

class MainWindow : public QMainWindow
{
    Q_OBJECT

    int glob_i ;
    int glob_flow;
    int vector_schet; 

public:
    explicit MainWindow(QWidget *parent = 0);
    ~MainWindow();

public slots:
    void start_sending(bool); 

private slots:
    void on_pushButton_clicked();

private:
    Ui::MainWindow *ui;

    QThread *thread = new QThread();
    QVector<QThread*> vector_thread;

    QList<MyDimasCheckBox*> test_checkbox;   
    MyDimasCheckBox *checkBox = new MyDimasCheckBox();       

     QWidget *checkBoxWidget = new QWidget();
     QHBoxLayout *layoutCheckBox = new QHBoxLayout(checkBoxWidget);
};

class NewsThread: public QThread
{
    Q_OBJECT
public slots:
    void run_NEW(); 
    void run_NEW(int, QString);  

signals:
    void otprawka (int);
};

#endif // MAINWINDOW_H

#include "mainwindow.h"
#include "ui_mainwindow.h"

MainWindow::MainWindow(QWidget *parent) :
    QMainWindow(parent),
    ui(new Ui::MainWindow)
{
    glob_i=0;
    glob_flow =0;
    vector_schet =0;


    ui->setupUi(this);
}

MainWindow::~MainWindow()
{
    delete ui;
    test_checkbox.clear();
}

void MainWindow::on_pushButton_clicked()
{
    glob_i++;

    checkBoxWidget = new QWidget(); 
    checkBox = new MyDimasCheckBox();      
    layoutCheckBox = new QHBoxLayout(checkBoxWidget); 
    test_checkbox.append(checkBox);

    connect(checkBox, SIGNAL(toggled(bool)),this, SLOT(start_sending(bool))); 

    checkBox->setText(QString::number(glob_i));

    layoutCheckBox->addWidget(checkBox);            

    layoutCheckBox->setAlignment(Qt::AlignCenter);  
    layoutCheckBox->setContentsMargins(0,0,0,0);    

    ui->tW_test->insertRow(ui->tW_test->rowCount());
    ui->tW_test->setCellWidget(ui->tW_test->rowCount()-1, 1,  checkBoxWidget); 

    qDebug() << "glob_i: " << glob_i;
}

void MainWindow::start_sending(bool Value)
{
    qDebug() << "start_sending  "  ;
    // когда нажата отрабатывает, отжата то не отрабатывает
    if (Value == true)
    {
        NewsThread *two_cl = new NewsThread(); 
        qDebug() << "chekbocks: "<< " TRUE" ;
        for (int i =0;i < test_checkbox.length();i++ )
        {
            if(test_checkbox[i]->isChecked() ==Value)
            {
                glob_flow++;

//                connect(test_checkbox[i], SIGNAL(stateChanged(int)), two_cl , SLOT(run_NEW()));
                connect(test_checkbox[i], SIGNAL(stateChanged(int, QString)), two_cl , SLOT(run_NEW(int, QString))); 

                thread = new QThread(); 
                vector_thread.append(thread);

                vector_schet++;
                qDebug() << "vector_schet : " << vector_schet ;
                two_cl->moveToThread(vector_thread[vector_schet-1]); 
                vector_thread[vector_schet-1]->start();  
            }
        }
    }
    else {
        qDebug() << "chekbocks:" << " False";
        glob_flow--;
        qDebug() << "vector_schet : " << vector_schet ;
        vector_thread[vector_schet-1]->exit();
    }
}

void NewsThread::run_NEW()
{
    qDebug() << "run_NEW()";
    for(;;){  
        for (int i=0; i<500; i++){
            qDebug()<< "Число :" << i <<"number \"flow\" :"  ;
            usleep(100000);
        }
    }
}

void NewsThread::run_NEW(int i, QString str){
    qDebug() << "run_NEW(int i, QString str) ";
    for(;;){  
        for (int i=0; i<500; i++){
            qDebug() << " i : " << i;
            qDebug() << " str : " << str;
            qDebug()<< "Число :" << i <<"number \"flow\" :"  ;
            usleep(100000);
        }
    }
}

class MyDimasCheckBox : public QCheckBox
{
    Q_OBJECT
public:
    MyDimasCheckBox(QWidget *parent =0);
    ~MyDimasCheckBox();

    QString stroka;
private slots:
    // Emits the new signal
    void doEmitStateChanged(int i);

signals:
    void stateChanged(int, QString);
};

MyDimasCheckBox::MyDimasCheckBox(QWidget *parent) : QCheckBox(parent) {
    // Connect original signal to slot 
    connect(this, SIGNAL(stateChanged(int)), this, SLOT(doEmitStateChanged(int)));
}

void MyDimasCheckBox::doEmitStateChanged(int i) { 
    emit stateChanged(i, stroka); 
}

connect(this, qOverload<int>(&QCheckBox::stateChanged), 
        // "this" context-object for QThread-Affinity
        this, [=](int i) { emit this->stateChanged(i, this->stroka); });