花开花落为谁愁
花开花落为谁愁

QT学习资料整理

5、QMainWindow

QMainWindow是一个为用户提供主窗口程序的类，包含一个菜单栏（menu bar）、多个工具栏(tool bars)、多个锚接部件(dock widgets)、一个状态栏(status bar)及一个中心部件(central widget)，是许多应用程序的基础，如文本编辑器，图片编辑器等。

简单版：直接创建一个带UI界面的东西吧，直接在里面点点。状态栏还是建议用代码的方式
QT学习资料整理_第1张图片

1.1菜单栏 只能有一个

一个主窗口最多只有一个菜单栏。位于主窗口顶部、主窗口标题栏下面。创建菜单栏，通过QMainWindow类的menubar（）函数获取主窗口菜单栏指针
Qt 并没有专门的菜单项类，只是使用一个QAction类，抽象出公共的动作。当我们把QAction对象添加到菜单，就显示成一个菜单项，添加到工具栏，就显示成一个工具按钮。用户可以通过点击菜单项、点击工具栏按钮、点击快捷键来激活这个动作。

//创建菜单栏，通过QMainWindow类的menubar（）函数获取主窗口菜单栏指针
QMenuBar *	menuBar() const 


//创建菜单，调用QMenu的成员函数addMenu来添加菜单
QAction* addMenu(QMenu * menu)
QMenu* addMenu(const QString & title)
QMenu* addMenu(const QIcon & icon, const QString & title)


// 创建菜单项，调用QMenu的成员函数addAction来添加菜单项
QAction* activeAction() const
QAction* addAction(const QString & text)
QAction* addAction(const QIcon & icon, const QString & text)
QAction* addAction(const QString & text, const QObject * receiver, const char * member, const QKeySequence & shortcut = 0)
QAction* addAction(const QIcon & icon, const QString & text, const QObject * receiver, const char * member, const QKeySequence & shortcut = 0)
  • 1.1.1 QMenuBar* bar = menuBar() 创建
  • 1.1.2 setMenuBar(bar) ;设置到窗口中
  • 1.1.3 QMenu* menu = bar->addMenu(“文件”) 添加菜单
  • 1.1.4 QAction * newAction = menu->addAction(“新建”); 添加菜单项
  • 1.1.5 添加分割线fileMenu->addSeparator();
    QT学习资料整理_第2张图片

1.2工具栏 可以有多个

主窗口的工具栏上可以有多个工具条，通常采用一个菜单对应一个工具条的的方式，也可根据需要进行工具条的划分。

  • 直接调用QMainWindow类的addToolBar（）函数获取主窗口的工具条对象，每增加一个工具条都需要调用一次该函数。
  • 插入属于工具条的动作，即在工具条上添加操作。
    – 通过QToolBar类的addAction函数添加。
  • 工具条是一个可移动的窗口，它的停靠区域由QToolBar的allowAreas决定，包括：
Qt::LeftToolBarArea			//停靠在左侧
Qt::RightToolBarArea		//停靠在右侧
Qt::TopToolBarArea			//停靠在顶部
Qt::BottomToolBarArea   	//停靠在底部
Qt::AllToolBarAreas			//以上四个位置都可停靠

// 使用setAllowedAreas（）函数指定停靠区域：
setAllowedAreas（Qt::LeftToolBarArea | Qt::RightToolBarArea）;

// 使用setMoveable（）函数设定工具栏的可移动性：
setMoveable（false）		//工具条不可移动, 只能停靠在初始化的位置上
  • 1.2.1 QToolBar* toolbar = new QToolBar();
  • 1.2.2 addToolBar( 默认停靠范围 Qt::LeftToolBarArea ,toolbar) 添加到窗口中
  • 1.2.3 设置 只允许左右停靠、 setAllowedAreas
  • 1.2.4 设置浮动、 setFloatable
  • 1.2.5 设置移动 setMovable
    QT学习资料整理_第3张图片

1.3状态栏 只能有一个

派生自QWidget类，使用方法与QWidget类似，QStatusBar类常用成员函数：
状态栏也只能最多有一个

//添加小部件
void addWidget(QWidget * widget, int stretch = 0)
//插入小部件
int	insertWidget(int index, QWidget * widget, int stretch = 0)
//删除小部件
void removeWidget(QWidget * widget)
  • 1.3.1 QStatusBar * stBar = statusBar();
  • 1.3.2 setStatusBar(stBar);
  • 1.3.3 stBar->addWidget(label1); 左侧信息添加
  • 1.3.4 stBar->addPermanentWidget(label2); 右侧信息添加
    QT学习资料整理_第4张图片

1.4 铆接部件 可以有多个

QDockWidget * dock = new QDockWidget("标题",this);
addDockWidget(Qt::LeftDockWidgetArea,dock);
dock->setAllowedAreas(Qt::LeftDockWidgetArea | Qt::RightDockWidgetArea | Qt::TopDockWidgetArea);  设置区域范围
  • 1.4.1 QDockWidget * dockWidget = new QDockWidget;
  • 1.4.2 addDockWidget(Qt::BottomDockWidgetArea,dock); 添加到窗口中
  • 1.4.3 dock->setAllowedAreas(Qt::LeftDockWidgetArea | Qt::RightDockWidgetArea); 设置后期停靠范围

1.5核心部件 只能有一个

除了以上几个部件，中心显示的部件都可以作为核心部件，例如一个记事本文件，可以利用QTextEdit做核心部件

  • 1.5.1 setCentralWidget(edit);
    QT学习资料整理_第5张图片

1.6 代码示例

// mainwindow.h
#ifndef MAINWINDOW_H
#define MAINWINDOW_H

#include 

class MainWindow : public QMainWindow{
    Q_OBJECT

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

#endif // MAINWINDOW_H



// mainwindow.cpp
#include "mainwindow.h"
#include 
#include 
#include 
#include 
#include 
#include 
MainWindow::MainWindow(QWidget *parent): QMainWindow(parent){

    resize(600,400);

    //1、菜单栏 只能有一个
    QMenuBar * bar = menuBar();
    setMenuBar(bar);

    //创建菜单
    QMenu * fileMenu = bar->addMenu("文件");
    QMenu * editMenu = bar->addMenu("编辑");

    //创建菜单项
    QAction * newAction = fileMenu->addAction("新建");

    //添加分割线
    fileMenu->addSeparator();

    QAction * openAction = fileMenu->addAction("打开");


    //2、工具栏 可以有多个
    QToolBar * toolBar = new QToolBar(this);
    addToolBar(Qt::LeftToolBarArea,toolBar);

    //设置只允许左右停靠
    toolBar->setAllowedAreas(Qt::LeftToolBarArea | Qt::RightToolBarArea);

    //设置浮动
    toolBar->setFloatable(false);

    //设置移动 （总开关）
    toolBar->setMovable(false);

    //工具栏中放入小部件
    toolBar->addAction(newAction);
    //添加分割线
    toolBar->addSeparator();
    toolBar->addAction(openAction);

    //3、状态栏  只能有一个
    QStatusBar * stBar = statusBar();
    setStatusBar(stBar);

    QLabel * label1 = new QLabel("左侧提示信息",this);
    stBar->addWidget(label1);

    QLabel * label2 = new QLabel("右侧提示信息",this);
    stBar->addPermanentWidget(label2);


    //4、铆接部件 （浮动窗口）  可以有多个
    QDockWidget * dock = new QDockWidget("aaa" ,this);
    addDockWidget(Qt::BottomDockWidgetArea,dock);

    //只允许左右停靠
    dock->setAllowedAreas(Qt::LeftDockWidgetArea | Qt::RightDockWidgetArea);

    //5、核心部件  只能有一个
    QTextEdit * edit = new QTextEdit(this);
    setCentralWidget(edit);
}



MainWindow::~MainWindow()
{
}

1.7 资源文件添加

Qt 资源系统是一个跨平台的资源机制，用于将程序运行时所需要的资源以二进制的形式存储于可执行文件内部。如果你的程序需要加载特定的资源（图标、文本翻译等），那么，将其放置在资源文件中，就再也不需要担心这些文件的丢失。也就是说，如果你将资源以资源文件形式存储，它是会编译到可执行文件内部。
使用 Qt Creator 可以很方便地创建资源文件。我们可以在工程上点右键，选择“添加新文件…”，可以在 Qt 分类下找到“Qt 资源文件”：
2.1将资源文件放入到项目下
QT学习资料整理_第6张图片
2.2右键项目->添加新文件 -> Qt ->Qt Recourse File
QT学习资料整理_第7张图片
点击“选择…”按钮，打开“新建 Qt 资源文件”对话框。在这里我们输入资源文件的名字和路径：

2.3给资源文件起名 res 生成 res.qrc
QT学习资料整理_第8张图片
QT学习资料整理_第9张图片
点击下一步，选择所需要的版本控制系统，然后直接选择完成。我们可以在 Qt Creator 的左侧文件列表中看到“资源文件”一项，也就是我们新创建的资源文件：
2.4用编辑的方式打开 res.qrc
QT学习资料整理_第10张图片

2.5添加前置 - 添加文件
右侧的编辑区有个“添加”，我们首先需要添加前缀，比如我们将前缀取名为 images。然后选中这个前缀，继续点击添加文件，可以找到我们所需添加的文件。这里，我们选择 document-open.png 文件。当我们完成操作之后，Qt Creator 应该是这样子的：
QT学习资料整理_第11张图片

2.6使用 “ : + 前缀名 + 文件名 ”

接下来，我们还可以添加另外的前缀或者另外的文件。这取决于你的需要。当我们添加完成之后，我们可以像前面一章讲解的那样，通过使用 : 开头的路径来找到这个文件。比如，我们的前缀是 /images，文件是 document-open.png，那么就可以使用:/images/document-open.png找到这个文件。
这么做带来的一个问题是，如果以后我们要更改文件名，比如将 docuemnt-open.png 改成 docopen.png，那么，所有使用了这个名字的路径都需要修改。所以，更好的办法是，我们给这个文件去一个“别名”，以后就以这个别名来引用这个文件。具体做法是，选中这个文件，添加别名信息：
QT学习资料整理_第12张图片
这样，我们可以直接使用:/images/hudie引用到这个资源，无需关心图片的真实文件名。
如果我们使用文本编辑器打开 res.qrc 文件，就会看到一下内容：

如果我们使用文本编辑器打开 res.qrc 文件，就会看到一下内容：

<RCC>
    <qresource prefix="/">
        <file alias="hudie">Image/butterfly.png</file>		//取得别名
        <file>Image/butterfly1.png</file>
        <file>Image/down.png</file>
        <file>Image/Frame.jpg</file>
        <file>Image/Luffy.png</file>
        <file>Image/LuffyQ.png</file>
        <file>Image/mario.gif</file>
        <file>Image/OnePiece.png</file>
        <file>Image/Sunny.jpg</file>
        <file>Image/sunny.png</file>
        <file>Image/up.png</file>
    </qresource>
</RCC>

我们可以对比一下，看看 Qt Creator 帮我们生成的是怎样的 qrc 文件。当我们编译工程之后，我们可以在构建目录中找到 qrc_res.cpp 文件，这就是 Qt 将我们的资源编译成了 C++ 代码。
QT学习资料整理_第13张图片

//给新建添加小图标
//ui->actionNew->setIcon(QIcon("E:/Image/Luffy.png"));

//资源文件添加   语法：   ": + 前缀名  + 文件名称"
ui->actionNew->setIcon(QIcon(":/Image/Luffy.png"));
ui->actionOpen->setIcon(QIcon(":/Image/LuffyQ.png"));

6、 对话框QDialog

6.1 基本概念

对话框是 GUI 程序中不可或缺的组成部分。很多不能或者不适合放入主窗口的功能组件都必须放在对话框中设置。对话框通常会是一个顶层窗口，出现在程序最上层，用于实现短期任务或者简洁的用户交互。

Qt 中使用QDialog类实现对话框。就像主窗口一样，我们通常会设计一个类继承QDialog。QDialog（及其子类，以及所有Qt::Dialog类型的类）的对于其 parent 指针都有额外的解释：如果 parent 为 NULL，则该对话框会作为一个顶层窗口，否则则作为其父组件的子对话框（此时，其默认出现的位置是 parent 的中心）。顶层窗口与非顶层窗口的区别在于，顶层窗口在任务栏会有自己的位置，而非顶层窗口则会共享其父组件的位置。

对话框分为模态对话框和非模态对话框。

  • 模态对话框，就是会阻塞同一应用程序中其它窗口的输入。
    模态对话框很常见，比如“打开文件”功能。你可以尝试一下记事本的打开文件，当打开文件对话框出现时，我们是不能对除此对话框之外的窗口部分进行操作的。
  • 非模态对话框，例如查找对话框，我们可以在显示着查找对话框的同时，继续对记事本的内容进行编辑。

6.2 标准对话框

利用静态成员函数可以弹出 警告、询问、信息、错误对话框

所谓标准对话框，是 Qt 内置的一系列对话框，用于简化开发。事实上，有很多对话框都是通用的，比如打开文件、设置颜色、打印设置等。这些对话框在所有程序中几乎相同，因此没有必要在每一个程序中都自己实现这么一个对话框。
Qt 的内置对话框大致分为以下几类：

QColorDialog：			选择颜色；
QFileDialog：			选择文件或者目录；
QFontDialog：			选择字体；
QInputDialog：			允许用户输入一个值，并将其值返回；
QMessageBox：			模态对话框，用于显示信息、询问问题等；
QPageSetupDialog：		为打印机提供纸张相关的选项；
QPrintDialog：			打印机配置；
QPrintPreviewDialog：	打印预览；
QProgressDialog：		显示操作过程。

6.3 自定义消息框

Qt 支持模态对话框和非模态对话框。
模态与非模态的实现：

  • 使用QDialog::exec()实现应用程序级别的模态对话框
  • 使用QDialog::open()实现窗口级别的模态对话框
  • 使用QDialog::show()实现非模态对话框。

模态对话框

  • Qt 有两种级别的模态对话框：
    • 应用程序级别的模态
      当该种模态的对话框出现时，用户必须首先对对话框进行交互，直到关闭对话框，然后才能访问程序中其他的窗口。
    • 窗口级别的模态
      该模态仅仅阻塞与对话框关联的窗口，但是依然允许用户与程序中其它窗口交互。窗口级别的模态尤其适用于多窗口模式。
      一般默认是应用程序级别的模态。

在下面的示例中，我们调用了exec()将对话框显示出来，因此这就是一个模态对话框。当对话框出现时，我们不能与主窗口进行任何交互，直到我们关闭了该对话框。

//模态对话框创建
QDialog dlg(this);
dlg.resize(120,30);
dlg.exec();

QT学习资料整理_第14张图片

QDialog dialog;
dialog.setWindowTitle(tr("Hello, dialog!"));
dialog.exec();

QT学习资料整理_第15张图片

非模态对话框

下面我们试着将exec()修改为show()，看看非模态对话框：

QDialog dialog(this);		//这里不能在栈上创建
dialog.setWindowTitle(tr("Hello, dialog!"));
dialog.show();

是不是事与愿违？对话框竟然一闪而过！这是因为，show()函数不会阻塞当前线程，对话框会显示出来，然后函数立即返回，代码继续执行。注意，dialog 是建立在栈上的，show()函数返回，MainWindow::open()函数结束，dialog 超出作用域被析构，因此对话框消失了。知道了原因就好改了，我们将 dialog 改成堆上建立，当然就没有这个问题了：

QDialog *dialog = new QDialog;
dialog->setWindowTitle(tr("Hello, dialog!"));
dialog->show();

如果你足够细心，应该发现上面的代码是有问题的：dialog 存在内存泄露！dialog 使用 new 在堆上分配空间，却一直没有 delete。解决方案也很简单：将 MainWindow 的指针赋给 dialog 即可。还记得我们前面说过的 Qt 的对象系统吗？

不过，这样做有一个问题：如果我们的对话框不是在一个界面类中出现呢？由于QWidget的 parent 必须是QWidget指针，那就限制了我们不能将一个普通的 C++ 类指针传给 Qt 对话框。另外，如果对内存占用有严格限制的话，当我们将主窗口作为 parent 时，主窗口不关闭，对话框就不会被销毁，所以会一直占用内存。在这种情景下，我们可以设置 dialog 的WindowAttribute：

//正确的非模态对话框设置
QDialog *dlg2 = new QDialog(this);
dlg2->resize(120,30);
dlg2->show();
//设置 55号属性
dlg2->setAttribute(Qt::WA_DeleteOnClose);


//或者
QDialog *dialog = new QDialog;
dialog->setAttribute(Qt::WA_DeleteOnClose);
dialog->setWindowTitle(tr("Hello, dialog!"));
dialog->show();

setAttribute()函数设置对话框关闭时，自动销毁对话框。
QT学习资料整理_第16张图片

6.4 消息对话框

QMessageBox用于显示消息提示。我们一般会使用其提供的几个 static 函数：

  • 显示关于对话框。
void about(QWidget * parent, const QString & title, const QString & text)

QMessageBox::about(this, "傻逼", "你TM才傻逼");   //自己做了个小测试，这个是模态的

QT学习资料整理_第17张图片

这是一个最简单的对话框，其标题是 title，内容是 text，父窗口是 parent。对话框只有一个 OK 按钮。

