• 2023/9/20 -- C++/QT


    时钟:

    widget.h:

    1. #ifndef WIDGET_H
    2. #define WIDGET_H
    3. #include
    4. #include
    5. #include
    6. #include
    7. #include
    8. #include
    9. #include
    10. QT_BEGIN_NAMESPACE
    11. namespace Ui { class Widget; }
    12. QT_END_NAMESPACE
    13. class Widget : public QWidget
    14. {
    15. Q_OBJECT
    16. public:
    17. Widget(QWidget *parent = nullptr);
    18. ~Widget();
    19. void paintEvent(QPaintEvent *event) override;
    20. void timerEvent(QTimerEvent *event) override;
    21. private:
    22. Ui::Widget *ui;
    23. QLabel *lab12;
    24. QLabel *lab3;
    25. QLabel *lab6;
    26. QLabel *lab9;
    27. int time_id;
    28. };
    29. #endif // WIDGET_H

    widget.cpp:

    1. #include "widget.h"
    2. #include "ui_widget.h"
    3. Widget::Widget(QWidget *parent)
    4. : QWidget(parent)
    5. , ui(new Ui::Widget)
    6. {
    7. ui->setupUi(this);
    8. lab12 = new QLabel(this);
    9. lab12->setText("12");
    10. lab12->setFont(QFont("楷体",25,3));
    11. lab12->move(this->width()/2-20,this->height()/2-175);
    12. lab3 = new QLabel(this);
    13. lab3->setText("3");
    14. lab3->setFont(QFont("楷体",25,3));
    15. lab3->move(this->width()/2+150,this->height()/2-20);
    16. lab6 = new QLabel(this);
    17. lab6->setText("6");
    18. lab6->setFont(QFont("楷体",25,3));
    19. lab6->move(this->width()/2-10,this->height()/2+135);
    20. lab9 = new QLabel(this);
    21. lab9->setText("9");
    22. lab9->setFont(QFont("楷体",25,3));
    23. lab9->move(this->width()/2-160,this->height()/2-20);
    24. time_id = startTimer(1000);
    25. }
    26. Widget::~Widget()
    27. {
    28. delete ui;
    29. }
    30. void Widget::paintEvent(QPaintEvent *event)
    31. {
    32. //获取系统时间
    33. QTime sys_t = QTime::currentTime();
    34. int hour = sys_t.hour();
    35. int minute = sys_t.minute();
    36. int second = sys_t.second();
    37. //分刻度绘制
    38. QPainter painterMinute(this);
    39. QPen penMinute;
    40. penMinute.setStyle(Qt::SolidLine);
    41. penMinute.setWidth(5);
    42. painterMinute.setPen(penMinute);
    43. painterMinute.translate(this->width()/2,this->height()/2);
    44. painterMinute.drawEllipse(QPoint(0,0),200,200);
    45. for(int i = 0;i < 12;i++){
    46. painterMinute.drawLine(0,-200,0,-180);
    47. painterMinute.rotate(360/12);
    48. }
    49. //秒钟刻度绘制
    50. QPainter painterSecond(this);
    51. QPen penSecond;
    52. penSecond.setStyle(Qt::SolidLine);
    53. penSecond.setWidth(3);
    54. painterSecond.setPen(penSecond);
    55. painterSecond.translate(this->width()/2,this->height()/2);
    56. for(int i = 0;i < 60;i++){
    57. painterSecond.drawLine(0,-200,0,-190);
    58. painterSecond.rotate(360/60);
    59. }
    60. //时针绘制
    61. QPainter painterHourPoint(this);
    62. QPen penHourPoint;
    63. penHourPoint.setStyle(Qt::SolidLine);
    64. penHourPoint.setWidth(5);
    65. painterHourPoint.setPen(penHourPoint);
    66. painterHourPoint.translate(this->width()/2,this->height()/2);
    67. painterHourPoint.rotate((360/12)*(hour%12+minute/60+second/3600));
    68. painterHourPoint.drawLine(0,10,0,-50);
    69. //分针绘制
    70. QPainter painterMinutePoint(this);
    71. QPen penMinutePoint;
    72. penMinutePoint.setStyle(Qt::SolidLine);
    73. penMinutePoint.setWidth(4);
    74. painterMinutePoint.setPen(penMinutePoint);
    75. painterMinutePoint.translate(this->width()/2,this->height()/2);
    76. painterMinutePoint.rotate((360/60)*(minute+second/60));
    77. painterMinutePoint.drawLine(0,10,0,-150);
    78. //秒针绘制
    79. QPainter painterSecondPoint(this);
    80. QPen penSecondPoint;
    81. penSecondPoint.setStyle(Qt::SolidLine);
    82. penSecondPoint.setWidth(2);
    83. painterSecondPoint.setPen(penSecondPoint);
    84. painterSecondPoint.translate(this->width()/2,this->height()/2);
    85. painterSecondPoint.rotate((360/60)*second);
    86. painterSecondPoint.drawLine(0,10,0,-150);
    87. }
    88. void Widget::timerEvent(QTimerEvent *event)
    89. {
    90. if(time_id == event->timerId()){
    91. this->update();
    92. }
    93. }

    效果图:

    一、QT连接TCP网络通信

    1.1 回顾网络编程中的通信内容

    1.2 QT中服务器端实现

    1> 实例化一个QTcpServer的类对象,那么一个服务器就创建好了

    2> 调用服务器的listen函数,将服务器设置成监听状态,监听时,可以给定特定的主机地址,也可以监听所有主机地址;可以指定端口号访问该服务器,也可以由该服务器自动分配一个端口号

    3> 此时,如果有客户端向服务器发来连接请求,那么该服务器就会自动发射一个newConnection信号,我们可以在该信号对应的槽函数中处理逻辑

    4> 可以调用nextPaddingConnection获取最新连接的客户端套接字的地址,并将该地址,放入自己的客户端容器中

    5> 如果有客户端向服务器发来数据,那么该客户端就会自动发射一个readyRead信号,我们可以在该信号对应槽函数中处理逻辑

    6> 可以通过套接字的成员函数,完成数据通信,发送数据:write函数实现,接收数据:read、readLine、readAll实现

    7> 可以调用成员函数close用于停止监听客户端的连接

    案例

    1、ui界面

    2、配置文件

    3、头文件

    1. #ifndef WIDGET_H
    2. #define WIDGET_H
    3. #include
    4. #include //服务器头文件
    5. #include //客户端头文件
    6. #include //链表容器
    7. #include //消息对话框
    8. #include
    9. QT_BEGIN_NAMESPACE
    10. namespace Ui { class Widget; }
    11. QT_END_NAMESPACE
    12. class Widget : public QWidget
    13. {
    14. Q_OBJECT
    15. public:
    16. Widget(QWidget *parent = nullptr);
    17. ~Widget();
    18. private slots:
    19. void on_startBtn_clicked();
    20. void newConnection_slot(); //自定义处理newConnection信号的槽函数的声明
    21. void readyRead_slot(); //自定义处理readyRead信号的槽函数的声明
    22. private:
    23. Ui::Widget *ui;
    24. //定义服务器指针
    25. QTcpServer *server;
    26. //定义客户端容器
    27. QList clientList;
    28. };
    29. #endif // WIDGET_H

    4、源文件

    1. #include "widget.h"
    2. #include "ui_widget.h"
    3. Widget::Widget(QWidget *parent)
    4. : QWidget(parent)
    5. , ui(new Ui::Widget)
    6. {
    7. ui->setupUi(this);
    8. //实例化一个服务器
    9. server = new QTcpServer(this);
    10. //此时,服务器已经成功进入监听状态,如果有客户端向服务器发来连接请求
    11. //那么该服务器,就会自动发射一个newConnection的信号,我们可以将该信号连接到对应槽函数中执行相关逻辑
    12. //由于只需要连接一次即可,所以可以将该连接放在构造函数中完成
    13. connect(server, &QTcpServer::newConnection, this, &Widget::newConnection_slot);
    14. }
    15. Widget::~Widget()
    16. {
    17. delete ui;
    18. }
    19. //启动服务器按钮对应的槽函数
    20. void Widget::on_startBtn_clicked()
    21. {
    22. quint16 port = ui->portEdit->text().toUInt(); //获取ui界面上的端口号
    23. //监听客户端的连接请求
    24. //函数原型:bool listen(const QHostAddress &address = QHostAddress::Any, quint16 port = 0);
    25. //参数1:要监听的主机地址,如果是any表示监听任意一个主机地址,也可以是特定的主机地址
    26. //参数2:该服务器提供的端口号,如果是0,表示由服务器自动指定,一般由程序员指定
    27. //返回值:成功进入监听状态,返回true,其他情况返回false
    28. if(!server->listen(QHostAddress::Any, port))
    29. {
    30. QMessageBox::information(this, "失败", "监听失败");
    31. return ;
    32. }else
    33. {
    34. QMessageBox::information(this, "成功", "服务器启动成功");
    35. }
    36. //此时,服务器已经成功进入监听状态,如果有客户端向服务器发来连接请求
    37. //那么该服务器,就会自动发射一个newConnection的信号,我们可以将该信号连接到对应槽函数中执行相关逻辑
    38. //由于只需要连接一次即可,所以可以将该连接放在构造函数中完成
    39. }
    40. //自定义处理newConnection信号的槽函数的实现
    41. void Widget::newConnection_slot()
    42. {
    43. qDebug()<<"您有新的客户端发来连接请求了";
    44. //获取最新连接的客户端套接字
    45. //函数原型:virtual QTcpSocket *nextPendingConnection();
    46. //参数:无
    47. //返回值:最新连接过来的客户端套接字的地址
    48. QTcpSocket *s = server->nextPendingConnection();
    49. //将该套接字,放入客户端链表中
    50. clientList.push_back(s);
    51. //至此,多个客户端已经跟服务器建立连接,并放入客户端容器中了
    52. //此时,如果有客户端向服务器发来数据,那么对应的客户端套接字就会自动发射一个readyRead信号
    53. //我们可以将该信号连接到自定义的槽函数中,处理相关逻辑
    54. connect(s, &QTcpSocket::readyRead, this, &Widget::readyRead_slot);
    55. }
    56. //readyRead信号对应槽函数的实现
    57. void Widget::readyRead_slot()
    58. {
    59. qDebug()<<"有新的客户端消息发来了";
    60. //遍历客户端链表,将无效的客户端移除
    61. for(int i=0; isize(); i++)
    62. {
    63. //判断当前套接字是否是有效连接
    64. //函数原型: SocketState state() const;
    65. //参数:无
    66. //返回值:套接字的状态,如果是0,表示该套接字为无效连接
    67. if(clientList[i]->state() ==0)
    68. {
    69. //将该套接字移除客户端容器
    70. clientList.removeAt(i);
    71. }
    72. }
    73. //遍历客户端链表,判断是哪个客户端发来的数据
    74. for(int i=0; isize(); i++)
    75. {
    76. //函数原型:qint64 bytesAvailable() const override;
    77. //功能:求当前客户端套接字中待读数据的字节数
    78. //参数:无
    79. //返回值:待读数据的字节数,如果是0,表示无数据待读
    80. if(clientList[i]->bytesAvailable() != 0)
    81. {
    82. //将该套接字中的数据读取出来
    83. QByteArray msg = clientList[i]->readAll();
    84. //将数据展示到ui界面
    85. ui->msgWidget->addItem( QString::fromLocal8Bit(msg) );
    86. //将接受到的数据,转发给所有客户端
    87. for(int j=0; jsize(); j++)
    88. {
    89. clientList[j]->write(msg);
    90. }
    91. }
    92. }
    93. }

    1.3 QT中的客户端实现

    1> 实例化一个QTcpSocket的对象,此时就创建了一个客户端了

    2> 使用该类提供的成员函数connectToHost,向服务器发送连接请求,调用该函数时,需要指定服务器的主机地址和端口号

    3> 如果成功连接客户端,那么该客户端就会自动发射一个connected的信号,我们可以在该信号对应的槽函数中处理相关逻辑

    4> 此时,客户端和服务就已经建立起来连接了,如果客户端接收到服务器发来的数据,那么该客户端就会自动发射一个readyRead信号

    5> 在该信号对应的槽函数中,可以使用成员函数,完成数据通信,发送数据:write函数实现,接收数据:read、readLine、readAll实现

    6> 断开连接,使用成员函数disconnectFromHost,如果成功断开连接,该客户端就会自动发射一个disconnected的信号

    7> 我们可以在该信号处理函数中处理相关逻辑

    案例

    1、ui界面

    2、配置文件

    3、头文件

    1. #ifndef WIDGET_H
    2. #define WIDGET_H
    3. #include
    4. #include //客户端类
    5. #include
    6. QT_BEGIN_NAMESPACE
    7. namespace Ui { class Widget; }
    8. QT_END_NAMESPACE
    9. class Widget : public QWidget
    10. {
    11. Q_OBJECT
    12. public:
    13. Widget(QWidget *parent = nullptr);
    14. ~Widget();
    15. private slots:
    16. void on_connectBtn_clicked();
    17. void connected_slot(); //自定义处理connected信号的槽函数的声明
    18. void readyRead_slot(); //自定义处理readyRead信号的槽函数的声明
    19. void on_sendBtn_clicked();
    20. void on_disconnectBtn_clicked();
    21. void disconnected_slot(); //自定义处理disconnected信号的槽函数的声明
    22. private:
    23. Ui::Widget *ui;
    24. //定义客户端指针
    25. QTcpSocket * socket;
    26. //定义字符串接受用户
    27. QString userName;
    28. };
    29. #endif // WIDGET_H

    4、源文件

    1. #include "widget.h"
    2. #include "ui_widget.h"
    3. Widget::Widget(QWidget *parent)
    4. : QWidget(parent)
    5. , ui(new Ui::Widget)
    6. {
    7. ui->setupUi(this);
    8. //给客户端指针实例化对象
    9. socket = new QTcpSocket(this);
    10. //此时,已经向服务器发送连接请求了,如果成功连接服务器,那么该客户端就会自动发射一个connected的信号
    11. //我们可以将该信号连接到自定义的槽函数中处理逻辑
    12. //由于只需要连接一次,所以将连接写在构造函数中
    13. connect(socket, &QTcpSocket::connected, this, &Widget::connected_slot);
    14. //如果服务器向客户端发来消息,那么该客户端就会自动发射一个readyRead信号
    15. //我们可以将该进行连接到自定义的槽函数中处理相关逻辑
    16. connect(socket, &QTcpSocket::readyRead, this, &Widget::readyRead_slot);
    17. //当成功与服务器断开连接后,该客户端会自动发射一个disconnected的信号
    18. //我们可以将该信号连接到自定义的槽函数中处理相关逻辑
    19. //由于该连接只需连接一次即可,所以放在构造函数中进行
    20. connect(socket, &QTcpSocket::disconnected, this, &Widget::disconnected_slot);
    21. }
    22. Widget::~Widget()
    23. {
    24. delete ui;
    25. }
    26. //连接服务器按钮对应的槽函数
    27. void Widget::on_connectBtn_clicked()
    28. {
    29. //获取ui界面上的相关信息
    30. userName = ui->userNameEdit->text(); //获取用户名
    31. QString ip = ui->ipEdit->text(); //主机地址
    32. quint16 port = ui->portEdit->text().toUInt(); //端口号
    33. //函数原型:virtual void connectToHost(const QHostAddress &address, quint16 port);
    34. //功能:将客户端连接到给定的服务器
    35. //参数1:服务器的主机地址
    36. //参数2:端口号
    37. //返回值:无
    38. socket->connectToHost(ip, port);
    39. //此时,已经向服务器发送连接请求了,如果成功连接服务器,那么该客户端就会自动发射一个connected的信号
    40. //我们可以将该信号连接到自定义的槽函数中处理逻辑
    41. //由于只需要连接一次,所以将连接写在构造函数中
    42. }
    43. //处理connected信号的槽函数的定义
    44. void Widget::connected_slot()
    45. {
    46. QMessageBox::information(this, "成功", "您已经成功进入聊天室");
    47. //向服务器发送一条数据:***:进入聊天室
    48. QString msg = userName +": 进入聊天室";
    49. socket->write(msg.toLocal8Bit()); //将数据写给服务器
    50. }
    51. //处理readyRead信号的槽函数的定义
    52. void Widget::readyRead_slot()
    53. {
    54. //读取套接字中的信息
    55. QByteArray msg = socket->readAll();
    56. //将数据展示到ui界面
    57. ui->msgWidget->addItem(QString::fromLocal8Bit(msg));
    58. }
    59. //发送按钮对应的槽函数
    60. void Widget::on_sendBtn_clicked()
    61. {
    62. //获取ui界面输入的内容
    63. QString msg =userName+ ": " + ui->msgEdit->text();
    64. //发送给服务器
    65. socket->write(msg.toLocal8Bit());
    66. //清空编辑框内容
    67. ui->msgEdit->clear();
    68. }
    69. //断开服务器按钮对应的槽函数
    70. void Widget::on_disconnectBtn_clicked()
    71. {
    72. //告诉大家我走了
    73. QString msg = userName +": 离开聊天室";
    74. socket->write(msg.toLocal8Bit());
    75. //断开连接
    76. //函数原型: virtual void disconnectFromHost();
    77. socket->disconnectFromHost();
    78. //当成功与服务器断开连接后,该客户端会自动发射一个disconnected的信号
    79. //我们可以将该信号连接到自定义的槽函数中处理相关逻辑
    80. //由于该连接只需连接一次即可,所以放在构造函数中进行
    81. }
    82. //disconnected信号对应槽函数的定义
    83. void Widget::disconnected_slot()
    84. {
    85. QMessageBox::information(this, "提示", "退出成功");
    86. }

     

    二、QT连接数据库

    2.1 QT将数据库分为三个层次

    1> 数据库驱动层:QSqlDriver、QSqlDriverCreator、QSqlDriverCreatorBase、QSqlDriverPlugin

    2> sql接口层:QSqlDatabase、QSqlQuery、QSqlRecord、QSqlError

    3> 用户接口层:提供一些模型QSqlQueryModel、QSqlTableModel、QSqlRelationalTableModel

    2.2 实现数据库操作的相关方法

    1. 1、添加数据库:[static] QSqlDatabase QSqlDatabase::addDatabase(QSqlDriver *driver, const QString &connectionName = QLatin1String(defaultConnection))
    2. QSQLITE
    3. SQLite version 3 or above
    4. 2、设置数据库名称:void QSqlDatabase::setDatabaseName(const QString &name)
    5. 3、包含数据库:bool QSqlDatabase::contains(const QString &connectionName = QLatin1String(defaultConnection))
    6. 4、打开数据库:bool QSqlDriver::open(const QString &db)
    7. 5、关闭数据库:void QSqlDatabase::close()
    8. 6、错误信息:QSqlError QSqlDatabase::lastError()
    9. 7、sql语句执行:构造一个QSqlQuery类对象,调用其成员函数exec,执行sql语句:bool QSqlQuery::exec(const QString &query)
    10. 8、bool QSqlQuery::next():遍历查询结果的函数

    2.3 通过数据库实现学生管理系统

    1> ui界面

    2> 配置文件

    3> 头文件

    1. #ifndef WIDGET_H
    2. #define WIDGET_H
    3. #include
    4. #include //数据库管理类
    5. #include //执行sql语句的类
    6. #include //数据库记录的类
    7. #include //消息对话框
    8. #include
    9. QT_BEGIN_NAMESPACE
    10. namespace Ui { class Widget; }
    11. QT_END_NAMESPACE
    12. class Widget : public QWidget
    13. {
    14. Q_OBJECT
    15. public:
    16. Widget(QWidget *parent = nullptr);
    17. ~Widget();
    18. private slots:
    19. void on_insertBtn_clicked();
    20. void on_showBtn_clicked();
    21. private:
    22. Ui::Widget *ui;
    23. QSqlDatabase db; //定义一个数据库的类对象
    24. };
    25. #endif // WIDGET_H

    4> 源文件

    1. #include "widget.h"
    2. #include "ui_widget.h"
    3. Widget::Widget(QWidget *parent)
    4. : QWidget(parent)
    5. , ui(new Ui::Widget)
    6. {
    7. ui->setupUi(this);
    8. //判断自己的数据库对象中,是否包含了要处理的数据库,如果没有包含则添加一个数据库,如果包含了,就可以打开了
    9. if(!db.contains("mydatabase.db"))
    10. {
    11. //添加一个数据库,调用该类中的静态成员函数addDatabase
    12. //函数原型:static QSqlDatabase addDatabase(const QString& type);
    13. //参数:驱动类型 QSQLITE SQLite version 3
    14. //返回值:数据库对象
    15. db = QSqlDatabase::addDatabase("QSQLITE");
    16. //设置数据库的名字
    17. db.setDatabaseName("mydatabase.db");
    18. }
    19. //此时已经有一个名为mydatabase.db的数据库
    20. //打开数据库
    21. if(!db.open())
    22. {
    23. QMessageBox::information(this,"失败","数据库打开失败");
    24. return;
    25. }
    26. //需要使用sql语句进行创建表的操作
    27. //准备sql语句
    28. QString sql = "create table if not exists stu_info(" //创建表
    29. "numb integer primary key," //学号,主键
    30. "name varchar(10)," //姓名
    31. "sex varchar(2)," //性别
    32. "score integer)"; //成绩
    33. //准备语句执行者
    34. QSqlQuery querry;
    35. //让语句执行者执行sql语句
    36. //函数原型:bool exec(const QString& query);
    37. //参数:要执行的sql语句
    38. //返回值:成功执行返回true,失败返回false
    39. if(!querry.exec(sql))
    40. {
    41. QMessageBox::information(this, "失败", "创建表失败");
    42. return;
    43. }
    44. }
    45. Widget::~Widget()
    46. {
    47. delete ui;
    48. }
    49. //录入按钮对应的槽函数
    50. void Widget::on_insertBtn_clicked()
    51. {
    52. //获取ui界面中要录入的数据
    53. int numb = ui->numbEdit->text().toInt();
    54. QString name = ui->nameEdit->text();
    55. QString sex = ui->sexEdit->text();
    56. int score = ui->scoreEdit->text().toInt();
    57. //要确保每个编辑器中都有数据
    58. if(numb==0 || name.isEmpty() || sex.isEmpty() || score==0)
    59. {
    60. QMessageBox::information(this,"提示","请将信息填写完整");
    61. return;
    62. }
    63. //准备sql语句
    64. QString sql = QString("insert into stu_info(numb, name, sex, score) "
    65. "values(%1, '%2', '%3', %4)").arg(numb).arg(name).arg(sex).arg(score);
    66. //qDebug()<
    67. //准备语句执行者
    68. QSqlQuery querry;
    69. if(!querry.exec(sql))
    70. {
    71. QMessageBox::information(this,"失败", "添加失败");
    72. return;
    73. }else
    74. {
    75. QMessageBox::information(this,"成功", "添加成功");
    76. }
    77. }
    78. //显示按钮对应的槽函数
    79. void Widget::on_showBtn_clicked()
    80. {
    81. //准备sql语句
    82. QString sql = "select * from stu_info";
    83. //准备语句执行者
    84. QSqlQuery querry;
    85. //执行sql语句
    86. if(!querry.exec(sql))
    87. {
    88. QMessageBox::information(this,"提示","显示失败");
    89. return;
    90. }
    91. //此时,已经完成查询工作,并且将查询的结果全部都放入querry类对象中
    92. //要遍历查询结果,可以使用QSqlQuerry类中的成员函数next
    93. int i = 0; //记录行数
    94. while(querry.next())
    95. {
    96. //在该循环中,querry对象表示的是当前的记录
    97. //可以使用成员函数: QSqlRecord record() const;获取当前记录
    98. //可以使用QSqlRecord成员函数,count():获取当前记录中的项数
    99. //可以使用QSqlRecord成员函数,value(index):获取当前记录中第index项的值
    100. //qDebug()<
    101. //遍历每条记录中的每一项的内容
    102. for(int j=0; jrecord().count(); j++)
    103. {
    104. //qDebug()<
    105. ui->tableWidget->setItem(i,j, new QTableWidgetItem(querry.record().value(j).toString()));
    106. }
    107. i++; //继续遍历下一条记录
    108. }
    109. }

  • 相关阅读:
    迁移 MySQL 数据到 OceanBase 集群
    前端使用 Konva 实现可视化设计器(1)
    神经网络模型训练简记(一)
    Git 常用命令
    Java Field.getType()方法具有什么功能呢?
    基于python的短视频智能推荐/django的影视网站/视频推荐系统
    NIO总结文——一篇读懂NIO整个流程
    Apollo简易地图制作
    CSS阴影优化气泡框样式
    第七章 设计zrlog项目的测试用例(7.1章节)
  • 原文地址:https://blog.csdn.net/weixin_54147737/article/details/133101217