QT开发积累——qt中的double和float精度问题

标签：const QT int double float 参数 static 方法 Qt

目录

• 引出
• • qt中的double和float精度问题
  • qt中的三元表达式
  • char 和 qchar的区别
• 总结
• 日积月累，开发集锦
• • 方法参数加const和不加const的区别
  • 方法加static和不加static的区别
  • Qt遍历list提高效率
  • 显示函数的调用
  • 使用`&`与不使用`&`
  • qt方法的参数中使用`&`与不使用`&`
  • 除法的一个坑
• 项目创建相关
• • 新建一个项目
• 其他
• • 规范和帮助文档
  • 创建第一个Qt程序
  • 对象树概念
  • 信号signal槽slot
  • 自定义信号和槽
  • • 1.自定义信号
    • 2.自定义槽
    • 3.建立连接
    • 4.进行触发
  • 自定义信号重载
  • • 带参数的
    • 按钮触发
    • 信号触发信号
    • 拓展
  • lambda表达式
  • • 返回值
    • mutable修饰
    • 案例
  • 打开关闭窗口案例

引出

QT开发积累——qt中的double和float精度问题

---

qt中的double和float精度问题

在C++中，float和double是两种常用的浮点数类型，但它们的表示范围和精度有所不同。以下是它们的一些关键区别：

float

• 大小：通常占用4个字节（32位）。
• 精度：大约7位十进制数字。
• 范围：大约 1.2E-38 到 3.4E+38。
• 用途：适用于空间和精度要求不高的场景，例如图形处理。

double

• 大小：通常占用8个字节（64位）。
• 精度：大约15-16位十进制数字。
• 范围：大约 2.3E-308 到 1.7E+308。
• 用途：适用于需要更高精度和更大范围的场景，例如科学计算。

解释

1. 浮点数值：
   • 输出表明float类型只能精确到约7位小数，而double类型可以精确到约15-16位小数。
2. 精度和范围：
   • 使用std::numeric_limits类，可以获取浮点数类型的精度和范围信息。
   • digits10成员表示该类型可以精确表示的十进制位数。
   • min和max成员表示该类型可以表示的最小值和最大值。
3. 潜在的精度差异：
   • 在实际应用中，特别是涉及大量浮点运算或需要高精度的计算时，double 类型通常比 float 类型更可靠。

通过这些信息，你可以更好地理解float和double的区别，并根据具体需求选择合适的浮点数类型。

在Qt中，使用qDebug()来输出浮点数时，你可以设置输出格式，以确保小数点后有固定的位数。为了实现这一点，你可以使用QTextStream来格式化输出。以下是一个示例，展示如何在qDebug()中输出小数点后固定10位的小数：

使用 QTextStream 格式化输出：

• 创建两个 QString 对象 floatOutput 和 doubleOutput，用于存储格式化后的字符串。
• 创建两个 QTextStream 对象 floatStream 和 doubleStream，分别与 floatOutput 和 doubleOutput 关联。

设置 QTextStream 的格式：

• 使用 setRealNumberNotation(QTextStream::FixedNotation) 设置为定点表示法。
• 使用 setRealNumberPrecision(10) 设置输出精度为10位小数。

将浮点数写入 QTextStream：

• 将 floatVal 和 doubleVal 写入各自的 QTextStream。

使用 qDebug() 输出格式化后的字符串：

• 将 floatOutput 和 doubleOutput 输出。

// Two float values
        float num1 = 1.2345678f;
        float num2 = 9.8765432f;

        // Multiplication results
        float resultFloat = num1 * num2;
        double resultDouble = num1 * num2;

        // Using QTextStream to format the output
        QString floatOutput, doubleOutput;
        QTextStream floatStream(&floatOutput);
        QTextStream doubleStream(&doubleOutput);

        floatStream.setRealNumberNotation(QTextStream::FixedNotation);
        floatStream.setRealNumberPrecision(10);
        doubleStream.setRealNumberNotation(QTextStream::FixedNotation);
        doubleStream.setRealNumberPrecision(10);