  • 显示关于 Qt 对话框。该对话框用于显示有关 Qt 的信息。
void aboutQt(QWidget * parent, const QString & title = QString())： 

QMessageBox::aboutQt(this, "傻逼");		//自己做了个小测试，这个是模态的

QT学习资料整理_第18张图片

  • 显示严重错误对话框。
StandardButton critical(QWidget * parent, 
const QString & title, 
const QString & text, 
StandardButtons buttons = Ok, 
StandardButton defaultButton = NoButton);

//错误提示对话框
QMessageBox::critical(this,"错误","critical");   	//自己做了个小测试，这个是模态的

QT学习资料整理_第19张图片

这个对话框将显示一个红色的错误符号。我们可以通过 buttons 参数指明其显示的按钮。默认情况下只有一个 Ok 按钮，我们可以使用StandardButtons类型指定多种按钮。

  • 与QMessageBox::critical()类似，不同之处在于这个对话框提供一个普通信息图标。
StandardButton information(QWidget * parent, 
const QString & title, 
const QString & text, 
StandardButtons buttons = Ok, 
StandardButton defaultButton = NoButton)

//信息提示对话框
QMessageBox::information(this,"信息","info");  //自己做了个小测试，这个是模态的

QT学习资料整理_第20张图片

  • 与QMessageBox::critical ()类似，不同之处在于这个对话框提供一个问号图标，并且其显示的按钮是“是”和“否”。
StandardButton question(QWidget * parent,
const QString & title, 
const QString & text, 
StandardButtons buttons = StandardButtons( Yes | No ), 
StandardButton defaultButton = NoButton) 

//询问提示对话框
// 参数1   父窗口  参数2  标题  参数3  提示信息  参数4  按键类型  参数5  默认关联回车按键
if( QMessageBox::Save ==  QMessageBox::question(this,"询问","question" , QMessageBox::Save | QMessageBox::Cancel ,QMessageBox::Cancel))
{
     qDebug()<<"点击的是保存";
}
else
{
     qDebug()<<"点击的是取消";
}

QT学习资料整理_第21张图片

  • 与QMessageBox::critical()类似，不同之处在于这个对话框提供一个黄色叹号图标。
StandardButton warning(QWidget * parent, 
const QString & title, 
const QString & text, 
StandardButtons buttons = Ok, 
StandardButton defaultButton = NoButton)

QMessageBox::warning(this,"警告","warning");

QT学习资料整理_第22张图片

我们可以通过下面的代码来演示下如何使用QMessageBox。

if (QMessageBox::Yes == QMessageBox::question(this,tr("Question"), tr("Are you OK?"),QMessageBox::Yes | QMessageBox::No,QMessageBox::Yes)) {
	QMessageBox::information(this, tr("Hmmm..."), 
	tr("I'm glad to hear that!"));
} 
else {
	QMessageBox::information(this, tr("Hmmm..."), 
	tr("I'm sorry!"));
}

QT学习资料整理_第23张图片QT学习资料整理_第24张图片QT学习资料整理_第25张图片

我们使用QMessageBox::question()来询问一个问题。

  • 这个对话框的父窗口是 this。
    QMessageBox是QDialog的子类，这意味着它的初始显示位置将会是在 parent 窗口的中央。
  • 第二个参数是对话框的标题。
  • 第三个参数是我们想要显示的内容。
  • 第四个参数是关联的按键类型，我们可以使用或运算符（|）指定对话框应该出现的按钮。比如我们希望是一个 Yes 和一个 No。
  • 最后一个参数指定默认选择的按钮。
    这个函数有一个返回值，用于确定用户点击的是哪一个按钮。按照我们的写法，应该很容易的看出，这是一个模态对话框，因此我们可以直接获取其返回值。

QMessageBox类的 static 函数优点是方便使用，缺点也很明显：非常不灵活。我们只能使用简单的几种形式。为了能够定制QMessageBox细节，我们必须使用QMessageBox的属性设置 API。如果我们希望制作一个询问是否保存的对话框，我们可以使用如下的代码：

QMessageBox msgBox;
msgBox.setText(tr("The document has been modified."));
msgBox.setInformativeText(tr("Do you want to save your changes?"));
msgBox.setDetailedText(tr("Differences here..."));
msgBox.setStandardButtons(QMessageBox::Save | QMessageBox::Discard | QMessageBox::Cancel);
msgBox.setDefaultButton(QMessageBox::Save);
int ret = msgBox.exec();
switch (ret) 
{
	case QMessageBox::Save:
	    qDebug() << "Save document!";
	    break;
	case QMessageBox::Discard:
	    qDebug() << "Discard changes!";
	    break;
	case QMessageBox::Cancel:
	    qDebug() << "Close document!";
	    break;
}

msgBox 是一个建立在栈上的QMessageBox实例。我们设置其主要文本信息为“The document has been modified.”，informativeText 则是会在对话框中显示的简单说明文字。下面我们使用了一个detailedText，也就是详细信息，当我们点击了详细信息按钮时，对话框可以自动显示更多信息。我们自己定义的对话框的按钮有三个：保存、丢弃和取消。然后我们使用了exec()是其成为一个模态对话框，根据其返回值进行相应的操作。
QT学习资料整理_第26张图片
QT学习资料整理_第27张图片

6.5 颜色对话框

//颜色对话框
 QColor color = QColorDialog::getColor(Qt::red);
 qDebug() << color.red() << color.green() << color.blue() ;

QT学习资料整理_第28张图片

6.6 字体对话框

bool flag;
QFont font = QFontDialog::getFont(&flag,QFont("华文彩云",36));
qDebug() << "字体" << font.family().toUtf8().data() << "字号"<< font.pointSize()
         << "是否加粗"<<font.bold() << "是否倾斜" << font.italic();

QT学习资料整理_第29张图片

6.7 标准文件对话框

//文件对话框
QString fileName = QFileDialog::getOpenFileName(this,"打开文件","C:\\Users\\zhangtao\\Desktop","(*.*)");
qDebug () <<fileName;

QT学习资料整理_第30张图片

QFileDialog，也就是文件对话框。在本节中，我们将尝试编写一个简单的文本文件编辑器，我们将使用QFileDialog来打开一个文本文件，并将修改过的文件保存到硬盘。
首先，我们需要创建一个带有文本编辑功能的窗口。借用我们前面的程序代码，应该可以很方便地完成：

QAction* openAction = new QAction(QIcon(":/images/file-open"),tr("&Open..."), this);
openAction->setStatusTip(tr("Open an existing file"));

QAction* saveAction = new QAction(QIcon(":/images/file-save"), tr("&Save..."), this);
saveAction->setStatusTip(tr("Save a new file"));

QMenu *file = menuBar()->addMenu(tr("&File"));
file->addAction(openAction);
file->addAction(saveAction);

QToolBar* toolBar = addToolBar(tr("&File"));
toolBar->addAction(openAction);
toolBar->addAction(saveAction);

QTextEdit* textEdit = new QTextEdit(this);
setCentralWidget(textEdit);

connect(openAction, &QAction::triggered, this, &MainWindow::openFile);
connect(saveAction, &QAction::triggered, this, &MainWindow::saveFile);

我们在菜单和工具栏添加了两个动作：打开和保存。接下来是一个QTextEdit类，这个类用于显示富文本文件。也就是说，它不仅仅用于显示文本，还可以显示图片、表格等等。不过，我们现在只用它显示纯文本文件。QMainWindow有一个setCentralWidget()函数，可以将一个组件作为窗口的中心组件，放在窗口中央显示区。显然，在一个文本编辑器中，文本编辑区就是这个中心组件，因此我们将QTextEdit作为这种组件。
我们使用connect()函数，为这两个QAction对象添加响应的动作：

connect(openAction, &QAction::triggered, this, &MainWindow::openFile);
connect(saveAction, &QAction::triggered, this, &MainWindow::saveFile);

下面是最主要的openFile()和saveFile()这两个函数的代码：

//打开文件
void MainWindow::openFile()
{
    QString path = QFileDialog::getOpenFileName(this,tr("Open File"), ".", tr("Text Files(*.txt)"));
    if(!path.isEmpty()){
        QFile file(path);
        if (!file.open(QIODevice::ReadOnly | QIODevice::Text)) {
            QMessageBox::warning(this, tr("Read File"),tr("Cannot open file:\n%1").arg(path));
            return;
        }
        QTextStream in(&file);
        ui->textEdit->setText(in.readAll());		//这一步有问题会导致程序崩溃
        file.close();
    }
    else
    {
        QMessageBox::warning(this, tr("Path"),tr("You did not select any file."));
    }
}

//保存文件
void MainWindow::saveFile()
{
    QString path = QFileDialog::getSaveFileName(this,tr("Open File"), ".", tr("Text Files(*.txt)"));
    if(!path.isEmpty()){
        QFile file(path);
        if (!file.open(QIODevice::WriteOnly | QIODevice::Text)){
            QMessageBox::warning(this, tr("Write File"),tr("Cannot open file:\n%1").arg(path));
            return;
        }
        QTextStream out(&file);
        out << ui->textEdit->toPlainText();
        file.close();
    }
    else
    {
        QMessageBox::warning(this, tr("Path"), tr("You did not select any file."));
    }
}

在openFile()函数中，我们使用QFileDialog::getOpenFileName()来获取需要打开的文件的路径。这个函数原型如下：

QString getOpenFileName(QWidget * parent = 0,
                        const QString & caption = QString(),
                        const QString & dir = QString(),
                        const QString & filter = QString(),
                        QString * selectedFilter = 0,
                        Options options = 0)

不过注意，它的所有参数都是可选的，因此在一定程度上说，这个函数也是简单的。这六个参数分别是：

  • parent：父窗口。
    Qt 的标准对话框提供静态函数，用于返回一个模态对话框；
  • caption：对话框标题；
  • dir：对话框打开时的默认目录
  • “.” 代表程序运行目录
  • “/” 代表当前盘符的根目录（特指 Windows 平台；Linux 平台当然就是根目录），这个参数也可以是平台相关的，比如“C:\”等；
  • filter：过滤器。
    我们使用文件对话框可以浏览很多类型的文件，但是，很多时候我们仅希望打开特定类型的文件。比如，文本编辑器希望打开文本文件，图片浏览器希望打开图片文件。过滤器就是用于过滤特定的后缀名。如果我们使用“Image Files(.jpg .png)”，则只能显示后缀名是 jpg 或者 png 的文件。如果需要多个过滤器，使用“;;”分割，比如“JPEG Files(.jpg);;PNG Files(.png)”；
  • selectedFilter：默认选择的过滤器；
  • options：对话框的一些参数设定
    比如只显示文件夹等等，它的取值是enum QFileDialog::Option，每个选项可以使用 | 运算组合起来。

QFileDialog::getOpenFileName()返回值是选择的文件路径。我们将其赋值给 path。通过判断 path 是否为空，可以确定用户是否选择了某一文件。只有当用户选择了一个文件时，我们才执行下面的操作。
在saveFile()中使用的QFileDialog::getSaveFileName()也是类似的。使用这种静态函数，在 Windows、Mac OS 上面都是直接调用本地对话框，但是 Linux 上则是QFileDialog自己的模拟。这暗示了，如果你不使用这些静态函数，而是直接使用QFileDialog进行设置，那么得到的对话框很可能与系统对话框的外观不一致。这一点是需要注意的。

7、 布局管理器

所谓 GUI 界面，归根结底，就是一堆组件的叠加。我们创建一个窗口，把按钮放上面，把图标放上面，这样就成了一个界面。在放置时，组件的位置尤其重要。我们必须要指定组件放在哪里，以便窗口能够按照我们需要的方式进行渲染。这就涉及到组件定位的机制。

Qt 提供了两种组件定位机制：绝对定位和布局定位。

  • 绝对定位就是一种最原始的定位方法：给出这个组件的坐标和长宽值。
    这样，Qt 就知道该把组件放在哪里以及如何设置组件的大小。但是这样做带来的一个问题是，如果用户改变了窗口大小，比如点击最大化按钮或者使用鼠标拖动窗口边缘，采用绝对定位的组件是不会有任何响应的。这也很自然，因为你并没有告诉 Qt，在窗口变化时，组件是否要更新自己以及如何更新。或者，还有更简单的方法：禁止用户改变窗口大小。但这总不是长远之计。
  • 布局定位：你只要把组件放入某一种布局，布局由专门的布局管理器进行管理。当需要调整大小或者位置的时候，Qt 使用对应的布局管理器进行调整。
    布局定位完美的解决了使用绝对定位的缺陷。

Qt 提供的布局中以下三种是我们最常用的：

