QT窗体之间值的传递，多种方法实现

宁静致远2021

已于 2023-05-12 10:35:28 修改

阅读量5.4k

点赞数 10

分类专栏： Qt经验总结文章标签： qt 开发语言 c++

于 2023-05-12 08:34:33 首次发布

本文链接：https://blog.csdn.net/m0_46577050/article/details/130634253

版权

Qt经验总结专栏收录该内容

108 篇文章 84 订阅

订阅专栏

QT窗体之间值的传递，多种方法实现

前言
[1] QT窗体之间值的传递，多种方法实现
[2] Qt在子窗口接收父窗口的信号(思路)
[3] Qt子窗口给父窗口传值（信号与槽机制）
[4] qt 子窗口向父窗口发送信息
[5] Qt主窗口向子窗口传值
[6] Qt窗体间传递变量方法总结
[7] qt 将主窗口的数据传到子窗口去

前言

在使用QT进行界面开发时，经常会出现父窗口和子窗口进行数据交互的情况。

比方说，单击父窗口上的一个控件，子窗口发生一些动作。或者单击子窗口上的一个控件，父窗口发生一些动作。

父窗口向子窗口传递数据较简单，单击父窗口上的控制时，直接使用槽函数调用子窗口的成员函数，然后传递参数即可，执行相应的动作即可。

主窗口向子窗口传值的过程中，由于子窗口里的控件是其私有成员，所以主窗口不能直接访问。解决的方法是在子窗口中定义一个公有函数，通过调用此函数实现私有成员的访问。

但单击子窗口时，向父窗口传递参数并调用父窗口执行一些操作，需要通过信号与槽函数来完成。

解决思路：

在子窗口类里面定义个信号，父窗口类里面定义个槽函数。

总结整体思路

1 子窗口给父窗口发送数据，我们可以在子窗口中定义信号，然后在父窗口中定义槽，在父窗口中将槽和信号连接起来，这样，你子窗口中的事件触发了信号，父窗口中的槽就会被执行，数据也就传递过来了，signal（参数1，参数2），slot（参数1，参数2）。

2 父窗口给子窗口发送数据，可以通过两种方式，第一种就是主窗口向子窗口传值的过程中，由于子窗口里的控件是其私有成员，所以主窗口不能直接访问。解决的方法是在子窗口中定义一个公有函数，通过调用此函数实现私有成员的访问（或者可以给自窗口的类中定义公有变量，然后在主窗口中改变此公有变量的值来达到传递的目的）。第二种就是信号和槽的方式，通过在子窗口中定义槽，在主窗口中定义信号，然后连接，利用参数传递数据。

[1] QT窗体之间值的传递，多种方法实现

在桌面程序中很多时候会出现很多窗口，各个窗口中免不了会有数据的传输。
下面给大家带来三种方法来实现QT的窗体数据传递。

1、新建工程

在这里插入图片描述
新建工程过后添加一个新的窗口到工程中，实际目录结构如上，然后我们实现按钮方式打开新建的窗,在主窗口中包含副窗口的头，再添加子窗口的类到主窗口的成员变量中，然后我们添加一个按钮并通过槽函数的方式打开子窗口。
在这里插入图片描述
到这里我们要实现传值的工程就搭建完成了下面开始传值的方法实现。

2、全局变量extern

通过全局变量的方法来设置子窗口的标题设置，首先我们需要在主窗口的CPP文件中添加一个全局变量，然后在子窗口的构造函数中我们使用这个全局变量来设置窗口标题。
在这里插入图片描述

然后我们编译工程可以看到标题栏已经跟随主窗口CPP文件中的全局变量所更改了，下面我们将工程改变一下将子窗口类添加到父窗口成员变量中去方便我们调用。

3、公共成员函数public

接下来我们来实现通过调用公共成员函数的方法在主窗口中获取子窗口空间中的内容，我们先在主窗口和子窗口各添加一些控件，效果如下图：
在这里插入图片描述

然后我们在子页面添加一个公共成员函数用来获取编辑框的内容。