//        floatStream << num1;
//        doubleStream << num2;

//        qDebug() << "num1: " << floatOutput;
//        qDebug() << "num2: " << doubleOutput;

        floatStream << resultFloat;
        doubleStream << resultDouble;

        qDebug() << "float: " << floatOutput;
        qDebug() << "double: " << doubleOutput;

qt中的三元表达式

在 Qt（以及整个 C++）中，三元表达式（也叫条件运算符）是一个简洁的条件判断方式。其语法如下：

cpp
condition ? expression1 : expression2;

其中，condition 是一个布尔表达式，如果 condition 为 true，则整个表达式的值为 expression1，否则为 expression2。

这是一个简单的例子，展示了如何在 Qt 中使用三元表达式：

#include <QCoreApplication>
#include <QDebug>

int main(int argc, char *argv[]) {
    QCoreApplication a(argc, argv);

    int x = 5;
    int y = 10;

    // 使用三元表达式
    int max = (x > y) ? x : y;

    qDebug() << "The maximum value is:" << max;

    return a.exec();
}

在这个示例中：

1. 我们有两个整数 x 和 y。
2. 使用三元表达式 (x > y) ? x : y 计算 x 和 y 中的较大值，并将结果赋值给 max。
3. 使用 qDebug() 打印出 max 的值。

三元表达式在许多场合下可以使代码更加简洁和易读，特别是用于简单的条件判断时。它们在 Qt 和标准 C++ 中都是相同的。

更复杂的例子

如果你想在 Qt 中用三元表达式处理更复杂的逻辑，例如决定要显示的字符串，你可以这样：

#include <QCoreApplication>
#include <QString>
#include <QDebug>

int main(int argc, char *argv[]) {
    QCoreApplication a(argc, argv);

    bool isMorning = true;
    QString greeting = isMorning ? QString("Good morning") : QString("Good evening");

    qDebug() << greeting;

    return a.exec();
}

在这个示例中：

1. 我们有一个布尔变量 isMorning，表示当前是否是早上。
2. 使用三元表达式决定 greeting 应该是 "Good morning" 还是 "Good evening"。
3. 使用 qDebug() 打印出 greeting 的值。

这个示例展示了如何在 Qt 中使用三元表达式来处理 QString 对象，从而根据条件生成不同的字符串。

char 和 qchar的区别

char 和 QChar 是两种不同的数据类型，分别用于不同的上下文和库。以下是它们的主要区别：

char

• 类型定义：char 是 C++ 标准库中的基本数据类型之一，用于表示单个字符。
• 大小：通常占用 1 字节（8 位）的内存。
• 编码：通常使用 ASCII 编码，但也可以用于其他编码方式（如 UTF-8）。
• 范围：可以表示从 -128 到 127 或从 0 到 255 的整数值，具体取决于是否使用有符号或无符号类型。
• 使用场景：主要用于 C++ 标准字符串（如 std::string）和 C 风格字符串（如 char[] 或 char*）。

QChar

• 类型定义：QChar 是 Qt 库中定义的数据类型，用于表示 Unicode 字符。
• 大小：通常占用 2 字节（16 位）的内存。
• 编码：支持 Unicode 编码，可以表示几乎所有的 Unicode 字符。
• 范围：可以表示从 U+0000 到 U+FFFF 的 Unicode 字符。
• 使用场景：主要用于 Qt 的字符串类（如 QString），这些类支持 Unicode 字符串操作。

主要区别总结

• 编码支持：char 主要用于 ASCII 或 UTF-8 编码，而 QChar 用于 Unicode 编码。
• 内存占用：char 通常占用 1 字节，而 QChar 占用 2 字节。
• 功能和方法：QChar 提供了许多方便的方法来处理 Unicode 字符，而 char 则更基础，依赖于标准库或自定义方法。