  • QHBoxLayout：按照水平方向从左到右布局；
  • QVBoxLayout：按照竖直方向从上到下布局；
  • QGridLayout：在一个网格中进行布局，类似于 HTML 的 table；

7.1 系统提供的布局控件

QT学习资料整理_第31张图片

这4个为系统给我们提供的布局的控件，但是使用起来不是非常的灵活，这里就不详细介绍了。

7.2 利用widget做布局

第二种布局方式是利用控件里的widget来做布局，在Containers中
QT学习资料整理_第32张图片

在widget中的控件可以进行水平、垂直、栅格布局等操作，比较灵活。
再布局的同时我们需要灵活运用弹簧的特性让我们的布局更加的美观，下面是一个登陆窗口，利用widget可以搭建出如下登陆界面：
QT学习资料整理_第33张图片QT学习资料整理_第34张图片QT学习资料整理_第35张图片

这个垂直策略是使那个红框和内部的东西一样高。
QT学习资料整理_第36张图片

QT学习资料整理_第37张图片

8、 常用控件

Qt为我们应用程序界面开发提供的一系列的控件，下面我们介绍两种最常用一些控件，所有控件的使用方法我们都可以通过帮助文档获取。

8.1 QLabel控件使用

QLabel是我们最常用的控件之一，其功能很强大，我们可以用来显示文本，图片和动画等。

显示文字 （普通文本、html）

通过QLabel类的setText函数设置显示的内容:

void	setText(const QString &)
  • 可以显示普通文本字符串
QLable *label = new QLable;
label->setText(“Hello, World!”);
  • 可以显示HTML格式的字符串
    比如显示一个链接:
QLabel * label = new QLabel(this);
label ->setText("Hello, World");
label ->setText("
百度一下
");
label ->setOpenExternalLinks(true);

其中setOpenExternalLinks()函数是用来设置用户点击链接之后是否自动打开链接，如果参数指定为true则会自动打开。

显示图片
可以使用QLabel的成员函数setPixmap设置图片

void	setPixmap(const QPixmap &)

首先定义QPixmap对象

QPixmap pixmap;

然后加载图片

pixmap.load(":/Image/boat.jpg");

最后将图片设置到QLabel中

QLabel *label = new QLabel;
label.setPixmap(pixmap);

显示动画

可以使用QLabel 的成员函数setMovie加载动画，可以播放gif格式的文件

void	setMovie(QMovie * movie)

首先定义QMovied对象，并初始化:

QMovie *movie = new QMovie(":/Mario.gif");

播放加载的动画：

movie->start();

将动画设置到QLabel中：

QLabel *label = new QLabel；
label->setMovie(movie);

8.2 QLineEdit

Qt提供的单行文本编辑框。

设置/获取内容

  • 获取编辑框内容使用text（），函数声明如下：
QString	text() const
  • 设置编辑框内容
void	setText(const QString &)

设置显示模式
使用QLineEdit类的setEchoMode () 函数设置文本的显示模式,函数声明:

void	setEchoMode(EchoMode mode)

EchoMode是一个枚举类型,一共定义了四种显示模式:

  • QLineEdit::Normal 模式显示方式，按照输入的内容显示。
  • QLineEdit::NoEcho 不显示任何内容，此模式下无法看到用户的输入。
  • QLineEdit::Password 密码模式，输入的字符会根据平台转换为特殊字符。
  • QLineEdit::PasswordEchoOnEdit 编辑时显示字符否则显示字符作为密码。
    另外，我们再使用QLineEdit显示文本的时候，希望在左侧留出一段空白的区域，那么，就可以使用QLineEdit给我们提供的setTextMargins函数：
void setTextMargins(int left, int top, int right, int bottom)

用此函数可以指定显示的文本与输入框上下左右边界的间隔的像素数。

8.3 其他控件

Qt中控件的使用方法可参考Qt提供的帮助文档。

1 按钮组

  • QPushButton 最常用按钮，里面可以加图片
  • QToolButton 工具按钮 用于显示图片
    • toolButtonStyle 设置显示图片和文件出现与否
    • autoRaise透明凸起效果
  • QRadioButton 单选按钮
    • 默认选中 setChecked(true)
  • QCheckBox 复选按钮
  • stateChanged 信号
    • 0 未选中
    • 1 半选中
    • 2 选中

Push Button简单按钮

在这里插入图片描述在这里插入图片描述

Tool Button工具按钮
在这里插入图片描述在这里插入图片描述QT学习资料整理_第38张图片
上面的autoRaise 表示鼠标放上去能有一个突起的效果

QT学习资料整理_第39张图片

复选框的半选中（全选中是2，半选中是1）
在这里插入图片描述

2 Item Widgets(Item_based)

List Widget 列表控件

创建项 QListWidgetItem * item = new QListWidgetItem("锄禾日当午");
//将项加载到 控件中
ui->listWidget->addItem(item);
设置对齐方式 item->setTextAlignment(Qt::AlignHCenter);
ui->listWidget->addItems(list); 可以一次性放入所有内容

//listWidget
QListWidgetItem * item = new QListWidgetItem("锄禾日当午");	//创建项

ui->listWidget->addItem(item);								//将项加载到 控件中 

item->setTextAlignment(Qt::AlignHCenter);					//设置对齐方式

QT学习资料整理_第40张图片

//QStringList   QList  list
QStringList list;
list << "锄禾日当午"<< "汗滴禾下土"<< "谁知盘中餐"<< "粒粒皆辛苦";
ui->listWidget->addItems(list);

QT学习资料整理_第41张图片
效果图 缺点就是无法设置对齐方式

tree Widget 树控件使用

设置头

ui->treeWidget->setHeaderLabels(QStringList()<<"英雄"<<"英雄简介");

创建根项目

QTreeWidgetItem * liItem = new QTreeWidgetItem(QStringList()<<"力量");

将根项目添加到树控件中

ui->treeWidget->addTopLevelItem(liItem);

挂载子项目

QTreeWidgetItem * l1 = new QTreeWidgetItem(heroL1);
liItem->addChild(l1);

//treeWidget树控件使用

    //设置头
    ui->treeWidget->setHeaderLabels(QStringList()<<"英雄"<<"英雄简介");       //QStringList()是匿名对象

    //创建出力量根
    QTreeWidgetItem * liItem = new QTreeWidgetItem(QStringList()<<"力量");
    QTreeWidgetItem * minItem = new QTreeWidgetItem(QStringList()<<"敏捷");
    QTreeWidgetItem * zhiItem = new QTreeWidgetItem(QStringList()<<"智力");
    //将根放入到树中
    ui->treeWidget->addTopLevelItem(liItem);
    ui->treeWidget->addTopLevelItem(minItem);
    ui->treeWidget->addTopLevelItem(zhiItem);

    QStringList heroL1,heroL2;
    heroL1 << "刚被猪" << "前排坦克，能在吸收伤害的同时造成可观的范围输出";
    heroL2 << "船长" << "前排坦克，能肉能输出能控场的全能英雄";
    QTreeWidgetItem * l1 = new QTreeWidgetItem(heroL1);
    QTreeWidgetItem * l2 = new QTreeWidgetItem(heroL2);
    liItem->addChild(l1);
    liItem->addChild(l2);

    QStringList heroM1,heroM2;
    heroM1 << "月骑" << "中排物理输出，可以使用分裂利刃攻击多个目标";
    heroM2 << "小鱼人" << "前排战士，擅长偷取敌人的属性来增强自身战力";
    QTreeWidgetItem * m1 = new QTreeWidgetItem(heroM1);
    QTreeWidgetItem * m2 = new QTreeWidgetItem(heroM2);
    minItem->addChild(m1);
    minItem->addChild(m2);

    QStringList heroZ1,heroZ2;
    heroZ1 << "死灵法师" << "前排法师坦克，魔法抗性较高，拥有治疗技能";
    heroZ2 << "巫医" << "后排辅助法师，可以使用奇特的巫术诅咒敌人与治疗队友";
    QTreeWidgetItem * z1 = new QTreeWidgetItem(heroZ1);
    QTreeWidgetItem * z2 = new QTreeWidgetItem(heroZ2);
    zhiItem->addChild(z1);
    zhiItem->addChild(z2);

QT学习资料整理_第42张图片

Table Widget 表格控件使用

设置列 ui->tableWidget->setColumnCount(3);
设置水平表头 ui->tableWidget->setHorizontalHeaderLabels(QStringList()<<"姓名"<<"性别"<<"年龄");
设置行数 ui->tableWidget->setRowCount(5);
设置正文 ui->tableWidget->setItem(行,列 , new QTableWidgetItem(“字符串”));

//tableWidget表格控件使用

//设置列数
ui->tableWidget->setColumnCount(3);

//设置水平表头
ui->tableWidget->setHorizontalHeaderLabels(QStringList()<<"姓名"<<"性别"<<"年龄");

//设置行数
ui->tableWidget->setRowCount(5);

QList<QString> nameList;
nameList << "亚瑟"<< "安琪拉"<<"妲己"<<"赵云"<< "孙悟空";
QStringList sexList;
sexList << "男"<< "女"<< "女"<< "男"<< "中立";


for(int i  = 0 ; i < 5;i++)    {
    int col = 0;
    ui->tableWidget->setItem(i,col++, new QTableWidgetItem(nameList[i]));
    ui->tableWidget->setItem(i,col++, new QTableWidgetItem(sexList.at(i)));

    //int 转 QString   QString::number(int)
    ui->tableWidget->setItem(i,col++, new QTableWidgetItem( QString::number(i+18)  ));
}

QT学习资料整理_第43张图片

3 containers

scrollArea
滚动条的功能，可以放一些按钮或者其他东西进去

QT学习资料整理_第44张图片

toolBox
工具盒子，相当于每一个栏目里面可以放置，官方的话就是家人、朋友、黑名单页。每一页（可以打开）下面可以放很多东西。

QT学习资料整理_第45张图片QT学习资料整理_第46张图片
QT学习资料整理_第47张图片QT学习资料整理_第48张图片

tabWidget
在里面就像网页浏览中切换页面的情景。

QT学习资料整理_第49张图片QT学习资料整理_第50张图片QT学习资料整理_第51张图片

QT学习资料整理_第52张图片QT学习资料整理_第53张图片

stackedWidget
做页面切换的，一般与按钮配合使用，通过点击不同的工具按钮可以在栈中切换我们想要的页面

QT学习资料整理_第54张图片QT学习资料整理_第55张图片QT学习资料整理_第56张图片

    //点击按钮 切换 stacked容器
    ui->stackedWidget->setCurrentIndex(0);//默认使用第一个栈

    connect(ui->btn_ScrollArea,&QPushButton::clicked,[=](){
           ui->stackedWidget->setCurrentIndex(0);
    });

    connect(ui->btn_ToolBox,&QPushButton::clicked,[=](){
           ui->stackedWidget->setCurrentIndex(1);
    });

    connect(ui->btn_TabWidget,&QPushButton::clicked,[=](){
           ui->stackedWidget->setCurrentIndex(2);
    });

容器中就上面几个常用，其他的自己自己玩一玩

4 Input Widgets

comboBox

下拉框的操作，下面有个按钮可以点击选中拖拉机的选项。

    //下拉框使用
    ui->comboBox->addItem("奔驰");
    ui->comboBox->addItem("宝马");
    ui->comboBox->addItem("拖拉机");

    //点击按钮 选中拖拉机下拉框内容
    connect(ui->btn_select,&QPushButton::clicked,[=](){
//        ui->comboBox->setCurrentIndex(2);
        ui->comboBox->setCurrentText("拖拉机");
    });

QT学习资料整理_第57张图片

fontComboBox
QT学习资料整理_第58张图片

lineEdit
textEdit
plainTextEdit

QT学习资料整理_第59张图片

spinBox
doubleSpinBox
timeEdit
dateEdit
dateTimeEdit
dial
QT学习资料整理_第60张图片

5 Display Widgets

Label
Qlabel显示图片

ui->label_img->setPixmap(QPixmap(":/Image/butterfly.png"));

QLabel显示gif图片

QMovie * movie =new QMovie(":/Image/mario.gif");
ui->label_movie->setMovie(movie);
movie->start();

QT学习资料整理_第61张图片

8.4 自定义控件

  • 自定义控件封装
    • 右键项目- 添加新文件
    • Qt - Qt设计师界面类
    • 在ui文件中设计自定义控件
  • 在主窗口中 拖拽 Widget做提升的操作
  • 在自定义控件中 封装对外接口
    • SpinBox和 slider控件交互
    • getData获取显示数字
    • setData设置数字
      QT学习资料整理_第62张图片
      QT学习资料整理_第63张图片
      QT学习资料整理_第64张图片
      在这里插入图片描述
      QT学习资料整理_第65张图片

在搭建Qt窗口界面的时候，在一个项目中很多窗口，或者是窗口中的某个模块会被经常性的重复使用。一般遇到这种情况我们都会将这个窗口或者模块拿出来做成一个独立的窗口类，以备以后重复使用。

在使用Qt的ui文件搭建界面的时候，工具栏栏中只为我们提供了标准的窗口控件，如果我们想使用自定义控件怎么办？
例如：我们从QWidget派生出一个类SmallWidget，实现了一个自定窗口，

// smallwidget.h
class SmallWidget : public QWidget
{
    Q_OBJECT
public:
    explicit SmallWidget(QWidget *parent = 0);

signals:

public slots:
private:
    QSpinBox* spin;
    QSlider* slider;
};

// smallwidget.cpp
SmallWidget::SmallWidget(QWidget *parent) : QWidget(parent)
{
    spin = new QSpinBox(this);
    slider = new QSlider(Qt::Horizontal, this);

    // 创建布局对象
    QHBoxLayout* layout = new QHBoxLayout;
    
    // 将控件添加到布局中
    layout->addWidget(spin);
    layout->addWidget(slider);
    
    // 将布局设置到窗口中
    setLayout(layout);

    // 添加消息响应
    connect(spin, static_cast<void (QSpinBox::*)(int)>(&QSpinBox::valueChanged), slider, &QSlider::setValue);
    connect(slider, &QSlider::valueChanged, spin, &QSpinBox::setValue);
}

QT学习资料整理_第66张图片

那么这个SmallWidget可以作为独立的窗口显示,也可以作为一个控件来使用：
打开Qt的.ui文件,因为SmallWidget是派生自Qwidget类,所以需要在ui文件中先放入一个QWidget控件, 然后再上边鼠标右键
QT学习资料整理_第67张图片

弹出提升窗口部件对话框

添加要提升的类的名字,然后选择 添加

添加之后,类名会显示到上边的列表框中,然后单击提升按钮,完成操作.
我们可以看到, 这个窗口对应的类从原来的QWidget变成了SmallWidget
在这里插入图片描述

再次运行程序,这个widget_3中就能显示出我们自定义的窗口了.

// smallwidget.h
#ifndef SMALLWIDGET_H
#define SMALLWIDGET_H

#include 

namespace Ui {
	class SmallWidget;
}

class SmallWidget : public QWidget{
    Q_OBJECT

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

    //设置值
    void setData(int val);
    //获取值
    int getData();

private:
    Ui::SmallWidget *ui;
};
#endif // SMALLWIDGET_H

// smallwidget.cpp
#include "smallwidget.h"
#include "ui_smallwidget.h"

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

    //修改SpinBox  右侧滚动条 跟着移动
    void(QSpinBox:: *spinBoxP)(int) = &QSpinBox::valueChanged;   //函数指针表示指定某个函数，防止有重载版本函数的干扰
    connect(ui->spinBox,spinBoxP , [=](int val){ui->horizontalSlider->setValue(val);});

    //右侧滚动条移动，左侧跟着改变数字
    connect(ui->horizontalSlider,&QSlider::valueChanged , [=](int val){ui->spinBox->setValue(val);});
}

//设置值
void SmallWidget::setData(int val){
    ui->horizontalSlider->setValue(val);
}

//获取值
int SmallWidget::getData(){
    return ui->horizontalSlider->value();
}

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


// widget.cpp
#include "widget.h"
#include "ui_widget.h"
#include 
Widget::Widget(QWidget *parent) :
    QWidget(parent),
    ui(new Ui::Widget)
{
    ui->setupUi(this);

    //点击设置按钮，将小控件设置到一半位置
    connect(ui->btn_set,&QPushButton::clicked,[=](){ui->widget->setData(50);});

    //点击获取按钮，获取当前显示数字
    connect(ui->btn_get,&QPushButton::clicked,[=](){qDebug() << ui->widget->getData();});
}

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

9、 Qt消息机制和事件

9.1 事件

Qt鼠标常用事件

    //鼠标进入事件
    void enterEvent(QEvent *);
    //鼠标离开事件
    void leaveEvent(QEvent *);

    //鼠标按下事件
    void mousePressEvent(QMouseEvent *ev);
    //鼠标释放事件
    void mouseReleaseEvent(QMouseEvent *ev);
    //鼠标移动事件
    void mouseMoveEvent(QMouseEvent *ev);

获取 x y 坐标 ev->x() ev->y()
判断如果是左键 按下

ev->button()   移动  ev->buttons() &   //组合键 做判断

设置鼠标追踪状态

setMouseTracking(true);

QT学习资料整理_第68张图片
QT学习资料整理_第69张图片
QT学习资料整理_第70张图片
再修改mylabel.h中的东西。让他继承Qlabel中的东西
QT学习资料整理_第71张图片

再修改mylabel.cpp中的东西。让他继承Qlabel中的东西在这里插入图片描述QT学习资料整理_第72张图片

事件（event）是由系统或者 Qt 本身在不同的时刻发出的。当用户按下鼠标、敲下键盘，或者是窗口需要重新绘制的时候，都会发出一个相应的事件。一些事件在对用户操作做出响应时发出，如键盘事件等；另一些事件则是由系统自动发出，如计时器事件。

在前面我们也曾经简单提到，Qt 程序需要在main()函数创建一个QApplication对象，然后调用它的exec()函数。这个函数就是开始 Qt 的事件循环。在执行exec()函数之后，程序将进入事件循环来监听应用程序的事件。当事件发生时，Qt 将创建一个事件对象。Qt 中所有事件类都继承于QEvent。在事件对象创建完毕后，Qt 将这个事件对象传递给QObject的event()函数。event()函数并不直接处理事件，而是按照事件对象的类型分派给特定的事件处理函数（event handler），关于这一点，会在后边详细说明。

在所有组件的父类QWidget中，定义了很多事件处理的回调函数，如

