Qt bidirectionnel client-serveur à l'aide de QTcpSocket et QTcpServer

Je suis en train de mettre en œuvre une bidirectionnel programme client-serveur, où les clients et les serveurs peuvent passer d'objets sérialisés entre l'un de l'autre. Je suis en train de faire cela à l'aide de Qt (QTcpSocket et QTcpServer). J'ai mis en œuvre de tels programmes en java, mais je ne peux pas comprendre comment le faire en utilisant Qt. J'ai vérifié le la fortune du client et fortune serveur exemples...mais de ce que je peux voir, le client est tout simplement de signalisation le serveur, et le serveur envoie des données. J'ai besoin pour le client et le serveur pour envoyer les objets d'avant en arrière. Je ne suis pas à la recherche d'une solution complète, tout ce que je cherche, c'est une certaine orientation dans la bonne direction.

J'ai écrit du code, qui accepte une connexion, mais ne pas accepter les données.

SERVEUR

cette classe est le serveur; il devrait accepter une connexion et à la sortie de la taille de la mémoire tampon qui est envoyé. Cependant, il est sortie 0

#include "comms.h"

Comms::Comms(QString hostIP, quint16 hostPort)
{
    server = new QTcpServer(this);
    hostAddress.setAddress(hostIP);
    this->hostPort = hostPort;


}

void Comms::attemptConnection(){
    connect(server, SIGNAL(newConnection()), this, SLOT(connectionAccepted()));
    //socket = server->nextPendingConnection();
    server->listen(hostAddress,hostPort);
    //receivedData = socket->readAll();
}

void Comms::connectionAccepted(){
    qDebug()<<"Connected";
    socket = new QTcpSocket(server->nextPendingConnection());

    char* rec = new char[socket->readBufferSize()];
    qDebug()<<socket->readBufferSize();
}

CLIENT

Cette classe est la classe client. Il convient de l'envoi de la chaîne de caractères "bonjour". Il l'envoie avec succès (à ma connaissance)

#include "toplevelcomms.h"
#include "stdio.h"

TopLevelComms::TopLevelComms(QString hostIP, quint16 hostPort)
{
    tcpSocket = new QTcpSocket();
    hostAddress.setAddress(hostIP);
    this->hostPort = hostPort;
}


void TopLevelComms::connect(){
    tcpSocket->connectToHost(hostAddress,hostPort,QIODevice::ReadWrite);
    //tcpSocket->waitForConnected(1);

    QString string = "Hello";
    QByteArray array;
    array.append(string);
    qDebug()<<tcpSocket->write(array);
}

S'il vous plaît dites-moi ce que je fais mal, ou me dire la logique générale de l'établissement de ce que je veux dans Qt.

OriginalL'auteur PTBG | 2012-01-18

  1. 10

    QTcpSocket est asynchrone par défaut, de sorte que lorsque vous appelez connectToHost et écrire dans le même contexte, il ne sera pas envoyé, comme le socket n'est pas connecté. Vous devriez changer votre "client" code:

    void TopLevelComms::connect(){
    tcpSocket->connectToHost(hostAddress,hostPort,QIODevice::ReadWrite);
    if(tcpSocket->waitForConnected()) //putting 1 as parameter isn't reasonable, using default 3000ms value
    {
        QString string = "Hello";
        QByteArray array;
        array.append(string);
        qDebug()<<tcpSocket->write(array);
    }
    else
    {
        qDebug() << "couldn't connect";
    }
}

    Remarque: vous aussi n'a pas vérifier si vous êtes en mesure d'écouter

    void Comms::attemptConnection(){
    connect(server, SIGNAL(newConnection()), this, SLOT(connectionAccepted()));
    //socket = server->nextPendingConnection();

    if(server->listen(hostAddress,hostPort))
    {
        qDebug() << "Server listening";
    }
    else
    {
        qDebug() << "Couldn't listen to port" << server->serverPort() << ":" << server->errorString();
    }
    //receivedData = socket->readAll();
}

    Et dernière chose. Notez que QTcpServer::nextPendingConnection() retour QTcpSocket, donc au lieu de prendre cette nouvelle connexion que vous créer de nouveaux QTcpSocket avec nextPendingConnection en tant que parent

    void Comms::connectionAccepted(){
    qDebug()<<"Connected";
    //WRONG! it will use QTcpSocket::QTcpSocket(QObject * parent)
    //socket = new QTcpSocket(server->nextPendingConnection());
    //use simple asign
    socket = server->nextPendingConnection();
    //move reading to slot
    connect(socket, SIGNAL(readyRead()), this, SLOT(readSocket()));
}

    maintenant, nous allons passer de la lecture à séparer fente

    void Comms::readSocket()
{
    //note that dynamic size array is incompatible with some compilers
    //we will use Qt data structure for that
    //char* rec = new char[socket->readBufferSize()];
    qDebug()<<socket->readBufferSize();
    //note that QByteArray can be casted to char * and const char *
    QByteArray data = socket->readAll();
}

    Je dois bien avouer que c'est beaucoup d'erreurs pour un tel petit exemple de code. Vous avez besoin d'acquérir des connaissances sur les connexions TCP/IP. Ceux sont des cours d'eau et il n'y a aucune garantie que l'ensemble des données de morceau aurez à vous à la fois

    Merci beaucoup, j'ai été en mesure d'envoyer des données sur le support. Cependant, je suis encore en train de la taille du tampon de 0 pour une raison quelconque. Aucune idée pourquoi?
    À partir de la documentation "Une taille de tampon de lecture de 0 (valeur par défaut) signifie que le tampon n'a pas de limite de taille, de s'assurer qu'aucune donnée n'est perdue". Par conséquent, il ne donne aucune indication sur le contenu. Vous devez utiliser socket->size() ou socket->bytesAvailable()

    OriginalL'auteur Kamil Klimek

  2. 5

    Il semble que vous avez un problème de synchronisation. Depuis votre client et le serveur sont des processus différents, il n'ya aucun moyen que vous pouvez garantir que la totalité des TopLevelComms::connect() est en cours d'exécution (avec le réseau de transfert de données) avant de votre serveur connectionAccepted() fonction tente de lire à partir de la prise.

    Je soupçonne que si vous prenez avantage de QTcpSocket de waitForReadyRead() fonction, vous devez avoir plus de chance:

    void Comms::connectionAccepted(){
    qDebug()<<"Connected";
    socket = new QTcpSocket(server->nextPendingConnection());

    if( socket->waitForReadyRead() ) {
        char* rec = new char[socket->readBufferSize()];
        qDebug()<<socket->readBufferSize();
    }
}

    OriginalL'auteur Chris