// 核心代码
class Dialog : public QDialog
{
    Q_OBJECT

public:
    explicit Dialog(QWidget *parent = nullptr);
    ~Dialog();

public:
    QString getFromText();

private:
    Ui::Dialog *ui;
};

QString Dialog::getFromText()
{
    return ui->lineEdit->text();;
}

然后我们在主窗口中来调用这个成员函数获得控件的值；

// 核心代码
void Widget::on_pushButton_2_clicked()
{
    ui->lineEdit->setText(w->getFromText());
}

在这里插入图片描述

4、信号与槽singnals

最后一个方法我们实现从子窗口来改变父窗口中编辑框中的内容，首先我们需要在子窗口类中发出一个senddata的信号，然后在主窗口中connect绑定这个信号在接受函数中将其内容设置到lineEdit上就可以实现这个效果，新建一个发送信号的按钮，然后再头文件中添加信号函数；

// 核心代码
signals:
   void sendDate(QString);


void Dialog::on_pushButton_clicked()
{
    sendDate(ui->lineEdit->text());
}

然后我们再主窗口中绑定该信号并将该信号传过来的内容设置到编辑框中；

// 核心代码
void Widget::on_pushButton_clicked()
{
    w = new Dialog();
    connect(w,SIGNAL(sendDate(QString)),this,SLOT(receiveData(QString)));
    w->show();
}

void Widget::receiveDate(QString date)
{
    ui->lineEdit->setText(date);
}

在这里插入图片描述

5、总结与工程分享

主窗口.cpp文件

#include "widget.h"
#include "ui_widget.h"

QString formTitle = "子窗口标题";

Widget::Widget(QWidget *parent)
    : QWidget(parent)
    , ui(new Ui::Widget)
{
    ui->setupUi(this);
}

Widget::~Widget()
{
    delete ui;
}


void Widget::on_pushButton_clicked()
{
    w = new Dialog();
    connect(w,SIGNAL(sendDate(QString)),this,SLOT(receiveDate(QString)));
    w->show();
}

void Widget::on_pushButton_2_clicked()
{
    ui->lineEdit->setText(w->getFromText());
}

void Widget::receiveDate(QString date)
{
    ui->lineEdit->setText(date);
}

主窗口头文件

#ifndef WIDGET_H
#define WIDGET_H

#include <QWidget>
#include "dialog.h"

QT_BEGIN_NAMESPACE
namespace Ui { class Widget; }
QT_END_NAMESPACE

class Widget : public QWidget
{
    Q_OBJECT

public:
    Widget(QWidget *parent = nullptr);
    ~Widget();

private slots:
    void on_pushButton_clicked();

    void on_pushButton_2_clicked();

    void receiveDate(QString date);
private:
    Ui::Widget *ui;
    Dialog *w;
};
#endif // WIDGET_H

子窗口.cpp文件

#include "dialog.h"
#include "ui_dialog.h"

extern QString formTitle;

Dialog::Dialog(QWidget *parent) :
    QDialog(parent),
    ui(new Ui::Dialog)
{
    ui->setupUi(this);
    this->setWindowTitle(formTitle);
}

Dialog::~Dialog()
{
    delete ui;
}

QString Dialog::getFromText()
{
    return ui->lineEdit->text();;
}

void Dialog::on_pushButton_clicked()
{
    sendDate(ui->lineEdit->text());
}

子窗口头文件

#ifndef DIALOG_H
#define DIALOG_H

#include <QDialog>

namespace Ui {
class Dialog;
}

class Dialog : public QDialog
{
    Q_OBJECT

public:
    explicit Dialog(QWidget *parent = nullptr);
    ~Dialog();

public:
    QString getFromText();

private slots:
    void on_pushButton_clicked();

signals:
   void sendDate(QString);

private:
    Ui::Dialog *ui;
};

#endif // DIALOG_H

总结：QT的核心就是信号与槽，所以上面的方法我更推荐使用第三种。

完整工程下载：https://pan.baidu.com/s/1M8mTtkYD7wMTulvk-Ew5wA?pwd=j0q2 提取码：j0q2

[2] Qt在子窗口接收父窗口的信号(思路)

原文链接：https://blog.csdn.net/u013345672/article/details/103242109