  • keyPressEvent()
  • keyReleaseEvent()
  • mouseDoubleClickEvent()
  • mouseMoveEvent()
  • mousePressEvent()
  • mouseReleaseEvent() 等。

这些函数都是 protected virtual 的，也就是说，我们可以在子类中重新实现这些函数。下面来看一个例子：

class EventLabel : public QLabel{
protected:
    void mouseMoveEvent(QMouseEvent *event);
    void mousePressEvent(QMouseEvent *event);
    void mouseReleaseEvent(QMouseEvent *event);
};
 
void EventLabel::mouseMoveEvent(QMouseEvent *event){
this->setText(QString("
Move: (%1, %2)
").arg(QString::number(event->x()),
            QString::number(event->y())));
}
 
void EventLabel::mousePressEvent(QMouseEvent *event)
{
    this->setText(QString("
Press:(%1, %2)
").arg(QString::number(event->x()),
                QString::number(event->y())));
}
 
void EventLabel::mouseReleaseEvent(QMouseEvent *event){
    QString msg;
    msg.sprintf("
Release: (%d, %d)
",event->x(), event->y());
    this->setText(msg);
}
 
int main(int argc, char *argv[])
{
    QApplication a(argc, argv);
 
    EventLabel *label = new EventLabel;
    label->setWindowTitle("MouseEvent Demo");
    label->resize(300, 200);
    label->show();
 
    return a.exec();
}
  • EventLabel继承了QLabel，覆盖了mousePressEvent()、mouseMoveEvent()和MouseReleaseEvent()三个函数。我们并没有添加什么功能，只是在鼠标按下（press）、鼠标移动（move）和鼠标释放（release）的时候，把当前鼠标的坐标值显示在这个Label上面。由于QLabel是支持 HTML 代码的，因此我们直接使用了 HTML 代码来格式化文字。
  • QString的arg()函数可以自动替换掉QString中出现的占位符。其占位符以 % 开始，后面是占位符的位置，例如 %1，%2 这种。
QString("[%1, %2]").arg(x).arg(y);

语句将会使用x替换 %1，y替换 %2，因此，生成的QString为[x, y]。

  • 在mouseReleaseEvent()函数中，我们使用了另外一种QString的构造方法。我们使用类似 C 风格的格式化函数sprintf()来构造QString。
    运行上面的代码，当我们点击了一下鼠标之后，label 上将显示鼠标当前坐标值。

为什么要点击鼠标之后才能在mouseMoveEvent()函数中显示鼠标坐标值？
这是因为QWidget中有一个mouseTracking属性，该属性用于设置是否追踪鼠标。只有鼠标被追踪时，mouseMoveEvent()才会发出。如果mouseTracking是 false（默认即是），组件在至少一次鼠标点击之后，才能够被追踪，也就是能够发出mouseMoveEvent()事件。如果mouseTracking为 true，则mouseMoveEvent()直接可以被发出。
知道了这一点，我们就可以在main()函数中添加如下代码：

label->setMouseTracking(true);

在运行程序就没有这个问题了。

9.2 event（）事件分发器

事件对象创建完毕后，Qt 将这个事件对象传递给QObject的event()函数。event()函数并不直接处理事件，而是将这些事件对象按照它们不同的类型，分发给不同的事件处理器（event handler）。
如上所述，event()函数主要用于事件的分发。所以，如果你希望在事件分发之前做一些操作，就可以重写这个event()函数了。例如，我们希望在一个QWidget组件中监听 tab 键的按下，那么就可以继承QWidget，并重写它的event()函数，来达到这个目的：

bool CustomWidget::event(QEvent *e){
    if (e->type() == QEvent::KeyPress) {
        QKeyEvent *keyEvent = static_cast<QKeyEvent *>(e);
        if (keyEvent->key() == Qt::Key_Tab) {
            qDebug() << "You press tab.";
            return true;
        }
    }
    return QWidget::event(e);
}
  • CustomWidget是一个普通的QWidget子类。我们重写了它的event()函数，这个函数有一个QEvent对象作为参数，也就是需要转发的事件对象。函数返回值是 bool 类型。
  • 如果传入的事件已被识别并且处理，则需要返回 true，否则返回 false。如果返回值是 true，那么 Qt 会认为这个事件已经处理完毕，不会再将这个事件发送给其它对象，而是会继续处理事件队列中的下一事件。
  • 在event()函数中，调用事件对象的accept()和ignore()函数是没有作用的，不会影响到事件的传播。
    我们可以通过使用QEvent::type()函数可以检查事件的实际类型，其返回值是QEvent::Type类型的枚举。我们处理过自己感兴趣的事件之后，可以直接返回 true，表示我们已经对此事件进行了处理；对于其它我们不关心的事件，则需要调用父类的event()函数继续转发，否则这个组件就只能处理我们定义的事件了。为了测试这一种情况，我们可以尝试下面的代码：
bool CustomTextEdit::event(QEvent *e){
   if (e->type() == QEvent::KeyPress) {
        QKeyEvent *keyEvent = static_cast<QKeyEvent *>(e);
       if (keyEvent->key() == Qt::Key_Tab) {
            qDebug() << "You press tab.";
            return true;
       }
    }
    return false;
}

CustomTextEdit是QTextEdit的一个子类。我们重写了其event()函数，却没有调用父类的同名函数。这样，我们的组件就只能处理 Tab 键，再也无法输入任何文本，也不能响应其它事件，比如鼠标点击之后也不会有光标出现。这是因为我们只处理的KeyPress类型的事件，并且如果不是KeyPress事件，则直接返回 false，鼠标事件根本不会被转发，也就没有了鼠标事件。
通过查看QObject::event()的实现，我们可以理解，event()函数同前面的章节中我们所说的事件处理器有什么联系：

//!!! Qt5
bool QObject::event(QEvent *e){
    switch (e->type()) {
    case QEvent::Timer:
        timerEvent((QTimerEvent*)e);
        break;

    case QEvent::ChildAdded:
    case QEvent::ChildPolished:
    case QEvent::ChildRemoved:
        childEvent((QChildEvent*)e);
        break;
    // ...
    default:
        if (e->type() >= QEvent::User) {
            customEvent(e);
            break;
        }
        return false;
    }
    return true;
}

这是 Qt 5 中QObject::event()函数的源代码（Qt 4 的版本也是类似的）。我们可以看到，同前面我们所说的一样，Qt 也是使用QEvent::type()判断事件类型，然后调用了特定的事件处理器。比如，如果event->type()返回值是QEvent::Timer，则调用timerEvent()函数。可以想象，QWidget::event()中一定会有如下的代码：

switch (event->type()) {
    case QEvent::MouseMove:
        mouseMoveEvent((QMouseEvent*)event);
        break;
    // ...
}

事实也的确如此。timerEvent()和mouseMoveEvent()这样的函数，就是我们前面章节所说的事件处理器 event handler。也就是说，event()函数中实际是通过事件处理器来响应一个具体的事件。这相当于event()函数将具体事件的处理“委托”给具体的事件处理器。而这些事件处理器是 protected virtual 的，因此，我们重写了某一个事件处理器，即可让 Qt 调用我们自己实现的版本。
由此可以见，event()是一个集中处理不同类型的事件的地方。如果你不想重写一大堆事件处理器，就可以重写这个event()函数，通过QEvent::type()判断不同的事件。鉴于重写event()函数需要十分小心注意父类的同名函数的调用，一不留神就可能出现问题，所以一般还是建议只重写事件处理器（当然，也必须记得是不是应该调用父类的同名处理器）。这其实暗示了event()函数的另外一个作用：屏蔽掉某些不需要的事件处理器。正如我们前面的CustomTextEdit例子看到的那样，我们创建了一个只能响应 tab 键的组件。这种作用是重写事件处理器所不能实现的。

9.3 事件过滤器

有时候，对象需要查看、甚至要拦截发送到另外对象的事件。例如，对话框可能想要拦截按键事件，不让别的组件接收到；或者要修改回车键的默认处理。

通过前面的章节，我们已经知道，Qt 创建了QEvent事件对象之后，会调用QObject的event()函数处理事件的分发。显然，我们可以在event()函数中实现拦截的操作。由于event()函数是 protected 的，因此，需要继承已有类。如果组件很多，就需要重写很多个event()函数。这当然相当麻烦，更不用说重写event()函数还得小心一堆问题。好在 Qt 提供了另外一种机制来达到这一目的：事件过滤器。

QObject有一个eventFilter()函数，用于建立事件过滤器。函数原型如下：

virtual bool QObject::eventFilter ( QObject * watched, QEvent * event );

这个函数正如其名字显示的那样，是一个“事件过滤器”。所谓事件过滤器，可以理解成一种过滤代码。事件过滤器会检查接收到的事件。如果这个事件是我们感兴趣的类型，就进行我们自己的处理；如果不是，就继续转发。这个函数返回一个 bool 类型，如果你想将参数 event 过滤出来，比如，不想让它继续转发，就返回 true，否则返回 false。事件过滤器的调用时间是目标对象（也就是参数里面的watched对象）接收到事件对象之前。也就是说，如果你在事件过滤器中停止了某个事件，那么，watched对象以及以后所有的事件过滤器根本不会知道这么一个事件。

我们来看一段简单的代码：

class MainWindow : public QMainWindow {
 public:
     MainWindow();
 protected:
     bool eventFilter(QObject *obj, QEvent *event);
 private:
     QTextEdit *textEdit;
 };
 
 MainWindow::MainWindow() {
     textEdit = new QTextEdit;
     setCentralWidget(textEdit);
     textEdit->installEventFilter(this);
 }
 
 bool MainWindow::eventFilter(QObject *obj, QEvent *event){
     if (obj == textEdit) {
         if (event->type() == QEvent::KeyPress) {
             QKeyEvent *keyEvent = static_cast<QKeyEvent *>(event);
             qDebug() << "Ate key press" << keyEvent->key();
             return true;
         } else {
             return false;
         }
     } else {
         // pass the event on to the parent class
         return QMainWindow::eventFilter(obj, event);
     }
 }
  • MainWindow是我们定义的一个类。我们重写了它的eventFilter()函数。为了过滤特定组件上的事件，首先需要判断这个对象是不是我们感兴趣的组件，然后判断这个事件的类型。在上面的代码中，我们不想让textEdit组件处理键盘按下的事件。所以，首先我们找到这个组件，如果这个事件是键盘事件，则直接返回 true，也就是过滤掉了这个事件，其他事件还是要继续处理，所以返回 false。对于其它的组件，我们并不保证是不是还有过滤器，于是最保险的办法是调用父类的函数。
  • eventFilter()函数相当于创建了过滤器，然后我们需要安装这个过滤器。安装过滤器需要调用QObject::installEventFilter()函数。函数的原型如下：
void QObject::installEventFilter ( QObject * filterObj )

这个函数接受一个QObject *类型的参数。记得刚刚我们说的，eventFilter()函数是QObject的一个成员函数，因此，任意QObject都可以作为事件过滤器（问题在于，如果你没有重写eventFilter()函数，这个事件过滤器是没有任何作用的，因为默认什么都不会过滤）。已经存在的过滤器则可以通过QObject::removeEventFilter()函数移除。

  • 我们可以向一个对象上面安装多个事件处理器，只要调用多次installEventFilter()函数。如果一个对象存在多个事件过滤器，那么，最后一个安装的会第一个执行，也就是后进先执行的顺序。

还记得我们前面的那个例子吗？我们使用event()函数处理了 Tab 键：

bool CustomWidget::event(QEvent *e){
    if (e->type() == QEvent::KeyPress) {
        QKeyEvent *keyEvent = static_cast<QKeyEvent *>(e);
        if (keyEvent->key() == Qt::Key_Tab) {
            qDebug() << "You press tab.";
            return true;
        }
    }
    return QWidget::event(e);
}

现在，我们可以给出一个使用事件过滤器的版本：

bool FilterObject::eventFilter(QObject *object, QEvent *event){
    if (object == target && event->type() == QEvent::KeyPress) {
        QKeyEvent *keyEvent = static_cast<QKeyEvent *>(event);
        if (keyEvent->key() == Qt::Key_Tab) {
            qDebug() << "You press tab.";
            return true;
        } else {
            return false;
        }
    }
    return false;
}

事件过滤器的强大之处在于，我们可以为整个应用程序添加一个事件过滤器。记得，installEventFilter()函数是QObject的函数，QApplication或者QCoreApplication对象都是QObject的子类，因此，我们可以向QApplication或者QCoreApplication添加事件过滤器。这种全局的事件过滤器将会在所有其它特性对象的事件过滤器之前调用。尽管很强大，但这种行为会严重降低整个应用程序的事件分发效率。因此，除非是不得不使用的情况，否则的话我们不应该这么做。
注意，
事件过滤器和被安装过滤器的组件必须在同一线程，否则，过滤器将不起作用。另外，如果在安装过滤器之后，这两个组件到了不同的线程，那么，只有等到二者重新回到同一线程的时候过滤器才会有效。

9.4 总结

Qt 的事件是整个 Qt 框架的核心机制之一，也比较复杂。说它复杂，更多是因为它涉及到的函数众多，而处理方法也很多，有时候让人难以选择。现在我们简单总结一下 Qt 中的事件机制。

Qt 中有很多种事件：鼠标事件、键盘事件、大小改变的事件、位置移动的事件等等。如何处理这些事件，实际有两种选择：

  • 所有事件对应一个事件处理函数，在这个事件处理函数中用一个很大的分支语句进行选择，其代表作就是 win32 API 的WndProc()函数：
LRESULT CALLBACK WndProc(HWND hWnd,
                         UINT message,
                         WPARAM wParam,
                         LPARAM lParam)

在这个函数中，我们需要使用switch语句，选择message参数的类型进行处理，典型代码是：

switch(message)
{
    case WM_PAINT:
        // ...
        break;
    case WM_DESTROY:
        // ...
        break;
    ...
}
  • 每一种事件对应一个事件处理函数。Qt 就是使用的这么一种机制：
    • mouseEvent()
    • keyPressEvent()
    • …
      Qt 具有这么多种事件处理函数，肯定有一个地方对其进行分发，否则，Qt 怎么知道哪一种事件调用哪一个事件处理函数呢？这个分发的函数，就是event()。显然，当QMouseEvent产生之后，event()函数将其分发给mouseEvent()事件处理器进行处理。

event()函数会有两个问题：

  • event()函数是一个 protected 的函数，这意味着我们要想重写event()，必须继承一个已有的类。试想，我的程序根本不想要鼠标事件，程序中所有组件都不允许处理鼠标事件，是不是我得继承所有组件，一一重写其event()函数？protected 函数带来的另外一个问题是，如果我基于第三方库进行开发，而对方没有提供源代码，只有一个链接库，其它都是封装好的。我怎么去继承这种库中的组件呢？
  • event()函数的确有一定的控制，不过有时候我的需求更严格一些：我希望那些组件根本看不到这种事件。event()函数虽然可以拦截，但其实也是接收到了QMouseEvent对象。我连让它收都收不到。这样做的好处是，模拟一种系统根本没有那个事件的效果，所以其它组件根本不会收到这个事件，也就无需修改自己的事件处理函数。这种需求怎么办呢？

这两个问题是event()函数无法处理的。于是，Qt 提供了另外一种解决方案：事件过滤器。事件过滤器给我们一种能力，让我们能够完全移除某种事件。事件过滤器可以安装到任意QObject类型上面，并且可以安装多个。如果要实现全局的事件过滤器，则可以安装到QApplication或者QCoreApplication上面。这里需要注意的是，如果使用installEventFilter()函数给一个对象安装事件过滤器，那么该事件过滤器只对该对象有效，只有这个对象的事件需要先传递给事件过滤器的eventFilter()函数进行过滤，其它对象不受影响。如果给QApplication对象安装事件过滤器，那么该过滤器对程序中的每一个对象都有效，任何对象的事件都是先传给eventFilter()函数。

事件过滤器可以解决刚刚我们提出的event()函数的两点不足：

  • 首先，事件过滤器不是 protected 的，因此我们可以向任何QObject子类安装事件过滤器；
  • 其次，事件过滤器在目标对象接收到事件之前进行处理，如果我们将事件过滤掉，目标对象根本不会见到这个事件。

事实上，还有一种方法，我们没有介绍。Qt 事件的调用最终都会追溯到QCoreApplication::notify()函数，因此，最大的控制权实际上是重写QCoreApplication::notify()。这个函数的声明是：

virtual bool QCoreApplication::notify ( QObject * receiver, QEvent * event );

该函数会将event发送给receiver，也就是调用receiver->event(event)，其返回值就是来自receiver的事件处理器。注意，这个函数为任意线程的任意对象的任意事件调用，因此，它不存在事件过滤器的线程的问题。不过我们并不推荐这么做，因为notify()函数只有一个，而事件过滤器要灵活得多。

现在我们可以总结一下 Qt 的事件处理，实际上是有五个层次：

  • 重写paintEvent()、mousePressEvent()等事件处理函数。这是最普通、最简单的形式，同时功能也最简单。
  • 重写event()函数。event()函数是所有对象的事件入口，QObject和QWidget中的实现，默认是把事件传递给特定的事件处理函数。
  • 在特定对象上面安装事件过滤器。该过滤器仅过滤该对象接收到的事件。
  • 在QCoreApplication::instance()上面安装事件过滤器。该过滤器将过滤所有对象的所有事件，因此和notify()函数一样强大，但是它更灵活，因为可以安装多个过滤器。全局的事件过滤器可以看到 disabled 组件上面发出的鼠标事件。全局过滤器有一个问题：只能用在主线程。
  • 重写QCoreApplication::notify()函数。这是最强大的，和全局事件过滤器一样提供完全控制，并且不受线程的限制。但是全局范围内只能有一个被使用（因为QCoreApplication是单例的）。

9.5 案列源码

1 Qt鼠标常用事件

    //鼠标进入事件
    void enterEvent(QEvent *);
    //鼠标离开事件
    void leaveEvent(QEvent *);

    //鼠标按下事件
    void mousePressEvent(QMouseEvent *ev);
    //鼠标释放事件
    void mouseReleaseEvent(QMouseEvent *ev);
    //鼠标移动事件
    void mouseMoveEvent(QMouseEvent *ev);

获取 x y 坐标 ev->x() ev->y()

 QString str =  QString("鼠标移动了 x =  %1  y = %2 " ).arg(ev->x()).arg(ev->y());

ev->button()   移动  ev->buttons() &   //组合键 做判断
if(ev->buttons() & Qt::LeftButton)    //判断如果是左键 按下

设置鼠标追踪状态

setMouseTracking(true);

2 定时器

定时器1
定时器事件 void timerEvent( QTimerEvent * e)
启动定时器 id1 = startTimer(毫秒)
判断具体定时器标准 e->timerId() == id1

定时器2
通过定时器类实现 QTimer类
创建定时器对象 QTimer * timer1 = new QTimer(this);
开启定时器 timer1->start(x毫秒)
每隔x毫秒 会抛出一个信号timeout出来
监听信号处理逻辑
暂停定时器 timer1->stop();

3 事件分发器

用途：用于分发事件
原型 bool event(QEvent * e)；
返回值如果是 true代表用户自己处理事件，不在向下分发

4 事件过滤器

步骤1 给控件安装过滤器 ui->label->installEventFilter(this);
步骤2 重写过滤器事件 bool Widget::eventFilter(QObject * obj , QEvent * e)

// mylabel.cpp
#ifndef MYLABEL_H
#define MYLABEL_H
#include 

class MyLabel : public QLabel{
    Q_OBJECT
public:
    explicit MyLabel(QWidget *parent = 0);

    //鼠标进入事件
    void enterEvent(QEvent *);
    //鼠标离开事件
    void leaveEvent(QEvent *);

    //鼠标按下事件
    void mousePressEvent(QMouseEvent *ev);
    //鼠标释放事件
    void mouseReleaseEvent(QMouseEvent *ev);
    //鼠标移动事件
    void mouseMoveEvent(QMouseEvent *ev);

    //事件分发器
    bool event(QEvent *e);

signals:

public slots:
};

#endif // MYLABEL_H

// widget.h
#ifndef WIDGET_H
#define WIDGET_H
#include 
namespace Ui {class Widget;}

class Widget : public QWidget{
    Q_OBJECT
public:
    explicit Widget(QWidget *parent = 0);
    ~Widget();

    //添加定时器事件
    void timerEvent(QTimerEvent *);

    //第一个定时器 标志
    int id1;
    //第二个定时器 标志
    int id2;

    //重写过滤器事件
    bool eventFilter(QObject *, QEvent *);
private:
    Ui::Widget *ui;
};

#endif // WIDGET_H

// mylabel.cpp
#include "mylabel.h"
#include 
#include 
MyLabel::MyLabel(QWidget *parent) : QLabel(parent){
    //设置鼠标追踪
   // setMouseTracking(true);
}

//鼠标进入事件
void MyLabel::enterEvent(QEvent *){
//    qDebug() << "鼠标进入了";
}
//鼠标离开事件
void MyLabel::leaveEvent(QEvent *){
//     qDebug() << "鼠标离开了";
}

//鼠标按下事件
void MyLabel::mousePressEvent(QMouseEvent *ev){     //鼠标中的所有的参数都放在ev里 
    //鼠标左键按下  打印信息
//    if(ev->button() == Qt::LeftButton){
        QString str =  QString("鼠标按下了 x =  %1  y = %2 " ).arg(ev->x()).arg(ev->y());        //字符串拼接
        qDebug() << str;
//    }
}
//鼠标释放事件
void MyLabel::mouseReleaseEvent(QMouseEvent *ev){
    if(ev->button() == Qt::LeftButton){
        QString str =  QString("鼠标释放了 x =  %1  y = %2 " ).arg(ev->x()).arg(ev->y());
        qDebug() << str;
    }

}
//鼠标移动事件
void MyLabel::mouseMoveEvent(QMouseEvent *ev){
//    if(ev->buttons() & Qt::LeftButton){
        QString str =  QString("鼠标移动了 x =  %1  y = %2 " ).arg(ev->x()).arg(ev->y());
        qDebug() <<str;
//    }
}

//事件分发器 :用途，分发事件
bool MyLabel::event(QEvent *e){
    if( e->type() == QEvent::MouseButtonPress)    {
        //如果是鼠标按下  拦截事件，不向下分发
        QMouseEvent *ev = static_cast<QMouseEvent *>(e);

        QString str =  QString("event中  鼠标按下了 x =  %1  y = %2 " ).arg(ev->x()).arg(ev->y());
        qDebug() << str;

        return true;
    }

    //其他事件  抛给父类去处理
    return QLabel::event(e);
}

// widget.cpp
#include "widget.h"
#include "ui_widget.h"
#include  //定时器类
#include 
#include 

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

    //开启定时器方法1，不推荐
    id1 = startTimer(1000); //单位 毫秒
    id2 = startTimer(2000); //单位 毫秒

    //创建定时器对象方法2，推荐
    QTimer * timer1 = new QTimer(this);
    timer1->start(500);

    //每隔0.5秒 会抛出一个信号timeout出来
    connect(timer1,&QTimer::timeout , [=](){
        //每隔0.5秒中 让label_4数字++
        static int num = 1;
        ui->label_4->setText( QString::number(num++) );
    });

    //点击暂停按钮  停止定时器
    connect(ui->pushButton,&QPushButton::clicked,[=](){timer1->stop();});

    //给label添加事件过滤器 ，做更高级的拦截操作
    //1、给控件安装过滤器
    ui->label->installEventFilter(this);

}

//重写过滤器事件
bool Widget::eventFilter(QObject * obj , QEvent * e){
    if(obj == ui->label){
        if( e->type() == QEvent::MouseButtonPress){
            //如果是鼠标按下  拦截事件，不向下分发
            QMouseEvent *ev = static_cast<QMouseEvent *>(e);

            QString str =  QString("事件过滤器  鼠标按下了 x =  %1  y = %2 " ).arg(ev->x()).arg(ev->y());
            qDebug() << str;

            return true;
        }
    }

    //其他事件抛给父类
    return QWidget::eventFilter(obj,e);
}


//添加定时器事件
void Widget::timerEvent(QTimerEvent * e){
    if(e->timerId() == id1){
        //每隔1秒中 让label_2数字++
        static int num = 1;
        ui->label_2->setText( QString::number(num++) );
    }
    if(e->timerId() == id2){
        //每隔2秒让label_3数字++
        static int num2 = 1;
        ui->label_3->setText( QString::number(num2++) );
    }
}

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

QT学习资料整理_第73张图片
QT学习资料整理_第74张图片

10 绘图和绘图设备

10.1 QPainter

Qt 的绘图系统允许使用相同的 API 在屏幕和其它打印设备上进行绘制。整个绘图系统基于QPainter，QPainterDevice和QPaintEngine三个类。