转换方法

• 从 QChar 到 char：可以使用 QChar::toLatin1() 或 QChar::toAscii() 方法将 QChar 转换为 char。
• 从 char 到 QChar：可以直接将 char 赋值给 QChar，因为 QChar 提供了相应的构造函数。

例如：

QChar qchar('A'); // 直接从 char 构造 QChar
char ch = qchar.toLatin1(); // 将 QChar 转换为 char

在处理国际化和多语言文本时，QChar 和 QString 提供了更强大的功能和更好的支持，特别是在需要处理非 ASCII 字符和 Unicode 字符时。

---

总结

QT开发积累——qt中的double和float精度问题

---

日积月累，开发集锦

方法参数加const和不加const的区别

在Qt和C++中，方法参数是否加const关键字主要影响该参数在方法内部的修改权限。下面是加const和不加const的区别：

不加const

1. 可修改性：如果方法参数没有声明为const，那么在该方法内部，你可以修改这个参数的值。
2. 适用场景：当你需要在方法内部修改传入的参数时，不应该使用const。

加const

1. 不可修改性：如果方法参数声明为const，那么在该方法内部，你不能修改这个参数的值。任何尝试修改const参数的行为都会导致编译错误。
2. 适用场景：当你希望确保方法不会修改传入的参数时，应该使用const。这有助于提高代码的可读性和可维护性，因为它清楚地表明了方法的意图。
3. 性能优势：在某些情况下，编译器可能会对const参数进行优化，例如通过避免不必要的复制来提高性能。
4. 安全性：使用const可以减少意外修改参数的风险，从而提高代码的健壮性。

示例

假设有一个Qt类MyClass，它有一个方法process，该方法接受一个字符串参数：

class MyClass : public QObject {
    Q_OBJECT

public:
    void process(QString& text) {
        // 可以修改text
        text.append(" (modified)");
    }

    void print(const QString& text) const {
        // 不能修改text
        // text.append(" (modified)"); // 这将导致编译错误
        qDebug() << text;
    }
};

• 在process方法中，参数text没有声明为const，因此可以在方法内部修改它。
• 在print方法中，参数text声明为const，因此不能在方法内部修改它。

总结来说，方法参数加const主要是为了确保该参数在方法内部不被修改，从而提供更好的代码清晰度和安全性。如果不加const，则意味着参数可以在方法内部被修改。根据方法的实际需求和设计意图，选择合适的const使用方式。

方法加static和不加static的区别

在Qt类中，方法（成员函数）是否声明为static主要影响该方法的访问方式和作用域。下面是static方法和非static方法之间的主要区别：

非static方法（实例方法）

1. 访问方式：非static方法必须通过类的实例（对象）来调用。这意味着你需要先创建一个类的对象，然后才能调用其方法。
2. 访问成员变量：非static方法可以访问类的所有成员变量，包括private和protected成员。
3. 作用域：每个对象都有自己的一组非static成员变量的副本，因此非static方法操作的是调用它的对象的成员变量。
4. 生命周期：非static方法的生命周期与对象的生命周期相关联。

static方法（类方法）

1. 访问方式：static方法可以直接通过类名来调用，无需创建类的实例。例如，ClassName::staticMethod()。
2. 访问成员变量：static方法只能访问类的static成员变量。它不能直接访问非static成员变量，因为static方法不与任何特定的对象实例关联。
3. 作用域：static方法属于类本身，而不是类的任何特定实例。因此，它操作的是类的static成员变量，这些变量在所有实例之间共享。
4. 生命周期：static方法的生命周期与程序的生命周期相同，不依赖于对象的创建或销毁。

示例

假设有一个Qt类MyClass，它有一个非static方法nonStaticMethod()和一个static方法staticMethod()：

class MyClass : public QObject {
    Q_OBJECT

public:
    MyClass() {}

