qt c++ 大小端字节序数据获取与转换

于 2024-06-07 14:52:55 发布
阅读量473 收藏 7
点赞数 1
分类专栏： C++ 文章标签： c++ qt
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wml00876/article/details/139526754
版权
  • 按照约定的大小端顺序，在数组中取出指定数据，并转为指令的大小端字节序的一些方法

qint8 extractqInt8(const QByteArray &byteArray, int startPos)
{
    // 检查起始位置和数据是否足够
    if (startPos >= byteArray.size()) {
        qWarning() << "Invalid start position or insufficient data.";
        return 0;
    }

    // 从 QByteArray 中提取数据
    const char *data = byteArray.constData() + startPos;

    // 提取数据并进行符号扩展
    qint8 value = static_cast<qint8>(data[0]);

    return value;
}

quint8 extractqUint8(const QByteArray &byteArray, int startPos)
{
    // 检查起始位置和数据是否足够
    if (startPos >= byteArray.size()) {
        qWarning() << "Invalid start position or insufficient data.";
        return 0;
    }
    // 从 QByteArray 中提取数据
    const char *data = byteArray.constData() + startPos;
    // 提取数据并进行符号扩展
    quint8 value = static_cast<quint8>(data[0]);
    return value;
}

/**************** 输入数据为大端字节序 ****************/
// 提取小端字节序的 quint16 值
quint16 extractqUint16_BE2LE(const QByteArray &byteArray, int startPos)
{
    if (startPos + 2 > byteArray.size()) {
        qWarning() << "Invalid start position or insufficient data.";
        return 0;
    }

    const uchar *data = reinterpret_cast<const uchar *>(byteArray.constData() + startPos);
    quint16 value = static_cast<quint16>(data[1])
                    | (static_cast<quint16>(data[0]) << 8);
    return value;
}

// 提取小端字节序的 quint32 值
quint32 extractqUint32_BE2LE(const QByteArray &byteArray, int startPos)
{
    if (startPos + 4 > byteArray.size()) {
        qWarning() << "Invalid start position or insufficient data.";
        return 0;
    }

    const uchar *data = reinterpret_cast<const uchar *>(byteArray.constData() + startPos);
    quint32 value = static_cast<quint32>(data[3])
                    | (static_cast<quint32>(data[2]) << 8)
                    | (static_cast<quint32>(data[1]) << 16)
                    | (static_cast<quint32>(data[0]) << 24);
    return value;
}

// 提取小端字节序的 quint64 值
quint64 extractqUint64_BE2LE(const QByteArray &byteArray, int startPos)
{
    if (startPos + 8 > byteArray.size()) {
        qWarning() << "Invalid start position or insufficient data.";
        return 0;
    }

    const uchar *data = reinterpret_cast<const uchar *>(byteArray.constData() + startPos);
    quint64 value = static_cast<quint64>(data[7])
                    | (static_cast<quint64>(data[6]) << 8)
                    | (static_cast<quint64>(data[5]) << 16)
                    | (static_cast<quint64>(data[4]) << 24)
                    | (static_cast<quint64>(data[3]) << 32)
                    | (static_cast<quint64>(data[2]) << 40)
                    | (static_cast<quint64>(data[1]) << 48)
                    | (static_cast<quint64>(data[0]) << 56);
    return value;
}

// 提取小端字节序的 qint16 值
qint16 extractqInt16_BE2LE(const QByteArray &byteArray, int startPos)
{
    if (startPos + 2 > byteArray.size()) {
        qWarning() << "Invalid start position or insufficient data.";
        return 0;
    }

    const uchar *data = reinterpret_cast<const uchar *>(byteArray.constData() + startPos);
    qint16 value = static_cast<qint16>(data[1])
                   | (static_cast<qint16>(data[0]) << 8);
    return value;
}

// 提取小端字节序的 qint32 值
qint32 extractqInt32_BE2LE(const QByteArray &byteArray, int startPos)
{
    if (startPos + 4 > byteArray.size()) {
        qWarning() << "Invalid start position or insufficient data.";
        return 0;
    }

    const uchar *data = reinterpret_cast<const uchar *>(byteArray.constData() + startPos);
    qint32 value = static_cast<qint32>(data[3])
                   | (static_cast<qint32>(data[2]) << 8)
                   | (static_cast<qint32>(data[1]) << 16)
                   | (static_cast<qint32>(data[0]) << 24);
    return value;
}

