[网络协议]QT 自学内容 day04 UDP 数据传输， TCP 数据传输，ui 界面设计，按钮的设计自动绑定槽函数！

1.首先是UDP 数据传输，

DP 的客户端

1.我们在自定义的类里面 定义 套接字，和时间定时器

QUdpSocket *m_udp;

QTimer *m_pTimer;

头文件：

#include <QUdpSocket>//套接字

#include <QTimer>//时间定时器

2.在构造函数的时候我们 初始化数据??

m_udp = new QUdpSocket;//创建udp套接字
   m_pTimer = new QTimer;//创建定时器
    m_pTimer->setInterval(1000);//时间间隔1s。
    connect(m_pTimer,&QTimer::timeout,this,&udpclient::writedata);//每隔1s，发送数据，并且触发槽函数
   m_pTimer->start();//启动定时器

3.在析构函数的时候我们释放 数据

   delete m_udp;
    delete m_pTimer;

4.写槽函数

//发送数据报。
void udpclient::writedata()
{
    QByteArray data = "hello";
    m_udp->writeDatagram(data,data.size(),QHostAddress("191.161.110.1"),10001);//这里是自己主机的ip  和端口号
}

客户端的所有的代码：

udpclicent.h

#ifndef UDPCLIENT_H
#define UDPCLIENT_H

#include <QObject>
#include <QUdpSocket>
#include <QTimer>
#include <iostream>

using namespace std;

class udpclient : public QObject
{
    Q_OBJECT
public:
    explicit udpclient(QObject *parent = 0);
    ~udpclient();
signals:

public slots:
    void writedata();
private:
    QUdpSocket *m_udp;
    QTimer *m_pTimer;
};

#endif // UDPCLIENT_H

mian.cpp

#include <QCoreApplication>
#include <udpclient.h>

int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);
    udpclient *client = new udpclient();
    return a.exec();
}

udpclient.cpp

#include "udpclient.h"
#include <QByteArray>


udpclient::udpclient(QObject *parent) : QObject(parent)
{
    m_udp = new QUdpSocket;//创建udp套接字


   m_pTimer = new QTimer;//创建定时器
    m_pTimer->setInterval(1000);//时间间隔1s。
    connect(m_pTimer,&QTimer::timeout,this,&udpclient::writedata);//每隔1s，发送数据
   m_pTimer->start();//启动定时器
}

udpclient::~udpclient()
{
    delete m_udp;
    delete m_pTimer;
}
//发送数据报。
void udpclient::writedata()
{
    QByteArray data = "hello";
    m_udp->writeDatagram(data,data.size(),QHostAddress("192.168.150.1"),10001);//这里是自己主机的ip  和端口号
}

2.UDP? 的服务器数据的接收

1.我们在自定义的类里面 定义 套接字

QUdpSocket *m_udp;

头文件：

#include <QUdpSocket>//套接字

2.在构造函数的时候我们 初始化数据??

//创建套接字
    m_udp = new QUdpSocket();
    //服务器绑定电脑ip或端口
    m_udp->bind(QHostAddress("192.168.150.1"),10001);
    //接收数据
    connect(m_udp,&QUdpSocket::readyRead,this,&udpsever::recvdat);//套接字的接收函数，来触发自定义的显示函数

3.析构函数我们，关闭套接字

delete m_udp;

4.自定义的槽函数

void udpsever::recvdat()
{
    QByteArray pa;
    if(m_udp->hasPendingDatagrams())//首先判断是否读到数据报。
    {
        pa.resize(m_udp->pendingDatagramSize());//设置字符数组的大小。
        m_udp->readDatagram(pa.data(),pa.size());//udp套接字读取数据报
        //打印pa的数据
        qDebug() << pa.data() << endl;
    }
}

5.UDP所有的代码：

udpsever.h

#ifndef UDPSEVER_H
#define UDPSEVER_H

#include <QObject>
#include <QUdpSocket>

class udpsever : public QObject
{
    Q_OBJECT
public:
    explicit udpsever(QObject *parent = 0);
    ~udpsever();
signals:

public slots:
    void recvdat();
private:
    QUdpSocket *m_udp;
};

#endif // UDPSEVER_H

main.cpp

#include <QCoreApplication>
#include "udpsever.h"

int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);
    udpsever *server = new udpsever;
    return a.exec();
}

udpsever.cpp

#include "udpsever.h"
#include <QDebug>
#include <QByteArray>

