QT-基于TCP的网络通信

最新推荐文章于 2024-09-25 18:24:58 发布
最新推荐文章于 2024-09-25 18:24:58 发布
阅读量2.3k 收藏 3
点赞数 1
分类专栏： C++ 综合
C++ 同时被 2 个专栏收录
69 篇文章 0 订阅
订阅专栏
综合
29 篇文章 0 订阅
订阅专栏 
    Qt使用QtNetwork模块来进行网络编程，提供了一层统一的套接字抽象用于编写不同层次的网络程序，避免了应用套接字进行网络编的繁琐（因有时需引用底层操作系统的相关数据结构）。有较底层次的类如QTcpSocket、QTcpServer和QUdpSocket等来表示低层的网络概念；还有高层次的类如QNetworkRequest、QNetworkReply和QNetworkAccessManager使用相同的协议来执行网络操作；也提供了QNetworkConfiguration、QNetworkConfigurationManager和QNetworkSession等类来实现负载管理。

二、分析图
（1）网络通讯协议



（2）TCP和UDP客户端和服务器的创建流程



三、TCP
       TCP是一种可靠的、面向连接、面向数据流的传输协议，多数高层网络协议都使用TCP协议，包括HTTP和FTP，TCP协议非常适合数据的连续传输。QTcpSocket类为TCP提供了一个接口，继承自QAbstractSocket。TCP编程一般分为客户端和服务器端，即C/S（Client/Server）模型。
1、运行图


服务器监听8010端口，客户端连接。服务器端接收到连接及其信息的同时将信息发送给所有的客户端，客户端显示获得的信息。

2、代码
（1）TCP服务器端（完整代码在csdn上）


[cpp] view plain copy 在CODE上查看代码片派生到我的代码片
#include "tcpserver.h"  
#include <QApplication>  
  
  
int main( int argc, char **argv )  
{  
      
    QApplication a( argc, argv );  
    QTranslator translator(0);  
    translator.load("tcpserver_zh",".");  
    a.installTranslator(&translator);      
      
    TcpServer *tcpserver = new TcpServer();  
    tcpserver->show();  
    return a.exec();  
}  
[cpp] view plain copy 在CODE上查看代码片派生到我的代码片
#include "tcpserver.h"  
  
TcpServer::TcpServer( QWidget *parent, Qt::WindowFlags  f )  
    : QDialog( parent, f )  
{    
    QFont font("ZYSong18030",12);  
    setFont(font);  
          
    setWindowTitle(tr("TCP Server"));  
  
    QVBoxLayout *vbMain = new QVBoxLayout( this );  
  
    ListWidgetContent = new QListWidget( this);   
    vbMain->addWidget( ListWidgetContent );      
  
    QHBoxLayout *hb = new QHBoxLayout( );  
      
    LabelPort = new QLabel( this );  
    LabelPort->setText(tr("Port:"));  
    hb->addWidget( LabelPort );  
     
    LineEditPort = new QLineEdit(this);  
    hb->addWidget( LineEditPort );  
      
    vbMain->addLayout(hb);  
             
    PushButtonCreate = new QPushButton( this);  
    PushButtonCreate->setText( tr( "Create" ) );    
    vbMain->addWidget( PushButtonCreate );  
  
    connect(PushButtonCreate,SIGNAL(clicked()),this,SLOT(slotCreateServer()));    
  
    port = 8010;   
    LineEditPort->setText(QString::number(port));   
  
}  
  
TcpServer::~TcpServer()  
{  
}  
  
void TcpServer::slotCreateServer()                       
{           
    server = new Server(this,port);   
    connect(server,SIGNAL(updateServer(QString,int)),this,SLOT(updateServer(QString,int)));  
  
    PushButtonCreate->setEnabled(false);  
}  
  
void TcpServer::updateServer(QString msg,int length)  
{  
    ListWidgetContent->addItem (msg.left(length) );  
}  
[cpp] view plain copy 在CODE上查看代码片派生到我的代码片
#include <QtNetwork>  
  
  
#include "server.h"  
  
Server::Server(QObject *parent,int port)  
    : QTcpServer(parent)  
{  
    listen(QHostAddress::Any,port);  
}  
  
void Server::incomingConnection(int socketDescriptor)  
{  
    TcpClientSocket *tcpClientSocket = new TcpClientSocket(this);  
    connect(tcpClientSocket,SIGNAL(updateClients(QString,int)),this,SLOT(updateClients(QString,int)));  
    connect(tcpClientSocket,SIGNAL(disconnected(int)),this,SLOT(slotDisconnected(int)));  
      
    tcpClientSocket->setSocketDescriptor(socketDescriptor);  
  
    tcpClientSocketList.append(tcpClientSocket);  
  
}  
  