// 提取小端字节序的 qint64 值
qint64 extractqInt64_BE2LE(const QByteArray &byteArray, int startPos)
{
    if (startPos + 8 > byteArray.size()) {
        qWarning() << "Invalid start position or insufficient data.";
        return 0;
    }

    const uchar *data = reinterpret_cast<const uchar *>(byteArray.constData() + startPos);
    qint64 value = static_cast<qint64>(data[7])
                   | (static_cast<qint64>(data[6]) << 8)
                   | (static_cast<qint64>(data[5]) << 16)
                   | (static_cast<qint64>(data[4]) << 24)
                   | (static_cast<qint64>(data[3]) << 32)
                   | (static_cast<qint64>(data[2]) << 40)
                   | (static_cast<qint64>(data[1]) << 48)
                   | (static_cast<qint64>(data[0]) << 56);
    return value;
}

/**************** 输入小端字节序数据 ****************/
// 提取小端字节序的 quint16 值
quint16 extractqUint16_LE2LE(const QByteArray &byteArray, int startPos)
{
    if (startPos + 2 > byteArray.size()) {
        qWarning() << "Invalid start position or insufficient data.";
        return 0;
    }

    // 从 QByteArray 中提取数据
    quint16 littleEndianValue;
    std::memcpy(&littleEndianValue, byteArray.constData() + startPos, sizeof(quint16));

    return littleEndianValue;
}

// 提取小端字节序的 quint32 值
quint32 extractqUint32_LE2LE(const QByteArray &byteArray, int startPos)
{
    if (startPos + 4 > byteArray.size()) {
        qWarning() << "Invalid start position or insufficient data.";
        return 0;
    }

    //    const uchar *data = reinterpret_cast<const uchar *>(byteArray.constData() + startPos);
    //    quint32 littleEndianValue = static_cast<quint32>(data[0])
    //                                | (static_cast<quint32>(data[1]) << 8)
    //                                | (static_cast<quint32>(data[2]) << 16)
    //                                | (static_cast<quint32>(data[3]) << 24);
    quint32 littleEndianValue;
    std::memcpy(&littleEndianValue, byteArray.constData() + startPos, sizeof(quint32));
    return littleEndianValue;
}

// 提取小端字节序的 quint64 值
quint64 extractqUint64_LE2LE(const QByteArray &byteArray, int startPos)
{
    // 检查起始位置和数据是否足够
    if (startPos + 8 > byteArray.size()) {
        qWarning() << "Invalid start position or insufficient data.";
        return 0;
    }

    // 从 QByteArray 中提取数据
    quint64 littleEndianValue;
    std::memcpy(&littleEndianValue, byteArray.constData() + startPos, sizeof(quint64));
    return littleEndianValue;
}

// 提取小端字节序的 qint16 值
qint16 extractqInt16_LE2LE(const QByteArray &byteArray, int startPos)
{
    if (startPos + 2 > byteArray.size()) {
        qWarning() << "Invalid start position or insufficient data.";
        return 0;
    }

    // 从 QByteArray 中提取数据
    qint16 littleEndianValue;
    std::memcpy(&littleEndianValue, byteArray.constData() + startPos, sizeof(qint16));

    return littleEndianValue;
}

// 提取小端字节序的 qint32 值
qint32 extractqInt32_LE2LE(const QByteArray &byteArray, int startPos)
{
    if (startPos + 4 > byteArray.size()) {
        qWarning() << "Invalid start position or insufficient data.";
        return 0;
    }

    qint32 littleEndianValue;
    std::memcpy(&littleEndianValue, byteArray.constData() + startPos, sizeof(qint32));

    return littleEndianValue;
}

// 提取小端字节序的 qint64 值
qint64 extractqInt64_LE2LE(const QByteArray &byteArray, int startPos)
{
    if (startPos + 8 > byteArray.size()) {
        qWarning() << "Invalid start position or insufficient data.";
        return 0;
    }
    qint64 littleEndianValue;
    std::memcpy(&littleEndianValue, byteArray.constData() + startPos, sizeof(qint64));
    return littleEndianValue;
}