  • QPainter用来执行绘制的操作；
  • QPaintDevice是一个二维空间的抽象，这个二维空间允许QPainter在其上面进行绘制，也就是QPainter工作的空间；
  • QPaintEngine提供了画笔（QPainter）在不同的设备上进行绘制的统一的接口。QPaintEngine类应用于QPainter和QPaintDevice之间，通常对开发人员是透明的。除非你需要自定义一个设备，否则你是不需要关心QPaintEngine这个类的。我们可以把QPainter理解成画笔；把QPaintDevice理解成使用画笔的地方，比如纸张、屏幕等；而对于纸张、屏幕而言，肯定要使用不同的画笔绘制，为了统一使用一种画笔，我们设计了QPaintEngine类，这个类让不同的纸张、屏幕都能使用一种画笔。
class Widget : public QWidget{
    Q_OBJECT
public:
    explicit Widget(QWidget *parent = 0);
    ~Widget();

    //绘图事件
    void paintEvent(QPaintEvent *);
    //x坐标
    int posX;
private:
    Ui::Widget *ui;
};

//绘图事件
void Widget::paintEvent(QPaintEvent *){
    QPainter painter(this);     //这个this表示往这上面画东西
    //画线
    painter.drawLine(QPoint(0,0),QPoint(100,100));
    //画圆
    painter.drawEllipse( QPoint(100,100) , 50,50);    //两个50表示长半轴和短半轴
    //画矩形
    painter.drawRect(QRect(20,20,50,50));
    //写字
    painter.drawText(QRect(10,200,150,100),"好好学习，天天向上");
}

QT学习资料整理_第75张图片

 //设置画笔
QPen pen(QColor(255,0,0));
//设置画笔宽度
pen.setWidth(3);
//设置风格
pen.setStyle(Qt::DotLine);
painter.setPen(pen);      //拿起这个画笔

//画刷  可以使封闭图形填充颜色（Qt::cyan表示青色）
QBrush brush(Qt::cyan);
//设置风格
brush.setStyle(Qt::Dense4Pattern);
painter.setBrush(brush);  //设置填充色

//画线
painter.drawLine(QPoint(0,0),QPoint(100,100));
//画圆
painter.drawEllipse( QPoint(100,100) , 50,50);    //两个50表示长半轴和短半轴
//画矩形
painter.drawRect(QRect(20,20,50,50));
//写字
painter.drawText(QRect(10,200,150,100),"好好学习，天天向上");

QT学习资料整理_第76张图片

    painter.drawEllipse(QPoint(100,100) , 50,50);

    //设置抗锯齿能力   效率会稍微比低
    painter.setRenderHint(QPainter::Antialiasing);

    painter.drawEllipse(QPoint(250,100) , 50,50);

QT学习资料整理_第77张图片

painter.drawRect(QRect(20,20,50,50));

//移动画家
painter.translate(100,0);

//保存画家状态
painter.save();

painter.drawRect(QRect(20,20,50,50));

painter.translate(100,0);

//取出画家状态
painter.restore();

painter.drawRect(QRect(20,20,50,50));

QT学习资料整理_第78张图片
QT学习资料整理_第79张图片

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

    //点击移动按钮  让图片移动
    posX = 0;
    connect(ui->pushButton,&QPushButton::clicked,[=](){
        posX += 20;
        update();//手动调用绘图事件
    });

    QTimer * timer = new QTimer(this);
    timer->start(10);

    connect(timer,&QTimer::timeout,[=](){
         posX ++;
         update();
    });
}


//绘图事件
void Widget::paintEvent(QPaintEvent *){
    QPainter painter(this);     //这个this表示往这上面画东西

    //画资源图片
    QPixmap pix(":/Image/Luffy.png");

    //如果超出屏幕，强制变为 图片的负位置
    if(posX > this->width()){
        posX = -pix.width();
    }
    painter.drawPixmap(posX,0,pix);    //指定一个位置画出来什么东西


    //如果超出屏幕，强制变为0位置
//    if(posX > this->width()){
//        posX = 0;
//    }
//    painter.drawPixmap(posX,0,QPixmap(":/Image/Luffy.png"));
}

QT学习资料整理_第80张图片

下图给出了这三个类之间的层次结构:
在这里插入图片描述

上面的示意图告诉我们，Qt 的绘图系统实际上是，使用QPainter在QPainterDevice上进行绘制，它们之间使用QPaintEngine进行通讯（也就是翻译QPainter的指令）。
下面我们通过一个实例来介绍QPainter的使用：

class PaintedWidget : public QWidget{
    Q_OBJECT
public:
    PaintedWidget(QWidget *parent = 0);
protected:
    void paintEvent(QPaintEvent *);
}

注意我们重写了QWidget的paintEvent()函数。接下来就是PaintedWidget的源代码：

PaintedWidget::PaintedWidget(QWidget *parent) : QWidget(parent){
    resize(800, 600);
    setWindowTitle(tr("Paint Demo"));
}

void PaintedWidget::paintEvent(QPaintEvent *){
    QPainter painter(this);
    painter.drawLine(80, 100, 650, 500);
    painter.setPen(Qt::red);
    painter.drawRect(10, 10, 100, 400);
    painter.setPen(QPen(Qt::green, 5));
    painter.setBrush(Qt::blue);
    painter.drawEllipse(50, 150, 400, 200);
}

在构造函数中，我们仅仅设置了窗口的大小和标题。而paintEvent()函数则是绘制的代码。

首先，我们在栈上创建了一个QPainter对象，也就是说，每次运行paintEvent()函数的时候，都会重建这个QPainter对象。注意，这一点可能会引发某些细节问题：由于我们每次重建QPainter，因此第一次运行时所设置的画笔颜色、状态等，第二次再进入这个函数时就会全部丢失。有时候我们希望保存画笔状态，就必须自己保存数据，否则的话则需要将QPainter作为类的成员变量。

QPainter接收一个QPaintDevice指针作为参数。QPaintDevice有很多子类，比如QImage，以及QWidget。注意回忆一下，QPaintDevice可以理解成要在哪里去绘制，而现在我们希望画在这个组件，因此传入的是 this 指针。

QPainter有很多以 draw 开头的函数，用于各种图形的绘制，比如这里的drawLine()，drawRect()以及drawEllipse()等。当绘制轮廓线时，使用QPainter的pen()属性。
比如，我们调用了painter.setPen(Qt::red)将 pen 设置为红色，则下面绘制的矩形具有红色的轮廓线。接下来，我们将 pen 修改为绿色，5 像素宽（painter.setPen(QPen(Qt::green, 5))），又设置了画刷为蓝色。这时候再调用 draw 函数，则是具有绿色 5 像素宽轮廓线、蓝色填充的椭圆。

10.2 绘图设备

绘图设备是指继承QPainterDevice的子类。Qt提供了很多这样的类，例如QPixmap、QBitmap、QImage和 QPicture。其中，

  • QPixmap专门为图像在屏幕上的显示做了优化
  • QBitmap是QPixmap的一个子类，它的色深限定为1，可以使用 QPixmap的isQBitmap()函数来确定这个QPixmap是不是一个QBitmap。
  • QImage专门为图像的像素级访问做了优化。
  • QPicture则可以记录和重现QPainter的各条命令。

10.2.1 QPixmap、QBitmap、QImage

QPixmap继承了QPaintDevice，因此，你可以使用QPainter直接在上面绘制图形。QPixmap也可以接受一个字符串作为一个文件的路径来显示这个文件，比如你想在程序之中打开png、jpeg之类的文件，就可以使用 QPixmap。使用QPainter的drawPixmap()函数可以把这个文件绘制到一个QLabel、QPushButton或者其他的设备上面。QPixmap是针对屏幕进行特殊优化的，因此，它与实际的底层显示设备息息相关。注意，这里说的显示设备并不是硬件，而是操作系统提供的原生的绘图引擎。所以，在不同的操作系统平台下，QPixmap的显示可能会有所差别。

QBitmap继承自QPixmap，因此具有QPixmap的所有特性，提供单色图像。QBitmap的色深始终为1. 色深这个概念来自计算机图形学，是指用于表现颜色的二进制的位数。我们知道，计算机里面的数据都是使用二进制表示的。为了表示一种颜色，我们也会使用二进制。比如我们要表示8种颜色，需要用3个二进制位，这时我们就说色深是3. 因此，所谓色深为1，也就是使用1个二进制位表示颜色。1个位只有两种状态：0和1，因此它所表示的颜色就有两种，黑和白。所以说，QBitmap实际上是只有黑白两色的图像数据。

由于QBitmap色深小，因此只占用很少的存储空间，所以适合做光标文件和笔刷。
下面我们来看同一个图像文件在QPixmap和QBitmap下的不同表现：

void PaintWidget::paintEvent(QPaintEvent *)
{
    QPixmap pixmap(":/Image/butterfly.png");
    QPixmap pixmap1(":/Image/butterfly1.png");
    QBitmap bitmap(":/Image/butterfly.png");
    QBitmap bitmap1(":/Image/butterfly1.png");

    QPainter painter(this);
    painter.drawPixmap(0, 0, pixmap);
    painter.drawPixmap(200, 0, pixmap1);
    painter.drawPixmap(0, 130, bitmap);
    painter.drawPixmap(200, 130, bitmap1);
}

QT学习资料整理_第81张图片

这里我们给出了两张png图片。butterfly1.png是没有透明色的纯白背景，而butterfly.png是具有透明色的背景。我们分别使用QPixmap和QBitmap来加载它们。注意看它们的区别：白色的背景在QBitmap中消失了，而透明色在QBitmap中转换成了黑色；其他颜色则是使用点的疏密程度来体现的。

//QPixmap做绘图设备  对不同平台做了显示的优化
QPixmap pix(300,300);
pix.fill(Qt::white);      //填充白色，不写这个的话就是默认填充黑色

QPainter painter(&pix);                           //创建一个画家，他的画板就是QPixmap的一个对象

painter.setPen( QPen(Qt::red) );                  //设置画笔为红色
painter.drawEllipse(QPoint(150,150) , 100,100);   //画个圆
pix.save("D:\\pix.png");                          //保存图片

QT学习资料整理_第82张图片

//QImage做绘图设备   不同平台下显示效果一样，可以对像素的访问做了优化
QImage img(300,300,QImage::Format_RGB32);
img.fill(Qt::white);      //填充白色，不写这个的话就是默认填充黑色

QPainter painter(&img);
painter.setPen( QPen(Qt::green) );
painter.drawEllipse(QPoint(150,150) , 100,100);
img.save("D:\\img.png");

QT学习资料整理_第83张图片

void Widget::paintEvent(QPaintEvent *){
    QImage img;
    img.load(":/Image/Luffy.png");

    QPainter painter(this);
    //修改像素点
    for(int i  = 100;i< 150;i++){
        for(int j = 100;j< 150;j++){
           QRgb value  = qRgb(255,0,0);
           img.setPixel(i,j,value);
        }
    }
    painter.drawImage(0,0,img);
}

QT学习资料整理_第84张图片

QPixmap使用底层平台的绘制系统进行绘制，无法提供像素级别的操作，而QImage则是使用独立于硬件的绘制系统，实际上是自己绘制自己，因此提供了像素级别的操作，并且能够在不同系统之上提供一个一致的显示形式。
我们声明了一个QImage对象，大小是300 x 300，颜色模式是RGB32，即使用32位数值表示一个颜色的RGB值，也就是说每种颜色使用8位。然后我们对每个像素进行颜色赋值，从而构成了这个图像。我们可以把QImage想象成一个RGB颜色的二维数组，记录了每一像素的颜色。

void PaintWidget::paintEvent(QPaintEvent *){
    QPainter painter(this);
    QImage image(300, 300, QImage::Format_RGB32);
    QRgb value;

    //将图片背景填充为白色
    image.fill(Qt::white);

    //改变指定区域的像素点的值
    for(int i=50; i<100; ++i){
        for(int j=50; j<100; ++j){
            value = qRgb(255, 0, 0); // 红色
            image.setPixel(i, j, value);
        }
    }

    //将图片绘制到窗口中
    painter.drawImage(QPoint(0, 0), image);
}

QT学习资料整理_第85张图片

QImage与QPixmap的区别

  • QPixmap主要是用于绘图，针对屏幕显示而最佳化设计，QImage主要是为图像I/O、图片访问和像素修改而设计的
  • QPixmap依赖于所在的平台的绘图引擎，故例如反锯齿等一些效果在不同的平台上可能会有不同的显示效果，QImage使用Qt自身的绘图引擎，可在不同平台上具有相同的显示效果
  • 由于QImage是独立于硬件的，也是一种QPaintDevice，因此我们可以在另一个线程中对其进行绘制，而不需要在GUI线程中处理，使用这一方式可以很大幅度提高UI响应速度。
  • QImage可通过setPixpel()和pixel()等方法直接存取指定的像素。
    QImage与QPixmap之间的转换:
  • QImage转QPixmap
    使用QPixmap的静态成员函数: fromImage()
QPixmap	fromImage(const QImage & image, Qt::ImageConversionFlags flags = Qt::AutoColor)
  • QPixmap转QImage:
    使用QPixmap类的成员函数: toImage()