void Server::updateClients(QString msg,int length)  
{  
    emit updateServer(msg,length);  
  
    for(int i=0;i<tcpClientSocketList.count();i++)  
    {  
        QTcpSocket *item=tcpClientSocketList.at(i);  
        if(item->write(msg.toLatin1(), length)!=length)  
        {  
            continue ;  
        }     
    }  
}  
  
void Server::slotDisconnected(int descriptor)  
{  
    for(int i=0;i<tcpClientSocketList.count();i++)  
    {  
        QTcpSocket *item=tcpClientSocketList.at(i);  
        if(item->socketDescriptor ()==descriptor)  
        {  
            tcpClientSocketList.removeAt(i);  
            return;  
        }     
    }     
    return;  
}  
[cpp] view plain copy 在CODE上查看代码片派生到我的代码片
#include "tcpserver.h"  
  
TcpClientSocket::TcpClientSocket( QObject *parent)  
{    
    connect(this, SIGNAL(readyRead()),this, SLOT(dataReceived()));     
    connect(this, SIGNAL(disconnected()),this, SLOT(slotDisconnected()));  
}  
  
TcpClientSocket::~TcpClientSocket()  
{  
}  
                                                                               
void TcpClientSocket::dataReceived()  
{  
    while (bytesAvailable()>0)   
    {  
        char buf[1024];  
        int length=bytesAvailable();  
        read(buf, length);  
  
        QString msg=buf;  
          
        emit updateClients(msg,length);  
    }     
}  
  
void TcpClientSocket::slotDisconnected()  
{  
    emit disconnected(this->socketDescriptor ());  
}  
（2）TCP客户端

[cpp] view plain copy 在CODE上查看代码片派生到我的代码片
#include "tcpclient.h"  
  
TcpClient::TcpClient( QWidget *parent, Qt::WindowFlags  f )  
    : QDialog( parent, f )  
{    
    QFont font("ZYSong18030",12, QFont::Normal);  
    setFont(font);  
          
    setWindowTitle(tr("TCP Client"));  
  
    QVBoxLayout *vbMain = new QVBoxLayout( this );  
      
    ListWidgetContent = new QListWidget( this);   
    vbMain->addWidget( ListWidgetContent );   
      
    QHBoxLayout *hb1 = new QHBoxLayout( );  
        
    LineEditSend = new QLineEdit(this);  
    hb1->addWidget( LineEditSend );    
  
    PushButtonSend = new QPushButton( this);  
    PushButtonSend->setText( tr( "Send" ) );    
    hb1->addWidget( PushButtonSend );  
  
    vbMain->addLayout( hb1 );  
  
    QHBoxLayout *hb2 = new QHBoxLayout( );  
  
    LabelUser = new QLabel( this );  
    LabelUser->setText(tr("User Name:"));  
    hb2->addWidget( LabelUser );  
     
    LineEditUser = new QLineEdit(this);  
    hb2->addWidget( LineEditUser );  
  
    QHBoxLayout *hb3 = new QHBoxLayout( );  
  
    LabelServerIP = new QLabel( this );  
    LabelServerIP->setText(tr("Server:"));  
    hb3->addWidget( LabelServerIP );  
     
    LineEditServerIP = new QLineEdit(this);  
    hb3->addWidget( LineEditServerIP );  
      
    QHBoxLayout *hb4 = new QHBoxLayout( );  
      
    LabelPort = new QLabel( this );  
    LabelPort->setText(tr("Port:"));  
    hb4->addWidget( LabelPort );  
     
    LineEditPort = new QLineEdit(this);  
    hb4->addWidget( LineEditPort );  
      
    vbMain->addLayout(hb2);  
    vbMain->addLayout(hb3);  
    vbMain->addLayout(hb4);  
             
    PushButtonEnter = new QPushButton( this);  
    PushButtonEnter->setText( tr( "Enter" ) );    
    vbMain->addWidget( PushButtonEnter );  
  
    connect(PushButtonEnter,SIGNAL(clicked()),this,SLOT(slotEnter()));  
    connect(PushButtonSend,SIGNAL(clicked()),this,SLOT(slotSend()));      
  
    serverIP = new QHostAddress();  
    port = 8010;   
    LineEditPort->setText(QString::number(port));   
      
    status=false;  
      
    PushButtonSend->setEnabled( false );   
}  
  