/************************ 以下为大端数据，转为大端数据 *******************/
//x86架构默认为小端存储，所以以下方法在x86平台使用时，注意
// 提取大端字节序的 quint16 值
quint16 extractqUint16_BE2BE(const QByteArray &byteArray, int startPos)
{
    if (startPos + 2 > byteArray.size()) {
        qWarning() << "Invalid start position or insufficient data.";
        return 0;
    }

    // 从 QByteArray 中提取数据
    const uchar *data = reinterpret_cast<const uchar *>(byteArray.constData() + startPos);
    quint16 littleEndianValue = static_cast<quint16>(data[1])
                                | (static_cast<quint16>(data[0]) << 8);
    // 将小端字节序转换为大端字节序
    quint16 bigEndianValue = (littleEndianValue >> 8)
                             | (littleEndianValue << 8);
    return bigEndianValue;
}
// 提取大端字节序的 quint32 值
quint32 extractqUint32_BE2BE(const QByteArray &byteArray, int startPos)
{
    if (startPos + 4 > byteArray.size()) {
        qWarning() << "Invalid start position or insufficient data.";
        return 0;
    }

    const uchar *data = reinterpret_cast<const uchar *>(byteArray.constData() + startPos);
    quint32 littleEndianValue = static_cast<quint32>(data[3])
                                | (static_cast<quint32>(data[2]) << 8)
                                | (static_cast<quint32>(data[1]) << 16)
                                | (static_cast<quint32>(data[0]) << 24);

    // 将小端字节序转换为大端字节序
    quint32 bigEndianValue = ((littleEndianValue & 0x000000FF) << 24)
                             | ((littleEndianValue & 0x0000FF00) << 8)
                             | ((littleEndianValue & 0x00FF0000) >> 8)
                             | ((littleEndianValue & 0xFF000000) >> 24);

    return bigEndianValue;
}

// 提取大端字节序的 quint64 值
quint64 extractqUint64_BE2BE(const QByteArray &byteArray, int startPos)
{
    // 检查起始位置和数据是否足够
    if (startPos + 8 > byteArray.size()) {
        qWarning() << "Invalid start position or insufficient data.";
        return 0;
    }

    // 从 QByteArray 中提取数据
    const uchar *data = reinterpret_cast<const uchar *>(byteArray.constData() + startPos);
    quint64 littleEndianValue = static_cast<quint64>(data[7])
                                | (static_cast<quint64>(data[6]) << 8)
                                | (static_cast<quint64>(data[5]) << 16)
                                | (static_cast<quint64>(data[4]) << 24)
                                | (static_cast<quint64>(data[3]) << 32)
                                | (static_cast<quint64>(data[2]) << 40)
                                | (static_cast<quint64>(data[1]) << 48)
                                | (static_cast<quint64>(data[0]) << 56);

    // 将小端字节序转换为大端字节序
    quint64 bigEndianValue = ((littleEndianValue & 0x00000000000000FFULL) << 56)
                             | ((littleEndianValue & 0x000000000000FF00ULL) << 40)
                             | ((littleEndianValue & 0x0000000000FF0000ULL) << 24)
                             | ((littleEndianValue & 0x00000000FF000000ULL) << 8)
                             | ((littleEndianValue & 0x000000FF00000000ULL) >> 8)
                             | ((littleEndianValue & 0x0000FF0000000000ULL) >> 24)
                             | ((littleEndianValue & 0x00FF000000000000ULL) >> 40)
                             | ((littleEndianValue & 0xFF00000000000000ULL) >> 56);

    return bigEndianValue;
}
// 提取大端字节序的 qint16 值
qint16 extractqInt16_BE2BE(const QByteArray &byteArray, int startPos)
{
    if (startPos + 2 > byteArray.size()) {
        qWarning() << "Invalid start position or insufficient data.";
        return 0;
    }

    // 从 QByteArray 中提取数据
    const uchar *data = reinterpret_cast<const uchar *>(byteArray.constData() + startPos);
    qint16 littleEndianValue = static_cast<qint16>(data[1])
                               | (static_cast<qint16>(data[0]) << 8);
    // 将小端字节序转换为大端字节序
    qint16 bigEndianValue = (littleEndianValue >> 8)
                            | (littleEndianValue << 8);
    return bigEndianValue;
}
// 提取大端字节序的 qint32 值
qint32 extractqInt32_BE2BE(const QByteArray &byteArray, int startPos)
{
    if (startPos + 4 > byteArray.size()) {
        qWarning() << "Invalid start position or insufficient data.";
        return 0;
    }

    const uchar *data = reinterpret_cast<const uchar *>(byteArray.constData() + startPos);
    qint32 littleEndianValue = static_cast<qint32>(data[3])
                               | (static_cast<qint32>(data[2]) << 8)
                               | (static_cast<qint32>(data[1]) << 16)
                               | (static_cast<qint32>(data[0]) << 24);

    // 将小端字节序转换为大端字节序
    qint32 bigEndianValue = ((littleEndianValue & 0x000000FF) << 24)
                            | ((littleEndianValue & 0x0000FF00) << 8)
                            | ((littleEndianValue & 0x00FF0000) >> 8)
                            | ((littleEndianValue & 0xFF000000) >> 24);

    return bigEndianValue;
}

