C++ (Qt)
struct BasePacket 
{
    enum { OpCodeOffset = 0, LenOffset = 2, ParamsOffset = 3; }
 
    BasePacket (QByteArray &packet): packet(packet) 
    {
    }
 
    quint16 opCode() const
    {
        quint16 opcode = 0;
        // read the opcode field from packet from OpCodeOffset 
        return opcode;
    }
 
    QByteArray packet;
};
 
struct FooPacket : public BasePacket 
{
    enum { Foo_OpCode = 0x1234, Foo_PacketSize = xxx };
 
    bool isValid() const
    {
        if (packet.size() != Foo_PacketSize)
            return false;
        if (packet.at(LenOffset ) != (packet.size() - ParamsOffset))
            return false;
        if (opCode() != Foo_OpCode)
            return false;
        return true;
    }
};
 
struct BarPacket : public BasePacket 
{
    enum { Bar_OpCode = 0x5678, Bar_PacketSize = yyy };
 
    bool isValid() const
    {
        if (packet.size() != Bar_PacketSize)
            return false;
        if (packet.at(LenOffset ) != (packet.size() - ParamsOffset))
            return false;
        if (opCode() != Bar_OpCode)
            return false;
        return true;
    }
};
 
 

C++ (Qt)
class BasePacketHandler
{
public:
    virtual bool canHandle(const QByteArray &packet) const = 0;
}
 
class FooPacketHandler : public BasePacketHandler
{
public:
    bool canHandle(const QByteArray &packet) const
    {
        return FooPacket(packet).isValid();
    }
}
 
class BarPacketHandler : public BasePacketHandler
{
public:
    bool canHandle(const QByteArray &packet) const
    {
        return BarPacket(packet).isValid();
    }
}
 

C++ (Qt)
struct BasePacket 
{
    enum { OpCodeOffset = 0, LenOffset = 2, ParamsOffset = 3; }
 
    BasePacket (QByteArray &packet): packet(packet) 
    {
    }
 
    static quint16 opCode(QByteArray &packet) {
        quint16 opcode = 0;
        // read the opcode field from packet from OpCodeOffset 
        return opcode;
    }
 
    QByteArray packet;
};
 
struct FooPacket : public BasePacket 
{
    enum { Foo_OpCode = 0x1234, Foo_PacketSize = xxx };
 
    static bool isValid(QByteArray &packet)
    {
        if (packet.size() != Foo_PacketSize)
            return false;
        if (packet.at(LenOffset ) != (packet.size() - ParamsOffset))
            return false;
        if (opCode(packet) != Foo_OpCode)
            return false;
        return true;
    }
};
 
struct BarPacket : public BasePacket 
{
    enum { Bar_OpCode = 0x5678, Bar_PacketSize = yyy };
 
    static bool isValid(QByteArray &packet)
    {
        if (packet.size() != Bar_PacketSize)
            return false;
        if (packet.at(LenOffset ) != (packet.size() - ParamsOffset))
            return false;
        if (opCode(packet) != Bar_OpCode)
            return false;
        return true;
    }
};
 

C++ (Qt)
class BasePacketHandler
{
public:
    virtual bool canHandle(const QByteArray &packet) const = 0;
};
 
class FooPacketHandler : public BasePacketHandler
{
public:
    bool canHandle(const QByteArray &packet) const
    {
        return FooPacket::isValid(packet);
    }
};
 
class BarPacketHandler : public BasePacketHandler
{
public:
    bool canHandle(const QByteArray &packet) const
    {
        return BarPacket::isValid(packet);
    }
};
 

C++ (Qt)
template <qint32 packID, qint32 packSize>
struct CPacket {
 CPacket( QByteArray & ba ) : mError(false), mBA(ba)
 {
   int id = 0, size = 0;
   QDataStream ds(ba);
   ds >> id >> size;
   mError = (id != packID) ||  (size != packSize) || (mBA.size() - sizeof(qint32) * 2 != packSize);
 }
 
 bool mError;
 QByteArray & mBA; 
};
 
int main(int argc, char *argv[]) 
{
	typedef CPacket <'PAC1', 32> MyPacket;
	QByteArray ba;
	MyPacket p(ba);
	if (!p.mError) return 1;
	return 0;
}

C++ (Qt)
 
QByteArray data1; // приняли пакет FooPacket 
FooPacket foo(data1);
QString name = foo.name();
 
QByteArray data2; // приняли пакет BarPacket 
BarPacket bar(data2);
quint8 type = bar.type();
Address address = bar.address();
 
 

C++ (Qt)
 
class BasePacketHandler
{
public:
    virtual bool canHandle(const QByteArray &packet) const = 0;
};
 
class FooPacketHandler : public BasePacketHandler
{
public:
    bool canHandle(const QByteArray &packet) const
    {
        // как тут правильнее парсить?
        return true/false;
    }
};
 
class BarPacketHandler : public BasePacketHandler
{
public:
    bool canHandle(const QByteArray &packet) const
    {
        // как тут правильнее парсить?
        return true/false;
    }
};
 
QList<BasePacketHandler *> handlers = QList<BasePacketHandler *>() << new FooPacketHandler << new BarPacketHandler;
 
void Manager::handleIncomingPacket(const QByteArray &packet)
{
    foreach (BasePacketHandler *handler, handlers) {
        if (handler->canHandle(packet) {
            // do something
        }
    }
}
 
 

C++ (Qt)
class BasePacketHandler
{
public:
    virtual bool canHandle(const QByteArray &packet) const = 0;
};
 
class FooPacketHandler : public BasePacketHandler
{
public:
    bool canHandle(const QByteArray &packet) const
    {
        // как тут правильнее парсить?
        return true/false;
    }
};
 

C++ (Qt)
class BasePacketHandler
{
public:
    virtual bool canHandle(const QByteArray &packet) const 
    {
        return (packet.size() >= 3) && (*(unsigned short *) &packet[0] == OpCode()); 
    }
};