TcpClient::~TcpClient()  
{  
}  
                                                                               
void TcpClient::slotEnter()                       
{           
    if(!status)  
    {  
        QString ip=LineEditServerIP->text();  
        if(!serverIP->setAddress(ip))  
        {  
            QMessageBox::information(this,tr("error"),tr("server ip address error!"));  
            return;  
        }  
        if(LineEditUser->text()=="")  
        {  
            QMessageBox::information(this,tr("error"),tr("User name error!"));  
            return ;  
        }     
        userName=LineEditUser->text();  
        tcpSocket = new QTcpSocket(this);  
        connect(tcpSocket,SIGNAL(connected()),this,SLOT(slotConnected()));  
        connect(tcpSocket,SIGNAL(disconnected()),this,SLOT(slotDisconnected()));  
        connect(tcpSocket, SIGNAL(readyRead()),this, SLOT(dataReceived()));  
          
        tcpSocket->connectToHost ( *serverIP, port);  
          
        status=true;  
    }  
    else  
    {  
        int length = 0;   
          
        QString msg=userName+tr(":Leave Chat Room");  
        if((length=tcpSocket->write(msg.toLatin1(),msg.length()))!=msg.length())  
        {  
            return ;  
        }             
        tcpSocket->disconnectFromHost();  
          
        status=false;  
    }  
      
}  
  
void TcpClient::slotConnected()                       
{  
    int length = 0;   
    PushButtonSend->setEnabled( true );  
    PushButtonEnter->setText(tr("Leave"));  
    QString msg=userName+tr(":Enter Chat Room");  
    if((length=tcpSocket->write(msg.toLatin1(),msg.length()))!=msg.length())  
    {  
        return ;  
    }     
}  
  
void TcpClient::slotDisconnected()                       
{  
    PushButtonSend->setEnabled( false );  
    PushButtonEnter->setText(tr("Enter"));  
}  
  
void TcpClient::slotSend()                       
{           
    if(LineEditSend->text()=="")  
    {  
        return ;  
    }  
      
    QString msg=userName+":"+LineEditSend->text();  
      
    tcpSocket->write(msg.toLatin1(),msg.length());  
    LineEditSend->clear();  
}  
  
void TcpClient::dataReceived()  
{  
    while (tcpSocket->bytesAvailable()>0)   
    {  
        QByteArray datagram;  
        datagram.resize(tcpSocket->bytesAvailable());  
        QHostAddress sender;  
  
  
        tcpSocket->read(datagram.data(), datagram.size());  
  
        QString msg=datagram.data();  
      
        ListWidgetContent->addItem (msg.left(datagram.size()));  
    }  
  
}  
3、其他TCP服务器和客户端代码
（1）TCP服务器——基本模式

[cpp] view plain copy 在CODE上查看代码片派生到我的代码片
#ifndef SERVER_H  
#define SERVER_H  
  
#include <QObject>  
#include <QTcpServer>  
  
class server : public QObject  
{  
    Q_OBJECT  
public:  
    explicit server(QObject *parent = 0);  
  
private:  
    QTcpServer *tcpServer;  
    QTcpSocket *clientConnection;  
  
signals:  
  
public slots:  
    void sendMessage();  
    void on_Ready_Read();  
};  
  
#endif // SERVER_H  
[cpp] view plain copy 在CODE上查看代码片派生到我的代码片
#include <QTcpSocket>  
#include "server.h"  
  
  
server::server(QObject *parent) :  
    QObject(parent)  
{  
    tcpServer = new QTcpServer(this);  
    // 使用了IPv4的本地主机地址，等价于QHostAddress("127.0.0.1")  
    if (!tcpServer->listen(QHostAddress::Any, 59769)) {  
        qDebug() << tcpServer->errorString();  
    }  
    connect(tcpServer, SIGNAL(newConnection()), this, SLOT(sendMessage()));  
}  
  
void server::sendMessage()  
{  
    clientConnection = tcpServer->nextPendingConnection();  
    clientConnection->write("hello client\r\n");  
    clientConnection->flush();     
    clientConnection->waitForBytesWritten(3000);  
    connect(clientConnection, SIGNAL(readyRead()), this, SLOT(on_Ready_Read()));   
    connect(clientConnection, SIGNAL(disconnected()), clientConnection, SLOT(deleteLater()));  
}  
void server::on_Ready_Read()  
{   
    QByteArray block = clientConnection->readAll();   
    qDebug() << "server = " << block;   
    QString commandXml = QString("<event>" " <object>USER</object>" " <action>LOGINSUCCESS</action>" " <data>" " </data>" "</event>");   
    QByteArray data = commandXml.toUtf8();   
    QString str = QString("%1:%2,").arg(data.size()).arg(QString::fromUtf8(data));   
    clientConnection->write(str.toUtf8()); clientConnection->disconnectFromHost();  
}  
（2）TCP服务器——线程处理


