TCP/IP Übertragung Alternative zu QDataStream

[zerobyte]

Hallo,

ich schreibe gerade einen Server und einen Client die per TCP/IP kommunizieren.Momentan schreibe ich die zu übertragenen Daten in ein QDataStream aber das setzt vorraus, dass der Client auch in QT programmiert ist, das möchte ich aber nicht und deswegen suche ich eine Alternative zu QDataStream, mit der ich zb auch zu einem Client, der mit .NET programmiert ist, Daten übertragen kann. Kennt jemand eine gute Alternative ?

Mfg

[Markus]

Hallo!

Ich habe schon C#-Clients geschrieben, die Daten von einem Qt-Programm über TCP/IP entgegen nehmen. Du mußt halt nur genau wissen, was über den Socket reinkommt. Aber da Du auch den Sender programmierst, sollte das kein Ding sein.

Evtl. einfach mal einen String per QTextStream zum Client senden und schauen, welche und was für Daten Du bekommst. Vielleicht sogar mit einen Telnet-Programm überprüfen.

Markus

[zerobyte]

Hallo,

hab mir mal die Daten in einem QDataStream genauer mit folgendem Code angeschaut:

Code: Alles auswählen

    char b = 1;
    int c = 2;
    QByteArray test("AAABA");
    QByteArray buff;
    QDataStream stream(&buff, QIODevice::ReadWrite);
    stream.setVersion(QDataStream::Qt_4_8);
    stream << test;
    stream << b;
    stream << c;
    qDebug() << buff.toHex();

folgendes bekomme ich :

0000000541414142410000000100000002

Also wird vor jedem String eine 4Byte Variable mit der Länge des Strings ohne Determinierende 0 gestellt. Was ich allerdings nun komisch finde ist, dass sowohl die int als auch die char Variable mit 4 Byte übertragen werden, nur wieso ? Das die char Variable mit 4 Byte übertragen wird ist doch verschwendung!

Mfg

[Markus]

Ich würde da eher ein QTextStream nehmen. Auch das Debugging ist dann einfacher. Wenn Du dann noch einen "Record" mit CR/LF beendest, kannst gut mit canReadLine() oder auf Untersuchung von "CR/LF" die Records erkennen oder per Telnet auf Deinen Server verbinden.

[zerobyte]

ich bin grad stark am überlegen ob ich eine eigene Klasse dafür schreiben soll, die dann alles in 1Byte große Blöcke zerlegt und in ein QByteArray schreibt.
Das wird mir noch eine Weile den Kopf zerbrechen.

[DBGTMaster]

Über was ich vor kurzem gestolpert bin:

https://developers.google.com/protocol-buffers/

[zerobyte]

so hab mich nun entschieden meine eigene Klasse zu schreiben, um die Daten zu serialisieren.
Die folgende Klasse liest nur die Werte ein und schreibt sie in ein QByteArray:

datastreamin.h

Code: Alles auswählen

#ifndef DATASTREAMIN_H
#define DATASTREAMIN_H

#include <QObject>
#include <QByteArray>

class datastreamin : public QObject
{
    Q_OBJECT
public:
    explicit datastreamin(QObject *parent = 0);
    void reset();
    void reservebytes(quint64);
    void in(qint8);
    void in(qint16);
    void in(qint32);
signals:

public slots:

private:
    QByteArray array;
};

#endif // DATASTREAMIN_H

datastreamin.cpp

Code: Alles auswählen

#include "datastreamin.h"

datastreamin::datastreamin(QObject *parent) :
    QObject(parent), array("0000")
{
}

void datastreamin::reset()
{
    array.clear();
}

void datastreamin::reservebytes(quint64 bytes)
{
    array.reserve(bytes);
}

void datastreamin::blocksize(quint32 bytes)
{
    union
    {
        char zeichenout[4];
        quint32 variablein;
    } x;
    x.variablein = bytes;
    char *p = x.zeichenout;
    array[0] = *p++;
    array[1] = *p++;
    array[2] = *p++;
    array[3] = *p;
}

void datastreamin::in(qint8 bytes)
{
    array.append(bytes);
}

void datastreamin::in(qint16 bytes)
{
    union
    {
        char zeichenout[2];
        quint16 variablein;
    } x;
    x.variablein = bytes;
    char *p = x.zeichenout;
    array.append(*p++);
    array.append(*p);
}

void datastreamin::in(qint32 bytes)
{
    union
    {
        char zeichenout[4];
        quint32 variablein;
    } x;
    x.variablein = bytes;
    char *p = x.zeichenout;
    array.append(*p++);
    array.append(*p++);
    array.append(*p++);
    array.append(*p);
}

so nun hab ich aber noch ein paar Fragen zu Performance:
wenn ich zb 4mal array.append aufrufe ist das nun langsamer als wenn ich zuerst die 4 Bytes in ein eigenes QByteArray schreibe und dann mit einmal append das QByteArray in das andere QByteArray schreibe ? ein zweites QByteArray zu erstellen braucht ja auch ein wenig Zeit und verschlingt Speicher, was bei vielen Verbindungen denke ich mal schon ins Gewicht fällt. sollte ich lieber direkt mit Zeigern ( so wie ich es getan habe ) arbeiten oder zb mit einer for-Schleife und die einzelnen Bytes mit ansprechen ? Ich weis , dass das alles Basics sind aber ich steht grad komplett auf dem Schlauch.

Mfg