    void nonStaticMethod() {
        // 可以访问非static成员变量
        // 必须通过对象调用
    }

    static void staticMethod() {
        // 只能访问static成员变量
        // 可以直接通过类名调用
    }

private:
    int nonStaticVar;
    static int staticVar;
};

int MyClass::staticVar = 0;

• 调用nonStaticMethod()：

MyClass obj;
obj.nonStaticMethod();

调用staticMethod()：

• MyClass::staticMethod();
  

总结来说，static方法和非static方法的主要区别在于它们如何与类的实例和成员变量交互，以及如何被调用。static方法更像是全局函数，但它们属于类，并且只能访问类的static成员。而非static方法则与类的实例紧密相关，可以访问所有类型的成员变量。

Qt遍历list提高效率

在Qt中遍历QList或其他容器时提高运算效率主要依赖于以下几点：

1. 使用迭代器而非索引访问：对于QList和其他Qt容器类，使用迭代器进行遍历通常比使用索引访问元素更高效，特别是在非随机访问容器（如QList对于大型对象）中。这是因为迭代器直接引用容器中的元素，而不是通过索引重新计算位置。

QList<int>::iterator it;
for (it = list.begin(); it != list.end(); ++it) {
    // 使用 *it 访问元素
}

或者使用C++11的范围基于的for循环：

for (int &element : list) {
    // 使用 element
}

避免不必要的对象复制：如果你的QList包含的是自定义类型或大型对象，请确保在遍历时使用引用（或常量引用，如果你不需要修改它们），这样可以避免遍历过程中对象的不必要拷贝。

for (CustomType &item : list) {
    // 使用 item
}

如果不需要修改元素，使用常量引用：

for (const CustomType &item : list) {
    // 只读访问 item
}

考虑使用更合适的容器：QList是一个非常通用的容器，但并不总是最高效的选择。如果你需要频繁地在序列中间插入或删除元素，可能会更倾向于使用QLinkedList。如果元素经常被访问（特别是随机访问），则QVector可能是更好的选择。选择最适合你需求的容器类型可以显著提高性能。

减少遍历次数：有时可以通过算法优化来减少对容器的遍历次数。例如，如果可能，尝试将多个操作合并到单个遍历中完成，而不是对同一个列表进行多次遍历。

使用Qt Concurrent进行并行处理：对于大型数据集和可以并行处理的任务，考虑使用Qt Concurrent模块中的函数，如QtConcurrent::map，它可以自动地将任务分配到多个线程中执行，从而利用多核处理器的优势。

#include <QtConcurrent>

void processItem(int &item) {
    // 对 item 进行处理
}

QList<int> list = ...;
QtConcurrent::map(list, processItem);

遵循这些指导原则可以帮助你在Qt应用程序中提高遍历QList（以及其他容器）的运算效率。然而，请记住，性能优化应该是基于实际需要和通过分析确定的瓶颈来进行的。在许多情况下，代码的清晰性和可维护性比微小的性能提升更为重要。

显示函数的调用

使用&与不使用&

在C++中，使用&与不使用&在for循环中会产生不同的行为：

1. 使用 &: 当在范围for循环（range-based for loop）中使用引用符号&时，你将获得对容器内元素的直接引用。这意味着在循环内部对这些元素进行的任何修改都会反映到原始容器中的元素上。例如：

for (CircleData &ct : cList) {
    ct.someProperty = newValue; // 这将修改cList中元素的属性
}

在这个例子中，任何对ct的修改都会直接修改cList中的对应CircleData对象。

不使用 &: 如果不使用引用符号，范围for循环将创建容器内每个元素的副本。在这种情况下，循环内部对副本所做的任何修改都不会影响原始容器中的元素。例如：

for (CircleData ct : cList) {
    ct.someProperty = newValue; // 这只会修改副本的属性，并不会影响cList中的元素
}

在这个例子中，ct是CircleData对象的一个临时副本，对它的修改不会影响cList中的原始对象。