[cpp] view plain copy 在CODE上查看代码片派生到我的代码片
#ifndef MYSERVER_H  
#define MYSERVER_H  
  
#include <QTcpServer>  
#include <QDebug>  
#include "mythread.h"  
  
class MyServer : public QTcpServer  
{  
    Q_OBJECT  
public:  
    explicit MyServer(QObject *parent = 0);  
    void StartServer();  
  
protected:  
    void incomingConnection(int  socketDescriptor);  
signals:  
  
public slots:  
  
};  
  
#endif // MYSERVER_H  
[cpp] view plain copy 在CODE上查看代码片派生到我的代码片
#ifndef MYTHREAD_H  
#define MYTHREAD_H  
  
#include <QThread>  
#include <QTcpSocket>  
#include <QDebug>  
  
class MyThread : public QThread  
{  
    Q_OBJECT  
public:  
    explicit MyThread(int ID, QObject *parent = 0);  
    void run();  
  
signals:  
    void error(QTcpSocket::SocketError socketerror);  
  
public slots:  
    void readyRead();  
    void disconnected();  
  
private:  
    QTcpSocket *socket;  
    int socketDescriptor;  
  
};  
#endif // MYTHREAD_H  
[cpp] view plain copy 在CODE上查看代码片派生到我的代码片
#include <QCoreApplication>  
#include "myserver.h"  
  
int main(int argc, char *argv[])  
{  
    QCoreApplication a(argc, argv);  
    MyServer server;  
    server.StartServer();  
  
    return a.exec();  
}  
[cpp] view plain copy 在CODE上查看代码片派生到我的代码片
#include "myserver.h"  
  
MyServer::MyServer(QObject *parent) :  
    QTcpServer(parent)  
{  
}  
  
void MyServer::StartServer()  
{  
    if (!listen(QHostAddress::Any, 1234)) {  
        qDebug() << "Could not start server";  
    }  
    else {  
        qDebug() << "Listening...";  
    }  
}  
  
void MyServer::incomingConnection(int socketDescriptor)  
{  
    qDebug() << socketDescriptor << ":connecting...";  
    MyThread *thread = new MyThread(socketDescriptor, this);  
    connect(thread, SIGNAL(finished()), this, SLOT(deleteLater()));  
    thread->start();  
}  
[cpp] view plain copy 在CODE上查看代码片派生到我的代码片
#include "mythread.h"  
  
MyThread::MyThread(int ID, QObject *parent) :  
    QThread(parent)  
{  
    socketDescriptor = ID;  
}  
  
  
void MyThread::run()  
{  
   //thread starts here  
    qDebug() << socketDescriptor << ":starting thread";  
    socket = new QTcpSocket;  
    if (!socket->setSocketDescriptor(socketDescriptor)) {  
        emit error(socket->error());  
        return;  
    }  
    connect(socket, SIGNAL(readyRead()), this, SLOT(readyRead()), Qt::DirectConnection);  
    connect(socket, SIGNAL(disconnected()), this, SLOT(disconnected()), Qt::DirectConnection);  
    qDebug() << socketDescriptor << ":client connected!";  
    exec();  
}  
void MyThread::readyRead()  
{  
    QByteArray Data = socket->readAll();  
    qDebug() << socketDescriptor << ":Data in:" << Data;  
    socket->write(Data);  
}  
void MyThread::disconnected()  
{  
    qDebug() << socketDescriptor << ":Disconnected!";  
    socket->deleteLater();  
    exit(0);  
}  
（3）TCP服务器——线程池


[cpp] view plain copy 在CODE上查看代码片派生到我的代码片
#ifndef MYSERVER_H  
#define MYSERVER_H  
  
#include <QTcpServer>  
#include <QThreadPool>  
#include <QDebug>  
#include "myrunnable.h"  
  
class MyServer : public QTcpServer  
{  
    Q_OBJECT  
public:  
    explicit MyServer(QObject *parent = 0);  
    void StartServer();  
  
protected:  
    void incomingConnection(int handle);  
  
private:  
    QThreadPool *pool;  
  
signals:  
  
public slots:  
  
};  
  
