• 复习 --- QT服务器客户端

     

    服务器：

    头文件：

    1. #ifndef WIDGET_H
    2. #define WIDGET_H
    3.  
    4. #include 
    5. #include
    6. #include
    7. #include
    8. #include
    9. #include
    10. #include
    11. #include
    12. #include
    13. #include
    14. QT_BEGIN_NAMESPACE
    15. namespace Ui { class Widget; }
    16. QT_END_NAMESPACE
    17.  
    18. class Widget : public QWidget
    19. {
    20.     Q_OBJECT
    21.  
    22. public:
    23.     Widget(QWidget *parent = nullptr);
    24.     ~Widget();
    25.  
    26. private:
    27.     Ui::Widget *ui;
    28.  
    29.     //客户端指针
    30.     QTcpSocket *client;
    31.     //存储用户名
    32.     QString uname;
    33.  
    34.     //聊天框
    35.     QListWidget *text;
    36.     //消息发送框
    37.     QLineEdit *msg;
    38.     //发送按钮
    39.     QPushButton *send;
    40.     //用户名、
    41.     QLabel *userLab;
    42.     //IP
    43.     QLabel *ipLab;
    44.     //PORT
    45.     QLabel *portLab;
    46.     //用户输入框
    47.     QLineEdit *unameEdit;
    48.     //IP输入框
    49.     QLineEdit *ipEdit;
    50.     //端口输入框
    51.     QLineEdit *portEdit;
    52.     //连接服务器按钮
    53.     QPushButton *bconnect;
    54.     //断开服务器按钮
    55.     QPushButton *bdisconnect;
    56.  
    57. public slots:
    58.     //连接按钮槽函数
    59.     void connectBtn_clicked();
    60.     //声明自定义处理connected信号的槽函数
    61.     void connected_slot();
    62.     //声明自定义处理readyRead信号的槽函数
    63.     void readyRead_slot();
    64.     //声明自定义处理disconnected信号的槽函数
    65.     void disconnected_slot();
    66.     //发送按钮槽函数
    67.     void  sendBtn_clicked();
    68.     //断开连接槽函数
    69.     void disconnectBtn_clicked();
    70. };
    71. #endif // WIDGET_H

    widget.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.     this->setFixedSize(720,680);
    10.  
    11.     //聊天框
    12.     text = new QListWidget(this);
    13.     text->setFixedSize(720,400);
    14.     //消息发送框
    15.     msg = new QLineEdit(this);
    16.     msg->resize(500,50);
    17.     msg->move(10,420);
    18.     //发送按钮
    19.     send = new QPushButton(this);
    20.     send->setText("发送");
    21.     send->resize(150,50);
    22.     send->move(520,420);
    23.     //用户名
    24.     userLab = new QLabel(this);
    25.     userLab->setText("用户名：");
    26.     userLab->setAlignment(Qt::AlignCenter);
    27.     userLab->resize(100,30);
    28.     userLab->move(30,500);
    29.     //IP
    30.     ipLab = new QLabel(this);
    31.     ipLab->setText("IP：");
    32.     ipLab->setAlignment(Qt::AlignCenter);
    33.     ipLab->resize(100,30);
    34.     ipLab->move(30,550);
    35.     //PORT
    36.     portLab = new QLabel(this);
    37.     portLab->setText("Port：");
    38.     portLab->setAlignment(Qt::AlignCenter);
    39.     portLab->resize(100,30);
    40.     portLab->move(30,600);
    41.     //用户输入框
    42.     unameEdit = new QLineEdit(this);
    43.     unameEdit->resize(300,30);
    44.     unameEdit->move(140,500);
    45.     //IP输入框
    46.     ipEdit = new QLineEdit(this);
    47.     ipEdit->resize(300,30);
    48.     ipEdit->move(140,550);
    49.     //端口输入框
    50.     portEdit = new QLineEdit(this);
    51.     portEdit->resize(300,30);
    52.     portEdit->move(140,600);
    53.     //连接服务器按钮
    54.     bconnect = new QPushButton(this);
    55.     bconnect->resize(120,50);
    56.     bconnect->setText("连接");
    57.     bconnect->move(520,500);
    58.     //断开服务器按钮
    59.     bdisconnect = new QPushButton(this);
    60.     bdisconnect->resize(120,50);
    61.     bdisconnect->setText("断开连接");
    62.     bdisconnect->move(520,580);
    63.  
    64.     client = new QTcpSocket(this);
    65.     //连接按钮信号
    66.     connect(bconnect,&QPushButton::clicked,this,&Widget::connectBtn_clicked);
    67.     //连接上后客户端自动发送一个connected信号,只需要连接一次
    68.     connect(client,&QTcpSocket::connected,this,&Widget::connected_slot);
    69.     //如果服务器有数据发送给该客户端，那么该套接字就会自动发射一个readyRead信号
    70.     connect(client, &QTcpSocket::readyRead, this, &Widget::readyRead_slot);
    71.     //发送按钮
    72.     connect(send,&QPushButton::clicked,this,&Widget::sendBtn_clicked);
    73.     //当成功与服务器断开连接后，该客户端就会自动发射一个disconnected的信号
    74.     connect(client, &QTcpSocket::disconnected, this, &Widget::disconnected_slot);
    75. }
    76.  
    77. Widget::~Widget()
    78. {
    79.     delete ui;
    80.  
    81. }
    82.  
    83. //连接按钮槽函数
    84. void Widget::connectBtn_clicked()
    85. {
    86.     //获取ip和端口
    87.     QString ip = ipEdit->text();
    88.     quint16 port = portEdit->text().toUInt();
    89.  
    90.     //连接主机
    91.     client->connectToHost(ip,port);
    92. }
    93. //声明自定义处理connected信号的槽函数
    94. void Widget::connected_slot()
    95. {
    96.     QMessageBox::information(this,"","连接服务器成功");
    97.  
    98.     uname = unameEdit->text();
    99.     QString msgs = uname+":进入聊天室";
    100.  
    101.     client->write(msgs.toLocal8Bit());
    102.  
    103.     msg->setEnabled(true);
    104.     send->setEnabled(true);
    105.     bdisconnect->setEnabled(true);
    106.     unameEdit->setEnabled(false);
    107.     ipEdit->setEnabled(false);
    108.     portEdit->setEnabled(false);
    109.     bconnect->setEnabled(false);
    110.  
    111. }
    112. //声明自定义处理readyRead信号的槽函数
    113. void Widget::readyRead_slot()
    114. {
    115.     //接收到服务器消息后
    116.     QByteArray msgbox = client->readAll();
    117.     //显示
    118.     text->addItem(QString::fromLocal8Bit(msgbox));
    119. }
    120. //声明自定义处理disconnected信号的槽函数
    121. void Widget::disconnected_slot()
    122. {
    123.     QString msgbox = uname+":离开聊天室";
    124.     client->write(msgbox.toLocal8Bit());
    125.     //断开后客户端会发送一个disconnected信号
    126.     client->disconnectFromHost();
    127. }
    128. //发送按钮槽函数
    129. void Widget::sendBtn_clicked()
    130. {
    131.     QString msgbox = msg->text();
    132.     msgbox = uname+":"+msgbox;
    133.     //发送
    134.     client->write(msgbox.toLocal8Bit());
    135.     msg->clear();
    136.  
    137. }
    138. //断开连接槽函数
    139. void Widget::disconnectBtn_clicked()
    140. {
    141.     QMessageBox::information(this,"","成功断开");
    142.     msg->setEnabled(false);
    143.     send->setEnabled(false);
    144.     bdisconnect->setEnabled(false);
    145.     unameEdit->setEnabled(true);
    146.     ipEdit->setEnabled(true);
    147.     portEdit->setEnabled(true);
    148.     bconnect->setEnabled(true);
    149. }
    150.

     

    客户端

    头文件

    1. #ifndef WIDGET_H
    2. #define WIDGET_H
    3.  
    4. #include 
    5. #include
    6. #include
    7. #include
    8. #include
    9. #include
    10. #include
    11. #include
    12. #include
    13. #include
    14.  
    15. QT_BEGIN_NAMESPACE
    16. namespace Ui { class Widget; }
    17. QT_END_NAMESPACE
    18.  
    19. class Widget : public QWidget
    20. {
    21.     Q_OBJECT
    22.  
    23. public:
    24.     Widget(QWidget *parent = nullptr);
    25.     ~Widget();
    26.  
    27. private:
    28.     Ui::Widget *ui;
    29.     //定义服务器指针
    30.     QTcpServer *server;
    31.     //定义客户端容器
    32.     QList socketList;
    33.  
    34.     //对话框
    35.     QListWidget *text;
    36.     //端口号
    37.     QLabel * l_port;
    38.     //端口输入框
    39.     QLineEdit *edit_port;
    40.     //启动按钮
    41.     QPushButton *bstart;
    42.  
    43. private slots:
    44.     //按键槽函数
    45.     void start_clicked();
    46.     //连接槽函数
    47.     void newConnection_slot();
    48.     //readyRead信号处理槽函数
    49.     void readyRead_slot();
    50.  
    51. };
    52. #endif // WIDGET_H

    widget.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.     this->setFixedSize(680,500);
    11.  
    12.     //对话框
    13.     text = new QListWidget(this);
    14.     text->setFixedSize(680,350);
    15.     //端口号
    16.     l_port = new QLabel(this);
    17.     l_port->setText("端口号:");
    18.     l_port->resize(50,30);
    19.     l_port->move(50,400);
    20.  
    21.     //端口输入框
    22.     edit_port = new QLineEdit(this);
    23.     edit_port->resize(380,30);
    24.     edit_port->move(120,400);
    25.     //启动按钮
    26.     bstart = new QPushButton(this);
    27.     bstart->setText("启动服务器");
    28.     bstart->resize(100,30);
    29.     bstart->move(520,400);
    30.  
    31.     server = new QTcpServer(this);
    32.  
    33.     connect(bstart,&QPushButton::clicked,this,&Widget::start_clicked);
    34. }
    35.  
    36. Widget::~Widget()
    37. {
    38.     delete ui;
    39. }
    40.  
    41. void Widget::start_clicked()
    42. {
    43.     qDebug()<<"ok";  //测试
    44.     //判断输入框中是否有内容
    45.     if(edit_port->text() == NULL)
    46.     {
    47.         QMessageBox::information(this,"错误","端口号为空！");
    48.     }
    49.     else
    50.     {
    51.         //获取输入框中的内容
    52.         quint16 port = edit_port->text().toUInt();
    53.         qDebug()<
    54.         QString ip = "192.168.1.2";
    55.         QHostAddress address(ip);
    56.  
    57.         //将服务器设置成监听状态，监听客户段发来的连接请求
    58.         if(server->listen(QHostAddress::Any,port))
    59.         {
    60.             QMessageBox::information(this,"","服务器启动成功");
    61.         }
    62.         else
    63.         {
    64.             QMessageBox::information(this,"","服务器启动失败");
    65.         }
    66.  
    67.         //此时服务器已经进入监听状态，客户段发来连接请求，服务器就会自动发射一个newConnext信号
    68.         connect(server,&QTcpServer::newConnection,this,&Widget::newConnection_slot);
    69.     }
    70. }
    71.  
    72. void Widget::newConnection_slot()
    73. {
    74.     qDebug()<<"有客户连接";
    75.     //获取最新连接的客户段套接字
    76.     QTcpSocket *client = server->nextPendingConnection();
    77.     //将套接字放入客户端容器
    78.     socketList.push_back(client);
    79.  
    80.     //监听套接字，有数据则客户端会发送一个readyRead信号
    81.     connect(client,&QTcpSocket::readyRead,this,&Widget::readyRead_slot);
    82. }
    83.  
    84. void Widget::readyRead_slot()
    85. {
    86.     //移除无效客户端
    87.     for (int i = 0;icount();i++)
    88.     {
    89.         //套接字状态为0表示无效客户端
    90.         if(socketList.at(i)->state() == 0)
    91.         {
    92.             socketList.removeAt(i);
    93.         }
    94.     }
    95.     //遍历套接字有消息发送给其他客户端
    96.     for (int i = 0;icount();i++)
    97.     {
    98.         //获取套接字是否有有效数据
    99.         if(socketList.at(i)->bytesAvailable() != 0)
    100.         {
    101.             //获取套接字内信息
    102.             QByteArray msg = socketList.at(i)->readAll();
    103.             text->addItem(QString::fromLocal8Bit(msg));
    104.             for (int j = 0;jcount();j++)
    105.             {
    106.                 socketList.at(j)->write(msg);
    107.  
    108.             }
    109.         }
    110.     }
    111. }
    112.
  • 相关阅读:
    flink的副输出sideoutput单元测试
    golang 中的go指针
    利用easy poi做文件导出
    JVM知识点总结
    EMM Cause #40 No EPS bearer context activated介绍
    学生HTML个人网页作业作品：基于web在线汽车网站的设计与实现 (宝马轿车介绍)
    AP360X 3D小夜灯 拍拍灯 智能充电 LED照明 手电筒驱动IC LED指示灯
    如何看待Java是一门半编译半解释型的语言（企业真题）
    广西民族大学计算机考研资料汇总
    python-sklearn模型通用方法的介绍
  • 原文地址：https://blog.csdn.net/weixin_61882921/article/details/133606093