1.在父窗口头文件：定义信号；

2.在需要发送的地方发送该信号；

3.在子窗口初始化类连接该信号，并实现槽函数；

 //在父类发送信号，
 //子窗口接收父窗口的消息，需要在子窗口中进行connect处理。
 connect(parent, SIGNAL(drawShapeOver()), this, SLOT(drawShape()));
///
void CellUi_Detection::drawShape()
{
	QMessageBox::information(this, "drawShape", "drawShape");
}

注意：子窗口接收父窗口的消息，需要在子窗口中进行connect处理。

[3] Qt子窗口给父窗口传值（信号与槽机制）

原文链接：https://blog.csdn.net/Learning_Well/article/details/125552987

1、父窗口和子窗口名称介绍

父窗口：Test_7

子窗口：testnew

2、父窗口与子窗口内容介绍

子窗口：声明信号、发送信号

父窗口：声明槽函数，定义槽函数，connect连接

3、在父窗口中（Test_7.cpp），完整代码如下：

#include "Test_7.h"
 
Test_7::Test_7(QWidget *parent)
	: QMainWindow(parent)
{
	ui.setupUi(this);
	w = new TestNew;
	connect(ui.pushButton, SIGNAL(clicked()), this, SLOT(OnpushButton()));
	connect(w, SIGNAL(SignalSendQString_1(QString)), this, SLOT(SlotGetQString_1(QString)));
}
 
void Test_7::SlotGetQString_1(QString str)
{
	ui.textEdit->insertPlainText(str);
}
 
void Test_7::OnpushButton()
{
	w->show();
}

4、父窗口中（Test_7.h），完整代码如下：

#pragma once
 
#include <QtWidgets/QMainWindow>
#include "ui_Test_7.h"
#include "testnew.h"
 
class Test_7 : public QMainWindow
{
	Q_OBJECT
 
public:
	Test_7(QWidget *parent = Q_NULLPTR);
 
private:
	Ui::Test_7Class ui;
	TestNew *w;
 
	private slots:
	void SlotGetQString_1(QString str);
	void OnpushButton();
};

5、子窗口（testnew.cpp），完整代码如下：

#include "testnew.h"
 
TestNew::TestNew(QWidget *parent)
	: QWidget(parent)
{
	ui.setupUi(this);
	connect(ui.pushButton,SIGNAL(clicked()), this, SLOT(OnpushButton()));
}
 
TestNew::~TestNew()
{
 
}
void TestNew::OnpushButton()
{
	QString str = ui.textEdit->toPlainText();
	emit SignalSendQString_1(str);
}

6、子窗口（testnew.h），完整代码如下：

#pragma once
 
#include <QWidget>
#include "ui_testnew.h"
 
class TestNew : public QWidget
{
	Q_OBJECT
 
public:
	TestNew(QWidget *parent = Q_NULLPTR);
	~TestNew();
signals:
	void SignalSendQString_1(QString);
 
private:
	Ui::TestNew ui;
 
	private slots:
	void OnpushButton();
};

7、程序运行结果，如下：

在这里插入图片描述

[4] qt 子窗口向父窗口发送信息

原文链接：https://blog.csdn.net/fuyouzhiyi/article/details/120885420

场景：点击父窗口按钮1，弹出子窗口。点击子窗口查询按钮，隐藏子窗口并把查询结果显示在父窗口上。
参考文献Qt实例–主窗口和子窗口互发信号

简化需求为：子窗口点击按钮，向父窗口发送消息，并显示在子窗口上：

子窗口 DatasetQueryConditionWgt.h

要定义两个函数：

点击按钮，发送信号的槽函数SlotQueryBtnClicked()，注意带上slots
发送信息的函数 SignalQueryConditionBtnClicked(QVariantMap m_queryCondition)，注意带上signals关键字

signals:
    void SignalQueryConditionBtnClicked(QVariantMap m_queryCondition);

protected slots:
    void SlotQueryBtnClicked();

子窗口 DatasetQueryConditionWgt.cpp