// 提取大端字节序的 qint64 值
qint64 extractqInt64_BE2BE(const QByteArray &byteArray, int startPos)
{
    // 从 QByteArray 中提取数据
    const uchar *data = reinterpret_cast<const uchar *>(byteArray.constData() + startPos);

    // 提取数据并进行符号扩展
    qint64 littleEndianValue = static_cast<qint64>(data[7])
                               | (static_cast<qint64>(data[6]) << 8)
                               | (static_cast<qint64>(data[5]) << 16)
                               | (static_cast<qint64>(data[4]) << 24)
                               | (static_cast<qint64>(data[3]) << 32)
                               | (static_cast<qint64>(data[2]) << 40)
                               | (static_cast<qint64>(data[1]) << 48)
                               | (static_cast<qint64>(data[0]) << 56);
    // 将小端字节序转换为大端字节序
    qint64 bigEndianValue = ((littleEndianValue & 0x00000000000000FFULL) << 56)
                            | ((littleEndianValue & 0x000000000000FF00ULL) << 40)
                            | ((littleEndianValue & 0x0000000000FF0000ULL) << 24)
                            | ((littleEndianValue & 0x00000000FF000000ULL) << 8)
                            | ((littleEndianValue & 0x000000FF00000000ULL) >> 8)
                            | ((littleEndianValue & 0x0000FF0000000000ULL) >> 24)
                            | ((littleEndianValue & 0x00FF000000000000ULL) >> 40)
                            | ((littleEndianValue & 0xFF00000000000000ULL) >> 56);

    return bigEndianValue;
}

/************************ 以下为小端数据，转为大端数据 *******************/
//x86架构默认为小端存储，所以以下方法在x86平台使用时，注意
// 提取大端字节序的 quint16 值
quint16 extractqUint16_LE2BE(const QByteArray &byteArray, int startPos)
{
    if (startPos + 2 > byteArray.size()) {
        qWarning() << "Invalid start position or insufficient data.";
        return 0;
    }

    // 从 QByteArray 中提取数据
    const uchar *data = reinterpret_cast<const uchar *>(byteArray.constData() + startPos);
    quint16 littleEndianValue = static_cast<quint16>(data[0])
                                | (static_cast<quint16>(data[1]) << 8);

    // 将小端字节序转换为大端字节序
    quint16 bigEndianValue = (littleEndianValue >> 8)
                             | (littleEndianValue << 8);
    return bigEndianValue;
}

// 提取大端字节序的 quint32 值
quint32 extractqUint32_LE2BE(const QByteArray &byteArray, int startPos)
{
    if (startPos + 4 > byteArray.size()) {
        qWarning() << "Invalid start position or insufficient data.";
        return 0;
    }

    const uchar *data = reinterpret_cast<const uchar *>(byteArray.constData() + startPos);
    quint32 littleEndianValue = static_cast<quint32>(data[0])
                                | (static_cast<quint32>(data[1]) << 8)
                                | (static_cast<quint32>(data[2]) << 16)
                                | (static_cast<quint32>(data[3]) << 24);

    // 将小端字节序转换为大端字节序
    quint32 bigEndianValue = ((littleEndianValue & 0x000000FF) << 24)
                             | ((littleEndianValue & 0x0000FF00) << 8)
                             | ((littleEndianValue & 0x00FF0000) >> 8)
                             | ((littleEndianValue & 0xFF000000) >> 24);

    return bigEndianValue;
}

