- Qt 6.4
- Qt Core
- <QtGlobal> - Global Qt Declarations
- Qt 6.4.2 Reference Documentation

# <QtGlobal> - Global Qt Declarations

The <QtGlobal> header file includes the fundamental global declarations. It is included by most other Qt header files. More...

Header: | #include <QtGlobal>

- Deprecated members

## Types

| QtMessageHandler
enum | QtMsgType { QtDebugMsg, QtInfoMsg, QtWarningMsg, QtCriticalMsg, QtFatalMsg, QtSystemMsg }
| qint8
| qint16
| qint32
| qint64
| qintptr
| qlonglong
| qptrdiff
| qreal
| qsizetype
| quint8
| quint16
| quint32
| quint64
| quintptr
| qulonglong
| uchar
| uint
| ulong
| ushort

## Functions

T | qAbs(const T &t)
typename std::enable_if_t<std::is_unsigned_v<T> || std::is_signed_v<T>, bool> | qAddOverflow(T v1, T v2, T *result)
typename std::add_const<T>::type & | qAsConst(T &t)
void | qAsConst(const T &&t)
const T & | qBound(const T &min, const T &val, const T &max)
auto | qConstOverload(T memberFunctionPointer)
QString | qEnvironmentVariable(const char *varName, const QString &defaultValue)
QString | qEnvironmentVariable(const char *varName)
int | qEnvironmentVariableIntValue(const char *varName, bool *ok = nullptr)
bool | qEnvironmentVariableIsEmpty(const char *varName)
bool | qEnvironmentVariableIsSet(const char *varName)
T | qExchange(T &obj, U &&newValue)
quint32 | qFloatDistance(float a, float b)
quint64 | qFloatDistance(double a, double b)
QString | qFormatLogMessage(QtMsgType type, const QMessageLogContext &context, const QString &str)
int | qFpClassify(double val)
int | qFpClassify(float val)
bool | qFuzzyCompare(double p1, double p2)
bool | qFuzzyCompare(float p1, float p2)
bool | qFuzzyIsNull(double d)
bool | qFuzzyIsNull(float f)
double | qInf()
QtMessageHandler | qInstallMessageHandler(QtMessageHandler handler)
bool | qIsFinite(double d)
bool | qIsFinite(float f)
bool | qIsInf(double d)
bool | qIsInf(float f)
bool | qIsNaN(double d)
bool | qIsNaN(float f)
const T & | qMax(const T &a, const T &b)
const T & | qMin(const T &a, const T &b)
typename std::enable_if_t<std::is_unsigned_v<T> || std::is_signed_v<T>, bool> | qMulOverflow(T v1, T v2, T *result)
auto | qNonConstOverload(T memberFunctionPointer)
auto | qOverload(T functionPointer)
double | qQNaN()
qint64 | qRound64(double d)
qint64 | qRound64(float d)
int | qRound(double d)
int | qRound(float d)
double | qSNaN()
void | qSetMessagePattern(const QString &pattern)
typename std::enable_if_t<std::is_unsigned_v<T> || std::is_signed_v<T>, bool> | qSubOverflow(T v1, T v2, T *result)
std::underlying_type_t<Enum> | qToUnderlying(Enum e)
const char * | qVersion()
T * | q_check_ptr(T *p)
QByteArray | qgetenv(const char *varName)
bool | qputenv(const char *varName, const QByteArray &value)
QString | qtTrId(const char *id, int n = -1)
bool | qunsetenv(const char *varName)

## Macros

| PRIXQUINTPTR
| PRIdQINTPTR
| PRIdQPTRDIFF
| PRIdQSIZETYPE
| PRIiQINTPTR
| PRIiQPTRDIFF
| PRIiQSIZETYPE
| PRIoQUINTPTR
| PRIuQUINTPTR
| PRIxQUINTPTR
| QT_DEPRECATED_WARNINGS
| QT_DISABLE_DEPRECATED_BEFORE
| QT_NO_DEPRECATED_WARNINGS
| QT_POINTER_SIZE
| QT_REQUIRE_VERSION(int argc, char **argv, const char *version)
| QT_TRANSLATE_NOOP3(context, sourceText, disambiguation)
| QT_TRANSLATE_NOOP(context, sourceText)
| QT_TRANSLATE_N_NOOP3(context, sourceText, comment)
| QT_TRANSLATE_N_NOOP(context, sourceText)
| QT_TRID_NOOP(id)
| QT_TRID_N_NOOP(id)
| QT_TR_NOOP(sourceText)
| QT_TR_N_NOOP(sourceText)
| QT_VERSION
| QT_VERSION_CHECK(major, minor, patch)
| QT_VERSION_STR
void | Q_ASSERT(bool test)
void | Q_ASSERT_X(bool test, const char *where, const char *what)
void | Q_ASSUME(bool expr)
| Q_BIG_ENDIAN
| Q_BYTE_ORDER
| Q_CC_BOR
| Q_CC_CDS
| Q_CC_CLANG
| Q_CC_COMEAU
| Q_CC_DEC
| Q_CC_EDG
| Q_CC_GHS
| Q_CC_GNU
| Q_CC_HIGHC
| Q_CC_HPACC
| Q_CC_KAI
| Q_CC_MIPS
| Q_CC_MSVC
| Q_CC_OC
| Q_CC_PGI
| Q_CC_SUN
| Q_CC_SYM
| Q_CC_USLC
| Q_CC_WAT
void | Q_CHECK_PTR(void *pointer)
| Q_CONSTINIT
| Q_DECLARE_TYPEINFO(Type, Flags)
| Q_DECL_EXPORT
| Q_DECL_IMPORT
void | Q_FALLTHROUGH
| Q_FORWARD_DECLARE_CF_TYPE(type)
| Q_FORWARD_DECLARE_MUTABLE_CF_TYPE(type)
| Q_FORWARD_DECLARE_OBJC_CLASS(classname)
const char* | Q_FUNC_INFO
qint64 | Q_INT64_C(literal)
| Q_LIKELY(expr)
| Q_LITTLE_ENDIAN
| Q_OS_AIX
| Q_OS_ANDROID
| Q_OS_BSD4
| Q_OS_CYGWIN
| Q_OS_DARWIN
| Q_OS_FREEBSD
| Q_OS_HPUX
| Q_OS_HURD
| Q_OS_IOS
| Q_OS_LINUX
| Q_OS_LYNX
| Q_OS_MAC
| Q_OS_MACOS
| Q_OS_NETBSD
| Q_OS_OPENBSD
| Q_OS_OSX
| Q_OS_QNX
| Q_OS_SOLARIS
| Q_OS_TVOS
| Q_OS_UNIX
| Q_OS_WASM
| Q_OS_WATCHOS
| Q_OS_WIN32
| Q_OS_WIN64
| Q_OS_WIN
| Q_OS_WINDOWS
| Q_PROCESSOR_X86
| Q_PROCESSOR_S390
| Q_PROCESSOR_ALPHA
| Q_PROCESSOR_ARM
| Q_PROCESSOR_ARM_V5
| Q_PROCESSOR_ARM_V6
| Q_PROCESSOR_ARM_V7
| Q_PROCESSOR_AVR32
| Q_PROCESSOR_BLACKFIN
| Q_PROCESSOR_HPPA
| Q_PROCESSOR_IA64
| Q_PROCESSOR_M68K
| Q_PROCESSOR_MIPS
| Q_PROCESSOR_MIPS_32
| Q_PROCESSOR_MIPS_64
| Q_PROCESSOR_MIPS_I
| Q_PROCESSOR_MIPS_II
| Q_PROCESSOR_MIPS_III
| Q_PROCESSOR_MIPS_IV
| Q_PROCESSOR_MIPS_V
| Q_PROCESSOR_POWER
| Q_PROCESSOR_POWER_32
| Q_PROCESSOR_POWER_64
| Q_PROCESSOR_RISCV
| Q_PROCESSOR_RISCV_32
| Q_PROCESSOR_RISCV_64
| Q_PROCESSOR_S390_X
| Q_PROCESSOR_SH
| Q_PROCESSOR_SH_4A
| Q_PROCESSOR_SPARC
| Q_PROCESSOR_SPARC_V9
| Q_PROCESSOR_X86_32
| Q_PROCESSOR_X86_64
quint64 | Q_UINT64_C(literal)
| Q_UNLIKELY(expr)
void | Q_UNREACHABLE
| Q_UNUSED(name)
| qCritical(const char *message, ...)
| qDebug(const char *message, ...)
| qFatal(const char *message, ...)
| qInfo(const char *message, ...)
const char * | qPrintable(const QString &str)
const wchar_t * | qUtf16Printable(const QString &str)
const char * | qUtf8Printable(const QString &str)
| qWarning(const char *message, ...)

## Detailed Description

The global declarations include types, functions and macros.

The type definitions are partly convenience definitions for basic types (some of which guarantee certain bit-sizes on all platforms supported by Qt), partly types related to Qt message handling. The functions are related to generating messages, Qt version handling and comparing and adjusting object values. And finally, some of the declared macros enable programmers to add compiler or platform specific code to their applications, while others are convenience macros for larger operations.

#### Types

The header file declares several type definitions that guarantee a specified bit-size on all platforms supported by Qt for various basic types, for example qint8 which is a signed char guaranteed to be 8-bit on all platforms supported by Qt. The header file also declares the qlonglong type definition for `long long int` (`__int64` on Windows).

Several convenience type definitions are declared: qreal for `double` or `float`, uchar for `unsigned` char, uint for `unsigned` int, ulong for `unsigned` long and ushort for `unsigned` short.

Finally, the QtMsgType definition identifies the various messages that can be generated and sent to a Qt message handler; QtMessageHandler is a type definition for a pointer to a function with the signature `void myMessageHandler(QtMsgType, const QMessageLogContext &, const char *)`. QMessageLogContext class contains the line, file, and function the message was logged at. This information is created by the QMessageLogger class.

#### Functions

The <QtGlobal> header file contains several functions comparing and adjusting an object's value. These functions take a template type as argument: You can retrieve the absolute value of an object using the qAbs() function, and you can bound a given object's value by given minimum and maximum values using the qBound() function. You can retrieve the minimum and maximum of two given objects using qMin() and qMax() respectively. All these functions return a corresponding template type; the template types can be replaced by any other type.

Example:

     int myValue = 10;
     int minValue = 2;
     int maxValue = 6;

     int boundedValue = qBound(minValue, myValue, maxValue);
     // boundedValue == 6

<QtGlobal> also contains functions that generate messages from the given string argument: qDebug(), qInfo(), qWarning(), qCritical(), and qFatal(). These functions call the message handler with the given message.

Example:

     if (!driver()->isOpen() || driver()->isOpenError()) {
         qWarning("QSqlQuery::exec: database not open");
         return false;
     }

The remaining functions are qRound() and qRound64(), which both accept a `double` or `float` value as their argument returning the value rounded up to the nearest integer and 64-bit integer respectively, the qInstallMessageHandler() function which installs the given QtMessageHandler, and the qVersion() function which returns the version number of Qt at runtime as a string.

#### Macros

The <QtGlobal> header file provides a range of macros (Q_CC_*) that are defined if the application is compiled using the specified platforms. For example, the Q_CC_SUN macro is defined if the application is compiled using Forte Developer, or Sun Studio C++. The header file also declares a range of macros (Q_OS_*) that are defined for the specified platforms. For example, Q_OS_UNIX which is defined for the Unix-based systems.