connect(ui.queryBtn, SIGNAL(clicked()), this, SLOT(SlotQueryBtnClicked()));//在子窗口的构造函数中写connect函数
...
void DatasetQueryConditionWgt::SlotQueryBtnClicked()
{
    ...//其他操作
    emit SignalQueryConditionBtnClicked( m_queryCondition);
}

父窗口 DataSetQueryWidget.h

申明槽函数，接受子窗口发送的信号

protected slots:
void DatasetQueryConditionWgtReceiveSignals(QVariantMap queryCondition);

父窗口 DataSetQueryWidget.cpp

connect(m_pWindow, &DatasetQueryConditionWgt::SignalQueryConditionBtnClicked, this, &DataSetQueryWidget::DatasetQueryConditionWgtReceiveSignals);
//参数分别是：子窗口实例化的对象指针，子窗口的信号函数，父窗口的对象指针，父窗口的槽函数
//一般在子窗口实例化，也就是new完之后 写connect

void DataSetQueryWidget::DatasetQueryConditionWgtReceiveSignals(QVariantMap queryCondition)
{
    m_pWindow->hide();
   queryCondition ···
}

坑一：
一开始我在父窗口的构造函数中写 connect，点击按钮没反应，因为构造函数运行时，子窗口还没有实例化，connect不起作用
new完之后再写就好了！！！

if(!m_pWindow)
			m_pWindow = new DatasetQueryConditionWgt(this);
        connect(m_pWindow, &DatasetQueryConditionWgt::SignalQueryConditionBtnClicked, this, &DataSetQueryWidget::DatasetQueryConditionWgtReceiveSignals);

坑二：
本来不打算用这个方法的，本来是打算直接在父窗口写子窗口的槽函数，但是在写connect时，发现子窗口.ui 无法使用。这个是子窗口私有化的对象，所以connect无法奏效。
同事给了一种解决方案：在子窗口中设置getui函数获取ui，应该也可以，但是我没试。当然这个发送消息的方式也时同时告诉我的

父窗口向子窗口发送信息

父界面.h

 signals:
    void SignalAddDataset(QString datasetName);

父界面.cpp

#include "子界面.h"
//构造函数
父界面::父界面(QWidget *parent)
    : QWidget(parent)
{
   connect(this, &DataSetManageTab::SignalAddDataset, ui.dataSetManageWgt, &DataSetManagementWidget::ShowDatasetInfo);
    //connect(this, SIGNAL(SignalAddDataset(QString)), ui.dataSetManageWgt, SLOT(ShowDatasetInfo(const QString & )));
}

某某函数()
{
	emit SignalAddDataset(selectedDatasets[0]);
}

注：被注释掉的connect不好用，它能发送信号，但是子界面收不到。

子界面.h

public:
 void ShowDatasetInfo(const QString& strDatasetName);

子界面.cpp

 void dataSetManageWgt::ShowDatasetInfo(const QString& strDatasetName)
 {
     ......
 }

完整代码：

主界面

在这里插入图片描述

点击 show child

在这里插入图片描述

父界面给子界面发消息

在这里插入图片描述

子给父发

在这里插入图片描述

parentWidget.h

#pragma once
#include <QMainWindow>
#include "childWidget.h"
#include<QPushButton>
#include<QLabel>
#include "ui_parentWidget.h"
class parentWidget :
	public QMainWindow
{
	Q_OBJECT
public:
	parentWidget(QWidget *parent = Q_NULLPTR);
	~parentWidget();
signals:
	void sendTextToChild(QString);
protected slots:
	void showChildWidget();
	void showChildSay(QString);
	void sendChildWidget();
private:
	childWidget* m_childWidget =nullptr;
	QPushButton *button = nullptr, *button2 = nullptr;
	QLabel *label = nullptr;
private:
	Ui::MainWindow *ui;
};

parentWidget .cpp

#include "parentWidget.h"

#include<QGridLayout>

