• QT 实现 TCP 客户端服务器代码

    服务器

    头文件：

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

    源文件：

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

    客户端：

    头文件：

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

    源文件：

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

  • 相关阅读:
    谷粒商城 (十九) --------- 商品服务 概念 SPU & SKU
    R语言中的函数19：openxlsx::read.xlsx(), write.xlsx(), writeData(), writeDataTable()
    springboot集成rabbitmq:fanout、topic
    【python操作Excel的方法】
    S波与P波的定义（光波电矢量）（菲涅耳公式）
    【AI+编程】工作日常场景随时可以AI编程，记一个问答SQL快速导出数据日常示例
    面试官：Java线程池是怎么统计线程的空闲时间的？
    下载生成af-only-gnomad.hg19.vcf.gz文件
    Reactive Programing与“响应式”
    基于SSH的校园网上购物系统Javaweb、MySQL、JSP
  • 原文地址：https://blog.csdn.net/2302_77738263/article/details/133611166