The purpose of these macros is to enable programmers to add compiler or platform specific code to their application.

The remaining macros are convenience macros for larger operations: The QT_TR_NOOP(), QT_TRANSLATE_NOOP(), and QT_TRANSLATE_NOOP3() macros provide the possibility of marking strings for delayed translation. QT_TR_N_NOOP(), QT_TRANSLATE_N_NOOP(), and QT_TRANSLATE_N_NOOP3() are numerator dependent variants of these. The Q_ASSERT() and Q_ASSERT_X() enables warning messages of various level of refinement. The Q_FOREACH() and foreach() macros implement Qt's foreach loop.

The Q_INT64_C() and Q_UINT64_C() macros wrap signed and unsigned 64-bit integer literals in a platform-independent way. The Q_CHECK_PTR() macro prints a warning containing the source code's file name and line number, saying that the program ran out of memory, if the pointer is `nullptr`. The qPrintable() and qUtf8Printable() macros represent an easy way of printing text.

The QT_POINTER_SIZE macro expands to the size of a pointer in bytes.

The macros QT_VERSION and QT_VERSION_STR expand to a numeric value or a string, respectively. These identify the version of Qt that the application is compiled with.

See also <QtAlgorithms> and QSysInfo.

## Type Documentation

### `[since 5.0]` QtMessageHandler

This is a typedef for a pointer to a function with the following signature:

     void myMessageHandler(QtMsgType, const QMessageLogContext &, const QString &);

This typedef was introduced in Qt 5.0.

See also QtMsgType and qInstallMessageHandler().

### enum QtMsgType

This enum describes the messages that can be sent to a message handler (QtMessageHandler). You can use the enum to identify and associate the various message types with the appropriate actions.

Constant | Value | Description
--- | --- | ---
`QtDebugMsg` | `0` | A message generated by the qDebug() function.
`QtInfoMsg` | `4` | A message generated by the qInfo() function.
`QtWarningMsg` | `1` | A message generated by the qWarning() function.
`QtCriticalMsg` | `2` | A message generated by the qCritical() function.
`QtFatalMsg` | `3` | A message generated by the qFatal() function.
`QtSystemMsg` | `QtCriticalMsg` |

`QtInfoMsg` was added in Qt 5.5.

See also QtMessageHandler and qInstallMessageHandler().

### qint8

Typedef for `signed char`. This type is guaranteed to be 8-bit on all platforms supported by Qt.

### qint16

Typedef for `signed short`. This type is guaranteed to be 16-bit on all platforms supported by Qt.

### qint32

Typedef for `signed int`. This type is guaranteed to be 32-bit on all platforms supported by Qt.

### qint64

Typedef for `long long int`. This type is guaranteed to be 64-bit on all platforms supported by Qt.

Literals of this type can be created using the Q_INT64_C() macro:

     qint64 value = Q_INT64_C(932838457459459);

See also Q_INT64_C(), quint64, and qlonglong.

### qintptr

Integral type for representing pointers in a signed integer (useful for hashing, etc.).

Typedef for either qint32 or qint64. This type is guaranteed to be the same size as a pointer on all platforms supported by Qt. On a system with 32-bit pointers, qintptr is a typedef for qint32; on a system with 64-bit pointers, qintptr is a typedef for qint64.

Note that qintptr is signed. Use quintptr for unsigned values.

In order to print values of this type by using formatted-output facilities such as `printf()`, qDebug(), QString::asprintf() and so on, you can use the `PRIdQINTPTR` and `PRIiQINTPTR` macros as format specifiers. They will both print the value as a base 10 number.

     qintptr p = 123;
     printf("The pointer is %" PRIdQINTPTR "\n", p);

See also qptrdiff, qint32, and qint64.

### qlonglong

Typedef for `long long int` (`__int64` on Windows). This is the same as qint64.

See also qulonglong and qint64.

### qptrdiff

Integral type for representing pointer differences.

Typedef for either qint32 or qint64. This type is guaranteed to be the same size as a pointer on all platforms supported by Qt. On a system with 32-bit pointers, quintptr is a typedef for quint32; on a system with 64-bit pointers, quintptr is a typedef for quint64.

Note that qptrdiff is signed. Use quintptr for unsigned values.

In order to print values of this type by using formatted-output facilities such as `printf()`, qDebug(), QString::asprintf() and so on, you can use the `PRIdQPTRDIFF` and `PRIiQPTRDIFF` macros as format specifiers. They will both print the value as a base 10 number.

     qptrdiff d = 123;
     printf("The difference is %" PRIdQPTRDIFF "\n", d);

See also quintptr, qint32, and qint64.

### qreal

Typedef for `double` unless Qt is configured with the `-qreal float` option.

### `[alias, since 5.10]` qsizetype

Integral type providing Posix' `ssize_t` for all platforms.

This type is guaranteed to be the same size as a `size_t` on all platforms supported by Qt.

Note that qsizetype is signed. Use `size_t` for unsigned values.

In order to print values of this type by using formatted-output facilities such as `printf()`, qDebug(), QString::asprintf() and so on, you can use the `PRIdQSIZETYPE` and `PRIiQSIZETYPE` macros as format specifiers. They will both print the value as a base 10 number.

     qsizetype s = 123;
     printf("The size is %" PRIdQSIZETYPE "\n", s);

This typedef was introduced in Qt 5.10.

See also qptrdiff.

### quint8

Typedef for `unsigned char`. This type is guaranteed to be 8-bit on all platforms supported by Qt.

### quint16

Typedef for `unsigned short`. This type is guaranteed to be 16-bit on all platforms supported by Qt.

### quint32

Typedef for `unsigned int`. This type is guaranteed to be 32-bit on all platforms supported by Qt.

### quint64

Typedef for `unsigned long long int`. This type is guaranteed to be 64-bit on all platforms supported by Qt.

Literals of this type can be created using the Q_UINT64_C() macro:

     quint64 value = Q_UINT64_C(932838457459459);

See also Q_UINT64_C(), qint64, and qulonglong.

### quintptr

Integral type for representing pointers in an unsigned integer (useful for hashing, etc.).

Typedef for either quint32 or quint64. This type is guaranteed to be the same size as a pointer on all platforms supported by Qt. On a system with 32-bit pointers, quintptr is a typedef for quint32; on a system with 64-bit pointers, quintptr is a typedef for quint64.

Note that quintptr is unsigned. Use qptrdiff for signed values.

In order to print values of this type by using formatted-output facilities such as `printf()`, qDebug(), QString::asprintf() and so on, you can use the following macros as format specifiers:

- `PRIuQUINTPTR`: prints the value as a base 10 number.
- `PRIoQUINTPTR`: prints the value as a base 8 number.
- `PRIxQUINTPTR`: prints the value as a base 16 number, using lowercase `a-f` letters.
- `PRIXQUINTPTR`: prints the value as a base 16 number, using uppercase `A-F` letters.

     quintptr p = 123u;
     printf("The pointer value is 0x%" PRIXQUINTPTR "\n", p);

See also qptrdiff, quint32, and quint64.

### qulonglong

Typedef for `unsigned long long int` (`unsigned __int64` on Windows). This is the same as quint64.

See also quint64 and qlonglong.

### uchar

Convenience typedef for `unsigned char`.

### uint

Convenience typedef for `unsigned int`.

### ulong

Convenience typedef for `unsigned long`.

### ushort

Convenience typedef for `unsigned short`.

## Function Documentation

### int qFpClassify(double val)

### int qFpClassify(float val)

Classifies a floating-point value.

The return values are defined in `<cmath>`: returns one of the following, determined by the floating-point class of val:

- FP_NAN not a number
- FP_INFINITE infinities (positive or negative)
- FP_ZERO zero (positive or negative)
- FP_NORMAL finite with a full mantissa
- FP_SUBNORMAL finite with a reduced mantissa

### `[since 5.10]` QString qEnvironmentVariable(const char *varName)

### `[since 5.10]` QString qEnvironmentVariable(const char *varName, const QString &defaultValue)

These functions return the value of the environment variable, varName, as a QString. If no variable varName is found in the environment and defaultValue is provided, defaultValue is returned. Otherwise QString() is returned.

The Qt environment manipulation functions are thread-safe, but this requires that the C library equivalent functions like getenv and putenv are not directly called.

The following table describes how to choose between qgetenv() and qEnvironmentVariable():

Condition | Recommendation
--- | ---
Variable contains file paths or user text | qEnvironmentVariable()
Windows-specific code | qEnvironmentVariable()
Unix-specific code, destination variable is not QString and/or is used to interface with non-Qt APIs | qgetenv()
Destination variable is a QString | qEnvironmentVariable()
Destination variable is a QByteArray or std::string | qgetenv()

Note: on Unix systems, this function may produce data loss if the original string contains arbitrary binary data that cannot be decoded by the locale codec. Use qgetenv() instead for that case. On Windows, this function is lossless.

Note: the variable name varName must contain only US-ASCII characters.

This function was introduced in Qt 5.10.

See also qputenv(), qgetenv(), qEnvironmentVariableIsSet(), and qEnvironmentVariableIsEmpty().

### template <typename T> T qAbs(const T &t)

Compares t to the 0 of type T and returns the absolute value. Thus if T is double, then t is compared to (double) 0.

Example:

     int absoluteValue;
     int myValue = -4;

     absoluteValue = qAbs(myValue);
     // absoluteValue == 4

### `[since 6.1]` template <typename T> typename std::enable_if_t<std::is_unsigned_v<T> || std::is_signed_v<T>, bool> qAddOverflow(T v1, T v2, T *result)

Adds two values v1 and v2, of a numeric type `T` and records the value in result. If the addition overflows the valid range for type `T`, returns `true`, otherwise returns `false`.

An implementation is guaranteed to be available for 8-, 16-, and 32-bit integer types, as well as integer types of the size of a pointer. Overflow math for other types, if available, is considered private API.

This function was introduced in Qt 6.1.

### `[since 5.7]` template <typename T> typename std::add_const<T>::type &qAsConst(T &t)

Returns t cast to `const T`.

This function is a Qt implementation of C++17's std::as_const(), a cast function like std::move(). But while std::move() turns lvalues into rvalues, this function turns non-const lvalues into const lvalues. Like std::as_const(), it doesn't work on rvalues, because it cannot be efficiently implemented for rvalues without leaving dangling references.

Its main use in Qt is to prevent implicitly-shared Qt containers from detaching:

         QString s = ...;
         for (QChar ch : s) // detaches 's' (performs a deep-copy if 's' was shared)
             process(ch);
         for (QChar ch : std::as_const(s)) // ok, no detach attempt
             process(ch);

Of course, in this case, you could (and probably should) have declared `s` as `const` in the first place:

         const QString s = ...;
         for (QChar ch : s) // ok, no detach attempt on const objects
             process(ch);

but often that is not easily possible.

It is important to note that qAsConst() does not copy its argument, it just performs a `const_cast<const T&>(t)`. This is also the reason why it is designed to fail for rvalues: The returned reference would go stale too soon. So while this works (but detaches the returned object):

         for (QChar ch : funcReturningQString())
             process(ch); // OK, the returned object is kept alive for the loop's duration