QImage toImage() const

10.2.2 QPicture(重现命令)

最后一个需要说明的是QPicture。这是一个可以记录和重现QPainter命令的绘图设备。 QPicture将QPainter的命令序列化到一个IO设备，保存为一个平台独立的文件格式。这种格式有时候会是“元文件(meta- files)”。Qt的这种格式是二进制的，不同于某些本地的元文件，Qt的pictures文件没有内容上的限制，只要是能够被QPainter绘制的元素，不论是字体还是pixmap，或者是变换，都可以保存进一个picture中。

QPicture是平台无关的，因此它可以使用在多种设备之上，比如svg、pdf、ps、打印机或者屏幕。回忆下我们这里所说的QPaintDevice，实际上是说可以有QPainter绘制的对象。QPicture使用系统的分辨率，并且可以调整 QPainter来消除不同设备之间的显示差异。
如果我们要记录下QPainter的命令，首先要使用QPainter::begin()函数，将QPicture实例作为参数传递进去，以便告诉系统开始记录，记录完毕后使用QPainter::end()命令终止。代码示例如下：

Widget::Widget(QWidget *parent):QWidget(parent),ui(new Ui::Widget){
    ui->setupUi(this);
    
    //QPicture  记录和重现绘图指令
    QPicture pic;
    QPainter painter;
    
    painter.begin(&pic);
    painter.setPen( QPen(Qt::blue) );
    painter.drawEllipse(QPoint(150,150) , 100,100);
    painter.end();
    
    pic.save("E:\\pic.zt");
}

void Widget::paintEvent(QPaintEvent *){
    QImage img;
    img.load(":/Image/Luffy.png");
    QPainter painter(this);
    //重现QPicture命令
    QPicture pic;
    pic.load("E:\\pic.zt");
    painter.drawPicture(0,0,pic);
}

11 文件系统

文件操作是应用程序必不可少的部分。Qt 作为一个通用开发库，提供了跨平台的文件操作能力。Qt 通过QIODevice提供了对 I/O 设备的抽象，这些设备具有读写字节块的能力。下面是 I/O 设备的类图（Qt5）：

  • QIODevice：所有 I/O 设备类的父类，提供了字节块读写的通用操作以及基本接口；
  • QFileDevice：Qt5新增加的类，提供了有关文件操作的通用实现。
  • QFlie：访问本地文件或者嵌入资源；
  • QTemporaryFile：创建和访问本地文件系统的临时文件；
  • QBuffer：读写QbyteArray, 内存文件；
  • QProcess：运行外部程序，处理进程间通讯；
  • QAbstractSocket：所有套接字类的父类；
  • QTcpSocket：TCP协议网络数据传输；
  • QUdpSocket：传输 UDP 报文；
  • QSslSocket：使用 SSL/TLS 传输数据；

11.0 文件系统分类:

  • 顺序访问设备:
    是指它们的数据只能访问一遍：从头走到尾，从第一个字节开始访问，直到最后一个字节，中途不能返回去读取上一个字节，这其中，QProcess、QTcpSocket、QUdpSoctet和QSslSocket是顺序访问设备。
  • 随机访问设备:
    可以访问任意位置任意次数，还可以使用QIODevice::seek()函数来重新定位文件访问位置指针，QFile、QTemporaryFile和QBuffer是随机访问设备，

11.1 基本文件操作

文件操作是应用程序必不可少的部分。Qt 作为一个通用开发库，提供了跨平台的文件操作能力。在所有的 I/O 设备中，文件 I/O 是最重要的部分之一。因为我们大多数的程序依旧需要首先访问本地文件（当然，在云计算大行其道的将来，这一观点可能改变）。QFile提供了从文件中读取和写入数据的能力。

我们通常会将文件路径作为参数传给QFile的构造函数。不过也可以在创建好对象最后，使用setFileName()来修改。QFile需要使用 / 作为文件分隔符，不过，它会自动将其转换成操作系统所需要的形式。例如 C:/windows 这样的路径在 Windows 平台下同样是可以的。

QFile主要提供了有关文件的各种操作，比如打开文件、关闭文件、刷新文件等。我们可以使用QDataStream或QTextStream类来读写文件，也可以使用QIODevice类提供的read()、readLine()、readAll()以及write()这样的函数。值得注意的是，有关文件本身的信息，比如文件名、文件所在目录的名字等，则是通过QFileInfo获取，而不是自己分析文件路径字符串。
下面我们使用一段代码来看看QFile的有关操作：

int main(int argc, char *argv[]){
    QApplication app(argc, argv);
 
    QFile file("in.txt");
    if (!file.open(QIODevice::ReadOnly | QIODevice::Text)) {
        qDebug() << "Open file failed.";
        return -1;
    } else {
        while (!file.atEnd()) {
            qDebug() << file.readLine();
        }
    }
 
    QFileInfo info(file);
    qDebug() << info.isDir();
    qDebug() << info.isExecutable();
    qDebug() << info.baseName();
    qDebug() << info.completeBaseName();
    qDebug() << info.suffix();
    qDebug() << info.completeSuffix(); 
    return app.exec();
}
  • 我们首先使用QFile创建了一个文件对象。
    这个文件名字是 in.txt。如果你不知道应该把它放在哪里，可以使用QDir::currentPath()来获得应用程序执行时的当前路径。只要将这个文件放在与当前路径一致的目录下即可。
  • 使用open()函数打开这个文件，打开形式是只读方式，文本格式。
    这个类似于fopen()的 r 这样的参数。open()函数返回一个 bool 类型，如果打开失败，我们在控制台输出一段提示然后程序退出。否则，我们利用 while 循环，将每一行读到的内容输出。
  • 可以使用QFileInfo获取有关该文件的信息。
    QFileInfo有很多类型的函数，我们只举出一些例子。比如：
    • isDir()检查该文件是否是目录；
    • isExecutable() 检查该文件是否是可执行文件等。
    • baseName() 可以直接获得文件名；
    • completeBaseName() 获取完整的文件名
    • suffix() 则直接获取文件后缀名。
    • completeSuffix() 获取完整的文件后缀
      我们可以由下面的示例看到，baseName()和completeBaseName()，以及suffix()和completeSuffix()的区别：
QFileInfo fi("/tmp/archive.tar.gz");
QString base  = fi.baseName();  // base = "archive"
QString base  = fi.completeBaseName();  // base = "archive.tar"
QString ext   = fi.suffix();  // ext = "gz"
QString ext   = fi.completeSuffix();  // ext = "tar.gz"

11.2 二进制文件读写

QDataStream提供了基于QIODevice的二进制数据的序列化。数据流是一种二进制流，这种流完全不依赖于底层操作系统、CPU 或者字节顺序（大端或小端）。例如，在安装了 Windows 平台的 PC 上面写入的一个数据流，可以不经过任何处理，直接拿到运行了 Solaris 的 SPARC 机器上读取。由于数据流就是二进制流，因此我们也可以直接读写没有编码的二进制数据，例如图像、视频、音频等。
QDataStream既能够存取 C++ 基本类型，如 int、char、short 等，也可以存取复杂的数据类型，例如自定义的类。实际上，QDataStream对于类的存储，是将复杂的类分割为很多基本单元实现的。
结合QIODevice，QDataStream可以很方便地对文件、网络套接字等进行读写操作。我们从代码开始看起：

QFile file("file.dat");
file.open(QIODevice::WriteOnly);
QDataStream out(&file);
out << QString("the answer is");
out << (qint32)42;
  • 在这段代码中，我们首先打开一个名为 file.dat 的文件（注意，我们为简单起见，并没有检查文件打开是否成功，这在正式程序中是不允许的）。然后，我们将刚刚创建的file对象的指针传递给一个QDataStream实例out。类似于std::cout标准输出流，QDataStream也重载了输出重定向<<运算符。后面的代码就很简单了：将“the answer is”和数字 42 输出到数据流。由于我们的 out 对象建立在file之上，因此相当于将问题和答案写入file。
  • 需要指出一点：最好使用 Qt 整型来进行读写，比如程序中的qint32。这保证了在任意平台和任意编译器都能够有相同的行为。

如果你直接运行这段代码，你会得到一个空白的 file.dat，并没有写入任何数据。这是因为我们的file没有正常关闭。为性能起见，数据只有在文件关闭时才会真正写入。因此，我们必须在最后添加一行代码：

file.close(); // 如果不想关闭文件，可以使用 file.flush();

接下来我们将存储到文件中的答案取出来
QFile file(“file.dat”);
file.open(QIODevice::ReadOnly);
QDataStream in(&file);
QString str;
qint32 a;
in >> str >> a;
唯一需要注意的是，你必须按照写入的顺序，将数据读取出来。顺序颠倒的话，程序行为是不确定的，严重时会直接造成程序崩溃。
那么，既然QIODevice提供了read()、readLine()之类的函数，为什么还要有QDataStream呢？QDataStream同QIODevice有什么区别？区别在于，QDataStream提供流的形式，性能上一般比直接调用原始 API 更好一些。我们通过下面一段代码看看什么是流的形式：

QFile file("file.dat");
file.open(QIODevice::ReadWrite);
 
QDataStream stream(&file);
QString str = "the answer is 42";

stream << str;

11.3 文本文件读写

上一节我们介绍了有关二进制文件的读写。二进制文件比较小巧，却不是人可读的格式。而文本文件是一种人可读的文件。为了操作这种文件，我们需要使用QTextStream类。QTextStream和QDataStream的使用类似，只不过它是操作纯文本文件的。

QTextStream会自动将 Unicode 编码同操作系统的编码进行转换，这一操作对开发人员是透明的。它也会将换行符进行转换，同样不需要自己处理。QTextStream使用 16 位的QChar作为基础的数据存储单位，同样，它也支持 C++ 标准类型，如 int 等。实际上，这是将这种标准类型与字符串进行了相互转换。
QTextStream同QDataStream的使用基本一致，例如下面的代码将把“The answer is 42”写入到 file.txt 文件中：

QFile data("file.txt");
if (data.open(QFile::WriteOnly | QIODevice::Truncate)) 
{
    QTextStream out(&data);
    out << "The answer is " << 42;
}

这里，我们在open()函数中增加了QIODevice::Truncate打开方式。我们可以从下表中看到这些打开方式的区别：

枚举值 描述
QIODevice::NotOpen 未打开
QIODevice::ReadOnly 以只读方式打开
QIODevice::WriteOnly 以只写方式打开
QIODevice::ReadWrite 以读写方式打开
QIODevice::Append 以追加的方式打开，新增加的内容将被追加到文件末尾
QIODevice::Truncate 以重写的方式打开，在写入新的数据时会将原有数据全部清除，游标设置在文件开头。
QIODevice::Text 在读取时，将行结束符转换成 \n；在写入时，将行结束符转换成本地格式，例如 Win32 平台上是 \r\n
QIODevice::Unbuffered 忽略缓存

我们在这里使用了QFile::WriteOnly | QIODevice::Truncate，也就是以只写并且覆盖已有内容的形式操作文件。注意，QIODevice::Truncate会直接将文件内容清空。

虽然QTextStream的写入内容与QDataStream一致，但是读取时却会有些困难：

QFile data("file.txt");
if (data.open(QFile::ReadOnly)) {
    QTextStream in(&data);
    QString str;
    int ans = 0;
    in >> str >> ans;
}

在使用QDataStream的时候，这样的代码很方便，但是使用了QTextStream时却有所不同：读出的时候，str 里面将是 The answer is 42，ans 是 0。这是因为当使用QDataStream写入的时候，实际上会在要写入的内容前面，额外添加一个这段内容的长度值。而以文本形式写入数据，是没有数据之间的分隔的。因此，使用文本文件时，很少会将其分割开来读取，而是使用诸如使用：

  • QTextStream::readLine() 读取一行
  • QTextStream::readAll()读取所有文本

这种函数之后再对获得的QString对象进行处理。
默认情况下，QTextStream的编码格式是 Unicode，如果我们需要使用另外的编码，可以使用：

stream.setCodec("UTF-8");

这样的函数进行设置。

11.4 例子

QT学习资料整理_第86张图片

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

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

    //点击按钮 弹出文件对话框，选择文件
    connect(ui->pushButton,&QPushButton::clicked,[=](){
        
        //获取文件的路径
         QString filePath = QFileDialog::getOpenFileName(this,"打开文件","C:\\Users\\zhangtao\\Desktop");
         qDebug() << filePath;
         if(filePath.isEmpty()){
             QMessageBox::warning(this,"警告","文件路径不能为空");
             return;
         }
         else{
             //将文件路径放入到 lineEdit中打印出来看看
             ui->lineEdit->setText(filePath);


             //读文件
             //文本编码格式类,Qt默认支持的格式是utf-8
             QTextCodec * codec = QTextCodec::codecForName("gbk");

             
             QFile file(filePath);

             //指定打开方式
             file.open(QIODevice::ReadOnly);

             //Qt默认支持的格式是utf-8
             QByteArray array;
//             array = file.readAll();



             while (!file.atEnd()) {
                  array += file.readLine();
             }

			//将文件内容 读取到 textEdit中
             ui->textEdit->setText(array);
             //ui->textEdit->setText( codec->toUnicode(array)  );       //把读取的文件转换为你想要的格式

             file.close();


             //写文件
//             file.open(QIODevice::Append); //QIODevice::Append追加的方式写文件
//             file.write("啊啊啊啊!");
//             file.close();


             //读取文件信息
             QFileInfo  info(filePath);

             qDebug() << "文件后缀名:" <<info.suffix() << "文件大小：" <<info.size() <<
                         "文件名："<< info.fileName() << "文件路径："<<info.filePath();

             qDebug() << "创建日期：" << info.created().toString("yyyy-MM-dd hh:mm:ss")<<
                         "最后修改日期："<<info.lastModified().toString("yyyy/MM/dd hh:mm:ss");
         }
    });
}

12 基于 TCP 的 Qt 网络通信

在标准 C++ 没有提供专门用于套接字通信的类，所以只能使用操作系统提供的基于 C 的 API 函数，基于这些 C 的 API 函数我们也可以封装自己的 C++ 类 C++ 套接字类的封装。但是 Qt 就不一样了，它是 C++ 的一个框架并且里边提供了用于套接字通信的类（TCP、UDP）这样就使得我们的操作变得更加简单了（当然，在Qt中使用标准C的API进行套接字通信也是完全没有问题的）。下面，给大家讲一下如果使用相关类的进行 TCP 通信。

使用 Qt 提供的类进行基于 TCP 的套接字通信需要用到两个类：

  • QTcpServer：服务器类，用于监听客户端连接以及和客户端建立连接。
  • QTcpSocket：通信的套接字类，客户端、服务器端都需要使用。

这两个套接字通信类都属于网络模块 network。

12.1 QTcpServer

QTcpServer 类用于监听客户端连接以及和客户端建立连接，在使用之前先介绍一下这个类提供的一些常用 API 函数：

1.1 公共成员函数

构造函数

QTcpServer::QTcpServer(QObject *parent = Q_NULLPTR);

// 给监听的套接字设置监听
bool QTcpServer::listen(const QHostAddress &address = QHostAddress::Any, quint16 port = 0);
// 判断当前对象是否在监听, 是返回true，没有监听返回false
bool QTcpServer::isListening() const;
// 如果当前对象正在监听返回监听的服务器地址信息, 否则返回 QHostAddress::Null
QHostAddress QTcpServer::serverAddress() const;
// 如果服务器正在侦听连接，则返回服务器的端口; 否则返回0
quint16 QTcpServer::serverPort() const
  • 参数：
    • address：通过类 QHostAddress 可以封装 IPv4、IPv6 格式的 IP 地址，QHostAddress::Any 表示自动绑定
    • port：如果指定为 0 表示随机绑定一个可用端口。
  • 返回值：绑定成功返回 true，失败返回 false

得到和客户端建立连接之后用于通信的 QTcpSocket 套接字对象，它是 QTcpServer 的一个子对象，当 QTcpServer 对象析构的时候会自动析构这个子对象，当然也可自己手动析构，建议用完之后自己手动析构这个通信的 QTcpSocket 对象。

QTcpSocket *QTcpServer::nextPendingConnection();

阻塞等待客户端发起的连接请求，不推荐在单线程程序中使用，建议使用非阻塞方式处理新连接，即使用信号 newConnection() 。

bool QTcpServer::waitForNewConnection(int msec = 0, bool *timedOut = Q_NULLPTR);
  • 参数：
    • msec：指定阻塞的最大时长，单位为毫秒（ms）
    • timeout：传出参数，如果操作超时 timeout 为 true，没有超时 timeout 为 false

1.2 信号

当接受新连接导致错误时，将发射如下信号。socketError 参数描述了发生的错误相关的信息。

[signal] void QTcpServer::acceptError(QAbstractSocket::SocketError socketError);

每次有新连接可用时都会发出 newConnection () 信号。

[signal] void QTcpServer::newConnection();

12.2 QTcpSocket

QTcpSocket 是一个套接字通信类，不管是客户端还是服务器端都需要使用。在 Qt 中发送和接收数据也属于 IO 操作（网络 IO），先来看一下这个类的继承关系：

2.1 公共成员函数

构造函数

QTcpSocket::QTcpSocket(QObject *parent = Q_NULLPTR);