parentWidget::parentWidget(QWidget *parent ):QMainWindow(parent)
{
	ui->setupUi(this);
	 button = new QPushButton(this);
	button->setText("talk to child");
	 label = new QLabel(this);
	 label->setText("show child say");
	button2 = new QPushButton(this);
	button2->setText("show child widget");
	QGridLayout* glayReview = new QGridLayout(parent);
	glayReview->addWidget(button,0,0,1,1);
	glayReview->addWidget(label,1,0, 1, 1);
	glayReview->addWidget(button2,2,0, 1, 1);
	ui->centralwidget->setLayout(glayReview);
	connect(button2, SIGNAL(clicked()), this, SLOT(showChildWidget()));
	connect(button, SIGNAL(clicked()), this, SLOT(sendChildWidget()));


}
parentWidget::~parentWidget()
{

}

void parentWidget::showChildWidget()
{
	if (!m_childWidget)
	{
		m_childWidget = new childWidget();
	}
	connect(this, &parentWidget::sendTextToChild, m_childWidget, &childWidget::showParentSay);
	connect(m_childWidget, &childWidget::sendTextToParent, this, &parentWidget::showChildSay);
	m_childWidget->show();
}

void parentWidget::sendChildWidget()
{
	emit sendTextToChild("Hello child");
}

void parentWidget::showChildSay(QString str)
{
	label->setText(str);
}

子界面childWidget.h

#pragma once
#include <qwidget.h>
#include<QPushButton>
#include<QLabel>
#include"ui_childWidget.h"
class childWidget :public QWidget
{
	Q_OBJECT
public:
		childWidget(QWidget *parent = Q_NULLPTR);
		~childWidget();
signals:
	void sendTextToParent(QString);
public slots:
	void showParentSay(QString);
	void sendToParentWidget();

private:
	QPushButton *button=nullptr;
	QLabel *label = nullptr;
private:
	Ui::childWidget *ui;
};

childWidget .cpp

 #include "childWidget.h"
#include<QPushButton>
#include<QLabel>
#include<QGridLayout>
childWidget::childWidget(QWidget *parent):QWidget(parent)
{
	ui->setupUi(this);
	button = new QPushButton();
	button->setText("talk to Parent");
	label = new QLabel();
	label->setText("show parent say");
	QGridLayout* glayReview = new QGridLayout(parent);
	glayReview->setContentsMargins(10, 10, 10, 10);
	glayReview->addWidget(button,0,0, 1, 1);
	glayReview->addWidget(label,1,0, 1, 1);
	setLayout(glayReview);
	connect(button, SIGNAL(clicked()), this, SLOT(sendToParentWidget()));
}
childWidget::~childWidget()
{

}

void childWidget::showParentSay(QString str)
{
	label->setText(str);
}
void childWidget::sendToParentWidget()
{
	emit sendTextToParent("Hello parent");
}

[5] Qt主窗口向子窗口传值

原文链接：https://blog.csdn.net/qinqinxiansheng/article/details/104985044

主窗口向子窗口传值的过程中，由于子窗口里的控件是其私有成员，所以主窗口不能直接访问。解决的方法是在子窗口中定义一个公有函数，通过调用此函数实现私有成员的访问。话不多说，看实现过程：

1.通过Qt Designer设计主窗口与子窗口

主窗口MainWindow包含一个按钮pushButton和一个文本编辑lineEdit
在这里插入图片描述
子窗口SubWidge包含一个标签label

2.程序：

mainwindow.h

#ifndef MAINWINDOW_H
#define MAINWINDOW_H
#include <QMainWindow>
#include <QPushButton>

namespace Ui {
class MainWindow;
}

class MainWindow : public QMainWindow
{
    Q_OBJECT

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

private:
    Ui::MainWindow *ui;

    private slots :
    void buttonEvent();//点击按钮的槽函数
};

#endif // MAINWINDOW_H

mainwindow.cpp

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

MainWindow::MainWindow(QWidget *parent) :
    QMainWindow(parent),
    ui(new Ui::MainWindow)
{
    ui->setupUi(this);
    //连接信号与槽
    connect(ui->pushButton, SIGNAL(clicked()), this, SLOT(buttonEvent()));
}

MainWindow::~MainWindow()
{
    delete ui;
}