this would not:

         for (QChar ch : std::as_const(funcReturningQString()))
             process(ch); // ERROR: ch is copied from deleted memory

To prevent this construct from compiling (and failing at runtime), qAsConst() has a second, deleted, overload which binds to rvalues.

This function was introduced in Qt 5.7.

### `[since 5.7]` template <typename T> void qAsConst(const T &&t)

This is an overloaded function.

This overload is deleted to prevent a dangling reference in code like

         for (QChar ch : std::as_const(funcReturningQString()))
             process(ch); // ERROR: ch is copied from deleted memory

This function was introduced in Qt 5.7.

### template <typename T> const T &qBound(const T &min, const T &val, const T &max)

Returns val bounded by min and max. This is equivalent to qMax(min, qMin(val, max)).

Example:

     int myValue = 10;
     int minValue = 2;
     int maxValue = 6;

     int boundedValue = qBound(minValue, myValue, maxValue);
     // boundedValue == 6

See also qMin() and qMax().

### `[since 5.7]` template <typename T> auto qConstOverload(T memberFunctionPointer)

Returns the memberFunctionPointer pointer to a constant member function:

         struct Foo {
             void overloadedFunction(int, const QString &);
             void overloadedFunction(int, const QString &) const;
         };
         ... qConstOverload<int, const QString &>(&Foo::overloadedFunction)
         ... qNonConstOverload<int, const QString &>(&Foo::overloadedFunction)

This function was introduced in Qt 5.7.

See also qOverload, qNonConstOverload, and Differences between String-Based and Functor-Based Connections.

### `[since 5.10]` QString qEnvironmentVariable(const char *varName, const QString &defaultValue)

This function was introduced in Qt 5.10.

### `[since 5.10]` QString qEnvironmentVariable(const char *varName)

This function was introduced in Qt 5.10.

### `[since 5.5]` int qEnvironmentVariableIntValue(const char *varName, bool *ok = nullptr)

Returns the numerical value of the environment variable varName. If ok is not null, sets `*ok` to `true` or `false` depending on the success of the conversion.

Equivalent to

         qgetenv(varName).toInt(ok, 0)

except that it's much faster, and can't throw exceptions.

Note: there's a limit on the length of the value, which is sufficient for all valid values of int, not counting leading zeroes or spaces. Values that are too long will either be truncated or this function will set ok to `false`.

This function was introduced in Qt 5.5.

See also qgetenv(), qEnvironmentVariable(), and qEnvironmentVariableIsSet().

### `[since 5.1]` bool qEnvironmentVariableIsEmpty(const char *varName)

Returns whether the environment variable varName is empty.

Equivalent to

         qgetenv(varName).isEmpty()

except that it's potentially much faster, and can't throw exceptions.

This function was introduced in Qt 5.1.

See also qgetenv(), qEnvironmentVariable(), and qEnvironmentVariableIsSet().

### `[since 5.1]` bool qEnvironmentVariableIsSet(const char *varName)

Returns whether the environment variable varName is set.

Equivalent to

         !qgetenv(varName).isNull()

except that it's potentially much faster, and can't throw exceptions.

This function was introduced in Qt 5.1.

See also qgetenv(), qEnvironmentVariable(), and qEnvironmentVariableIsEmpty().

### `[since 5.14]` template <typename T, typename U> T qExchange(T &obj, U &&newValue)

Replaces the value of obj with newValue and returns the old value of obj.

This is Qt's implementation of std::exchange(). It differs from std::exchange() only in that it is `constexpr` already before C++20 and noexcept already before C++23.

We strongly advise to use std::exchange() when you don't need the C++20 or C++23 variants.

Here is how to use qExchange() to implement move constructors:

     MyClass(MyClass &&other)
       : m_pointer{qExchange(other.m_pointer, nullptr)},
         m_int{qExchange(other.m_int, 0)},
         m_vector{std::move(other.m_vector)},
         ...

For members of class type, we can use std::move(), as their move-constructor will do the right thing. But for scalar types such as raw pointers or integer type, move is the same as copy, which, particularly for pointers, is not what we expect. So, we cannot use std::move() for such types, but we can use std::exchange()/qExchange() to make sure the source object's member is already reset by the time we get to the initialization of our next data member, which might come in handy if the constructor exits with an exception.