#endif // MYSERVER_H  
[cpp] view plain copy 在CODE上查看代码片派生到我的代码片
#ifndef MYRUNNABLE_H  
#define MYRUNNABLE_H  
  
#include <QRunnable>  
#include <QTcpSocket>  
#include <QDebug>  
  
class MyRunnable : public QRunnable  
{  
public:  
    MyRunnable();  
    int SocketDescriptor;  
  
protected:  
    void run();  
};  
  
#endif // MYRUNNABLE_H  
[cpp] view plain copy 在CODE上查看代码片派生到我的代码片
#include "myserver.h"  
  
MyServer::MyServer(QObject *parent) :  
    QTcpServer(parent)  
{  
    pool = new QThreadPool(this);  
    pool->setMaxThreadCount(5);  
}  
void MyServer::StartServer()  
{  
    if (listen(QHostAddress::Any, 1234)) {  
        qDebug() << "Server started!";  
    }  
    else {  
        qDebug() << "Server did not start!";  
    }  
}  
void MyServer::incomingConnection(int handle)  
{  
    MyRunnable *task = new MyRunnable();  
    task->setAutoDelete(true);  
    task->SocketDescriptor = handle;  
    pool->start(task);  
}  
[cpp] view plain copy 在CODE上查看代码片派生到我的代码片
#include "myrunnable.h"  
  
MyRunnable::MyRunnable()  
{  
}  
  
void MyRunnable::run()  
{  
    if (!SocketDescriptor)  return;  
  
    QTcpSocket socket;  
    socket.setSocketDescriptor(SocketDescriptor);  
  
    socket.write("hello world\r\n");  
    socket.flush();  
    socket.waitForBytesWritten();  
    socket.close();  
}  
[cpp] view plain copy 在CODE上查看代码片派生到我的代码片
#include <QCoreApplication>  
#include "myserver.h"  
  
int main(int argc, char *argv[])  
{  
    QCoreApplication a(argc, argv);  
    MyServer Server;  
    Server.StartServer();  
    return a.exec();  
}  
（4）TCP服务器——高级异步方式并使用线程池

尽可能理解这种方式，效率相对比较客观。运行结果：




[cpp] view plain copy 在CODE上查看代码片派生到我的代码片
#ifndef MYSERVER_H  
#define MYSERVER_H  
  
#include <QTcpServer>  
#include <QTcpSocket>  
#include <QAbstractSocket>  
#include "myclient.h"  
  
class MyServer : public QTcpServer  
{  
    Q_OBJECT  
public:  
    explicit MyServer(QObject *parent = 0);  
    void StartServer();  
  
protected:  
    void incomingConnection(int handle);  
  
signals:  
  
public slots:  
  
};  
  
#endif // MYSERVER_H  
[cpp] view plain copy 在CODE上查看代码片派生到我的代码片
#ifndef MYCLIENT_H  
#define MYCLIENT_H  
  
#include <QObject>  
#include <QTcpSocket>  
#include <QDebug>  
#include <QThreadPool>  
#include "mytask.h"  
  
class MyClient : public QObject  
{  
    Q_OBJECT  
public:  
    explicit MyClient(QObject *parent = 0);  
    void SetSocket(int Descriptor);  
  
signals:  
  
public slots:  
    void connected();  
    void disconnected();  
    void readyRead();  
    void TaskResult(int Number);  
  
private:  
    QTcpSocket *socket;  
};  
  
#endif // MYCLIENT_H  
[cpp] view plain copy 在CODE上查看代码片派生到我的代码片
#ifndef MYTASK_H  
#define MYTASK_H  
  
#include <QRunnable>  
#include <QDebug>  
  
class MyTask : public QObject, public QRunnable  
{  
    Q_OBJECT  
public:  
    MyTask();  
  
signals:  
    void Result(int Number);  
  
protected:  
    void run();  
};  
  
#endif // MYTASK_H  
[cpp] view plain copy 在CODE上查看代码片派生到我的代码片
#include "myserver.h"  
  
MyServer::MyServer(QObject *parent) :  
    QTcpServer(parent)  
{  
}  
void MyServer::StartServer()  
{  
    if (listen(QHostAddress::Any, 1234)) {  
        qDebug() << "Server started!";  
    }  
    else {  
        qDebug() << "Server did not start!";  
    }  
}  
  