总之，如果你打算修改循环中的元素，应当使用引用（&），这将避免不必要的对象副本并确保修改作用于容器中的实际元素。如果你不需要修改元素或者只是想读取元素的数据，那么可以省略&来避免潜在的副作用。然而，即使在只读情况下，为了避免不必要的拷贝操作，通常也会使用常量引用（const &），如下：

for (const CircleData &ct : cList) {
    // 只读取ct的数据，不进行修改
}

这样可以提高效率，特别是在处理大型对象时。

qt方法的参数中使用&与不使用&

在 Qt 和 C++ 中，方法参数中使用 & 和不使用 & 的区别主要涉及到参数传递的方式，即值传递和引用传递。这两种方式在性能、副作用和语义上有所不同。

值传递

当方法参数不使用 & 时，参数是通过值传递的。这意味着在调用方法时，会创建参数的一个副本，并在方法内部使用这个副本。

void modifyValue(int value) {
    value = 10;
}

int main() {
    int x = 5;
    modifyValue(x);
    qDebug() << x; // 输出: 5
    return 0;
}

在这个例子中，modifyValue 方法接收一个 int 类型的参数 value，并修改其值为 10。但由于 value 是通过值传递的，原始变量 x 的值不会被修改。

引用传递

当方法参数使用 & 时，参数是通过引用传递的。这意味着在调用方法时，传递的是原始变量的引用，而不是副本。因此，在方法内部对参数的任何修改都会直接反映到原始变量上。

void modifyValue(int &value) {
    value = 10;
}

int main() {
    int x = 5;
    modifyValue(x);
    qDebug() << x; // 输出: 10
    return 0;
}

在这个例子中，modifyValue 方法接收一个 int 类型的引用参数 value，并修改其值为 10。由于 value 是通过引用传递的，原始变量 x 的值被修改为 10。

常量引用传递

在某些情况下，你可能希望避免参数的副本创建，但又不想修改原始变量。这时可以使用常量引用传递。

void printValue(const int &value) {
    qDebug() << value;
}

int main() {
    int x = 5;
    printValue(x); // 输出: 5
    return 0;
}

在这个例子中，printValue 方法接收一个 const int & 类型的参数 value，并打印其值。由于 value 是常量引用，方法内部不能修改其值，但可以避免创建副本，提高性能。

总结

• 值传递：创建参数的副本，方法内部对参数的修改不会影响原始变量。
• 引用传递：传递原始变量的引用，方法内部对参数的修改会直接影响原始变量。
• 常量引用传递：避免创建副本，同时保证参数不被修改。

在 Qt 和 C++ 编程中，选择合适的参数传递方式可以提高代码的性能和可读性。通常，对于大型对象或需要在方法内部修改参数值的情况，使用引用传递或常量引用传递是更好的选择。

除法的一个坑

在C++（包括Qt）中，如果你执行整数除法（例如 1 / 2），结果将是一个整数，因为操作数都是整数。这意味着结果会被截断，而不是四舍五入。因此，1 / 2 的结果将是 0，而不是 0.5。

如果你想得到 0.5 这个结果，你需要确保至少有一个操作数是浮点数。这可以通过将其中一个操作数显式转换为浮点数来实现，或者直接使用浮点数进行运算。

以下是在Qt中如何将 1 / 2 的结果用浮点数接收的示例：

#include <QDebug>

int main() {
    // 方法1: 将其中一个操作数转换为浮点数
    float result1 = static_cast<float>(1) / 2;
    qDebug() << "Result 1:" << result1;  // 输出: Result 1: 0.5

    // 方法2: 直接使用浮点数进行运算
    float result2 = 1.0f / 2.0f;
    qDebug() << "Result 2:" << result2;  // 输出: Result 2: 0.5

    return 0;
}