连接服务器，需要指定服务器端绑定的IP和端口信息。

[virtual] void QAbstractSocket::connectToHost(const QString &hostName, quint16 port, OpenMode openMode = ReadWrite, NetworkLayerProtocol protocol = AnyIPProtocol);

[virtual] void QAbstractSocket::connectToHost(const QHostAddress &address, quint16 port, OpenMode openMode = ReadWrite);

在 Qt 中不管调用读操作函数接收数据，还是调用写函数发送数据，操作的对象都是本地的由 Qt 框架维护的一块内存。因此，调用了发送函数数据不一定会马上被发送到网络中，调用了接收函数也不是直接从网络中接收数据，关于底层的相关操作是不需要使用者来维护的。

接收数据

// 指定可接收的最大字节数 maxSize 的数据到指针 data 指向的内存中
qint64 QIODevice::read(char *data, qint64 maxSize);
// 指定可接收的最大字节数 maxSize，返回接收的字符串
QByteArray QIODevice::read(qint64 maxSize);
// 将当前可用操作数据全部读出，通过返回值返回读出的字符串
QByteArray QIODevice::readAll();

发送数据

// 发送指针 data 指向的内存中的 maxSize 个字节的数据
qint64 QIODevice::write(const char *data, qint64 maxSize);
// 发送指针 data 指向的内存中的数据，字符串以 \0 作为结束标记
qint64 QIODevice::write(const char *data);
// 发送参数指定的字符串
qint64 QIODevice::write(const QByteArray &byteArray);

2.2 信号

在使用 QTcpSocket 进行套接字通信的过程中，如果该类对象发射出 readyRead() 信号，说明对端发送的数据达到了，之后就可以调用 read 函数接收数据了。

[signal] void QIODevice::readyRead();

调用 connectToHost() 函数并成功建立连接之后发出 connected() 信号。

[signal] void QAbstractSocket::connected();

在套接字断开连接时发出 disconnected() 信号。

[signal] void QAbstractSocket::disconnected();

12.3 通信流程

使用 Qt 提供的类进行套接字通信比使用标准 C API 进行网络通信要简单（因为在内部进行了封装）原始的 TCP 通信流程 Qt 中的套接字通信流程如下：

3.1 服务器端

3.1.1 通信流程

  1. 创建套接字服务器 QTcpServer 对象
  2. 通过 QTcpServer 对象设置监听，即：QTcpServer::listen()
  3. 基于 QTcpServer::newConnection() 信号检测是否有新的客户端连接
  4. 如果有新的客户端连接调用 QTcpSocket *QTcpServer::nextPendingConnection() 得到通信的套接字对象
  5. 使用通信的套接字对象 QTcpSocket 和客户端进行通信

3.1.2 代码片段
服务器端的窗口界面如下图所示：

QT学习资料整理_第87张图片

头文件

class MainWindow : public QMainWindow{
    Q_OBJECT

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

private slots:
    void on_startServer_clicked();
    void on_sendMsg_clicked();

private:
    Ui::MainWindow *ui;
    QTcpServer* m_server;
    QTcpSocket* m_tcp;
};

源文件

MainWindow::MainWindow(QWidget *parent): QMainWindow(parent), ui(new Ui::MainWindow){
    ui->setupUi(this);
    setWindowTitle("TCP - 服务器");
    // 创建 QTcpServer 对象
    m_server = new QTcpServer(this);
    // 检测是否有新的客户端连接
    connect(m_server, &QTcpServer::newConnection, this, [=](){
        m_tcp = m_server->nextPendingConnection();
        ui->record->append("成功和客户端建立了新的连接...");
        m_status->setPixmap(QPixmap(":/connect.png").scaled(20, 20));
        // 检测是否有客户端数据
        connect(m_tcp, &QTcpSocket::readyRead, this, [=](){
            // 接收数据
            QString recvMsg = m_tcp->readAll();
            ui->record->append("客户端Say: " + recvMsg);
        });
        // 客户端断开了连接
        connect(m_tcp, &QTcpSocket::disconnected, this, [=](){
            ui->record->append("客户端已经断开了连接...");
            m_tcp->deleteLater();
            m_status->setPixmap(QPixmap(":/disconnect.png").scaled(20, 20));
        });
    });
}

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

// 启动服务器端的服务按钮
void MainWindow::on_startServer_clicked(){
    unsigned short port = ui->port->text().toInt();
    // 设置服务器监听
    m_server->listen(QHostAddress::Any, port);
    ui->startServer->setEnabled(false);
}

// 点击发送数据按钮
void MainWindow::on_sendMsg_clicked(){
    QString sendMsg = ui->msg->toPlainText();
    m_tcp->write(sendMsg.toUtf8());
    ui->record->append("服务器Say: " + sendMsg);
    ui->msg->clear();
}

3.2 客户端

3.2.1 通信流程

  1. 创建通信的套接字类 QTcpSocket 对象
  2. 使用服务器端绑定的 IP 和端口连接服务器 QAbstractSocket::connectToHost()
  3. 使用 QTcpSocket 对象和服务器进行通信

3.2.2 代码片段
客户端的窗口界面如下图所示：
在这里插入图片描述
头文件

class MainWindow : public QMainWindow{
    Q_OBJECT
public:
    explicit MainWindow(QWidget *parent = 0);
    ~MainWindow();

private slots:
    void on_connectServer_clicked();
    void on_sendMsg_clicked();
    void on_disconnect_clicked();
private:
    Ui::MainWindow *ui;
    QTcpSocket* m_tcp;
};

源文件

MainWindow::MainWindow(QWidget *parent):QMainWindow(parent),ui(new Ui::MainWindow){
    ui->setupUi(this);
    setWindowTitle("TCP - 客户端");

    // 创建通信的套接字对象
    m_tcp = new QTcpSocket(this);
    // 检测服务器是否回复了数据
    connect(m_tcp, &QTcpSocket::readyRead, [=](){
        // 接收服务器发送的数据
        QByteArray recvMsg = m_tcp->readAll();
        ui->record->append("服务器Say: " + recvMsg);
    });
        
    // 检测是否和服务器是否连接成功了
    connect(m_tcp, &QTcpSocket::connected, this, [=](){
        ui->record->append("恭喜, 连接服务器成功!!!");
        m_status->setPixmap(QPixmap(":/connect.png").scaled(20, 20));
    });
        
    // 检测服务器是否和客户端断开了连接
    connect(m_tcp, &QTcpSocket::disconnected, this, [=](){
        ui->record->append("服务器已经断开了连接, ...");
        ui->connectServer->setEnabled(true);
        ui->disconnect->setEnabled(false);
    });
}

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

// 连接服务器按钮按下之后的处理动作
void MainWindow::on_connectServer_clicked(){
    QString ip = ui->ip->text();
    unsigned short port = ui->port->text().toInt();
    // 连接服务器
    m_tcp->connectToHost(QHostAddress(ip), port);
    ui->connectServer->setEnabled(false);
    ui->disconnect->setEnabled(true);
}

// 发送数据按钮按下之后的处理动作
void MainWindow::on_sendMsg_clicked(){
    QString sendMsg = ui->msg->toPlainText();
    m_tcp->write(sendMsg.toUtf8());
    ui->record->append("客户端Say: " + sendMsg);
    ui->msg->clear();
}

// 断开连接按钮被按下之后的处理动作
void MainWindow::on_disconnect_clicked(){
    m_tcp->close();
    ui->connectServer->setEnabled(true);
    ui->disconnect->setEnabled(false);
}

参考：

零基础入门六天学会QT完整版
爱编程的大丙