void MyServer::incomingConnection(int handle)  
{  
    MyClient *client = new MyClient(this);  
    client->SetSocket(handle);  
}  
[cpp] view plain copy 在CODE上查看代码片派生到我的代码片
#include "myclient.h"  
  
MyClient::MyClient(QObject *parent) :  
    QObject(parent)  
{  
    QThreadPool::globalInstance()->setMaxThreadCount(15);  
}  
  
void MyClient::SetSocket(int Descriptor)  
{  
    socket = new QTcpSocket(this);  
  
    connect(socket, SIGNAL(connected()), this, SLOT(connected()));  
    connect(socket, SIGNAL(disconnected()), this, SLOT(disconnected()));  
    connect(socket, SIGNAL(readyRead()), this, SLOT(readyRead()));  
  
    socket->setSocketDescriptor(Descriptor);  
    qDebug() << "client connected";  
}  
  
void MyClient::connected()  
{  
    qDebug() << "client connected event";  
}  
  
void MyClient::disconnected()  
{  
    qDebug() << "client disconnected";  
}  
  
void MyClient::readyRead()  
{  
    qDebug() << socket->readAll();  
    //Time Consumer  
    MyTask *mytask = new MyTask;  
    mytask->setAutoDelete(true);  
    connect(mytask, SIGNAL(Result(int)), this, SLOT(TaskResult(int)));  
    QThreadPool::globalInstance()->start(mytask);  
}  
  
void MyClient::TaskResult(int Number)  
{  
    //right here  
    QByteArray Buffer;  
    Buffer.append("\r\nTask Result = ");  
    Buffer.append(QString::number(Number));  
  
    socket->write(Buffer);  
}  
[cpp] view plain copy 在CODE上查看代码片派生到我的代码片
#include "mytask.h"  
  
MyTask::MyTask()  
{  
}  
  
void MyTask::run()  
{  
    //time consumer  
    qDebug() << "Task Start";  
    int iNumber = 0;  
    for (int i = 0; i < 100; i++) {  
        iNumber += i;  
    }  
    qDebug() << "Task Done";  
  
    emit Result(iNumber);  
}  

[cpp] view plain copy 在CODE上查看代码片派生到我的代码片
#include <QCoreApplication>  
#include "myserver.h"  
  
int main(int argc, char *argv[])  
{  
    QCoreApplication a(argc, argv);  
    MyServer Server;  
    Server.StartServer();  
  
    return a.exec();  
}  
（5）TCP客户端——异步等待


[cpp] view plain copy 在CODE上查看代码片派生到我的代码片
#ifndef SOCKETTEST_H  
#define SOCKETTEST_H  
  
#include <QObject>  
#include <QTcpSocket>  
  
class SocketTest : public QObject  
{  
    Q_OBJECT  
public:  
    explicit SocketTest(QObject *parent = 0);  
    void Connect();  
  
private:  
    QTcpSocket *socket;  
  
signals:  
  
public slots:  
  
};  
  
#endif // SOCKETTEST_H  
[cpp] view plain copy 在CODE上查看代码片派生到我的代码片
#include "sockettest.h"  
  
SocketTest::SocketTest(QObject *parent) :  
    QObject(parent)  
{  
}  
  
void SocketTest::Connect()  
{  
    socket = new QTcpSocket(this);  
    socket->connectToHost("203.116.165.138", 80);  
  
    if (socket->waitForConnected(3000)) {  
        qDebug() << "connected!";  
  
        //send  
        socket->write("hello server\r\n\r\n\r\n");  
        socket->waitForBytesWritten(1000);  
        socket->waitForReadyRead(3000);  
        qDebug() << "Reading:" << socket->bytesAvailable();  
  
        qDebug() << socket->readAll();  
  
        socket->close();  
    }  
    else {  
        qDebug() << "not connected!";  
    }  
}  
（6）TCP客户端——信号槽连接
[cpp] view plain copy 在CODE上查看代码片派生到我的代码片
#include <QCoreApplication>  
#include <QTextCodec>  
#include "sockettest.h"  
  
int main(int argc, char *argv[])  
{  
    QCoreApplication a(argc, argv);  
    QTextCodec *codec = QTextCodec::codecForName("System");  
    QTextCodec::setCodecForLocale(codec);  
    QTextCodec::setCodecForCStrings(codec);  
    QTextCodec::setCodecForTr(codec);  
    SocketTest mTest;  
    mTest.Test();  
    return a.exec();  
}  
[cpp] view plain copy 在CODE上查看代码片派生到我的代码片
#ifndef SOCKETTEST_H  
#define SOCKETTEST_H  
  
