- Qt 6.10
- Qt Core
- <QtEndian> - Endian Conversion Functions
- Qt 6.10.2 Reference Documentation

# <QtEndian> - Endian Conversion Functions

The <QtEndian> header provides functions to convert between little and big endian representations of numbers. More...

Header: | `#include <QtEndian>`

## Types

| qint16_be
| qint16_le
| qint32_be
| qint32_le
| qint64_be
| qint64_le
| quint16_be
| quint16_le
| quint32_be
| quint32_le
| quint64_be
| quint64_le

## Functions

T | qFromBigEndian(const void *src)
T | qFromBigEndian(T src)
void | qFromBigEndian(const void *src, qsizetype count, void *dest)
T | qFromLittleEndian(const void *src)
T | qFromLittleEndian(T src)
void | qFromLittleEndian(const void *src, qsizetype count, void *dest)
void | qToBigEndian(T src, void *dest)
T | qToBigEndian(T src)
void | qToBigEndian(const void *src, qsizetype count, void *dest)
void | qToLittleEndian(T src, void *dest)
T | qToLittleEndian(T src)
void | qToLittleEndian(const void *src, qsizetype count, void *dest)

## Detailed Description

## Type Documentation

### qint16_be

Typedef for QBEInteger<qint16>. This type is guaranteed to be stored in memory as a 16-bit big-endian signed integer on all platforms supported by Qt.

See also qint16.

### qint16_le

Typedef for QLEInteger<qint16>. This type is guaranteed to be stored in memory as a 16-bit little-endian signed integer on all platforms supported by Qt.

See also qint16.

### qint32_be

Typedef for QBEInteger<qint32>. This type is guaranteed to be stored in memory as a 32-bit big-endian signed integer on all platforms supported by Qt.

See also qint32.

### qint32_le

Typedef for QLEInteger<qint32>. This type is guaranteed to be stored in memory as a 32-bit little-endian signed integer on all platforms supported by Qt.

See also qint32.

### qint64_be

Typedef for QBEInteger<qint64>. This type is guaranteed to be stored in memory as a 64-bit big-endian signed integer on all platforms supported by Qt.

See also qint64.

### qint64_le

Typedef for QLEInteger<qint64>. This type is guaranteed to be stored in memory as a 64-bit little-endian signed integer on all platforms supported by Qt.

See also qint64.

### quint16_be

Typedef for QBEInteger<quint16>. This type is guaranteed to be stored in memory as a 16-bit big-endian unsigned integer on all platforms supported by Qt.

See also quint16.

### quint16_le

Typedef for QLEInteger<quint16>. This type is guaranteed to be stored in memory as a 16-bit little-endian unsigned integer on all platforms supported by Qt.

See also quint16.

### quint32_be

Typedef for QBEInteger<quint32>. This type is guaranteed to be stored in memory as a 32-bit big-endian unsigned integer on all platforms supported by Qt.

See also quint32.

### quint32_le

Typedef for QLEInteger<quint32>. This type is guaranteed to be stored in memory as a 32-bit little-endian unsigned integer on all platforms supported by Qt.

See also quint32.

### quint64_be

Typedef for QBEInteger<quint64>. This type is guaranteed to be stored in memory as a 64-bit big-endian unsigned integer on all platforms supported by Qt.

See also quint64.

### quint64_le

Typedef for QLEInteger<quint64>. This type is guaranteed to be stored in memory as a 64-bit little-endian unsigned integer on all platforms supported by Qt.

See also quint64.

## Function Documentation

### template <typename T> T qFromBigEndian(const void *src)

Reads a big-endian number from memory location src and returns the number in the host byte order representation. On CPU architectures where the host byte order is little-endian (such as x86) this will swap the byte order; otherwise it will just read from src.

Note: Template type `T` can either be a quint16, qint16, quint32, qint32, quint64, or qint64. Other types of integers, e.g., qlong, are not applicable.

Note: Since Qt 5.7, the type of the src parameter is a void pointer.

There are no data alignment constraints for src.

See also qFromLittleEndian(), qToBigEndian(), and qToLittleEndian().

### `[constexpr]` template <typename T> T qFromBigEndian(T src)

Converts src from big-endian byte order and returns the number in host byte order representation of that number. On CPU architectures where the host byte order is little-endian (such as x86) this will return src with the byte order swapped; otherwise it will return src unmodified.

This is an overloaded function.

### template <typename T> void qFromBigEndian(const void *src, qsizetype count, void *dest)

Reads count big-endian numbers from memory location src and stores them in the host byte order representation at dest. On CPU architectures where the host byte order is little-endian (such as x86) this will swap the byte order; otherwise it will just perform a `memcpy` from src to dest.

Note: Template type `T` can either be a quint16, qint16, quint32, qint32, quint64, or qint64. Other types of integers, e.g., qlong, are not applicable.

There are no data alignment constraints for src. However, dest is expected to be naturally aligned for type `T`.