在这两个示例中，我们都确保了除法运算至少有一个浮点数参与，这样结果就会是浮点数，而不是整数。这样，当你将结果赋值给一个浮点数变量时，你将得到正确的浮点数结果 0.5。

项目创建相关

新建一个项目

---

其他

规范和帮助文档

//类名首字母大写，单词和单词之间首字母大写
//函数名变量名称首字母小写，单词和单词之间首字母大写
//快捷键
//注释ctrl +/
// 运行 ctrl +r
// 编译 ctrl b
//字体缩放ctr1+ 鼠标滚轮
//查找 ctrl+f
//整行移动 ctrl+shift+↑或者，
//帮助文档F1
//自动对齐 ctrl i;
//同名之间的.h和.cpp切换 F4
//帮助文档第一种方式F1第二种左侧按钮 1
//D:\MyPrograme\QT\5.14.2\mingw73_32\bin

创建第一个Qt程序

2.1点击创建项目后，选择项目路径到以及给项目起名称
2.2名称·不能有中文不能有空格
2.3路径·不能有中文路径
2.4默认创建有窗口类，yWidget,基类有三种选择：QWidget、QMainWindowQDialog

2.5 main函数
2.5.1 QApplication a应用程序对象，有且仅有一个
2.5.2 mywidget w;实例化窗口对象
2.5.3 w.show0调用show函数显示窗口
2.5.4 return a.exec(让应用程序对家进入消总循环机，制中，代码阻塞到当前行

#include "mywidget.h"

#include <QApplication> // 应用程序头文件
#include <QLabel>

// main程序入口 argc 命令行变量数量，argv命令行变量数组
int main(int argc, char *argv[])
{
    // 应用程序对象，qt中有且只有一个
    QApplication a(argc, argv);

    // 窗口默认不显示，需要调用show方法
    myWidget w;

    w.show();

    // 进入消息循环，死循环
    return a.exec();
}

3按钮控件常用API
3.1 创建QPushButton*btn=new QPushButton
3.2 设置父亲setParent(this
3.3 设置文本 setText(文字")
3.4 设置位置move宽，高W
3.5 重新指定商口大小 resize
3.6 设置窗口标题 setwindowTitle
3.7 设置窗口固定大小setFixedsize

#include "mywidget.h"

#include <QLabel>
#include <QPushButton>


myWidget::myWidget(QWidget *parent)
    : QWidget(parent)
{
    QLabel *label = new QLabel("hello qt");
    label->setParent(this);

    // 创建按钮
    QPushButton *btn = new QPushButton("第二个按钮",this);

    btn->move(100,100);
    // 充值窗口大小
    resize(600,400);

    setWindowTitle("第一个窗口");
}

myWidget::~myWidget()
{
}

对象树概念

4对像树
4.1 当创建的对象在堆区时候，如果指定的父亲是QObject派生下来的类或者QObject子类派生下来的类，可以不用管理释放的操作，将对象会放入到对象树中。
4.2 一定程度上简化了内存回收机制

信号signal槽slot

信号的发送者，发送的具体信号，信号的接受者，信号的处理（槽）

信号槽的优点，松散耦合，信号发送端和接受端本身是没有关联的，通过 connect连接将两端耦合在一起

6信号和槽
6.1连接函数：connect
6.2参数
6.2.1参数1 信号的发送者
6.2.2参数2 发送的信号（函数地址）
6.2.3参数3 信号的接受者
6.2.4参数4 处理的槽函数(函数的地址)
6.3松散羯合

自定义信号和槽

1.自定义信号

写到signals下
返回void
需要声明，不需要实现
可以有参数，可以重戟

2.自定义槽

返回void
需要声明，也需要实现
可以有参数，可以重载
写到public slot下或者public或者全局函数

3.建立连接

// 老师饿了，学生请吃饭
connect(te,&Teacher::hungry,st,&Student::treat);

4.进行触发

自定义信号重载

当自定义信号和槽出现重载
8.1 需要利用还数指针明确指向函数的地址·
8.2void(Teacher::tsignal )QString )=&Teacher::hungry;
8.3 QString转成char *
8.3.1.ToUtf80转为QByteArray
8.3.2.Data0转为Char *
8.4信号可以连接信号
8.5断开信号disconnect

带参数的

    void (Teacher::*teacherSignal)(QString) = &Teacher::hungry;
    void (Student::*StudentSlot)(QString) = &Student::treat;

void Student::treat(QString foodName){
    // QString -> char * 先转成QByteArray(.toUtf8())  再转成Char* ()
    qDebug() << "请老师吃。。。" << foodName.toUtf8().data();
}

按钮触发

    // 用一个按钮调用下课
    QPushButton *btn = new QPushButton("下课了",this);

    // 重置窗口daxiao
    this->resize(600,400);

    connect(btn,&QPushButton::clicked,this,&Widget::classIsOver);

信号触发信号

    // 无参的信号和槽连接
    void (Teacher::*teacherSignal2)(void) = &Teacher::hungry;
    void (Student::*StudentSlot2)(void) = &Student::treat;
    connect(te,teacherSignal2,st,StudentSlot2);

    // 信号连接信号
    connect(btn,&QPushButton::clicked,te,teacherSignal2);

断开信号disconnect

拓展

1、信号是可以连接信号
2、一个信号可以连接多个槽函数
3、多个信号可以连接同一个糟函数
4、信号和槽函数的参数必须类型一一对应
5、信号和槽的参数个数是不是要一致？信号的参数个数可以多余槽函数的参数个数

connect(信号的发送者，发送的信号signal信号)，信号接受者，槽函数SLOT)
优点：参数直观
缺点：编译器不会检测爸数类型：

lambda表达式

    [=](){
        btn->setText("aaa");
    }();

返回值

    int ret = []()->int{return 1000;}();
    qDebug() << "ret = " << ret;

mutable修饰

    QPushButton *myBtn1 = new QPushButton(this);
    QPushButton *myBtn2 = new QPushButton(this);
    myBtn1->move(100,100);
    int m = 10;
    connect(myBtn1,&QPushButton::clicked,this,
            [m]()mutable {m=100+10;qDebug()<< m;});
    connect(myBtn2,&QPushButton::clicked,this,
            [=](){qDebug()<<m;});
    qDebug() << m;

案例

    QPushButton * btnClose = new QPushButton;
    btnClose->setText("close");
    btnClose->move(100,0);
    btnClose->setParent(this);
    connect(btnClose,&QPushButton::clicked,this,
            [=](){
        btnClose->setText("关闭");
        emit te->hungry("娃哈哈");
//        this->close();
    });

打开关闭窗口案例

#include "widget.h"
#include "ui_widget.h"
#include <QPushButton>

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

    // 窗口
    QWidget *myWidget = new QWidget;
    myWidget->resize(200,200);

    QPushButton *btnOpen = new QPushButton("打开",this);
    this->resize(600,400);
    connect(btnOpen,&QPushButton::clicked,
            this,[=](){
        myWidget->show();
    });

    QPushButton *btnclose = new QPushButton("关闭",this);
    btnclose->move(200,0);
    connect(btnclose,&QPushButton::clicked,
            this,[=](){
        myWidget->close();
    });


    // 一个按钮控制两个窗口
    QWidget *myWidget1 = new QWidget;
    myWidget1->resize(300,100);

    QPushButton *myBtn = new QPushButton("open",this);
    myBtn->move(50,50);

    connect(myBtn,&QPushButton::clicked,this,
            [=](){
    if(myBtn->text()=="open"){
        myBtn->setText("close");
        myWidget1->show();
    }
    else {
        myBtn->setText("open");
        myWidget1->close();
    }
    });

}

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

标签：const,QT,int,double,float,参数,static,方法,Qt
From： https://blog.csdn.net/Pireley/article/details/140801933