Here is how to use qExchange() to write a loop that consumes the collection it iterates over:

     for (auto &e : qExchange(collection, {})
         doSomethingWith(e);

Which is equivalent to the following, much more verbose code:

     {
         auto tmp = std::move(collection);
         collection = {};                    // or collection.clear()
         for (auto &e : tmp)
             doSomethingWith(e);
     }                                       // destroys 'tmp'

This is perfectly safe, as the for-loop keeps the result of qExchange() alive for as long as the loop runs, saving the declaration of a temporary variable. Be aware, though, that qExchange() returns a non-const object, so Qt containers may detach.

This function was introduced in Qt 5.14.

### `[since 5.2]` quint32 qFloatDistance(float a, float b)

Returns the number of representable floating-point numbers between a and b.

This function provides an alternative way of doing approximated comparisons of floating-point numbers similar to qFuzzyCompare(). However, it returns the distance between two numbers, which gives the caller a possibility to choose the accepted error. Errors are relative, so for instance the distance between 1.0E-5 and 1.00001E-5 will give 110, while the distance between 1.0E36 and 1.00001E36 will give 127.

This function is useful if a floating point comparison requires a certain precision. Therefore, if a and b are equal it will return 0. The maximum value it will return for 32-bit floating point numbers is 4,278,190,078. This is the distance between `-FLT_MAX` and `+FLT_MAX`.

The function does not give meaningful results if any of the arguments are `Infinite` or `NaN`. You can check for this by calling qIsFinite().

The return value can be considered as the "error", so if you for instance want to compare two 32-bit floating point numbers and all you need is an approximated 24-bit precision, you can use this function like this:

         if (qFloatDistance(a, b) < (1 << 7)) {   // The last 7 bits are not
                                                 // significant
             // precise enough
         }

This function was introduced in Qt 5.2.

See also qFuzzyCompare().

### `[since 5.2]` quint64 qFloatDistance(double a, double b)

Returns the number of representable floating-point numbers between a and b.

This function serves the same purpose as `qFloatDistance(float, float)`, but returns the distance between two `double` numbers. Since the range is larger than for two `float` numbers (`[-DBL_MAX,DBL_MAX]`), the return type is quint64.

This function was introduced in Qt 5.2.

See also qFuzzyCompare().

### `[since 5.4]` QString qFormatLogMessage(QtMsgType type, const QMessageLogContext &context, const QString &str)

Generates a formatted string out of the type, context, str arguments.

qFormatLogMessage returns a QString that is formatted according to the current message pattern. It can be used by custom message handlers to format output similar to Qt's default message handler.

The function is thread-safe.

This function was introduced in Qt 5.4.

See also qInstallMessageHandler() and qSetMessagePattern().

### int qFpClassify(double val)

### int qFpClassify(float val)

### bool qFuzzyCompare(double p1, double p2)

Compares the floating point value p1 and p2 and returns `true` if they are considered equal, otherwise `false`.

Note that comparing values where either p1 or p2 is 0.0 will not work, nor does comparing values where one of the values is NaN or infinity. If one of the values is always 0.0, use qFuzzyIsNull instead. If one of the values is likely to be 0.0, one solution is to add 1.0 to both values.

     // Instead of comparing with 0.0
     qFuzzyCompare(0.0, 1.0e-200); // This will return false
     // Compare adding 1 to both values will fix the problem
     qFuzzyCompare(1 + 0.0, 1 + 1.0e-200); // This will return true

The two numbers are compared in a relative way, where the exactness is stronger the smaller the numbers are.

Note: This function is thread-safe.

### bool qFuzzyCompare(float p1, float p2)

Compares the floating point value p1 and p2 and returns `true` if they are considered equal, otherwise `false`.

The two numbers are compared in a relative way, where the exactness is stronger the smaller the numbers are.

Note: This function is thread-safe.

### bool qFuzzyIsNull(double d)

Returns true if the absolute value of d is within 0.000000000001 of 0.0.

Note: This function is thread-safe.

### bool qFuzzyIsNull(float f)

Returns true if the absolute value of f is within 0.00001f of 0.0.

Note: This function is thread-safe.

### double qInf()

Returns the bit pattern for an infinite number as a double.

See also qIsInf().

### `[since 5.0]` QtMessageHandler qInstallMessageHandler(QtMessageHandler handler)

Installs a Qt message handler which has been defined previously. Returns a pointer to the previous message handler.

The message handler is a function that prints out debug messages, warnings, critical and fatal error messages. The Qt library (debug mode) contains hundreds of warning messages that are printed when internal errors (usually invalid function arguments) occur. Qt built in release mode also contains such warnings unless QT_NO_WARNING_OUTPUT and/or QT_NO_DEBUG_OUTPUT have been set during compilation. If you implement your own message handler, you get total control of these messages.

The default message handler prints the message to the standard output under X11 or to the debugger under Windows. If it is a fatal message, the application aborts immediately after handling that message. Custom message handlers should not attempt to exit an application on their own.

Only one message handler can be defined, since this is usually done on an application-wide basis to control debug output.

To restore the message handler, call `qInstallMessageHandler(0)`.

Example:

     #include <qapplication.h>
     #include <stdio.h>
     #include <stdlib.h>

     void myMessageOutput(QtMsgType type, const QMessageLogContext &context, const QString &msg)
     {
         QByteArray localMsg = msg.toLocal8Bit();
         const char *file = context.file ? context.file : "";
         const char *function = context.function ? context.function : "";
         switch (type) {
         case QtDebugMsg:
             fprintf(stderr, "Debug: %s (%s:%u, %s)\n", localMsg.constData(), file, context.line, function);
             break;
         case QtInfoMsg:
             fprintf(stderr, "Info: %s (%s:%u, %s)\n", localMsg.constData(), file, context.line, function);
             break;
         case QtWarningMsg:
             fprintf(stderr, "Warning: %s (%s:%u, %s)\n", localMsg.constData(), file, context.line, function);
             break;
         case QtCriticalMsg:
             fprintf(stderr, "Critical: %s (%s:%u, %s)\n", localMsg.constData(), file, context.line, function);
             break;
         case QtFatalMsg:
             fprintf(stderr, "Fatal: %s (%s:%u, %s)\n", localMsg.constData(), file, context.line, function);
             break;
         }
     }

     int main(int argc, char **argv)
     {
         qInstallMessageHandler(myMessageOutput);
         QApplication app(argc, argv);
         ...
         return app.exec();
     }

This function was introduced in Qt 5.0.

See also QtMessageHandler, QtMsgType, qDebug(), qInfo(), qWarning(), qCritical(), qFatal(), and Debugging Techniques.

### bool qIsFinite(double d)

Returns `true` if the double d is a finite number.

### bool qIsFinite(float f)

Returns `true` if the float f is a finite number.

### bool qIsInf(double d)

Returns `true` if the double d is equivalent to infinity.

See also qInf().

### bool qIsInf(float f)

Returns `true` if the float f is equivalent to infinity.

See also qInf().

### bool qIsNaN(double d)

Returns `true` if the double d is not a number (NaN).

### bool qIsNaN(float f)

Returns `true` if the float f is not a number (NaN).

### template <typename T> const T &qMax(const T &a, const T &b)

Returns the maximum of a and b.

Example:

     int myValue = 6;
     int yourValue = 4;

     int maxValue = qMax(myValue, yourValue);
     // maxValue == myValue

See also qMin() and qBound().

### template <typename T> const T &qMin(const T &a, const T &b)

Returns the minimum of a and b.

Example:

     int myValue = 6;
     int yourValue = 4;

     int minValue = qMin(myValue, yourValue);
     // minValue == yourValue

See also qMax() and qBound().

### `[since 6.1]` template <typename T> typename std::enable_if_t<std::is_unsigned_v<T> || std::is_signed_v<T>, bool> qMulOverflow(T v1, T v2, T *result)

Multiplies v1 and v2, and records the resulting value in result. If the multiplication overflows the valid range for type `T`, returns `true`, otherwise returns `false`.

An implementation is guaranteed to be available for 8-, 16-, and 32-bit integer types, as well as integer types of the size of a pointer. Overflow math for other types, if available, is considered private API.

This function was introduced in Qt 6.1.

### `[since 5.7]` template <typename T> auto qNonConstOverload(T memberFunctionPointer)

Returns the memberFunctionPointer pointer to a non-constant member function:

         struct Foo {
             void overloadedFunction(int, const QString &);
             void overloadedFunction(int, const QString &) const;
         };
         ... qConstOverload<int, const QString &>(&Foo::overloadedFunction)
         ... qNonConstOverload<int, const QString &>(&Foo::overloadedFunction)

This function was introduced in Qt 5.7.

See also qOverload, qNonConstOverload, and Differences between String-Based and Functor-Based Connections.

### `[since 5.7]` template <typename T> auto qOverload(T functionPointer)

Returns a pointer to an overloaded function. The template parameter is the list of the argument types of the function. functionPointer is the pointer to the (member) function:

         struct Foo {
             void overloadedFunction();
             void overloadedFunction(int, const QString &);
         };
         ... qOverload<>(&Foo::overloadedFunction)
         ... qOverload<int, const QString &>(&Foo::overloadedFunction)

If a member function is also const-overloaded qConstOverload and qNonConstOverload need to be used.

qOverload() requires C++14 enabled. In C++11-only code, the helper classes QOverload, QConstOverload, and QNonConstOverload can be used directly:

         ... QOverload<>::of(&Foo::overloadedFunction)
         ... QOverload<int, const QString &>::of(&Foo::overloadedFunction)

Note: Qt detects the necessary C++14 compiler support by way of the feature test recommendations from C++ Committee's Standing Document 6.

This function was introduced in Qt 5.7.

See also qConstOverload(), qNonConstOverload(), and Differences between String-Based and Functor-Based Connections.

### double qQNaN()

Returns the bit pattern of a quiet NaN as a double.

See also qIsNaN().

### qint64 qRound64(double d)

Rounds d to the nearest 64-bit integer.

Rounds half away from zero (e.g. 0.5 -> 1, -0.5 -> -1).

Note: This function does not guarantee correctness for high precisions.

Example:

     double valueA = 42949672960.3;
     double valueB = 42949672960.7;

     qint64 roundedValueA = qRound64(valueA);
     // roundedValueA = 42949672960
     qint64 roundedValueB = qRound64(valueB);
     // roundedValueB = 42949672961

### qint64 qRound64(float d)

Rounds d to the nearest 64-bit integer.

Rounds half away from zero (e.g. 0.5f -> 1, -0.5f -> -1).

Note: This function does not guarantee correctness for high precisions.

Example:

     float valueA = 42949672960.3;
     float valueB = 42949672960.7;

     qint64 roundedValueA = qRound64(valueA);
     // roundedValueA = 42949672960
     qint64 roundedValueB = qRound64(valueB);
     // roundedValueB = 42949672961

### int qRound(double d)

Rounds d to the nearest integer.

Rounds half away from zero (e.g. 0.5 -> 1, -0.5 -> -1).

Note: This function does not guarantee correctness for high precisions.

Example:

     double valueA = 2.3;
     double valueB = 2.7;

     int roundedValueA = qRound(valueA);
     // roundedValueA = 2
     int roundedValueB = qRound(valueB);
     // roundedValueB = 3

### int qRound(float d)

Rounds d to the nearest integer.

Rounds half away from zero (e.g. 0.5f -> 1, -0.5f -> -1).

Note: This function does not guarantee correctness for high precisions.

Example:

     float valueA = 2.3;
     float valueB = 2.7;

     int roundedValueA = qRound(valueA);
     // roundedValueA = 2
     int roundedValueB = qRound(valueB);
     // roundedValueB = 3

### double qSNaN()

Returns the bit pattern of a signalling NaN as a double.

### `[since 5.0]` void qSetMessagePattern(const QString &pattern)

Changes the output of the default message handler.

Allows to tweak the output of qDebug(), qInfo(), qWarning(), qCritical(), and qFatal(). The category logging output of qCDebug(), qCInfo(), qCWarning(), and qCCritical() is formatted, too.

Following placeholders are supported:

Placeholder | Description
--- | ---
`%{appname}` | QCoreApplication::applicationName()
`%{category}` | Logging category
`%{file}` | Path to source file
`%{function}` | Function
`%{line}` | Line in source file
`%{message}` | The actual message
`%{pid}` | QCoreApplication::applicationPid()
`%{threadid}` | The system-wide ID of current thread (if it can be obtained)
`%{qthreadptr}` | A pointer to the current QThread (result of QThread::currentThread())
`%{type}` | "debug", "warning", "critical" or "fatal"
`%{time process}` | time of the message, in seconds since the process started (the token "process" is literal)
`%{time boot}` | the time of the message, in seconds since the system boot if that can be determined (the token "boot" is literal). If the time since boot could not be obtained, the output is indeterminate (see QElapsedTimer::msecsSinceReference()).
`%{time [format]}` | system time when the message occurred, formatted by passing the `format` to QDateTime::toString(). If the format is not specified, the format of Qt::ISODate is used.

`%{backtrace [depth=N] [separator="..."]}`

A backtrace with the number of frames specified by the optional `depth` parameter (defaults to 5), and separated by the optional `separator` parameter (defaults to "|").

This expansion is available only on some platforms (currently only platfoms using glibc). Names are only known for exported functions. If you want to see the name of every function in your application, make sure your application is compiled and linked with `-rdynamic`, or an equivalent of it.

When reading backtraces, take into account that frames might be missing due to inlining or tail call optimization.

You can also use conditionals on the type of the message using `%{if-debug}`, `%{if-info}` `%{if-warning}`, `%{if-critical}` or `%{if-fatal}` followed by an `%{endif}`. What is inside the `%{if-*}` and `%{endif}` will only be printed if the type matches.

Finally, text inside `%{if-category}` ... `%{endif}` is only printed if the category is not the default one.

Example:

         QT_MESSAGE_PATTERN="[%{time yyyyMMdd h:mm:ss.zzz t} %{if-debug}D%{endif}%{if-info}I%{endif}%{if-warning}W%{endif}%{if-critical}C%{endif}%{if-fatal}F%{endif}] %{file}:%{line} - %{message}"

The default pattern is `%{if-category}%{category}: %{endif}%{message}`.

The pattern can also be changed at runtime by setting the QT_MESSAGE_PATTERN environment variable; if both qSetMessagePattern() is called and QT_MESSAGE_PATTERN is set, the environment variable takes precedence.

Note: The information for the placeholders `category`, `file`, `function` and `line` is only recorded in debug builds. Alternatively, `QT_MESSAGELOGCONTEXT` can be defined explicitly. For more information refer to the QMessageLogContext documentation.

Note: The message pattern only applies to unstructured logging, such as the default `stderr` output. Structured logging such as systemd will record the message as is, along with as much structured information as can be captured.

Custom message handlers can use qFormatLogMessage() to take pattern into account.

This function was introduced in Qt 5.0.

See also qInstallMessageHandler(), Debugging Techniques, QLoggingCategory, and QMessageLogContext.

### `[since 6.1]` template <typename T> typename std::enable_if_t<std::is_unsigned_v<T> || std::is_signed_v<T>, bool> qSubOverflow(T v1, T v2, T *result)

Subtracts v2 from v1 and records the resulting value in result. If the subtraction overflows the valid range for type `T`, returns `true`, otherwise returns `false`.

An implementation is guaranteed to be available for 8-, 16-, and 32-bit integer types, as well as integer types of the size of a pointer. Overflow math for other types, if available, is considered private API.

This function was introduced in Qt 6.1.

### `[since 6.2]` template <typename Enum> std::underlying_type_t<Enum> qToUnderlying(Enum e)

Converts the enumerator e to the equivalent value expressed in its enumeration's underlying type.

This function was introduced in Qt 6.2.

### const char *qVersion()

Returns the version number of Qt at runtime as a string (for example, "6.1.2"). This may be a different version than the version the application was compiled with.

See also QT_VERSION_STR and QLibraryInfo::version().

### template <typename T> T *q_check_ptr(T *p)

Uses Q_CHECK_PTR on p, then returns p.

This can be used as an inline version of Q_CHECK_PTR.

### QByteArray qgetenv(const char *varName)

Returns the value of the environment variable with name varName as a QByteArray. If no variable by that name is found in the environment, this function returns a default-constructed QByteArray.

The Qt environment manipulation functions are thread-safe, but this requires that the C library equivalent functions like getenv and putenv are not directly called.

To convert the data to a QString use QString::fromLocal8Bit().

Note: on desktop Windows, qgetenv() may produce data loss if the original string contains Unicode characters not representable in the ANSI encoding. Use qEnvironmentVariable() instead. On Unix systems, this function is lossless.

Note: This function is thread-safe.

See also qputenv(), qEnvironmentVariable(), qEnvironmentVariableIsSet(), and qEnvironmentVariableIsEmpty().

### bool qputenv(const char *varName, const QByteArray &value)

This function sets the value of the environment variable named varName. It will create the variable if it does not exist. It returns 0 if the variable could not be set.

Calling qputenv with an empty value removes the environment variable on Windows, and makes it set (but empty) on Unix. Prefer using qunsetenv() for fully portable behavior.

Note: qputenv() was introduced because putenv() from the standard C library was deprecated in VC2005 (and later versions). qputenv() uses the replacement function in VC, and calls the standard C library's implementation on all other platforms.

See also qgetenv() and qEnvironmentVariable().

### QString qtTrId(const char *id, int n = -1)

The qtTrId function finds and returns a translated string.

Returns a translated string identified by id. If no matching string is found, the id itself is returned. This should not happen under normal conditions.

If n >= 0, all occurrences of `%n` in the resulting string are replaced with a decimal representation of n. In addition, depending on n's value, the translation text may vary.

Meta data and comments can be passed as documented for QObject::tr(). In addition, it is possible to supply a source string template like that:

`//% <C string>`

or

`\begincomment% <C string> \endcomment`

Example:

         //% "%n fooish bar(s) found.\n"
         //% "Do you want to continue?"
         QString text = qtTrId("qtn_foo_bar", n);

Creating QM files suitable for use with this function requires passing the `-idbased` option to the `lrelease` tool.

Warning: This method is reentrant only if all translators are installed before calling this method. Installing or removing translators while performing translations is not supported. Doing so will probably result in crashes or other undesirable behavior.

Note: This function is reentrant.

See also QObject::tr(), QCoreApplication::translate(), and Internationalization with Qt.

### `[since 5.1]` bool qunsetenv(const char *varName)

This function deletes the variable varName from the environment.

Returns `true` on success.

This function was introduced in Qt 5.1.

See also qputenv(), qgetenv(), and qEnvironmentVariable().

## Macro Documentation

### `[since 6.2]` PRIdQSIZETYPE

### `[since 6.2]` PRIiQSIZETYPE

See qsizetype.

This function was introduced in Qt 6.2.

### `[since 6.2]` PRIdQPTRDIFF

### `[since 6.2]` PRIiQPTRDIFF

See qptrdiff.

This function was introduced in Qt 6.2.

### `[since 6.2]` PRIXQUINTPTR

### `[since 6.2]` PRIoQUINTPTR

### `[since 6.2]` PRIuQUINTPTR

### `[since 6.2]` PRIxQUINTPTR

See quintptr.

This function was introduced in Qt 6.2.

### `[since 6.2]` PRIdQINTPTR

### `[since 6.2]` PRIiQINTPTR

See qintptr.

This function was introduced in Qt 6.2.

### `[since 6.2]` PRIXQUINTPTR

This macro was introduced in Qt 6.2.

### `[since 6.2]` PRIdQINTPTR

This macro was introduced in Qt 6.2.

### `[since 6.2]` PRIdQPTRDIFF

This macro was introduced in Qt 6.2.

### `[since 6.2]` PRIdQSIZETYPE

This macro was introduced in Qt 6.2.

### `[since 6.2]` PRIiQINTPTR

This macro was introduced in Qt 6.2.

### `[since 6.2]` PRIiQPTRDIFF

This macro was introduced in Qt 6.2.

### `[since 6.2]` PRIiQSIZETYPE

This macro was introduced in Qt 6.2.

### `[since 6.2]` PRIoQUINTPTR

This macro was introduced in Qt 6.2.

### `[since 6.2]` PRIuQUINTPTR

This macro was introduced in Qt 6.2.

### `[since 6.2]` PRIxQUINTPTR

This macro was introduced in Qt 6.2.

### QT_DEPRECATED_WARNINGS

Since Qt 5.13, this macro has no effect. In Qt 5.12 and before, if this macro is defined, the compiler will generate warnings if any API declared as deprecated by Qt is used.

See also QT_DISABLE_DEPRECATED_BEFORE and QT_NO_DEPRECATED_WARNINGS.

### QT_DISABLE_DEPRECATED_BEFORE

This macro can be defined in the project file to disable functions deprecated in a specified version of Qt or any earlier version. The default version number is 5.0, meaning that functions deprecated in or before Qt 5.0 will not be included.

For instance, when preparing to upgrade to Qt 6.3, setting `QT_DISABLE_DEPRECATED_BEFORE=0x0602ff` will disable functions deprecated in Qt 6.2 and earlier, making it easy to find changes worth making before the upgrade. In any release, set `QT_DISABLE_DEPRECATED_BEFORE=0x000000` to enable all functions, including the ones deprecated in Qt 5.0 (although most of those have by now been removed entirely).

See also QT_DEPRECATED_WARNINGS.

### `[since 5.13]` QT_NO_DEPRECATED_WARNINGS

This macro can be used to suppress deprecation warnings that would otherwise be generated when using deprecated APIs.

This macro was introduced in Qt 5.13.

See also QT_DISABLE_DEPRECATED_BEFORE.

### QT_POINTER_SIZE

Expands to the size of a pointer in bytes (4 or 8). This is equivalent to `sizeof(void *)` but can be used in a preprocessor directive.

### QT_REQUIRE_VERSION(int argc, char **argv, const char *version)

This macro can be used to ensure that the application is run with a recent enough version of Qt. This is especially useful if your application depends on a specific bug fix introduced in a bug-fix release (for example, 6.1.2).

The argc and argv parameters are the `main()` function's `argc` and `argv` parameters. The version parameter is a string literal that specifies which version of Qt the application requires (for example, "6.1.2").

Example:

     #include <QApplication>
     #include <QMessageBox>

     int main(int argc, char *argv[])
     {
         QT_REQUIRE_VERSION(argc, argv, "6.1.2")

         QApplication app(argc, argv);
         ...
         return app.exec();
     }

### QT_TRANSLATE_NOOP3(context, sourceText, disambiguation)

Marks the UTF-8 encoded string literal sourceText for delayed translation in the given context with the given disambiguation. The context is typically a class and also needs to be specified as a string literal. The string literal disambiguation should be a short semantic tag to tell apart otherwise identical strings.

The macro tells lupdate to collect the string, and expands to an anonymous struct of the two string literals passed as sourceText and disambiguation.

Example:

     static { const char *source; const char *comment; } greeting_strings[] =
     {
         QT_TRANSLATE_NOOP3("FriendlyConversation", "Hello",
                            "A really friendly hello"),
         QT_TRANSLATE_NOOP3("FriendlyConversation", "Goodbye",
                            "A really friendly goodbye")
     };

     QString FriendlyConversation::greeting(int type)
     {
         return tr(greeting_strings[type].source,
                   greeting_strings[type].comment);
     }

     QString global_greeting(int type)
     {
         return qApp->translate("FriendlyConversation",
                                greeting_strings[type].source,
                                greeting_strings[type].comment);
     }

See also QT_TR_NOOP(), QT_TRANSLATE_NOOP(), and Internationalization with Qt.

### QT_TRANSLATE_NOOP(context, sourceText)

Marks the UTF-8 encoded string literal sourceText for delayed translation in the given context. The context is typically a class name and also needs to be specified as a string literal.

The macro tells lupdate to collect the string, and expands to sourceText itself.

Example:

     static const char *greeting_strings[] = {
         QT_TRANSLATE_NOOP("FriendlyConversation", "Hello"),
         QT_TRANSLATE_NOOP("FriendlyConversation", "Goodbye")
     };

     QString FriendlyConversation::greeting(int type)
     {
         return tr(greeting_strings[type]);
     }

     QString global_greeting(int type)
     {
         return qApp->translate("FriendlyConversation",
                                greeting_strings[type]);
     }

See also QT_TR_NOOP(), QT_TRANSLATE_NOOP3(), and Internationalization with Qt.

### `[since 5.12]` QT_TRANSLATE_N_NOOP3(context, sourceText, comment)

Marks the UTF-8 encoded string literal sourceText for numerator dependent delayed translation in the given context with the given comment. The context is typically a class and also needs to be specified as a string literal. The string literal comment should be a short semantic tag to tell apart otherwise identical strings.

The macro tells lupdate to collect the string, and expands to an anonymous struct of the two string literals passed as sourceText and comment.

Example:

     static { const char * const source; const char * const comment; } status_strings[] = {
         QT_TRANSLATE_N_NOOP3("Message Status", "Hello, you have %n message(s)",
                              "A login message status"),
         QT_TRANSLATE_N_NOOP3("Message status", "You have %n new message(s)",
                              "A new message query status")
     };

     QString FriendlyConversation::greeting(int type, int count)
     {
         return tr(status_strings[type].source,
                   status_strings[type].comment, count);
     }

     QString global_greeting(int type, int count)
     {
         return qApp->translate("Message Status",
                                status_strings[type].source,
                                status_strings[type].comment,
                                count);
     }

This macro was introduced in Qt 5.12.

See also QT_TR_NOOP(), QT_TRANSLATE_NOOP(), QT_TRANSLATE_NOOP3(), and Internationalization with Qt.

### `[since 5.12]` QT_TRANSLATE_N_NOOP(context, sourceText)

Marks the UTF-8 encoded string literal sourceText for numerator dependent delayed translation in the given context. The context is typically a class name and also needs to be specified as a string literal.

The macro tells lupdate to collect the string, and expands to sourceText itself.

Example:

     static const char * const greeting_strings[] = {
         QT_TRANSLATE_N_NOOP("Welcome Msg", "Hello, you have %n message(s)"),
         QT_TRANSLATE_N_NOOP("Welcome Msg", "Hi, you have %n message(s)")
     };

     QString global_greeting(int type, int msgcnt)
     {
         return translate("Welcome Msg", greeting_strings[type], nullptr, msgcnt);
     }

This macro was introduced in Qt 5.12.

See also QT_TRANSLATE_NOOP(), QT_TRANSLATE_N_NOOP3(), and Internationalization with Qt.

### QT_TRID_NOOP(id)

The QT_TRID_NOOP macro marks an id for dynamic translation.

The only purpose of this macro is to provide an anchor for attaching meta data like to qtTrId().

The macro expands to id.

Example:

     static const char * const ids[] = {
         //% "This is the first text."
         QT_TRID_NOOP("qtn_1st_text"),
         //% "This is the second text."
         QT_TRID_NOOP("qtn_2nd_text"),
         0
     };

     void TheClass::addLabels()
     {
         for (int i = 0; ids[i]; ++i)
             new QLabel(qtTrId(ids[i]), this);
     }

See also qtTrId() and Internationalization with Qt.

### `[since 6.3]` QT_TRID_N_NOOP(id)

The QT_TRID_N_NOOP macro marks an id for numerator dependent dynamic translation.

The only purpose of this macro is to provide an anchor for attaching meta data like to qtTrId().

The macro expands to id.

Example:

     static const char * const ids[] = {
         //% "%n foo(s) found."
         QT_TRID_N_NOOP("qtn_foo"),
         //% "%n bar(s) found."
         QT_TRID_N_NOOP("qtn_bar"),
         0
     };

     QString result(int type, int n)
     {
         return qtTrId(ids[type], n);
     }

This macro was introduced in Qt 6.3.

See also qtTrId() and Internationalization with Qt.

### QT_TR_NOOP(sourceText)

Marks the UTF-8 encoded string literal sourceText for delayed translation in the current context (class).

The macro tells lupdate to collect the string, and expands to sourceText itself.

Example:

     QString FriendlyConversation::greeting(int type)
     {
         static const char *greeting_strings[] = {
             QT_TR_NOOP("Hello"),
             QT_TR_NOOP("Goodbye")
         };
         return tr(greeting_strings[type]);
     }

The macro QT_TR_NOOP_UTF8() is identical and obsolete; this applies to all other _UTF8 macros as well.

See also QT_TRANSLATE_NOOP() and Internationalization with Qt.

### `[since 5.12]` QT_TR_N_NOOP(sourceText)

Marks the UTF-8 encoded string literal sourceText for numerator dependent delayed translation in the current context (class).

The macro tells lupdate to collect the string, and expands to sourceText itself.

The macro expands to sourceText.

Example:

     static const char * const StatusClass::status_strings[] = {
         QT_TR_N_NOOP("There are %n new message(s)"),
         QT_TR_N_NOOP("There are %n total message(s)")
     };

     QString StatusClass::status(int type, int count)
     {
         return tr(status_strings[type], nullptr, count);
     }

This macro was introduced in Qt 5.12.

See also QT_TR_NOOP and Internationalization with Qt.

### QT_VERSION

This macro expands to a numeric value of the same form as QT_VERSION_CHECK() constructs, that specifies the version of Qt with which code using it is compiled. For example, if you compile your application with Qt 6.1.2, the QT_VERSION macro will expand to `0x060102`, the same as `QT_VERSION_CHECK(6, 1, 2)`. Note that this need not agree with the version the application will find itself using at runtime.

You can use QT_VERSION to select the latest Qt features where available while falling back to older implementations otherwise. Using QT_VERSION_CHECK() for the value to compare with is recommended.

Example:

     #if QT_VERSION >= QT_VERSION_CHECK(4, 1, 0)
         QIcon icon = style()->standardIcon(QStyle::SP_TrashIcon);
     #else
         QPixmap pixmap = style()->standardPixmap(QStyle::SP_TrashIcon);
         QIcon icon(pixmap);
     #endif

See also QT_VERSION_STR, QT_VERSION_CHECK(), and qVersion().

### QT_VERSION_CHECK(major, minor, patch)

Turns the major, minor and patch numbers of a version into an integer that encodes all three. When expressed in hexadecimal, this integer is of form `0xMMNNPP` wherein `0xMM ==` major, `0xNN ==` minor, and `0xPP ==` patch. This can be compared with another similarly processed version ID.

Example:

     #include <QtGlobal>

     #if QT_VERSION >= QT_VERSION_CHECK(5, 0, 0)
     #include <QtWidgets>
     #else
     #include <QtGui>
     #endif

Note: the parameters are read as integers in the normal way, so should normally be written in decimal (so a `0x` prefix must be used if writing them in hexadecimal). Thus `QT_VERSION_CHECK(5, 15, 0)` is equal to `0x050f00`, which could equally be written `QT_VERSION_CHECK(5, 0xf, 0)`.

See also QT_VERSION.

### QT_VERSION_STR

This macro expands to a string that specifies Qt's version number (for example, "6.1.2"). This is the version with which the application is compiled. This may be a different version than the version the application will find itself using at runtime.

See also qVersion() and QT_VERSION.

### void Q_ASSERT(bool test)

Prints a warning message containing the source code file name and line number if test is `false`.

Q_ASSERT() is useful for testing pre- and post-conditions during development. It does nothing if `QT_NO_DEBUG` was defined during compilation.

Example:

     // File: div.cpp

     #include <QtGlobal>

     int divide(int a, int b)
     {
         Q_ASSERT(b != 0);
         return a / b;
     }

If `b` is zero, the Q_ASSERT statement will output the following message using the qFatal() function:

     ASSERT: "b != 0" in file div.cpp, line 7

See also Q_ASSERT_X(), qFatal(), and Debugging Techniques.

### void Q_ASSERT_X(bool test, const char *where, const char *what)

Prints the message what together with the location where, the source file name and line number if test is `false`.

Q_ASSERT_X is useful for testing pre- and post-conditions during development. It does nothing if `QT_NO_DEBUG` was defined during compilation.

Example:

     // File: div.cpp

     #include <QtGlobal>

     int divide(int a, int b)
     {
         Q_ASSERT_X(b != 0, "divide", "division by zero");
         return a / b;
     }

If `b` is zero, the Q_ASSERT_X statement will output the following message using the qFatal() function:

     ASSERT failure in divide: "division by zero", file div.cpp, line 7

See also Q_ASSERT(), qFatal(), and Debugging Techniques.

### `[since 5.0]` void Q_ASSUME(bool expr)

Causes the compiler to assume that expr is `true`. This macro is useful for improving code generation, by providing the compiler with hints about conditions that it would not otherwise know about. However, there is no guarantee that the compiler will actually use those hints.

This macro could be considered a "lighter" version of Q_ASSERT(). While Q_ASSERT will abort the program's execution if the condition is `false`, Q_ASSUME will tell the compiler not to generate code for those conditions. Therefore, it is important that the assumptions always hold, otherwise undefined behaviour may occur.

If expr is a constantly `false` condition, Q_ASSUME will tell the compiler that the current code execution cannot be reached. That is, Q_ASSUME(false) is equivalent to Q_UNREACHABLE().

In debug builds the condition is enforced by an assert to facilitate debugging.

Note: Q_LIKELY() tells the compiler that the expression is likely, but not the only possibility. Q_ASSUME tells the compiler that it is the only possibility.

This macro was introduced in Qt 5.0.

See also Q_ASSERT(), Q_UNREACHABLE(), and Q_LIKELY().

### Q_BIG_ENDIAN

This macro represents a value you can compare to the macro Q_BYTE_ORDER to determine the endian-ness of your system. In a big-endian system, the most significant byte is stored at the lowest address. The other bytes follow in decreasing order of significance.

     #if Q_BYTE_ORDER == Q_BIG_ENDIAN
     ...
     #endif

See also Q_BYTE_ORDER and Q_LITTLE_ENDIAN.

### Q_BYTE_ORDER

This macro can be used to determine the byte order your system uses for storing data in memory. i.e., whether your system is little-endian or big-endian. It is set by Qt to one of the macros Q_LITTLE_ENDIAN or Q_BIG_ENDIAN. You normally won't need to worry about endian-ness, but you might, for example if you need to know which byte of an integer or UTF-16 character is stored in the lowest address. Endian-ness is important in networking, where computers with different values for Q_BYTE_ORDER must pass data back and forth.

Use this macro as in the following examples.

     #if Q_BYTE_ORDER == Q_BIG_ENDIAN
     ...
     #endif

     or

     #if Q_BYTE_ORDER == Q_LITTLE_ENDIAN
     ...
     #endif

See also Q_BIG_ENDIAN and Q_LITTLE_ENDIAN.

### Q_CC_BOR

Defined if the application is compiled using Borland/Turbo C++.

### Q_CC_CDS

Defined if the application is compiled using Reliant C++.

### Q_CC_CLANG

Defined if the application is compiled using Clang.

### Q_CC_COMEAU

Defined if the application is compiled using Comeau C++.

### Q_CC_DEC

Defined if the application is compiled using DEC C++.

### Q_CC_EDG

Defined if the application is compiled using Edison Design Group C++.

### Q_CC_GHS

Defined if the application is compiled using Green Hills Optimizing C++ Compilers.

### Q_CC_GNU

Defined if the application is compiled using GNU C++.

### Q_CC_HIGHC

Defined if the application is compiled using MetaWare High C/C++.

### Q_CC_HPACC

Defined if the application is compiled using HP aC++.

### Q_CC_KAI

Defined if the application is compiled using KAI C++.

### Q_CC_MIPS

Defined if the application is compiled using MIPSpro C++.

### Q_CC_MSVC

Defined if the application is compiled using Microsoft Visual C/C++, Intel C++ for Windows.

### Q_CC_OC

Defined if the application is compiled using CenterLine C++.

### Q_CC_PGI

Defined if the application is compiled using Portland Group C++.

### Q_CC_SUN

Defined if the application is compiled using Forte Developer, or Sun Studio C++.

### Q_CC_SYM

Defined if the application is compiled using Digital Mars C/C++ (used to be Symantec C++).

### Q_CC_USLC

Defined if the application is compiled using SCO OUDK and UDK.

### Q_CC_WAT

Defined if the application is compiled using Watcom C++.

### void Q_CHECK_PTR(void *pointer)

If pointer is `nullptr`, prints a message containing the source code's file name and line number, saying that the program ran out of memory and aborts program execution. It throws `std::bad_alloc` instead if exceptions are enabled.

Q_CHECK_PTR does nothing if `QT_NO_DEBUG` and `QT_NO_EXCEPTIONS` were defined during compilation. Therefore you must not use Q_CHECK_PTR to check for successful memory allocations because the check will be disabled in some cases.

Example:

     int *a;

     Q_CHECK_PTR(a = new int[80]);   // WRONG!

     a = new (nothrow) int[80];      // Right
     Q_CHECK_PTR(a);

See also qWarning() and Debugging Techniques.

### `[since 6.4]` Q_CONSTINIT

Enforces constant initialization when supported by the compiler.

If the compiler supports the C++20 `constinit` keyword, Clang's `[[clang::require_constant_initialization]]` or GCC's `__constinit`, then this macro expands to the first one of these that is available, otherwise it expands to nothing.

Variables marked as `constinit` cause a compile-error if their initialization would have to be performed at runtime.

For constants, you can use `constexpr` since C++11, but `constexpr` makes variables `const`, too, whereas `constinit` ensures constant initialization, but doesn't make the variable `const`:

Keyword | Added | immutable | constant-initialized
--- | --- | --- | ---
`const` | C++98 | yes | not required
`constexpr` | C++11 | yes | required
`constinit` | C++20 | no | required

This macro was introduced in Qt 6.4.

### Q_DECLARE_TYPEINFO(Type, Flags)

You can use this macro to specify information about a custom type Type. With accurate type information, Qt's generic containers can choose appropriate storage methods and algorithms.

Flags can be one of the following:

- `Q_PRIMITIVE_TYPE` specifies that Type is a POD (plain old data) type with no constructor or destructor, and for which memcpy()ing creates a valid independent copy of the object.
- `Q_RELOCATABLE_TYPE` specifies that Type has a constructor and/or a destructor but can be moved in memory using `memcpy()`.
- `Q_MOVABLE_TYPE` is the same as `Q_RELOCATABLE_TYPE`. Prefer to use `Q_RELOCATABLE_TYPE` in new code. Note: despite the name, this has nothing to do with move constructors or C++ move semantics.
- `Q_COMPLEX_TYPE` (the default) specifies that Type has constructors and/or a destructor and that it may not be moved in memory.

Example of a "primitive" type:

     struct Point2D
     {
         int x;
         int y;
     };

     Q_DECLARE_TYPEINFO(Point2D, Q_PRIMITIVE_TYPE);

An example of a non-POD "primitive" type is QUuid: Even though QUuid has constructors (and therefore isn't POD), every bit pattern still represents a valid object, and memcpy() can be used to create a valid independent copy of a QUuid object.

Example of a relocatable type:

     class Point2D
     {
     public:
         Point2D() { data = new int[2]; }
         Point2D(const Point2D &other) { ... }
         ~Point2D() { delete[] data; }

         Point2D &operator=(const Point2D &other) { ... }

         int x() const { return data[0]; }
         int y() const { return data[1]; }

     private:
         int *data;
     };

     Q_DECLARE_TYPEINFO(Point2D, Q_RELOCATABLE_TYPE);

Qt will try to detect the class of a type using std::is_trivial_v<T> to identify primitive types and it will require both std::is_trivially_copyable_v<T> and std::is_trivially_destructible_v<T> to identify relocatable types. Use this macro to tune the behavior. For instance many types would be candidates for Q_RELOCATABLE_TYPE despite not being trivially-copyable.

### Q_DECL_EXPORT

This macro marks a symbol for shared library export (see Creating Shared Libraries).

See also Q_DECL_IMPORT.

### Q_DECL_IMPORT

This macro declares a symbol to be an import from a shared library (see Creating Shared Libraries).

See also Q_DECL_EXPORT.

### `[since 5.8]` void Q_FALLTHROUGH

Can be used in switch statements at the end of case block to tell the compiler and other developers that that the lack of a break statement is intentional.

This is useful since a missing break statement is often a bug, and some compilers can be configured to emit warnings when one is not found.

This macro was introduced in Qt 5.8.

See also Q_UNREACHABLE().

### `[since 5.2]` Q_FORWARD_DECLARE_CF_TYPE(type)

Forward-declares a Core Foundation type. This includes the actual type and the ref type. For example, Q_FORWARD_DECLARE_CF_TYPE(CFString) declares __CFString and CFStringRef.

This macro was introduced in Qt 5.2.

### `[since 5.2]` Q_FORWARD_DECLARE_MUTABLE_CF_TYPE(type)

Forward-declares a mutable Core Foundation type. This includes the actual type and the ref type. For example, Q_FORWARD_DECLARE_MUTABLE_CF_TYPE(CFMutableString) declares __CFMutableString and CFMutableStringRef.

This macro was introduced in Qt 5.2.

### `[since 5.2]` Q_FORWARD_DECLARE_OBJC_CLASS(classname)

Forward-declares an Objective-C classname in a manner such that it can be compiled as either Objective-C or C++.

This is primarily intended for use in header files that may be included by both Objective-C and C++ source files.

This macro was introduced in Qt 5.2.

### const char*Q_FUNC_INFO

Expands to a string that describe the function the macro resides in. How this string looks more specifically is compiler dependent. With GNU GCC it is typically the function signature, while with other compilers it might be the line and column number.

Q_FUNC_INFO can be conveniently used with qDebug(). For example, this function:

     template<typename TInputType>
     const TInputType &myMin(const TInputType &value1, const TInputType &value2)
     {
         qDebug() << Q_FUNC_INFO << "was called with value1:" << value1 << "value2:" << value2;

         if(value1 < value2)
             return value1;
         else
             return value2;
     }

when instantiated with the integer type, will with the GCC compiler produce:

`const TInputType& myMin(const TInputType&, const TInputType&) [with TInputType = int] was called with value1: 3 value2: 4`

If this macro is used outside a function, the behavior is undefined.

### qint64 Q_INT64_C(literal)

Wraps the signed 64-bit integer literal in a platform-independent way.

Example:

     qint64 value = Q_INT64_C(932838457459459);

See also qint64 and Q_UINT64_C().

### Q_LIKELY(expr)

Hints to the compiler that the enclosed condition, expr, is likely to evaluate to `true`.

Use of this macro can help the compiler to optimize the code.

Example:

         // the condition inside the "if" will be successful most of the times
         for (int i = 1; i <= 365; i++) {
             if (Q_LIKELY(isWorkingDay(i))) {
                 ...
             }
             ...
         }

See also Q_UNLIKELY().

### Q_LITTLE_ENDIAN

This macro represents a value you can compare to the macro Q_BYTE_ORDER to determine the endian-ness of your system. In a little-endian system, the least significant byte is stored at the lowest address. The other bytes follow in increasing order of significance.

     #if Q_BYTE_ORDER == Q_LITTLE_ENDIAN
     ...
     #endif

See also Q_BYTE_ORDER and Q_BIG_ENDIAN.

### Q_OS_AIX

Defined on AIX.

### Q_OS_ANDROID

Defined on Android.

### Q_OS_BSD4

Defined on Any BSD 4.4 system.

### Q_OS_CYGWIN

Defined on Cygwin.

### Q_OS_DARWIN

Defined on Darwin-based operating systems such as macOS, iOS, watchOS, and tvOS.

### Q_OS_FREEBSD

Defined on FreeBSD.

### Q_OS_HPUX

Defined on HP-UX.

### Q_OS_HURD

Defined on GNU Hurd.

### Q_OS_IOS

Defined on iOS.

### Q_OS_LINUX

Defined on Linux.

### Q_OS_LYNX

Defined on LynxOS.

### Q_OS_MAC

Deprecated synonym for `Q_OS_DARWIN`. Do not use.

### Q_OS_MACOS

Defined on macOS.

### Q_OS_NETBSD

Defined on NetBSD.

### Q_OS_OPENBSD

Defined on OpenBSD.

### Q_OS_OSX

Deprecated synonym for `Q_OS_MACOS`. Do not use.

### Q_OS_QNX

Defined on QNX Neutrino.

### Q_OS_SOLARIS

Defined on Sun Solaris.

### Q_OS_TVOS

Defined on tvOS.

### Q_OS_UNIX

Defined on Any UNIX BSD/SYSV system.

### Q_OS_WASM

Defined on Web Assembly.

### Q_OS_WATCHOS

Defined on watchOS.

### Q_OS_WIN32

Defined on 32-bit and 64-bit versions of Windows.

### Q_OS_WIN64

Defined on 64-bit versions of Windows.

### Q_OS_WIN

Defined on all supported versions of Windows. That is, if Q_OS_WIN32 or Q_OS_WIN64 is defined.

### Q_OS_WINDOWS

This is a synonym for Q_OS_WIN.

### Q_PROCESSOR_X86

Defined if the application is compiled for x86 processors. Qt currently supports two x86 variants: Q_PROCESSOR_X86_32 and Q_PROCESSOR_X86_64.

See also QSysInfo::buildCpuArchitecture().

### Q_PROCESSOR_S390

Defined if the application is compiled for S/390 processors. Qt supports one optional variant of S/390: Q_PROCESSOR_S390_X.

See also QSysInfo::buildCpuArchitecture().

### Q_PROCESSOR_ALPHA

Defined if the application is compiled for Alpha processors.

See also QSysInfo::buildCpuArchitecture().

### Q_PROCESSOR_ARM

Defined if the application is compiled for ARM processors. Qt currently supports three optional ARM revisions: Q_PROCESSOR_ARM_V5, Q_PROCESSOR_ARM_V6, and Q_PROCESSOR_ARM_V7.

See also QSysInfo::buildCpuArchitecture().

### Q_PROCESSOR_ARM_V5

Defined if the application is compiled for ARMv5 processors. The Q_PROCESSOR_ARM macro is also defined when Q_PROCESSOR_ARM_V5 is defined.

See also QSysInfo::buildCpuArchitecture().

### Q_PROCESSOR_ARM_V6

Defined if the application is compiled for ARMv6 processors. The Q_PROCESSOR_ARM and Q_PROCESSOR_ARM_V5 macros are also defined when Q_PROCESSOR_ARM_V6 is defined.

See also QSysInfo::buildCpuArchitecture().

### Q_PROCESSOR_ARM_V7

Defined if the application is compiled for ARMv7 processors. The Q_PROCESSOR_ARM, Q_PROCESSOR_ARM_V5, and Q_PROCESSOR_ARM_V6 macros are also defined when Q_PROCESSOR_ARM_V7 is defined.

See also QSysInfo::buildCpuArchitecture().

### Q_PROCESSOR_AVR32

Defined if the application is compiled for AVR32 processors.

See also QSysInfo::buildCpuArchitecture().

### Q_PROCESSOR_BLACKFIN

Defined if the application is compiled for Blackfin processors.

See also QSysInfo::buildCpuArchitecture().

### Q_PROCESSOR_HPPA

Defined if the application is compiled for PA-RISC processors.

See also QSysInfo::buildCpuArchitecture().

### Q_PROCESSOR_IA64

Defined if the application is compiled for IA-64 processors. This includes all Itanium and Itanium 2 processors.

See also QSysInfo::buildCpuArchitecture().

### Q_PROCESSOR_M68K

Defined if the application is compiled for Motorola 68000 processors.

See also QSysInfo::buildCpuArchitecture().

### Q_PROCESSOR_MIPS

Defined if the application is compiled for MIPS processors. Qt currently supports seven MIPS revisions: Q_PROCESSOR_MIPS_I, Q_PROCESSOR_MIPS_II, Q_PROCESSOR_MIPS_III, Q_PROCESSOR_MIPS_IV, Q_PROCESSOR_MIPS_V, Q_PROCESSOR_MIPS_32, and Q_PROCESSOR_MIPS_64.

See also QSysInfo::buildCpuArchitecture().

### Q_PROCESSOR_MIPS_32

Defined if the application is compiled for MIPS32 processors. The Q_PROCESSOR_MIPS, Q_PROCESSOR_MIPS_I, and Q_PROCESSOR_MIPS_II macros are also defined when Q_PROCESSOR_MIPS_32 is defined.

See also QSysInfo::buildCpuArchitecture().

### Q_PROCESSOR_MIPS_64

Defined if the application is compiled for MIPS64 processors. The Q_PROCESSOR_MIPS, Q_PROCESSOR_MIPS_I, Q_PROCESSOR_MIPS_II, Q_PROCESSOR_MIPS_III, Q_PROCESSOR_MIPS_IV, and Q_PROCESSOR_MIPS_V macros are also defined when Q_PROCESSOR_MIPS_64 is defined.

See also QSysInfo::buildCpuArchitecture().

### Q_PROCESSOR_MIPS_I

Defined if the application is compiled for MIPS-I processors. The Q_PROCESSOR_MIPS macro is also defined when Q_PROCESSOR_MIPS_I is defined.

See also QSysInfo::buildCpuArchitecture().

### Q_PROCESSOR_MIPS_II

Defined if the application is compiled for MIPS-II processors. The Q_PROCESSOR_MIPS and Q_PROCESSOR_MIPS_I macros are also defined when Q_PROCESSOR_MIPS_II is defined.

See also QSysInfo::buildCpuArchitecture().

### Q_PROCESSOR_MIPS_III

Defined if the application is compiled for MIPS-III processors. The Q_PROCESSOR_MIPS, Q_PROCESSOR_MIPS_I, and Q_PROCESSOR_MIPS_II macros are also defined when Q_PROCESSOR_MIPS_III is defined.

See also QSysInfo::buildCpuArchitecture().

### Q_PROCESSOR_MIPS_IV

Defined if the application is compiled for MIPS-IV processors. The Q_PROCESSOR_MIPS, Q_PROCESSOR_MIPS_I, Q_PROCESSOR_MIPS_II, and Q_PROCESSOR_MIPS_III macros are also defined when Q_PROCESSOR_MIPS_IV is defined.

See also QSysInfo::buildCpuArchitecture().

### Q_PROCESSOR_MIPS_V

Defined if the application is compiled for MIPS-V processors. The Q_PROCESSOR_MIPS, Q_PROCESSOR_MIPS_I, Q_PROCESSOR_MIPS_II, Q_PROCESSOR_MIPS_III, and Q_PROCESSOR_MIPS_IV macros are also defined when Q_PROCESSOR_MIPS_V is defined.

See also QSysInfo::buildCpuArchitecture().

### Q_PROCESSOR_POWER

Defined if the application is compiled for POWER processors. Qt currently supports two Power variants: Q_PROCESSOR_POWER_32 and Q_PROCESSOR_POWER_64.

See also QSysInfo::buildCpuArchitecture().

### Q_PROCESSOR_POWER_32

Defined if the application is compiled for 32-bit Power processors. The Q_PROCESSOR_POWER macro is also defined when Q_PROCESSOR_POWER_32 is defined.

See also QSysInfo::buildCpuArchitecture().

### Q_PROCESSOR_POWER_64

Defined if the application is compiled for 64-bit Power processors. The Q_PROCESSOR_POWER macro is also defined when Q_PROCESSOR_POWER_64 is defined.

See also QSysInfo::buildCpuArchitecture().

### `[since 5.13]` Q_PROCESSOR_RISCV

Defined if the application is compiled for RISC-V processors. Qt currently supports two RISC-V variants: Q_PROCESSOR_RISCV_32 and Q_PROCESSOR_RISCV_64.

This macro was introduced in Qt 5.13.

See also QSysInfo::buildCpuArchitecture().

### `[since 5.13]` Q_PROCESSOR_RISCV_32

Defined if the application is compiled for 32-bit RISC-V processors. The Q_PROCESSOR_RISCV macro is also defined when Q_PROCESSOR_RISCV_32 is defined.

This macro was introduced in Qt 5.13.

See also QSysInfo::buildCpuArchitecture().

### `[since 5.13]` Q_PROCESSOR_RISCV_64

Defined if the application is compiled for 64-bit RISC-V processors. The Q_PROCESSOR_RISCV macro is also defined when Q_PROCESSOR_RISCV_64 is defined.

This macro was introduced in Qt 5.13.

See also QSysInfo::buildCpuArchitecture().

### Q_PROCESSOR_S390_X

Defined if the application is compiled for S/390x processors. The Q_PROCESSOR_S390 macro is also defined when Q_PROCESSOR_S390_X is defined.

See also QSysInfo::buildCpuArchitecture().

### Q_PROCESSOR_SH

Defined if the application is compiled for SuperH processors. Qt currently supports one SuperH revision: Q_PROCESSOR_SH_4A.

See also QSysInfo::buildCpuArchitecture().

### Q_PROCESSOR_SH_4A

Defined if the application is compiled for SuperH 4A processors. The Q_PROCESSOR_SH macro is also defined when Q_PROCESSOR_SH_4A is defined.

See also QSysInfo::buildCpuArchitecture().

### Q_PROCESSOR_SPARC

Defined if the application is compiled for SPARC processors. Qt currently supports one optional SPARC revision: Q_PROCESSOR_SPARC_V9.

See also QSysInfo::buildCpuArchitecture().

### Q_PROCESSOR_SPARC_V9

Defined if the application is compiled for SPARC V9 processors. The Q_PROCESSOR_SPARC macro is also defined when Q_PROCESSOR_SPARC_V9 is defined.

See also QSysInfo::buildCpuArchitecture().

### Q_PROCESSOR_X86_32

Defined if the application is compiled for 32-bit x86 processors. This includes all i386, i486, i586, and i686 processors. The Q_PROCESSOR_X86 macro is also defined when Q_PROCESSOR_X86_32 is defined.

See also QSysInfo::buildCpuArchitecture().

### Q_PROCESSOR_X86_64

Defined if the application is compiled for 64-bit x86 processors. This includes all AMD64, Intel 64, and other x86_64/x64 processors. The Q_PROCESSOR_X86 macro is also defined when Q_PROCESSOR_X86_64 is defined.

See also QSysInfo::buildCpuArchitecture().

### quint64 Q_UINT64_C(literal)

Wraps the unsigned 64-bit integer literal in a platform-independent way.

Example:

     quint64 value = Q_UINT64_C(932838457459459);

See also quint64 and Q_INT64_C().

### Q_UNLIKELY(expr)

Hints to the compiler that the enclosed condition, expr, is likely to evaluate to `false`.

Use of this macro can help the compiler to optimize the code.

Example:

     bool readConfiguration(const QFile &file)
     {
         // We expect to be asked to read an existing file
         if (Q_UNLIKELY(!file.exists())) {
             qWarning() << "File not found";
             return false;
         }

         ...
         return true;
     }

See also Q_LIKELY().

### `[since 5.0]` void Q_UNREACHABLE

Tells the compiler that the current point cannot be reached by any execution, so it may optimize any code paths leading here as dead code, as well as code continuing from here.

This macro is useful to mark impossible conditions. For example, given the following enum:

        enum Shapes {
            Rectangle,
            Triangle,
            Circle,
            NumShapes
        };

One can write a switch table like so:

        switch (shape) {
            case Rectangle:
                return rectangle();
            case Triangle:
                return triangle();
            case Circle:
                return circle();
            case NumShapes:
                Q_UNREACHABLE();
                break;
        }

The advantage of inserting Q_UNREACHABLE() at that point is that the compiler is told not to generate code for a shape variable containing that value. If the macro is missing, the compiler will still generate the necessary comparisons for that value. If the case label were removed, some compilers could produce a warning that some enum values were not checked.

By using this macro in impossible conditions, code coverage may be improved as dead code paths may be eliminated.

In debug builds the condition is enforced by an assert to facilitate debugging.

This macro was introduced in Qt 5.0.

See also Q_ASSERT(), Q_ASSUME(), and qFatal().

### Q_UNUSED(name)

Indicates to the compiler that the parameter with the specified name is not used in the body of a function. This can be used to suppress compiler warnings while allowing functions to be defined with meaningful parameter names in their signatures.

### qCritical(const char *message, ...)

Calls the message handler with the critical message message. If no message handler has been installed, the message is printed to stderr. Under Windows, the message is sent to the debugger. On QNX the message is sent to slogger2.

It exits if the environment variable QT_FATAL_CRITICALS is not empty.

This function takes a format string and a list of arguments, similar to the C printf() function. The format should be a Latin-1 string.

Example:

     void load(const QString &fileName)
     {
         QFile file(fileName);
         if (!file.exists())
             qCritical("File '%s' does not exist!", qUtf8Printable(fileName));
     }

If you include <QtDebug>, a more convenient syntax is also available:

     qCritical() << "Brush:" << myQBrush << "Other value:" << i;

A space is inserted between the items, and a newline is appended at the end.

To suppress the output at runtime, install your own message handler with qInstallMessageHandler().

Note: This macro is thread-safe.

See also qDebug(), qInfo(), qWarning(), qFatal(), qInstallMessageHandler(), and Debugging Techniques.

### qDebug(const char *message, ...)

Calls the message handler with the debug message message. If no message handler has been installed, the message is printed to stderr. Under Windows the message is sent to the console, if it is a console application; otherwise, it is sent to the debugger. On QNX, the message is sent to slogger2. This function does nothing if `QT_NO_DEBUG_OUTPUT` was defined during compilation.

If you pass the function a format string and a list of arguments, it works in similar way to the C printf() function. The format should be a Latin-1 string.

Example:

     qDebug("Items in list: %d", myList.size());

If you include `<QtDebug>`, a more convenient syntax is also available:

     qDebug() << "Brush:" << myQBrush << "Other value:" << i;

With this syntax, the function returns a QDebug object that is configured to use the QtDebugMsg message type. It automatically puts a single space between each item, and outputs a newline at the end. It supports many C++ and Qt types.

To suppress the output at runtime, install your own message handler with qInstallMessageHandler().

Note: This macro is thread-safe.

See also qInfo(), qWarning(), qCritical(), qFatal(), qInstallMessageHandler(), and Debugging Techniques.

### qFatal(const char *message, ...)

Calls the message handler with the fatal message message. If no message handler has been installed, the message is printed to stderr. Under Windows, the message is sent to the debugger. On QNX the message is sent to slogger2.

If you are using the default message handler this function will abort to create a core dump. On Windows, for debug builds, this function will report a _CRT_ERROR enabling you to connect a debugger to the application.

This function takes a format string and a list of arguments, similar to the C printf() function.

Example:

     int divide(int a, int b)
     {
         if (b == 0)                                // program error
             qFatal("divide: cannot divide by zero");
         return a / b;
     }

To suppress the output at runtime, install your own message handler with qInstallMessageHandler().

See also qDebug(), qInfo(), qWarning(), qCritical(), qInstallMessageHandler(), and Debugging Techniques.

### `[since 5.5]` qInfo(const char *message, ...)

Calls the message handler with the informational message message. If no message handler has been installed, the message is printed to stderr. Under Windows, the message is sent to the console, if it is a console application; otherwise, it is sent to the debugger. On QNX the message is sent to slogger2. This function does nothing if `QT_NO_INFO_OUTPUT` was defined during compilation.

If you pass the function a format string and a list of arguments, it works in similar way to the C printf() function. The format should be a Latin-1 string.

Example:

     qInfo("Items in list: %d", myList.size());

If you include `<QtDebug>`, a more convenient syntax is also available:

     qInfo() << "Brush:" << myQBrush << "Other value:" << i;

With this syntax, the function returns a QDebug object that is configured to use the QtInfoMsg message type. It automatically puts a single space between each item, and outputs a newline at the end. It supports many C++ and Qt types.

To suppress the output at runtime, install your own message handler using qInstallMessageHandler().

Note: This macro is thread-safe.

This macro was introduced in Qt 5.5.

See also qDebug(), qWarning(), qCritical(), qFatal(), qInstallMessageHandler(), and Debugging Techniques.

### const char *qPrintable(const QString &str)

Returns str as a `const char *`. This is equivalent to str.toLocal8Bit().constData().

The char pointer will be invalid after the statement in which qPrintable() is used. This is because the array returned by QString::toLocal8Bit() will fall out of scope.

Note: qDebug(), qInfo(), qWarning(), qCritical(), qFatal() expect %s arguments to be UTF-8 encoded, while qPrintable() converts to local 8-bit encoding. Therefore qUtf8Printable() should be used for logging strings instead of qPrintable().

See also qUtf8Printable().

### `[since 5.7]` const wchar_t *qUtf16Printable(const QString &str)

Returns str as a `const ushort *`, but cast to a `const wchar_t *` to avoid warnings. This is equivalent to str.utf16() plus some casting.

The only useful thing you can do with the return value of this macro is to pass it to QString::asprintf() for use in a `%ls` conversion. In particular, the return value is not a valid `const wchar_t*`!

In general, the pointer will be invalid after the statement in which qUtf16Printable() is used. This is because the pointer may have been obtained from a temporary expression, which will fall out of scope.

Example:

     qWarning("%ls: %ls", qUtf16Printable(key), qUtf16Printable(value));

This macro was introduced in Qt 5.7.

See also qPrintable(), qDebug(), qInfo(), qWarning(), qCritical(), and qFatal().

### `[since 5.4]` const char *qUtf8Printable(const QString &str)

Returns str as a `const char *`. This is equivalent to str.toUtf8().constData().

The char pointer will be invalid after the statement in which qUtf8Printable() is used. This is because the array returned by QString::toUtf8() will fall out of scope.

Example:

     qWarning("%s: %s", qUtf8Printable(key), qUtf8Printable(value));

This macro was introduced in Qt 5.4.

See also qPrintable(), qDebug(), qInfo(), qWarning(), qCritical(), and qFatal().

### qWarning(const char *message, ...)

Calls the message handler with the warning message message. If no message handler has been installed, the message is printed to stderr. Under Windows, the message is sent to the debugger. On QNX the message is sent to slogger2. This function does nothing if `QT_NO_WARNING_OUTPUT` was defined during compilation; it exits if at the nth warning corresponding to the counter in environment variable `QT_FATAL_WARNINGS`. That is, if the environment variable contains the value 1, it will exit on the 1st message; if it contains the value 10, it will exit on the 10th message. Any non-numeric value is equivalent to 1.

This function takes a format string and a list of arguments, similar to the C printf() function. The format should be a Latin-1 string.

Example:

     void f(int c)
     {
         if (c > 200)
             qWarning("f: bad argument, c == %d", c);
     }

If you include <QtDebug>, a more convenient syntax is also available:

     qWarning() << "Brush:" << myQBrush << "Other value:" << i;

This syntax inserts a space between each item, and appends a newline at the end.

To suppress the output at runtime, install your own message handler with qInstallMessageHandler().

Note: This macro is thread-safe.

See also qDebug(), qInfo(), qCritical(), qFatal(), qInstallMessageHandler(), and Debugging Techniques.