// 提取大端字节序的 quint64 值
quint64 extractqUint64_LE2BE(const QByteArray &byteArray, int startPos)
{
    // 检查起始位置和数据是否足够
    if (startPos + 8 > byteArray.size()) {
        qWarning() << "Invalid start position or insufficient data.";
        return 0;
    }

    // 从 QByteArray 中提取数据
    const uchar *data = reinterpret_cast<const uchar *>(byteArray.constData() + startPos);
    quint64 littleEndianValue = static_cast<quint64>(data[0])
                                | (static_cast<quint64>(data[1]) << 8)
                                | (static_cast<quint64>(data[2]) << 16)
                                | (static_cast<quint64>(data[3]) << 24)
                                | (static_cast<quint64>(data[4]) << 32)
                                | (static_cast<quint64>(data[5]) << 40)
                                | (static_cast<quint64>(data[6]) << 48)
                                | (static_cast<quint64>(data[7]) << 56);

    // 将小端字节序转换为大端字节序
    quint64 bigEndianValue = ((littleEndianValue & 0x00000000000000FFULL) << 56)
                             | ((littleEndianValue & 0x000000000000FF00ULL) << 40)
                             | ((littleEndianValue & 0x0000000000FF0000ULL) << 24)
                             | ((littleEndianValue & 0x00000000FF000000ULL) << 8)
                             | ((littleEndianValue & 0x000000FF00000000ULL) >> 8)
                             | ((littleEndianValue & 0x0000FF0000000000ULL) >> 24)
                             | ((littleEndianValue & 0x00FF000000000000ULL) >> 40)
                             | ((littleEndianValue & 0xFF00000000000000ULL) >> 56);

    return bigEndianValue;
}

// 提取大端字节序的 qint16 值
qint16 extractqInt16_LE2BE(const QByteArray &byteArray, int startPos)
{
    if (startPos + 2 > byteArray.size()) {
        qWarning() << "Invalid start position or insufficient data.";
        return 0;
    }

    // 从 QByteArray 中提取数据
    const uchar *data = reinterpret_cast<const uchar *>(byteArray.constData() + startPos);
    qint16 littleEndianValue = static_cast<qint16>(data[0])
                               | (static_cast<qint16>(data[1]) << 8);

    // 将小端字节序转换为大端字节序
    qint16 bigEndianValue = (littleEndianValue >> 8)
                            | (littleEndianValue << 8);
    return bigEndianValue;
}
// 提取大端字节序的 qint32 值
qint32 extractqInt32_LE2BE(const QByteArray &byteArray, int startPos)
{
    if (startPos + 4 > byteArray.size()) {
        qWarning() << "Invalid start position or insufficient data.";
        return 0;
    }

    const uchar *data = reinterpret_cast<const uchar *>(byteArray.constData() + startPos);
    qint32 littleEndianValue = static_cast<qint32>(data[0])
                               | (static_cast<qint32>(data[1]) << 8)
                               | (static_cast<qint32>(data[2]) << 16)
                               | (static_cast<qint32>(data[3]) << 24);

    // 将小端字节序转换为大端字节序
    qint32 bigEndianValue = ((littleEndianValue & 0x000000FF) << 24)
                            | ((littleEndianValue & 0x0000FF00) << 8)
                            | ((littleEndianValue & 0x00FF0000) >> 8)
                            | ((littleEndianValue & 0xFF000000) >> 24);

    return bigEndianValue;
}