udpsever::udpsever(QObject *parent) : QObject(parent)
{
    //创建套接字
    m_udp = new QUdpSocket();
    //服务器绑定电脑ip或端口
    m_udp->bind(QHostAddress("192.168.150.1"),10001);
    //接收数据
    connect(m_udp,&QUdpSocket::readyRead,this,&udpsever::recvdat);
}

udpsever::~udpsever()
{
    delete m_udp;
}

void udpsever::recvdat()
{
    QByteArray pa;
    if(m_udp->hasPendingDatagrams())//首先判断是否读到数据报。
    {
        pa.resize(m_udp->pendingDatagramSize());//设置字符数组的大小。
        m_udp->readDatagram(pa.data(),pa.size());//udp套接字读取数据报
        //打印pa的数据
        qDebug() << pa.data() << endl;
    }
}

6.UDP? 总结：
客户端部分：只要初始化套接字，然后利用函数writeDatagram 发送信息。

服务器部分： 初始化套接字，绑定IP? 和端口，? 然后利用函数QUdpSocket::readyRead（） 函数来判定是否有数据传输，激活槽函数输出数据。

7.TCP 数据的传输，

TCP 客户端的规则：

1.首先要规划号，连接的界面，ui->图片

2.类里面添加成员???QTcpSocket *m_tcp;//TCP 成员

?

?8. 构造函数的初始化数据

 m_tcp = new QTcpSocket(this);
    connect(m_tcp,&QTcpSocket::connected,this,&Widget::connect_slot);//连接成功，显示提示信息
    connect(m_tcp,&QTcpSocket::readyRead,this,&Widget::readdata);//当有readyRead信号时，客户端即可接收服务器数据。
//PushButton 是直接在ui设计界面定义槽函数，没有在这里使用 connect 连接

9.客户端的所有代码：

widget.h

#ifndef WIDGET_H
#define WIDGET_H

#include <QWidget>
#include <QTcpSocket>

namespace Ui {
class Widget;
}

class Widget : public QWidget
{
    Q_OBJECT

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

private slots:
    void on_connect_clicked();
    void connect_slot();
    void readdata();

    void on_disconnect_clicked();

    void on_send_clicked();

private:
    Ui::Widget *ui;
    QTcpSocket *m_tcp;
};

#endif // WIDGET_H

main.cpp

#include "widget.h"
#include <QApplication>

int main(int argc, char *argv[])
{
    QApplication a(argc, argv);
    Widget w;
    w.show();

    return a.exec();
}

widget.cpp

#include "widget.h"
#include "ui_widget.h"
#include <QHostAddress>

//1.创建TCP套接字对象
//2.连接服务器
//3.和服务器进行通讯
//4.断开连接。

Widget::Widget(QWidget *parent) :
    QWidget(parent),
    ui(new Ui::Widget)
{
    ui->setupUi(this);
    //1.创建TCP套接字对象
    m_tcp = new QTcpSocket(this);
    connect(m_tcp,&QTcpSocket::connected,this,&Widget::connect_slot);//连接成功，显示提示信息
    connect(m_tcp,&QTcpSocket::readyRead,this,&Widget::readdata);//当有readyRead信号时，客户端即可接收服务器数据。
}

Widget::~Widget()
{
    delete ui;
}
//2.连接服务器
void Widget::on_connect_clicked()
{
    QString ip = ui->ip->text();//IP
    unsigned short port = ui->port->text().toShort();//端口
    m_tcp->connectToHost(QHostAddress(ip),port);//客户端连接服务器
    ui->connect->setEnabled(false);//连接按钮失能   //就是这是由连接按钮是否还能被使用，命令使用过后，这个按键不能被使用了
    ui->disconnect->setEnabled(true);//断开按钮使能   //就是这是由断开按钮是否还能被使用，命令使用过后，这个按键能使用了
    ui->textBrowser->append("已经连接服务器ip:"+ip);
}

void Widget::connect_slot()
{
    ui->textBrowser->append("连接上服务器了");
}

void Widget::readdata()
{
    QString data = m_tcp->readAll();
    ui->textBrowser->append(QString("服务器说：") + data);
}

void Widget::on_disconnect_clicked()
{
    ui->textBrowser->append(QString("断开服务器了。。。"));
    m_tcp->close();
    ui->connect->setEnabled(true);   //就是这是由连接按钮是否还能被使用，命令使用过后，这个按键能使用了
    ui->disconnect->setEnabled(false);//就是这是由断开按钮是否还能被使用，命令使用过后，这个按键不能使用了 。
}

void Widget::on_send_clicked()
{
    QString data = ui->textEdit->toPlainText();
    m_tcp->write(data.toUtf8());//客户端向服务器发送数据
    ui->textBrowser->append(QString("客户端说：") + data);//显示记录
    ui->textEdit->clear();//清空发送文本框。
}