#include <QObject>  
#include <QDebug>  
#include <QTcpSocket>  
#include <QAbstractSocket>  
  
class SocketTest : public QObject  
{  
    Q_OBJECT  
public:  
    explicit SocketTest(QObject *parent = 0);  
    void Test();  
  
private:  
    QTcpSocket *socket;  
  
signals:  
  
public slots:  
    void connected();  
    void disconnected();  
    void bytesWritten(qint64 bytes);  
    void readyRead();  
    void displayError(QAbstractSocket::SocketError);  
};  
  
#endif // SOCKETTEST_H  
[cpp] view plain copy 在CODE上查看代码片派生到我的代码片
#include "sockettest.h"  
  
SocketTest::SocketTest(QObject *parent) :  
    QObject(parent)  
{  
}  
  
void SocketTest::Test()  
{  
    socket = new QTcpSocket(this);  
    connect(socket, SIGNAL(connected()), this, SLOT(connected()));  
    connect(socket, SIGNAL(disconnected()), this, SLOT(disconnected()));  
    connect(socket, SIGNAL(bytesWritten(qint64)), this, SLOT(bytesWritten(qint64)));  
    connect(socket, SIGNAL(readyRead()), this, SLOT(readyRead()));  
    connect(socket, SIGNAL(error(QAbstractSocket::SocketError)), this, SLOT(displayError(QAbstractSocket::SocketError)));  
  
    qDebug() << "connecting...";  
    socket->connectToHost("203.116.165.139", 80);  
  
    if (!socket->waitForConnected(1000)) {  
        qDebug() << "Error:" << socket->errorString();  
    }  
}  
  
void SocketTest::connected()  
{  
    qDebug() << "connected!";  
    socket->write("HEAD / HTTP/1.0\r\n\r\n\r\n");  
}  
  
void SocketTest::disconnected()  
{  
    qDebug() << "disconnected!";  
    socket->disconnectFromHost();  
}  
  
void SocketTest::bytesWritten(qint64 bytes)  
{  
    qDebug() << "we wrote:" << bytes;  
}  
  
void SocketTest::readyRead()  
{  
    qDebug() << "reading...";  
    qDebug() << socket->readAll();  
}  
void SocketTest::displayError(QAbstractSocket::SocketError)  
{  
    qDebug() << socket->errorString();  
}