你可能感兴趣的:(qt,windows,开发语言)

  • Linux下QT开发的动态库界面弹出操作（SDL2） 13jjyao QT类qt开发语言sdl2linux
    需求：操作系统为linux，开发框架为qt，做成需带界面的qt动态库，调用方为java等非qt程序难点：调用方为java等非qt程序，也就是说调用方肯定不带QApplication::exec()，缺少了这个，QTimer等事件和QT创建的窗口将不能弹出(包括opencv也是不能弹出)；这与qt调用本身qt库是有本质的区别的思路：1.调用方缺QApplication::exec()，那么我们在接口
  • linux sdl windows.h,Windows下的SDL安装 奔跑吧linux内核 linuxsdlwindows.h
    首先你要下载并安装SDL开发包。如果装在C盘下，路径为C:\SDL1.2.5如果在WINDOWS下。你可以按以下步骤：1.打开VC++，点击"Tools",Options2,点击directories选项3.选择"Includefiles"增加一个新的路径。"C:\SDL1.2.5\include"4，现在选择"Libaryfiles“增加"C:\SDL1.2.5\lib"现在你可以开始编写你的第
  • python os.environ_python os.environ 读取和设置环境变量 weixin_39605414 pythonos.environ
    >>>importos>>>os.environ.keys()['LC_NUMERIC','GOPATH','GOROOT','GOBIN','LESSOPEN','SSH_CLIENT','LOGNAME','USER','HOME','LC_PAPER','PATH','DISPLAY','LANG','TERM','SHELL','J2REDIR','LC_MONETARY','QT_QPA
  • 将cmd中命令输出保存为txt文本文件 落难Coder Windowscmdwindow
    最近深度学习本地的训练中我们常常要在命令行中运行自己的代码，无可厚非，我们有必要保存我们的炼丹结果，但是复制命令行输出到txt是非常麻烦的，其实Windows下的命令行为我们提供了相应的操作。其基本的调用格式就是：运行指令>输出到的文件名称或者具体保存路径测试下，我打开cmd并且ping一下百度：pingwww.baidu.com>./data.txt看下相同目录下data.txt的输出：如果你再
  • PHP环境搭建详细教程 好看资源平台 前端php
    PHP是一个流行的服务器端脚本语言，广泛用于Web开发。为了使PHP能够在本地或服务器上运行，我们需要搭建一个合适的PHP环境。本教程将结合最新资料，介绍在不同操作系统上搭建PHP开发环境的多种方法，包括Windows、macOS和Linux系统的安装步骤，以及本地和Docker环境的配置。1.PHP环境搭建概述PHP环境的搭建主要分为以下几类：集成开发环境：例如XAMPP、WAMP、MAMP，这
  • Python 实现图片裁剪（附代码） | Python工具 剑客阿良_ALiang
    前言本文提供将图片按照自定义尺寸进行裁剪的工具方法，一如既往的实用主义。环境依赖ffmpeg环境安装，可以参考我的另一篇文章：windowsffmpeg安装部署_阿良的博客-CSDN博客本文主要使用到的不是ffmpeg，而是ffprobe也在上面这篇文章中的zip包中。ffmpy安装：pipinstallffmpy-ihttps://pypi.douban.com/simple代码不废话了，上代码
  • esp32开发快速入门 8 : MQTT 的快速入门，基于esp32实现MQTT通信 z755924843 ESP32开发快速入门服务器网络运维
    MQTT介绍简介MQTT（MessageQueuingTelemetryTransport，消息队列遥测传输协议），是一种基于发布/订阅（publish/subscribe）模式的"轻量级"通讯协议，该协议构建于TCP/IP协议上，由IBM在1999年发布。MQTT最大优点在于，可以以极少的代码和有限的带宽，为连接远程设备提供实时可靠的消息服务。作为一种低开销、低带宽占用的即时通讯协议，使其在物联
  • 基于STM32与Qt的自动平衡机器人：从控制到人机交互的的详细设计流程 极客小张 stm32qt机器人物联网人机交互毕业设计c语言
    一、项目概述目标和用途本项目旨在开发一款基于STM32控制的自动平衡机器人，结合步进电机和陀螺仪传感器，实现对平衡机器人的精确控制。该机器人可以用于教育、科研、娱乐等多个领域，帮助用户了解自动控制、机器人运动学等相关知识。技术栈关键词STM32单片机步进电机陀螺仪传感器AD采集电路Qt人机界面实时数据监控二、系统架构系统架构设计本项目的系统架构设计包括以下主要组件：控制单元:STM32单片机传感器
  • ESP32-C3入门教程 网络篇⑩——基于esp_https_ota和MQTT实现开机主动升级和被动触发升级的OTA功能 小康师兄 ESP32-C3入门教程https服务器esp32OTAMQTT
    文章目录一、前言二、软件流程三、部分源码四、运行演示一、前言本文基于VSCodeIDE进行编程、编译、下载、运行等操作基础入门章节请查阅：ESP32-C3入门教程基础篇①——基于VSCode构建HelloWorld教程目录大纲请查阅：ESP32-C3入门教程——导读ESP32-C3入门教程网络篇⑨——基于esp_https_ota实现史上最简单的ESP32OTA远程固件升级功能二、软件流程
  • 2023最详细的Python安装教程（Windows版本） 程序员林哥 Pythonpythonwindows开发语言
    python安装是学习pyhon第一步，很多刚入门小白不清楚如何安装python，今天我来带大家完成python安装与配置，跟着我一步步来，很简单，你肯定能完成。第一部分：python安装（一）准备工作1、下载和安装python(认准官方网站)当然你不想去下载的话也可以分享给你，还有入门学习教程，点击下方卡片跳转进群领取（二）开始安装对于Windows操作系统，可以下载“executableins
  • windows下python opencv ffmpeg读取摄像头实现rtsp推流 拉流 图像处理大大大大大牛啊 opencv实战代码讲解视觉图像项目windowspythonopencv
    windows下pythonopencvffmpeg读取摄像头实现rtsp推流拉流整体流程1.下载所需文件1.1下载rtsp推流服务器1.2下载ffmpeg2.开启RTSP服务器3.opencv读取摄像头并调用ffmpeg进行推流4.opencv进行拉流5.opencv异步拉流整体流程1.下载所需文件1.1下载rtsp推流服务器下载RTSP服务器下载页面https://github.com/blu
  • 编译Windows平台的Nginx+ngx_http_proxy_connect_module Grovvy_Deng windowsnginxhttp
    编译Windows平台的Nginx+ngx_http_proxy_connect_module背景：由于公司的正向出局代理是windows机器。机器上的Squid不稳定，打算替换成nginx+ngx_http_proxy_connect_module实现。通过几天痛苦的尝试，最后参考了github大神项目通过在线CICD工具编译window平台可用的ng。步骤：获取git可识别的patch由于CI
  • 关闭Windows自动更新的6种方法 Gemini1995 windows
    在Windows操作系统中，可以使用多种方法来关闭自动更新。以下是其中一些常用的方法：使用设置应用：打开“设置”应用（Win+I），选择“更新和安全”。在左侧菜单中选择“Windows更新”。点击“更改活动时间”或“高级选项”。在“更新选项”下拉菜单中选择“通知我但不自动下载或安装”或“从不检查更新”。通过服务管理器：打开“服务”管理器，可以通过在运行对话框中输入services.msc来打开。找
  • 【nginx】ngx_http_proxy_connect_module 正向代理 等风来不如迎风去 网络服务入门与实战nginxhttp运维
    50.65无法访问服务器，(403错误)50.196可以访问服务器。那么，配置65通过196访问。需要一个nginx作为代理【nginx】搭配okhttp配置反向代理发送原生的nginx是不支持okhttp的CONNECT请求的。大神竟然给出了一个java工程GINX编译ngx_http_proxy_connect_module及做正向代理是linux构建的。是windows构建的：编译Windo
  • Windows安装ciphey编码工具，附一道ciscn编码题例 im-Miclelson CTF工具网络安全
    TA是什么一款智能化的编码分析解码工具，对于CTF中复杂性编码类题目可以快速攻破。编码自动分析解码的神器。如何安装Windows环境Python3.864位（最新的版本不兼容，32位的也不行）PIP直接安装pipinstallciphey-ihttps://pypi.mirrors.ustc.edu.cn/simple/安装后若是出现报错请根据错误代码行数找到对应文件，r修改成rb即可。使用标准语
  • Python程序打包指南：手把手教你一步步完成 Python_P叔 python数据库开发语言
    最近感兴趣想将开发的项目转成Package，研究了一下相关文章，并且自己跑通了，走了一下弯路，这里记录一下如何打包一个简单的Python项目，展示如何添加必要的文件和结构来创建包，如何构建包，以及如何将其上传到Python包索引（PyPI）。首先要确保安装最新版本：#Unix/macOSpython3-mpipinstall--upgradepip#windowspy-mpipinstall--u
  • 漫谈QWidget及其派生类(二) Caiaolun
    原文地址:https://blog.csdn.net/dbzhang800/article/details/6741344上一部分漫谈QWidget及其派生类(一)介绍了QWidget及其派生类,分：窗口、普通控件两种类型(其实有个Qt::SubWindow没有提，不过本系列中也没有介绍它的打算，因为我不熟)。本文接下来试图看看QLayout与窗口的几何尺寸控制。注意：本文只是试图解释，QLayo
  • 【解决内存泄漏的问题】 Qt 框架中的父子对象关系会自动管理内存，父对象会在其销毁时自动销毁所有子对象。 课堂随想 QTqt
    修改前的代码这段代码可能会出现内存泄漏问题，主要原因是构造函数中创建的LoginDialog和RegisterDialog对象未在合适的地方被正确释放。具体分析如下：1.构造函数中的问题_login_dlg=newLoginDialog();setCentralWidget(_login_dlg);_login_dlg->show();connect(_login_dlg,&LoginDialog
  • 管理员权限的软件不能开机自启动的解决方法 ss_ctrl
    这是几种解决方法：1.将启动参数写入到32位注册表里面去在64位系统下我们64位的程序访问此HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\Run注册表路径，是可以正确访问的，32位程序访问此注册表路径时，默认会被系统自动映射到HKEY_LOCAL_MACHINE\SOFTWARE\WOW6432Node\Microsoft
  • Github 2024-09-12 Go开源项目日报Top10 老孙正经胡说 githubgolang开源Github趋势分析开源项目PythonGolang
    根据GithubTrendings的统计，今日(2024-09-12统计)共有10个项目上榜。根据开发语言中项目的数量，汇总情况如下：开发语言项目数量Go项目10C项目1Terraform：基础设施即代码的开源工具创建周期：3626天开发语言：Go协议类型：OtherStar数量：40393个Fork数量：9397次关注人数：40393人贡献人数：358人OpenIssues数量：1943个Git
  • matlab游标标注移动,matlab实现图形窗口的数据游标 莫白想 matlab游标标注移动
    DatacursorsforfigurewindowSeveralrelatedfunctions:CreateCursorsetsupaverticalcursoronallaxesinafigure.Thecursorscanbemovedaroundusingthemouse.MultiplecursorsaresupportedineachfigureGetCursorLocationre
  • TA-Lib Python 库 Windows 64位安装包 黄桥壮Quinn
    TA-LibPython库Windows64位安装包TA.rar项目地址:https://gitcode.com/open-source-toolkit/3ff39简介本仓库提供了一个适用于Windows64位系统的TA-LibPython库安装包。TA-Lib是一个广泛用于金融技术分析的库，支持多种技术指标的计算。资源文件文件名TA-Lib-0.4.29-cp312-win-amd64.whl描
  • MacOS Catalina 从源码构建Qt6.2开发库之01: 编译Qt6.2源代码 捕鲸叉 QTmacosc++QT
    安装xcode，cmake，ninjabrewinstallnodemac下安装OpenGL库并使之对各项目可见在macOS上安装OpenGL通常涉及到安装一些依赖库，如MGL、GLUT或者是GLEW等，同时确保LLVM的OpenGL框架和相关工具链的兼容性。以下是一个基本的安装步骤，你可以在终端中执行：安装Homebrew（如果还没有安装的话）：/bin/bash-c"$(curl-fsSLht
  • 【Python爬虫】百度百科词条内容 PokiFighting 数据处理python爬虫开发语言
    词条内容我这里随便选取了一个链接，用的是FBI的词条importurllib.requestimporturllib.parsefromlxmlimportetreedefquery(url):headers={'user-agent':'Mozilla/5.0(WindowsNT6.1;Win64;x64)AppleWebKit/537.36(KHTML,likeGecko)Chrome/80.
  • 如何避免学习linux必然会遇到的几个问题 twintwin
    相信在看这篇文章的都是对linux系统所迷的志同道合的人，不管你是刚开始学，还是已经接触过一些linux的知识，下面的问题是你在学习linux所必须遇到的，若是没有的话那我只能说大神我服你了。下面我就作为一个过来人分享下我学习后的经验。一、无法摆脱Windows的思维方式相信大家接触电脑的时候都是从windows开始，windows的思维方式已经根深蒂固。不过现在你已经打算开始学习linux了，就
  • 两种方法判断Python的位数是32位还是64位 sanqima Python编程电脑python开发语言
      Python从1991年发布以来，凭借其简洁、清晰、易读的语法、丰富的标准库和第三方工具，在Web开发、自动化测试、人工智能、图形识别、机器学习等领域发展迅猛。  Python是一种胶水语言，通过Cython库与C/C++语言进行链接，通过Jython库与Java语言进行链接。  Python是跨平台的，可运行在多种操作系统上，包括但不限于Windows、Linux和macOS。这意味着用Py
  • 数据仓库介绍 阿龙的代码在报错 数据分析数据仓库数据库
    数据仓库数据仓库的概念数据仓库的主要特征数据仓库的主流开发语言-sql结构化数据sql语句数据仓库的概念数据仓库（英语：DataWarehouse，简称数仓、DW）,是一个用于存储、分析、报告的数据系统。数据仓库的目的是构建面向分析的集成化数据环境，分析结果为企业提供决策支持（DecisionSupport）。就是数据仓库只分析数据并不产生数据数据仓库的主要特征1、面向主题主题是一个抽象的概念，是
  • 外卖霸王餐返利外卖会员卡小程序开发 闹小艾 good506070微信小程序小程序
    外卖霸王餐返利外卖会员卡小程序开发"社交电商赋能下的外卖返利小程序"是专为商家与用户双赢而设计的创新平台。以下是其开发方案的详细步骤：一、需求梳理：首先，我们需要明确小程序的核心功能和特色。包括设定活动类型、返利策略，以及用户体验友好的界面设计。二、技术决策：技术选型是关键。我们采用小程序的开发框架，利用JavaScript作为前端开发语言，并结合微信提供的API进行后端接口调用与数据处理。三、账
  • python logging模块默认日志级别_一看就懂，Python 日志 logging 模块详解及应用 路易·罗莎 pythonlogging模块默认日志级别
    日志概述百度百科的日志概述：Windows网络操作系统都设计有各种各样的日志文件，如应用程序日志，安全日志、系统日志、Scheduler服务日志、FTP日志、WWW日志、DNS服务器日志等等，这些根据你的系统开启的服务的不同而有所不同。我们在系统上进行一些操作时，这些日志文件通常会记录下我们操作的一些相关内容，这些内容对系统安全工作人员相当有用。比如说有人对系统进行了IPC探测，系统就会在安全日志
  • 【免费】springboot项目申报管理系统|毕业设计|Javaweb项目 计算机学姐来啦 springbootssmjavaspringboot课程设计后端毕设毕业设计java-ee
    收藏点赞不迷路关注作者有好处编号：springboot375springboot项目申报管理系统开发语言：Java数据库：MySQL技术：Spring+SpringMVC+MyBatis工具：IDEA/Ecilpse、Navicat、Maven1.万字文档展示(部分)2.系统图片展示第5章系统详细设计5.1管理员功能模块的实现5.1.1项目列表如图5.1显示的就是项目列表页面，此页面提供给管理员的
  • js动画html标签（持续更新中） 843977358 htmljs动画mediaopacity
    1.jQuery 效果 - animate() 方法    改变 "div" 元素的高度：    $(".btn1").click(function(){      $("#box").animate({height:"300px
  • springMVC学习笔记 caoyong springMVC
    1、搭建开发环境    a>、添加jar文件，在ioc所需jar包的基础上添加spring-web.jar,spring-webmvc.jar    b>、在web.xml中配置前端控制器       <servlet>     &nbs
  • POI中设置Excel单元格格式 107x poistyle列宽合并单元格自动换行
    引用：http://apps.hi.baidu.com/share/detail/17249059 POI中可能会用到一些需要设置EXCEL单元格格式的操作小结： 先获取工作薄对象: HSSFWorkbook wb = new HSSFWorkbook(); HSSFSheet sheet = wb.createSheet(); HSSFCellStyle setBorder = wb.
  • jquery 获取A href 触发js方法的this参数 无效的情况 一炮送你回车库 jquery
    html如下：  <td class=\"bord-r-n bord-l-n c-333\"> <a class=\"table-icon edit\" onclick=\"editTrValues(this);\">修改</a> </td>"   j
  • md5 3213213333332132 MD5
    import java.security.MessageDigest; import java.security.NoSuchAlgorithmException; public class MDFive { public static void main(String[] args) { String md5Str = "cq
  • 完全卸载干净Oracle11g sophia天雪 orale数据库卸载干净清理注册表
    完全卸载干净Oracle11g A、存在OUI卸载工具的情况下：     第一步：停用所有Oracle相关的已启动的服务；     第二步：找到OUI卸载工具：在“开始”菜单中找到“oracle_OraDb11g_home”文件夹中         &
  • apache 的access.log 日志文件太大如何解决 darkranger apache
    CustomLog logs/access.log common  此写法导致日志数据一致自增变大。 直接注释上面的语法 #CustomLog logs/access.log common 增加： CustomLog "|bin/rotatelogs.exe -l logs/access-%Y-%m-d.log 
  • Hadoop单机模式环境搭建关键步骤 aijuans 分布式
            Hadoop环境需要sshd服务一直开启，故，在服务器上需要按照ssh服务，以Ubuntu Linux为例，按照ssh服务如下： sudo apt-get install ssh sudo apt-get install rsync 编辑HADOOP_HOME/conf/hadoop-env.sh文件，将JAVA_HOME设置为Java
  • PL/SQL DEVELOPER 使用的一些技巧 atongyeye javasql
    1 记住密码 这是个有争议的功能，因为记住密码会给带来数据安全的问题。 但假如是开发用的库，密码甚至可以和用户名相同，每次输入密码实在没什么意义，可以考虑让PLSQL Developer记住密码。 位置：Tools菜单－－Preferences－－Oracle－－Logon HIstory－－Store with password 2 特殊Copy 在SQL Window
  • PHP：在对象上动态添加一个新的方法 bardo 方法动态添加闭包
    有关在一个对象上动态添加方法，如果你来自Ruby语言或您熟悉这门语言，你已经知道它是什么...... Ruby提供给你一种方式来获得一个instancied对象，并给这个对象添加一个额外的方法。   好！不说Ruby了，让我们来谈谈PHP   PHP未提供一个“标准的方式”做这样的事情，这也是没有核心的一部分...   但无论如何，它并没有说我们不能做这样
  • ThreadLocal与线程安全 bijian1013 javajava多线程threadLocal
    首先来看一下线程安全问题产生的两个前提条件：  1.数据共享，多个线程访问同样的数据。  2.共享数据是可变的，多个线程对访问的共享数据作出了修改。    实例：         定义一个共享数据： public static int a = 0;        
  • Tomcat 架包冲突解决 征客丶 tomcatWeb
    环境： Tomcat 7.0.6 win7 x64 错误表象：【我的冲突的架包是：catalina.jar 与 tomcat-catalina-7.0.61.jar 冲突，不知道其他架包冲突时是不是也报这个错误】 严重: End event threw exception java.lang.NoSuchMethodException: org.apache.catalina.dep
  • 【Scala三】分析Spark源代码总结的Scala语法一 bit1129 scala
    Scala语法 1. classOf运算符 Scala中的classOf[T]是一个class对象，等价于Java的T.class,比如classOf[TextInputFormat]等价于TextInputFormat.class    2. 方法默认值 defaultMinPartitions就是一个默认值，类似C++的方法默认值    
  • java 线程池管理机制 BlueSkator java线程池管理机制
    编辑 Add Tools   jdk线程池   一、引言 第一：降低资源消耗。通过重复利用已创建的线程降低线程创建和销毁造成的消耗。第二：提高响应速度。当任务到达时，任务可以不需要等到线程创建就能立即执行。第三：提高线程的可管理性。线程是稀缺资源，如果无限制的创建，不仅会消耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一的分配，调优和监控。  
  • 关于hql中使用本地sql函数的问题（问-答） BreakingBad HQL存储函数
    转自于：http://www.iteye.com/problems/23775 问： 我在开发过程中，使用hql进行查询（mysql5）使用到了mysql自带的函数find_in_set()这个函数作为匹配字符串的来讲效率非常好，但是我直接把它写在hql语句里面（from ForumMemberInfo fm,ForumArea fa where find_in_set(fm.userId,f
  • 读《研磨设计模式》-代码笔记-迭代器模式-Iterator bylijinnan java设计模式
    声明： 本文只为方便我个人查阅和理解，详细的分析以及源代码请移步 原作者的博客http://chjavach.iteye.com/ import java.util.Arrays; import java.util.List; /** * Iterator模式提供一种方法顺序访问一个聚合对象中各个元素，而又不暴露该对象内部表示 * * 个人觉得，为了不暴露该
  • 常用SQL chenjunt3 oraclesqlC++cC#
    --NC建库 CREATE TABLESPACE NNC_DATA01 DATAFILE 'E:\oracle\product\10.2.0\oradata\orcl\nnc_data01.dbf' SIZE 500M AUTOEXTEND ON NEXT 50M EXTENT MANAGEMENT LOCAL UNIFORM SIZE 256K ; CREATE TABLESPA
  • 数学是科学技术的语言 comsci 工作活动领域模型
      从小学到大学都在学习数学，从小学开始了解数字的概念和背诵九九表到大学学习复变函数和离散数学，看起来好像掌握了这些数学知识，但是在工作中却很少真正用到这些知识，为什么？    最近在研究一种开源软件-CARROT2的源代码的时候，又一次感觉到数学在计算机技术中的不可动摇的基础作用，CARROT2是一种用于自动语言分类（聚类）的工具性软件，用JAVA语言编写，它
  • Linux系统手动安装rzsz 软件包 daizj linuxszrz
    1、下载软件 rzsz-3.34.tar.gz。登录linux，用命令 wget http://freeware.sgi.com/source/rzsz/rzsz-3.48.tar.gz下载。 2、解压 tar zxvf  rzsz-3.34.tar.gz 3、安装  cd rzsz-3.34 ; make posix 。注意：这个软件安装与常规的GNU软件不
  • 读源码之:ArrayBlockingQueue dieslrae java
        ArrayBlockingQueue是concurrent包提供的一个线程安全的队列,由一个数组来保存队列元素.通过 takeIndex和 putIndex来分别记录出队列和入队列的下标,以保证在出队列时 不进行元素移动. //在出队列或者入队列的时候对takeIndex或者putIndex进行累加,如果已经到了数组末尾就又从0开始,保证数
  • C语言学习九枚举的定义和应用 dcj3sjt126com c
    枚举的定义 # include <stdio.h> enum WeekDay { MonDay, TuesDay, WednesDay, ThursDay, FriDay, SaturDay, SunDay }; int main(void) { //int day; //day定义成int类型不合适 enum WeekDay day = Wedne
  • Vagrant 三种网络配置详解 dcj3sjt126com vagrant
    Forwarded port Private network Public network Vagrant 中一共有三种网络配置，下面我们将会详解三种网络配置各自优缺点。 端口映射(Forwarded port)，顾名思义是指把宿主计算机的端口映射到虚拟机的某一个端口上，访问宿主计算机端口时，请求实际是被转发到虚拟机上指定端口的。Vagrantfile中设定语法为： c
  • 16.性能优化-完结 frank1234 性能优化
    性能调优是一个宏大的工程，需要从宏观架构(比如拆分，冗余，读写分离，集群，缓存等)， 软件设计（比如多线程并行化，选择合适的数据结构）， 数据库设计层面（合理的表设计，汇总表，索引，分区，拆分，冗余等） 以及微观（软件的配置，SQL语句的编写，操作系统配置等）根据软件的应用场景做综合的考虑和权衡，并经验实际测试验证才能达到最优。 性能水很深， 笔者经验尚浅 ，赶脚也就了解了点皮毛而已，我觉得
  • Word Search hcx2013 search
    Given a 2D board and a word, find if the word exists in the grid. The word can be constructed from letters of sequentially adjacent cell, where "adjacent" cells are those horizontally or ve
  • Spring4新特性——Web开发的增强 jinnianshilongnian springspring mvcspring4
    Spring4新特性——泛型限定式依赖注入 Spring4新特性——核心容器的其他改进 Spring4新特性——Web开发的增强 Spring4新特性——集成Bean Validation 1.1(JSR-349)到SpringMVC  Spring4新特性——Groovy Bean定义DSL Spring4新特性——更好的Java泛型操作API  Spring4新
  • CentOS安装配置tengine并设置开机启动 liuxingguome centos
    yum install gcc-c++  yum install pcre pcre-devel  yum install zlib zlib-devel  yum install openssl openssl-devel Ubuntu上可以这样安装 sudo aptitude install libdmalloc-dev libcurl4-opens
  • 第14章 工具函数（上） onestopweb 函数
    index.html <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> <html xmlns="http://www.w3.org/
  • Xelsius 2008 and SAP BW at a glance blueoxygen BOXelsius
    Xelsius提供了丰富多样的数据连接方式，其中为SAP BW专属提供的是BICS。那么Xelsius的各种连接的优缺点比较以及Xelsius是如何直接连接到BEx Query的呢？ 以下Wiki文章应该提供了全面的概览。   http://wiki.sdn.sap.com/wiki/display/BOBJ/Xcelsius+2008+and+SAP+NetWeaver+BW+Co
  • oracle表空间相关 tongsh6 oracle
    在oracle数据库中，一个用户对应一个表空间，当表空间不足时，可以采用增加表空间的数据文件容量，也可以增加数据文件，方法有如下几种： 1.给表空间增加数据文件    ALTER TABLESPACE "表空间的名字" ADD DATAFILE    '表空间的数据文件路径' SIZE 50M;   &nb
  • .Net framework4.0安装失败 yangjuanjava .netwindows
    上午的.net framework 4.0，各种失败，查了好多答案，各种不靠谱，最后终于找到答案了 和Windows Update有关系，给目录名重命名一下再次安装，即安装成功了！ 下载地址：http://www.microsoft.com/en-us/download/details.aspx?id=17113 方法： 1.运行cmd，输入net stop WuAuServ 2.点击开
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他