10.TCP服务器的数据传输。

1.首先做好界面 ，ui -> 图片

2.做好类里面的成员对象的定义

头文件

#include <QTcpServer>

#include <QTcpSocket>

成员：

QTcpServer *m_sever;//TCP服务器

QTcpSocket *m_tcp;//TCP的套接字

ui - >图片：

?11.TCP服务器的所有代码：

widget.h

#ifndef WIDGET_H
#define WIDGET_H

#include <QWidget>
#include <QTcpServer>
#include <QTcpSocket>

namespace Ui {
class Widget;
}

class Widget : public QWidget
{
    Q_OBJECT

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

private slots:
    void on_pushButton_clicked();
    void newclient();
    void readdata();

    void on_pushButton_2_clicked();
    void clientdisconnect();

private:
    Ui::Widget *ui;
    QTcpServer *m_sever;//TCP服务器
    QTcpSocket *m_tcp;//TCP的套接字
};

#endif // WIDGET_H

main.cpp

#include "widget.h"
#include <QApplication>

int main(int argc, char *argv[])
{
    QApplication a(argc, argv);
    Widget w;
    w.show();

    return a.exec();
}

widget.cpp

#include "widget.h"
#include "ui_widget.h"
#include<QDebug>

Widget::Widget(QWidget *parent) :
    QWidget(parent),
    ui(new Ui::Widget)
{
    ui->setupUi(this);
    //第一步，创建TCP服务器m_server对象
    m_sever = new QTcpServer(this);
}

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

void Widget::on_pushButton_clicked()
{
    qDebug()<<"运行了 服务器的监听";
//第二步：设置服务器监听
    //port保存要监听的端口
    unsigned short port = ui->lineEdit->text().toShort();
    //监听本电脑的所有ip地址和port端口。
    m_sever->listen(QHostAddress::Any,port);

//第三步：响应客户端的连接
    connect(m_sever,&QTcpServer::newConnection,this,&Widget::newclient);
}

void Widget::newclient()
{
//第四步：通过nextpendingconnection函数，获取服务端的socket对象。
    ui->textBrowser->append("客户端连接上了...");
    //m_tcp是服务器m_sever的子对象，当tcpsever对象被销毁的时候，它也会自动销毁。
    //但最好显示删除，避免浪费内存。注意无法从另一个线程使用返回的QTcpSocket对象。
    //如果希望使用来自另一个线程的传入连接，需要重写incoming connection()。
    m_tcp = m_sever->nextPendingConnection();

//第五步：数据的接收
    connect(m_tcp,&QTcpSocket::readyRead,this,&Widget::readdata);
    connect(m_tcp,&QTcpSocket::disconnected,this,&Widget::clientdisconnect);
}

void Widget::readdata()
{
    QString temp = m_tcp->readAll();//服务器套接字m_tcp接收的所有数据。
    if(!temp.isEmpty())
    {
        ui->textBrowser->append("客户端说："+temp);
    }
}

void Widget::on_pushButton_2_clicked()
{
   //发送数据
    QString sendmsg = ui->textEdit->toPlainText();
    //服务器的套接字m_tcp发送数据。
    m_tcp->write(sendmsg.toUtf8());
    if(!sendmsg.isEmpty())
    {
        ui->textBrowser->append("服务器说："+sendmsg);
    }
    //清空“发送数据框”
    ui->textEdit->clear();
}

void Widget::clientdisconnect()
{
    //客户端断开了连接
    ui->textBrowser->append("客户端断开了连接....");
    //套接字m_tcp关闭
    m_tcp->close();
}

12.PushButton? 怎么在ui 设计界面? 设置槽函数！

1.找到 PushButton? 按键? 右键? ?选择? 转到槽

2.选择的函数：

?

13.ui? 界面设置槽函数? ?在代码里面 槽函数的定义规则：

查看QT帮助手册、编译生成该文件的原因是 文件中有该函数

[static] void QMetaObject::connectSlotsByName(QObject *object)
给出的说明：递归搜索给定对象的所有子对象，并将来自这些子对象的匹配信号连接到以下形式的对象插槽：

void on__();
假设我们的对象有一个类型为QPushButton的子对象，对象名为button1。捕捉按钮的clicked（）信号的槽是：

void on_button1_clicked();
如果对象本身具有正确设置的对象名称，则其自身的信号也将连接到其各自的插槽。

综上所述，只要槽函数名规则是这样的：on_子对象名_信号名.

?