//点击按钮的槽函数，生成子窗口，并显示信息
void MainWindow::buttonEvent()
{
   //生成子窗口
  SubWidge *subw = new SubWidge();
  subw->show();
   //将主窗口的文本信息，传进子窗口
  subw->setText(ui->lineEdit->text());
}

subwidge.h

#ifndef SUBWIDGE_H
#define SUBWIDGE_H

#include <QWidget>

namespace Ui {
class SubWidge;
}

class SubWidge : public QWidget
{
    Q_OBJECT

public:
    explicit SubWidge(QWidget *parent = nullptr);
    ~SubWidge();
    void setText(QString str);

private:
    Ui::SubWidge *ui;
};

#endif // SUBWIDGE_H

subwidge.cpp

#include "subwidge.h"
#include "ui_subwidge.h"

SubWidge::SubWidge(QWidget *parent) :
    QWidget(parent),
    ui(new Ui::SubWidge)
{
    ui->setupUi(this);
}

SubWidge::~SubWidge()
{
    delete ui;
}

 void SubWidge::setText(QString str)
 {
     ui->label->setText(str);
 }

3.程序运行结果：

主窗口输入一条文本后，点击按钮
子窗口弹出，label上显示该文本信息
在这里插入图片描述

[6] Qt窗体间传递变量方法总结

参考：http://blog.csdn.net/hanxing0/article/details/9087237

在写QT程序时，难免会碰到多窗体之间进行传值的问题。依照自己的理解，我把多窗体传值的可以使用的方法归纳如下：

1.使用QT中的Signal&Slot机制进行传值；
2.使用全局变量；
3.使用public形式的函数接口；
4.使用QT中的Event机制（这种没有把握，但是感觉应该是可以的），但是实现起来应该比前几种复杂，这里不做讨论。

下面分别进行讨论：

1、使用QT中的Signal&Slot机制进行传值：

QT中的Signal&Slot机制相比于MFC中的消息机制简单了许多，它保证了任何对象之间均可以通过这种方式进行通信，甚至可以得到消息的sender。这里就拿一个简单的窗体间传值作为例子。

首先看一下主窗体MainWindow：在设计器中拖拽一个Label和一个TextEdit控件到界面上，TextEdit用于显示传递过来的数据。
在这里插入图片描述
创建一个右下有两个按键的对话框，放置一个Label和一个LineEdit。

下面就是编码的操作了，我们需要在Dialog中声明一个信号，当用户点击OK时传递LineEdit中的内容到mainWindow中，具体的dialog.h代码为：

#ifndef DIALOG_H
#define DIALOG_H
 
#include <QDialog>
 
namespace Ui {
class Dialog;
}
 
class Dialog : public QDialog
{
    Q_OBJECT
    
public:
    explicit Dialog(QWidget *parent = 0);
    ~Dialog();
    
private:
    Ui::Dialog *ui;
signals:
    void  sendData(QString);
private slots:
    void on_buttonBox_accepted();
};
 
#endif // DIALOG_H

其中的signals:void sendData(QString)便是我们需要的信号函数，同时声明了一个槽函数void on_buttonBox_accepted();用于相应确定按钮的click事件。下面就是需要在该函数中产生一个信号。代码如下：

void Dialog::on_buttonBox_accepted()
{
    emit sendData(ui->lineEdit->text());
}

代码异乎寻常的简单，只需要用emit的方式调用sendData函数，将需要的参数传递进去即可。而MainWindow中则需要声明接收的槽函数，注意槽函数参数只能与信号函数少或相等，而不能多于信号函数参数个数。在MainWindow的头文件中声明槽函数：

private slots:
    void receiveData(QString data);

为了便于测试，我只在MainWindow的构造函数中创建了一个Dialog对象，并连接了信号和槽，具体为：

MainWindow::MainWindow(QWidget *parent) :
    QMainWindow(parent),
    ui(new Ui::MainWindow)
{
    ui->setupUi(this);
    //信号槽方式下父子窗体传值的测试
    Dialog *dlg = new Dialog;
    //关联信号和槽函数
    connect(dlg,SIGNAL(sendData(QString)),this,SLOT(receiveData(QString)));
  // dlg->setModal(true); 不论是模态或者非模态都可以正常传值
    dlg->show();
}