// 提取大端字节序的 qint64 值
qint64 extractqInt64_LE2BE(const QByteArray &byteArray, int startPos)
{
    // 从 QByteArray 中提取数据
    const uchar *data = reinterpret_cast<const uchar *>(byteArray.constData() + startPos);

    qint64 littleEndianValue = static_cast<qint64>(data[0])
                               | (static_cast<qint64>(data[1]) << 8)
                               | (static_cast<qint64>(data[2]) << 16)
                               | (static_cast<qint64>(data[3]) << 24)
                               | (static_cast<qint64>(data[4]) << 32)
                               | (static_cast<qint64>(data[5]) << 40)
                               | (static_cast<qint64>(data[6]) << 48)
                               | (static_cast<qint64>(data[7]) << 56);

    // 将小端字节序转换为大端字节序
    qint64 bigEndianValue = ((littleEndianValue & 0x00000000000000FFULL) << 56)
                            | ((littleEndianValue & 0x000000000000FF00ULL) << 40)
                            | ((littleEndianValue & 0x0000000000FF0000ULL) << 24)
                            | ((littleEndianValue & 0x00000000FF000000ULL) << 8)
                            | ((littleEndianValue & 0x000000FF00000000ULL) >> 8)
                            | ((littleEndianValue & 0x0000FF0000000000ULL) >> 24)
                            | ((littleEndianValue & 0x00FF000000000000ULL) >> 40)
                            | ((littleEndianValue & 0xFF00000000000000ULL) >> 56);

    return bigEndianValue;
}
没用的阿_吉
关注
专栏目录
C/C++获取操作系统字节序
技术成就梦想，梦想成就未来。If you try hard enough, it can be.
02-18 574
说明：我们知道网络字节序是大端字节序，但是各个操作系统的字节序就不固定了，可能是小端字节序，也有可能是大端字节序。 所以，我们在将网络字节流赋值给本地变量时，需要先判断下本地是否是大端字节序，如果不是，需要先将网络字节流转换为小端字节序，然后再赋值，否则，会出现解析错误。 封装 typedef enum BYTE_ORDER { BYTE_LITTLE_ENDIAN = 0, BYTE_BIG_ENDIAN, BYTE_OTHER }BYTE_ORDER; BYTE_ORDER GetB
Qt应用软件【数据篇】大小端数据转换
小鱼酱的博客
02-03 1054
Qt和C++中如何大小端数据进行转换
C++与Qt的字节序探究：
qq_37806107的博客
09-26 2464
字节序： 大端字节：数据的低位保存在内存的高地址中，而数据的高位保存在内存的低地址； 小端字节：数据的低位保存在内存的低地址中，而数据的高位保存在内存的高地址中；
Qt、C++中，大小端变量类型转换
he1234519的博客
09-15 1978
C++、qt、类型转换
【QT】Qt对大小端字节序的处理
Making Life Better. Making Others Better.
08-09 1万+
1、Endian Order什么是大小端字节序（Endian Order）？以四字节十六进制整型数0x12345678为例，按照书写习惯，从左到右，高位在前，低位在后，我们称0x12为最高有效字节，0x78为最低有效字节，在存储这个数字时，需要四字节的地址空间，比如说从0x00到0x03，地址空间是从低地址0x00到高地址0x03的一段连续地址，那么，低地址存储最高有效字节的形式为大端（Big En
QT/C++实现：四字节十六进制与浮点数相互转化——三种方法（亲自验证源码）
05-26
反之，从浮点数转换为十六进制字符串时，我们需要获取浮点数的二进制表示，将其拆分为四个字节，并将每个字节转换为十六进制字符串。 其次，是强制类型转换法。这种方法利用C++的类型转换特性，将十六进制字符串以...
C语言十六进制大小端转换,4字节十六进制数据和大小端传输
weixin_39623271的博客
05-18 1945
甲方使用的后台要求“整型数据采用小端传输”，大部分数据是4字节十六进制，有一些是2字节十六进制。关于大小端传输，简单来说可以这样认为。内存中低地址存最低有效字节的形式为小端传输内存中低地址存最高有效字节的形式为大端传输例如一个4字节十六进制数"0x11223344"，装入QByteArray中。按照字节左边为高位，右边为低位的规则。如果取出结果如下buff[0] == 0x44;buff[1] =...
4字节16进制数转换为float浮点数的原理及Qt算法实现示例
09-21
同时，注意在进行这种低级操作时，确保数据类型匹配和大小端问题，因为不同的系统可能使用不同的字节序。在必要的时候，还需要进行字节序转换（如大端转小端，小端转大端）以确保数据正确解读。 总的来说，4字节...
Qt中QByteArray之字符串截取
lsh11111的博客
01-10 3375
len表示要截取的子字节数组的长度，如果len为-1（默认值）或pos+len大于原字节数组的长度，则返回从pos开始一直到右边剩下的全部字节数组。该函数的原型声明如下：QByteArray right(int len)其中，参数len表示从右边开始要截取的子字节数组的长度，如果len大于原来整个字节数组的长度，则返回整个字节数组。QByteArray left(int len)其中，参数len表示从数组左边开始要截取的字节数组的长度，如果len大于原来整个字节数组的长度，则返回整个字节数组。
【C++基础】字节顺序：大端存储顺序、小端存储顺序
m0_56573171的博客
03-28 1440
需要注意的是，结构体对其规则可能因编译器和编译选项而异，因此在使用结构体来判断字节序时需要特别小心，最好使用特定的类型定义和编译选项来确保对其规则的一致性。也就是说，最低位的字节存储在最低的地址上，而最高位的字节存储在最高位的地址上。在小端存储中，结构体的最后一个成员变量的地址和整个结构体的地址相同。可以利用结构体来判断系统的字节序，其基本原理是利用结构体的对齐规则来判断不同字节序下结构体的大小和成员变量的内存地址。也就是说，最高位的字节存储在最低的地址上，而最低位的字节存储在最高的地址上。
大端模式、小端模式及其在Qt中的转换
热门推荐
usownh的专栏
01-11 3万+
大端模式和小端模式是计算机中经常涉及到的两种字节序，也有大端对齐、小端对齐、大尾、小尾等叫法。 一、起源 说起这两种模式，就不得不提一下大端(Big-endian)和小端(Little-endian)这两个英文上的起源。 “endian”一词来源于乔纳森·斯威夫特的小说格列佛游记。Lilliput和Blefuscu这两个强国在过去的36个月中一直在苦战。战争的原因：大家都知道，吃鸡蛋的时候，
Qt下的8字节转6字节，转4字节，2字节。
weixin_43246170的博客
03-02 631
8字节转为其它字节，将它以二进制的形式在字符串中记录，如12的二进制为0000000100000010，如果将它转为4字节，就是每个字节取末尾4个bit（小端情况下），然后记录到字符串中为“00010010”，这样就将所有的字节以二进制数据存到字符串中了，我们需要哪段就取哪段。在开发协议这块时，为了寻找一个快速的8字节转换其它字节的方式，百度许久也没有一款简洁好用，并且在Qt中也好调用的方法，所以设计出了以下方法，该方法支持8字节转为任意指定的字节长度。
qt中QByteArray字节数组
u011555996的博客
05-15 1万+
QByteArray bb("Hello"); //创建字节数组 int n=bb.size(); //返回字节数组的大小 //不包括终止符 QByteArray ba;//创建一个空字节数组 ba.resize(6);//设置字节数组的大小 // 为终止符 ba[0] = 0x3c; //赋值 ba[1] = 0xb8; ba[2] = 0x64; ba[3] = 0x18; ba[4] = 0xca; .
4字节十六进制数据和大小端传输
z55716368的博客
03-13 62
甲方使用的后台要求“整型数据采用小端传输”，大部分数据是4字节十六进制，有一些是2字节十六进制。 关于大小端传输，简单来说可以这样认为。 内存中低地址存最低有效字节的形式为小端传输 内存中低地址存最高有效字节的形式为大端传输 例如一个4字节十六进制数"0x11223344"，装入QByteArray中。 按照字节左边为高位，右边为低位的规则。 如果取出结果如下 buff[0] == 0x44; ...
c++字节序判断（大端和小端）
weixin_42579072的博客
10-28 1110
Little-Endian就是低位字节排放在内存的低地址端，高位字节排放在内存的高地址端 Big-Endian就是高位字节排放在内存的低地址端，低位字节排放在内存的高地址端 如:16bit宽的数0x1234在Little-endian模式（以及Big-endian模式）CPU内存中的存放方式（假设从地址0x4000开始存放）为： 字节序判断： 方法一 类型转换加解引用 BOOL IsBigE...
qt ，使用tcp/ip协议网络传输数据时，字节序转换方法
斧冰
12-11 2314
网络传输数据是需要保证字节序的正确，才能保证传输数据的准确，网络字节序一般是大端字节序。qt提供了以下两种方法来将本地字节序转换为网络字节序： 方法一，使用qt提供的字节序转换函数 T qFromBigEndian(const uchar * src) T qFromBigEndian(T src) T qFromLittleEndian(const uchar * src) T qFromLit...
qt大小端序转换函数
最新发布
07-18
Qt框架中并没有直接提供用于数据大小端序（endianness）转换的内置函数。在C++中，通常需要使用标准库提供的`std::endian`或特定平台的API来进行这样的操作。例如，如果你想要判断系统是大端（big-endian）还是小端...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值