If src and dest can be the same pointer, this function will perform an in-place swap (if necessary). If they are not the same, the memory regions must not overlap.

See also qFromLittleEndian(), qToBigEndian(), and qToLittleEndian().

### template <typename T> T qFromLittleEndian(const void *src)

Reads a little-endian number from memory location src and returns the number in the host byte order representation. On CPU architectures where the host byte order is big-endian (such as PowerPC) this will swap the byte order; otherwise it will just read from src.

Note: Template type `T` can either be a quint16, qint16, quint32, qint32, quint64, or qint64. Other types of integers, e.g., qlong, are not applicable.

Note: Since Qt 5.7, the type of the src parameter is a void pointer.

There are no data alignment constraints for src.

See also qFromBigEndian(), qToBigEndian(), and qToLittleEndian().

### `[constexpr]` template <typename T> T qFromLittleEndian(T src)

Converts src from little-endian byte order and returns the number in host byte order representation of that number. On CPU architectures where the host byte order is big-endian (such as PowerPC) this will return src with the byte order swapped; otherwise it will return src unmodified.

This is an overloaded function.

### template <typename T> void qFromLittleEndian(const void *src, qsizetype count, void *dest)

Reads count little-endian numbers from memory location src and stores them in the host byte order representation at dest. On CPU architectures where the host byte order is big-endian (such as PowerPC) this will swap the byte order; otherwise it will just perform a `memcpy` from src to dest.

Note: Template type `T` can either be a quint16, qint16, quint32, qint32, quint64, or qint64. Other types of integers, e.g., qlong, are not applicable.

There are no data alignment constraints for src. However, dest is expected to be naturally aligned for type `T`.

If src and dest can be the same pointer, this function will perform an in-place swap (if necessary). If they are not the same, the memory regions must not overlap.

See also qToBigEndian() and qToLittleEndian().

### template <typename T> void qToBigEndian(T src, void *dest)

Writes the number src with template type `T` to the memory location at dest in big-endian byte order.

Note: Template type `T` can either be a quint16, qint16, quint32, qint32, quint64, or qint64. Other types of integers, e.g., qlong, are not applicable.

There are no data alignment constraints for dest.

Note: Since Qt 5.7, the type of the dest parameter is a void pointer.

See also qFromBigEndian(), qFromLittleEndian(), and qToLittleEndian().

### `[constexpr]` template <typename T> T qToBigEndian(T src)

Converts src from host byte order and returns the number in big-endian byte order representation of that number. On CPU architectures where the host byte order is little-endian (such as x86) this will return src with the byte order swapped; otherwise it will return src unmodified.

This is an overloaded function.

### template <typename T> void qToBigEndian(const void *src, qsizetype count, void *dest)

Reads count numbers from memory location src in the host byte order and stores them in big-endian representation at dest. On CPU architectures where the host byte order is little-endian (such as x86) this will swap the byte order; otherwise it will just perform a `memcpy` from src to dest.

Note: Template type `T` can either be a quint16, qint16, quint32, qint32, quint64, or qint64. Other types of integers, e.g., qlong, are not applicable.

There are no data alignment constraints for dest. However, src is expected to be naturally aligned for type `T`.

If src and dest can be the same pointer, this function will perform an in-place swap (if necessary). If they are not the same, the memory regions must not overlap.

See also qFromLittleEndian(), qToBigEndian(), and qToLittleEndian().

### template <typename T> void qToLittleEndian(T src, void *dest)

Writes the number src with template type `T` to the memory location at dest in little-endian byte order.

Note: Template type `T` can either be a quint16, qint16, quint32, qint32, quint64, or qint64. Other types of integers, e.g., qlong, are not applicable.

There are no data alignment constraints for dest.

Note: Since Qt 5.7, the type of the dest parameter is a void pointer.

See also qFromBigEndian(), qFromLittleEndian(), and qToBigEndian().

### `[constexpr]` template <typename T> T qToLittleEndian(T src)

Converts src from host byte order and returns the number in little-endian byte order representation of that number. On CPU architectures where the host byte order is big-endian (such as PowerPC) this will return src with the byte order swapped; otherwise it will return src unmodified.

This is an overloaded function.

### template <typename T> void qToLittleEndian(const void *src, qsizetype count, void *dest)

Reads count numbers from memory location src in the host byte order and stores them in little-endian representation at dest. On CPU architectures where the host byte order is big-endian (such as PowerPC) this will swap the byte order; otherwise it will just perform a `memcpy` from src to dest.

Note: Template type `T` can either be a quint16, qint16, quint32, qint32, quint64, or qint64. Other types of integers, e.g., qlong, are not applicable.

There are no data alignment constraints for dest. However, src is expected to be naturally aligned for type `T`.

If src and dest can be the same pointer, this function will perform an in-place swap (if necessary). If they are not the same, the memory regions must not overlap.

See also qFromLittleEndian(), qToBigEndian(), and qToLittleEndian().