这里，我没有将父窗口的指针传递到Dialog中，如new Dialog(this),这种方式下，实际上可以归结到第三类传值方式中去。因为此时，可以使用MainWindow中的父窗口的函数进行数据的赋值和操作。这里，可能还有一个问题就是，父窗口如何给子窗口传值，一方面，仍然可以使用信号和槽的方式进行，但是，我感觉更便利的方式倒是使用这种public接口的方式进行传值。这种来的更直接和明显。当然，可以看出Signal&Signal方式进行此类的处理会更有通用性。在receiveData(QString)的槽函数中进行接收到数据的处理，这里仅仅进行了简单的显示：

void MainWindow::receiveData(QString data)
{
    ui->textEdit->setText(data);
}

最后看下结果：
在这里插入图片描述

最终的结果，因为信号和槽可以是多对多的，所以，在类似多个窗体广播信息时，这种方式就很有用，当然也可以使用全局变量的形式。

2、使用全局变量

这里介绍另一种方式全局变量进行传值，在上一次的界面中的mainWindow和dialog中分别加入一个Label和LineEdit以及一个pushbutton。效果如：
在这里插入图片描述
具体实现为：在mainWindow.cpp文件中加入：

QString globaldata;        //声明一个全局变量用于窗体间传值

在全局传值按钮的clicked事件中对globaldata进行赋值：

void MainWindow::on_globalpb_clicked()
{
    globaldata = ui->lineEdit->text();
}

在Dialog.cpp文件中声明外部变量：

extern QString globaldata;

在全局传值按钮的clicked事件中对globaldata进行显示：

void Dialog::on_pushButton_clicked()
{
    ui->lineEdit_2->setText(globaldata);
}

这种方式，可以看到一些缺点，就是不容易对UI界面进行实时显示，但是这对于一个系统来讲也有一些优势，就是可以方便地将一个系统的配置分配到相关的UI界面中去，但是，同样的，也增加了程序之间的耦合性。

3、使用public形式的函数接口

使用public函数接口的方式，就牵扯到两个方向间的传值，父到子以及子到父窗口，通过这种方式都很容易做到，如子到父，可以在子窗体中实现一个public方法如prepareDoingData(&data),将需要处理的data的引用传递到子窗体，子窗体中可以对其进行操作，这里展示父到子的传值：

在Dialog界面中增加一个TextEdit用于显示最终传递的内容，并增加一个公有的方法：

public:
void setTextEditData(QString data);

void Dialog::setTextEditData(QString data)
{
    ui->textEdit->setText(data);
}

上面部分是在头文件中的内容，下面为在.cpp中的内容，而在mainwindow.cpp中只需要进行调用即可：

dlg->setTextEditData(QString("我来测试公有接口方式传值！"));

在这里插入图片描述
至此，三种传值的方式已经全部讲解完毕，具体在项目中国使用哪种方式进行传值，则要视具体情况而定。个人感觉，基本传值可以采用信号槽方式降低耦合，系统配置可以使用单例模式然后在各个界面中进行配置，而public接口方式则适用于父子间窗体传值。

[7] qt 将主窗口的数据传到子窗口去

原文链接

方式2.主要是通过connect绑定信号和槽函数的机制实现的。

在这里插入图片描述

宁静致远2021

关注

10
点赞
踩
86

收藏

觉得还不错? 一键收藏
3
评论
QT窗体之间值的传递，多种方法实现

最后一个方法我们实现从子窗口来改变父窗口中编辑框中的内容，首先我们需要在子窗口类中发出一个senddata的信号，然后在主窗口中connect绑定这个信号在接受函数中将其内容设置到lineEdit上就可以实现这个效果，新建一个发送信号的按钮，然后再头文件中添加信号函数；新建工程过后添加一个新的窗口到工程中，实际目录结构如上，然后我们实现按钮方式打开新建的窗,在主窗口中包含副窗口的头，再添加子窗口的类到主窗口的成员变量中，然后我们添加一个按钮并通过槽函数的方式打开子窗口。4、信号与槽singnals。
复制链接

扫一扫