Qt网络通讯
11-12
Qt最早是在1991年由奇趣科技开发的，1996年进入商业领域，成为全世界范围内数千种成功的应用程序的基础。它也是目前流行的Linux桌面环境KDE的基础，KDE是Linux发行版的主要一个标准组件。2008年，奇趣科技被诺基亚公司收购，Qt成为诺基亚旗下的编程语言工具。2012年，Qt又被Digia公司收购。2014年，Digia宣布成立“The Qt Company”全资子公司，以进一步推动Qt产品的开发和市场扩张。
Qt5网络与通信
01-06
在应用程序开发中网络编程非常重要，目前互联网通信的TCP/IP协议，自上而下分为应用层、传输层、网际层和网络接口层这四层。实际编写网络应用程序时只使用到传输层和应用层，所涉及的协议主要包括UDP、TCP、FTP和HTTP等。
使用QT编写有图形界面的TCP局域网聊天室（app）
sjrhsk_hahaha的博客
09-11 783
1.使用QTcpServer类实例化一个对象，就得到了一个服务器端 2.调用该类对象的成员函数 listen 将服务器启动监听，该函数会进行绑定ip和端口号 ip地址可以指定也可以由系统自动绑定，端口号也可以自己指定和由系统自动指定 3.当有客户端发来连接请求后，该服务器就会自动发射一个newConnection的信号 我们可以将该信号绑定到自定义的槽函数中完成相关逻辑 4.可以使用类中的成员函数 nextPenddingConnection 可以获取最新连接的客户端套接字 5.可以使用该客
QT网络通信之TCP
最新发布
2403_84724114的博客
09-25 452
TCP(transmission control protocol)全称是传输控制协议，是一种面向连接的、可靠的、基于字节流的传输层的通信协议。
qt以太网通信
weixin_43829023的博客
01-06 3195
myudp.h #ifndef MYUDP_H #define MYUDP_H #include <WinSock2.h> #include #include #include #include typedef QVector v_chars; /* char 型容器 (可变长度char 数组)/ typedef QSharedPointer<v_chars>v_chars_ptr; / char 型容器的智能指针封装 */ cla.
QT5 网络通讯
weixin_30764137的博客
01-26 392
QT5 TCP网络通讯 服务器与客户端建立连接listen() - connectToHost(); 触发newPendingConnect信号 实时数据通讯write(); read(); 触发readyRead信号 通讯主要使用的类: QTcpServer Class QTcpSe...
Qt 网络通信
cosx_的博客
11-26 1194
Server。
QT-TCP通信-服务端与多客户端通信
06-25
在"QT-TCP通信-服务端与多客户端通信"这一主题中，我们主要探讨的是如何使用QT库中的QTCPSocket类来实现基于TCP的网络通信。以下是一些关键的知识点： 1. **QT的网络模块**：QT库提供了一整套网络编程接口，包括...
Qt教程11Qt网络通信TCP-qt简单实现聊天qq
04-02
资源详细介绍，见博客【Qt教程11】Qt网络通信TCP——qt简单实现聊天qqhttps://zhengjunxue.blog.csdn.net/article/details/137273401 - 使用Qt提供的类进行基于TCP的套接字通信需要用到两个类： - QTcpServer：...
qt 中 多线程tcp通信
10-13
在Qt框架下实现多线程TCP通信是一种常见且高效的方法，尤其在处理实时性要求高、数据量大的...以上就是基于Qt实现多线程TCP通信的主要内容，它提供了一种有效的方法来处理复杂的网络应用，确保了系统的稳定性和性能。
基于Qt的TCP网络调试助手
06-18
综上所述，"基于Qt的TCP网络调试助手"是一个利用Qt的网络功能和多线程技术实现的实用工具，对于理解和测试TCP网络通信具有很高的价值。通过这个工具，开发者可以更便捷地调试和优化他们的网络应用程序，提高代码的...
qt_net_test_qt以太网通讯_QT以太网通讯程序_Qt以太网_
09-28
使用QT编写的以太网通讯程序，非常适合不了解QT怎么编写网络的朋友使用
qt 编写的网络通信 超详细
12-14
qt 最基础 最详细的 qt 编写的网络通信 超详细 源代码 很适合基础薄弱的下载，学习这个之后你会对qt有很大的了解 手把手的 教会你qt 编写的网络通信
qt简单网络通讯（客户端和服务端）
09-05
服务端自动获取本机IP并自动设置，客户端发送信息，服务端能显示客户端Ip
TCP通信Qt源码
12-07
tcp通信Qt源码，客户端和服务器融合，可发文件和可发消息，
qt-client-server：服务器和客户端之间通过TCP进行的网络通信
02-05
本项目“qt-client-server”就是一个典型的示例，它展示了如何使用Qt库中的组件来构建一个基于TCP协议的服务器和客户端应用。下面将详细阐述相关知识点。 1. **Qt库**：Qt是一个跨平台的C++图形用户界面应用程序...
qt_网络通信
zylg
12-16 249
QHostInfo 主要是自身名称，ip信息 函数 作用 QList addresses() const 得到地址 QString errorString() const 错误原因 QString hostName() const 主机名称 QString localDomainName() 域 QString localHostName() 名 int loo...
Qt中的网络通信
随缘写随缘更新
04-06 964
C++没有封装专门的网络套接字的类，因此C++只能调用C对应的API，而在Linux和Windows环境下的API都是不一样的Qt作为一个C++框架提供了相关封装好的套接字通信类。
qt-stm32 网络通信 控制外设开关
04-30
Qt-stm32是基于Qt框架和stm32芯片的开发平台。网络通信方面，Qt-stm32支持多种通信协议，例如TCP、UDP、MQTT等。这些协议可以让Qt-stm32与其他设备进行通信，实现数据传输。我们可以利用Qt-stm32的网络通信功能，例如在客户端与服务器之间传输数据或实现远程控制。 在控制外设开关方面，Qt-stm32可以利用GPIO口控制外设的开关。我们可以通过Qt-stm32的GPIO口控制外设的状态，例如打开或关闭LED灯、继电器等。同时，Qt-stm32还支持多种外设的驱动库，像适配数字IO口外设的SIP接口、SPI接口、I2C接口等。这些接口可以让Qt-stm32控制外设，读取外设状态、控制外设状态，实现对外设的精确控制。 综上所述，Qt-stm32平台具有丰富的网络通信和控制外设开关的功能，能够满足多种应用场景的需求，例如智能家居、远程监测等。随着物联网技术的发展，Qt-stm32平台的应用前景广阔。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值