• QT 第五天 TCP通信与数据库

    一、数据库增删改查

    1. QT       += core gui sql
    2.  
    3. greaterThan(QT_MAJOR_VERSION, 4): QT += widgets
    4.  
    5. CONFIG += c++11
    6.  
    7. # The following define makes your compiler emit warnings if you use
    8. # any Qt feature that has been marked deprecated (the exact warnings
    9. # depend on your compiler). Please consult the documentation of the
    10. # deprecated API in order to know how to port your code away from it.

    .h

    1. #ifndef WIDGET_H
    2. #define WIDGET_H
    3.  
    4. #include 
    5. #include    //数据库管理类
    6. #include       //执行sql语句对应的类
    7. #include      //纪录类
    8. #include 
    9. #include 
    10.  
    11. QT_BEGIN_NAMESPACE
    12. namespace Ui { class Widget; }
    13. QT_END_NAMESPACE
    14.  
    15. class Widget : public QWidget
    16. {
    17.     Q_OBJECT
    18.  
    19. public:
    20.     Widget(QWidget *parent = nullptr);
    21.     ~Widget();
    22.  
    23. private slots:
    24.     void on_inputBtn_clicked();
    25.  
    26.     void on_showBtn_clicked();
    27.  
    28.     void on_searchBtn_clicked();
    29.  
    30.     void on_deleteBtn_clicked();
    31.  
    32. private:
    33.     Ui::Widget *ui;
    34.  
    35.     //定义一个数据对象
    36.     QSqlDatabase db;
    37. };
    38. #endif // WIDGET_H

    .cpp

    1. #include "widget.h"
    2. #include "ui_widget.h"
    3.  
    4. Widget::Widget(QWidget *parent)
    5.     : QWidget(parent)
    6.     , ui(new Ui::Widget)
    7. {
    8.     ui->setupUi(this);
    9.  
    10.     //判断数据库对象是否包含了自己使用的数据库Student.db
    11.     if(!db.contains("Student.db"))
    12.     {
    13.         //添加一个数据库
    14.         //函数原型：
    15.         //参数：
    16.         //返回值：
    17.         db = QSqlDatabase::addDatabase("QSQLITE"); //表明使用的是sqlite3版本数据库
    18.  
    19.         //给数据库命名
    20.         db.setDatabaseName("Student.db");
    21.     }
    22.  
    23.     //打开数据库
    24.     if(!db.open())
    25.     {
    26.         QMessageBox::information(this,"提示","数据库打开失败");
    27.         return;
    28.     }
    29.  
    30.     //此时说明数据库已经创建出来并打开了，就可以创建数据表了
    31.     //创建数据表需要使用sql语句，需要使用QSQLQuerry类对象来完成
    32.     //准备sql语句
    33.     QString sql = "create table if not exists myTable("              //创建表的sql语句
    34.                      "id integer primary key autoincrement,"          //id主键，允许自增
    35.                      "numb integer,"                                   //学号，是整形
    36.                      "name varchar(10),"                               //姓名   字符串
    37.                      "score integer,"                                  //分数是整形
    38.                      "sex varchar(4))";                                 //性别 字符串
    39.  
    40.     //定义语句执行者
    41.     QSqlQuery querry;
    42.  
    43.     //使用querry执行sql语句
    44.     if(!querry.exec(sql))
    45.     {
    46.         QMessageBox::information(this,"失败","创建表失败");
    47.     }
    48.     else
    49.     {
    50.          QMessageBox::information(this,"成功","创建表成功");
    51.     }
    52. }
    53.  
    54. Widget::~Widget()
    55. {
    56.     delete ui;
    57. }
    58.  
    59. //录入按钮对应的槽函数
    60. void Widget::on_inputBtn_clicked()
    61. {
    62.     //获取ui界面中要存入的数据
    63.     int numb_ui = ui->numbEdit->text().toInt();   //获取ui界面的学号
    64.     QString name_ui = ui->nameEdit->text();       //获取ui界面的姓名
    65.     int score_ui = ui->scoreEdit->text().toUInt();  //获取ui界面上的成绩
    66.     QString sex_ui = ui->sexEdit->text();          //获取ui界面的性别
    67.  
    68.     //判断是否有漏填数据
    69.     if(numb_ui == 0 || name_ui.isEmpty() || score_ui == 0 || sex_ui.isEmpty())
    70.     {
    71.         QMessageBox::information(this,"提示","请将信息填写完整");
    72.     }
    73.  
    74.     //准备sql语句
    75.     QString sql = QString("insert into myTable(numb,name,score,sex)"
    76.                   "values(%1,'%2',%3,'%4')").arg(numb_ui).arg(name_ui).arg(score_ui).arg(sex_ui);
    77.  
    78.     //定义语句执行
    79.     QSqlQuery querry;
    80.  
    81.     //调用执行者的相关函数执行sql语句
    82.     if(!querry.exec(sql))
    83.     {
    84.         QMessageBox::information(this,"失败","插入数据失败");
    85.     }else
    86.     {
    87.         QMessageBox::information(this,"成功","插入数据成功");
    88.     }
    89. }
    90. //展示按钮对应的槽函数
    91. void Widget::on_showBtn_clicked()
    92. {
    93.     //准备sql语句
    94.     QString sql = "select * from myTable";
    95.  
    96.     //准备语句执行者
    97.     QSqlQuery querry;
    98.  
    99.     //执行sql语句
    100.     if(!querry.exec(sql))
    101.     {
    102.         QMessageBox::information(this,"失败","查询失败");
    103.         return;
    104.  
    105.     }
    106.  
    107.     //此时，将查找到的所有结果，全部放在querry对象中了
    108.     //可以通过next函数不断遍历查询结果
    109.     int i = 0;   //记录行号
    110.     while(querry.next())
    111.     {
    112.         //此时，遍历的就是任意一组记录：querry.record
    113.         //qDebug() << querry.record();
    114.         //要找到每条，记录中的每个数据使用querry.record().value(i)
    115.         //qDebug() << querry.record().value(2);
    116.         //querry.record().count()  //返回当前记录对应数据项的个数
    117.         //querry.record().value(2).toString();  //将记录的某一项的数据转变成字符串
    118.  
    119.         //将数据库中的表格展示到ui界面
    120.         //ui->tableWidget->setItem()
    121.  
    122.         for(int j = 0; j < querry.record().count()-1; j++)
    123.         {
    124.             ui->tableWidget->setItem(i,j,new QTableWidgetItem(querry.record().value(j+1).toString()));
    125.         }
    126.            i++;  //进行下一行
    127.     }
    128. }
    129. //查找按钮对应的槽函数
    130. void Widget::on_searchBtn_clicked()
    131. {
    132.     //准备sql语句
    133.     QString sql = "select * from myTable where numb = 1001";
    134.     //准备语句执行者
    135.     QSqlQuery querry;
    136.  
    137.     //执行sql语句
    138.     if(!querry.exec(sql))
    139.     {
    140.         QMessageBox::information(this,"失败","查询失败");
    141.     }else
    142.     {
    143.         QMessageBox::information(this,"成功","查询成功");
    144.     }
    145.  
    146. }
    147. //删除按钮对应的槽函数
    148. void Widget::on_deleteBtn_clicked()
    149. {
    150.     //准备sql语句
    151.   //  QString sql = "delete from myTable where name = 'damei'";  //删除某一个
    152.     QString sql = "delete from myTable";   //全部删除
    153.  
    154.     //准备语句执行者
    155.     QSqlQuery querry;
    156.  
    157.     //执行sql语句
    158.     if(!querry.exec(sql))
    159.     {
    160.         QMessageBox::information(this,"删除","删除失败");
    161.     }else
    162.     {
    163.         QMessageBox::information(this,"删除","删除成功");
    164.     }
    165.  
    166.  
    167. }

    ui

    二.TCP通信

    server

    1. QT       += core gui network
    2.  
    3. greaterThan(QT_MAJOR_VERSION, 4): QT += widgets
    4.  
    5. CONFIG += c++11
    6.  
    7. # The following define makes your compiler emit warnings if you use
    8. # any Qt feature that has been marked deprecated (the exact warnings
    9. # depend on your compiler). Please consult the documentation of the
    10. # deprecated API in order to know how to port your code away from it.
    11. DEFINES += QT_DEPRECATED_WARNINGS
    1. #ifndef WIDGET_H
    2. #define WIDGET_H
    3.  
    4. #include 
    5. #include   //服务器头文件
    6. #include   //客户端头文件
    7. #include        //链表头文件，用来存放客户端容器
    8. #include 
    9. #include  //消息对话框类
    10.  
    11. QT_BEGIN_NAMESPACE
    12. namespace Ui { class Widget; }
    13. QT_END_NAMESPACE
    14.  
    15. class Widget : public QWidget
    16. {
    17.     Q_OBJECT
    18.  
    19. public:
    20.     Widget(QWidget *parent = nullptr);
    21.     ~Widget();
    22.  
    23. private slots:
    24.     void on_strartBtn_clicked();
    25.  
    26.     void newConnection_slot();  //每当有一个新的客户端发送信号进行连接时，则进入该槽函数处理相关逻辑
    27.  
    28.     //如果该套接字有数据项服务器发送过来，那么该套接字就会自动发射一个readyRead信号
    29.     //我们可以将该信号连接到自定义的槽函数中处理相关逻辑
    30.     void readyRead_slot();     //
    31.  
    32. private:
    33.     Ui::Widget *ui;
    34.  
    35.     //1.定义服务器指针
    36.     QTcpServer *server;
    37.  
    38.     //4.定义客户端指针链表容器
    39.     QListclientList;
    40.  
    41.  
    42. };
    43. #endif // WIDGET_H
    1. #include "widget.h"
    2. #include "ui_widget.h"
    3.  
    4. Widget::Widget(QWidget *parent)
    5.     : QWidget(parent)
    6.     , ui(new Ui::Widget)
    7. {
    8.     ui->setupUi(this);
    9.  
    10.     //1.给服务器实例化一个对象
    11.     server = new QTcpServer(this);  //此时创建服务器成功
    12. }
    13.  
    14. Widget::~Widget()
    15. {
    16.     delete ui;
    17. }
    18.  
    19. //2.启动按钮对应的槽函数，只有点击启动按钮后，才可以发射一个信号将服务器设置为监听状态
    20. void Widget::on_strartBtn_clicked()
    21. {
    22.     //获取ui界面上的端口号，在监听前后设置都可以
    23.     quint16 port = ui->portEdit->text().toInt();  //toInt 是将里面的文本转换为整型
    24.  
    25.     //将服务器设置为监听状态
    26.     //bool QTcpServer::listen(const QHostAddress &address = QHostAddress::Any, quint16 port = 0)
    27.     //参数一：要监听的主机地址，如果是any,表示监听所有主机地址，也可以给定特定的主机地址进行监听
    28.     //参数二：通过指定的端口号进行访问服务器，如果是0，则表示由服务器自动分配，如果非0，则表示指定端口号
    29.     //返回值：成功返回真，失败返回假
    30.     if(!server->listen(QHostAddress::Any,port))
    31.     {
    32.         QMessageBox::critical(this,"失败","服务器启动失败");
    33.         return;
    34.     }else
    35.     {
    36.         QMessageBox::information(this,"成功","服务器启动成功");
    37.     }
    38.  
    39.     //此时表明服务器启动成功，并对客户端连接进行监听
    40.     //如果有客户端向服务器发来连接请求，那么该服务器就会自动发射一个newConnection的信号
    41.     //我们可以将该信号连接到对应的槽函数中处理相关逻辑
    42.     //3.进行服务器客户端连接，每当新的客户端发送过来一个连接信号，则进行一次连接
    43.     //如果写在构造函数中只会连接一次所以不能写在构造函数中，要写在自定义的槽函数中
    44.     connect(server,&QTcpServer::newConnection,this,&Widget::newConnection_slot);
    45.  
    46. }
    47. //4.处理newConnection信号的槽函数实现
    48. void Widget::newConnection_slot()
    49. {
    50.     qDebug() << "有新的客户端发来连接请求了";
    51.  
    52.     //4.获取最新连接的客户端的套接字
    53.     //函数原型：[virtual] QTcpSocket *QTcpServer::nextPendingConnection()
    54.     //参数：无
    55.     //返回值：最新连接客户端套接字指针
    56.     QTcpSocket *s = server->nextPendingConnection();
    57.  
    58.     //4.将获取的套接字存放到客户端容器中
    59.     clientList.push_back(s);   //进行尾插
    60.  
    61.  
    62.     //5.此时，服务器已经和客户端建立连接请求了
    63.     //如果有客户端向服务器发来数据，那么对于的客户端套接字就会发射一个readyRead的信号
    64.     //我们可以将该信号连接到自定义的槽函数中处理相关逻辑
    65.     connect(s,&QTcpSocket::readyRead,this,&Widget::readyRead_slot);
    66. }
    67. void Widget::readyRead_slot()
    68. {
    69.     //6.进行循环遍历删除客户端链表中的无效客户端套接字
    70.     for(int i = 0;i<clientList.count();i++)
    71.     {
    72.         //判断套接字状态
    73.         //函数原型：SocketState state() const;
    74.         //功能：返回客户端套接字的状态
    75.         //参数：无
    76.         //返回值：客户端的状态，如果结果为0，表示未连接
    77.         if(clientList[i]->state() == 0)
    78.         {
    79.             clientList.removeAt(i);   //将下标为i的客户端移除掉
    80.         }
    81.     }
    82.  
    83.     //7.循环遍历所有客户端，查看是哪个客户端发来的数据
    84.     for(int i = 0;i<clientList.count();i++)
    85.     {
    86.         //函数原型：qint64 bytesAvailable() const override;
    87.         //功能：返回当前客户端套接字中的可读数据字节个数
    88.         //参数：无
    89.         //返回值：当前客户端待读的字节数，如果该数据为0，表示无待读数据
    90.         if(clientList[i]->bytesAvailable()!=0)
    91.         {
    92.             //读取当前客户端的相关数据
    93.             //函数原型：QByteArray readAll();
    94.             //功能：读取当前套接字中的所有数据，并返回一个字节数组
    95.             //参数：无
    96.             //返回值：数据的字节数组
    97.             QByteArray msg = clientList[i]->readAll();
    98.  
    99.             //将数据展示到ui界面上
    100.             //把本机字符串转换为Qstring类型的字符串
    101.             ui->msgList->addItem(QString::fromLocal8Bit(msg));
    102.  
    103.             //将接收到的该消息，发送给所有客户端
    104.             for(int j = 0;j<clientList.count();j++)
    105.             {
    106.                 clientList[j]->write(msg);
    107.             }
    108.         }
    109.     }
    110. }

    cli

    1. QT       += core gui network
    2.  
    3. greaterThan(QT_MAJOR_VERSION, 4): QT += widgets
    4.  
    5. CONFIG += c++11
    6.  
    7. # The following define makes your compiler emit warnings if you use
    8. # any Qt feature that has been marked deprecated (the exact warnings
    9. # depend on your compiler). Please consult the documentation of the
    10. # deprecated API in order to know how to port your code away from it.
    11. DEFINES += QT_DEPRECATED_WARNINGS
    12.  
    1. #ifndef WIDGET_H
    2. #define WIDGET_H
    3.  
    4. #include 
    5. #include    //客户端头文件
    6. #include   //消息对话框类
    7.  
    8. QT_BEGIN_NAMESPACE
    9. namespace Ui { class Widget; }
    10. QT_END_NAMESPACE
    11.  
    12. class Widget : public QWidget
    13. {
    14.     Q_OBJECT
    15.  
    16. public:
    17.     Widget(QWidget *parent = nullptr);
    18.     ~Widget();
    19.  
    20. private slots:
    21.     void readyRead_slot();
    22.  
    23.     void connected_slot();
    24.  
    25.     void on_sendBtn_clicked();
    26.  
    27.     void on_connectBtn_clicked();
    28.  
    29.     void on_disconnectBtn_clicked();
    30.  
    31.     void disconnected_slot();
    32.  
    33. private:
    34.     Ui::Widget *ui;
    35.  
    36.     //定义一个客户端指针
    37.     QTcpSocket *socket;
    38.  
    39.  
    40.     //用户名
    41.     QString userName;
    42. };
    43. #endif // WIDGET_H
    1. #include "widget.h"
    2. #include "ui_widget.h"
    3.  
    4. Widget::Widget(QWidget *parent)
    5.     : QWidget(parent)
    6.     , ui(new Ui::Widget)
    7. {
    8.     ui->setupUi(this);
    9.  
    10.     //给客户端指针实例化空间
    11.     socket = new QTcpSocket(this);
    12.  
    13.     //如果连接服务器成功，该客户端就会发射一个connected的信号，
    14.     //我们可以将该信号连接到自定义的槽函数中处理相关逻辑
    15.     //由于该连接只需连接一次，所以，写在构造函数中即可
    16.     connect(socket, &QTcpSocket::connected, this, &Widget::connected_slot);
    17.  
    18.     //客户端与服务器连接成功后，如果服务器向客户端发来数据，那么该客户端就会自动发射一个readyRead信号
    19.     //我们可以将该信号连接到自定义的槽函数中处理相关逻辑
    20.     connect(socket, &QTcpSocket::readyRead, this, &Widget::readyRead_slot);
    21.  
    22.     //当客户端与服务器断开连接后，该客户端就会自动发射一个disconnected的信号
    23.     //我们可以将该信号与自定义的槽函数连接
    24.     //由于只需要连接一次，所以将该连接写到构造函数中即可
    25.     connect(socket, &QTcpSocket::disconnected, this, &Widget::disconnected_slot);
    26. }
    27.  
    28. Widget::~Widget()
    29. {
    30.     delete ui;
    31. }
    32.  
    33.  
    34. void Widget::on_connectBtn_clicked()
    35. {
    36.     //获取ui界面的信息
    37.     userName = ui->userNameEdit->text();        //获取用户名
    38.     QString hostName = ui->ipEdit->text();       //获取主机地址
    39.     quint16 port = ui->portEdit->text().toUInt();  //获取端口号
    40.  
    41.  
    42.     //调用函数连接到主机
    43.     //函数原型：[virtual] void QAbstractSocket::connectToHost(const QString &hostName, quint16 port)
    44.     //参数1：服务器的主机地址
    45.     //参数2：端口号
    46.     //返回值：无
    47.     socket->connectToHost(hostName, port);
    48.  
    49.  
    50.     //如果连接服务器成功，该客户端就会发射一个connected的信号，
    51.     //我们可以将该信号连接到自定义的槽函数中处理相关逻辑
    52.     //由于该连接只需连接一次，所以，写在构造函数中即可
    53. }
    54. //关于处理connected信号的槽函数的定义
    55. void Widget::connected_slot()
    56. {
    57.     QMessageBox::information(this, "成功", "连接服务器成功");
    58.  
    59.  
    60.     //顺便向服务器发送一条消息，说：***：进入聊天室
    61.     QString msg = userName + ": 进入聊天室";
    62.  
    63.  
    64.     socket->write(msg.toLocal8Bit());
    65. }
    66. //关于readyRead信号对应槽函数的实现
    67. void Widget::readyRead_slot()
    68. {
    69.     //读取该客户端中的数据
    70.     QByteArray msg = socket->readAll();
    71.  
    72.  
    73.     //将数据展示在ui界面
    74.     ui->msgList->addItem(QString::fromLocal8Bit(msg));
    75. }
    76.  
    77. //发送按钮对应的槽函数
    78. void Widget::on_sendBtn_clicked()
    79. {
    80.     //获取UI界面中的编辑的文本内容
    81.     QString m = ui->msgEdit->text();
    82.  
    83.  
    84.     //整合要发送的信息
    85.     QString msg = userName + ": " + m;
    86.  
    87.  
    88.     //将消息发送给服务器
    89.     socket->write(msg.toLocal8Bit());
    90.  
    91.  
    92.     //将消息编辑框中的内容清空
    93.     ui->msgEdit->clear();
    94. }
    95.  
    96.  
    97. //断开服务器按钮对应的槽函数
    98. void Widget::on_disconnectBtn_clicked()
    99. {
    100.     //准备要发送的信息
    101.     QString msg = userName +": 离开聊天室";
    102.     socket->write(msg.toLocal8Bit());
    103.  
    104.  
    105.     //调用成员函数disconnectFromHost
    106.     //函数原型：virtual void disconnectFromHost();
    107.     //功能：断开客户端与服务器的连接
    108.     //参数：无
    109.     //返回值：无
    110.     socket->disconnectFromHost();
    111.  
    112.  
    113.     //当客户端与服务器断开连接后，该客户端就会自动发射一个disconnected的信号
    114.     //我们可以将该信号与自定义的槽函数连接
    115.     //由于只需要连接一次，所以将该连接写到构造函数中即可
    116.  
    117. }
    118. //disconnected信号对应槽函数的实现
    119. void Widget::disconnected_slot()
    120. {
    121.     QMessageBox::information(this, "退出", "断开成功");
    122. }

  • 相关阅读:
    广度优先搜索BFS：图与迷宫
    Spring Boot Actuator的常见Endpoint
    使用ipmitool配置X86服务器的BMC网络和用户信息
    关于git版本管理与分支管理
    万木成林，我种了“Vue技能树”
    rust换源
    【笔记】大话设计模式15
    排序算法——归并排序以及非递归实现
    可转债市场和发行体制——市场的结构、发行方式、市场参与者与角色
    记一次ThreadLocal引发的线上故障
  • 原文地址：https://blog.csdn.net/Meng_fighting/article/details/132675975