The <QtGlobal> header file includes the fundamental global declarations. It is included by most other Qt header files.
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 theqlonglong
type definition forlong long int
(__int64
on Windows).Several convenience type definitions are declared:
qreal
fordouble
orfloat
,uchar
forunsigned
char,uint
forunsigned
int,ulong
forunsigned
long andushort
forunsigned
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 signaturevoid myMessageHandler(QtMsgType, const QMessageLogContext &, const char *)
.QMessageLogContext
class contains the line, file, and function the message was logged at. This information is created by theQMessageLogger
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 theqBound()
function. You can retrieve the minimum and maximum of two given objects usingqMin()
andqMax()
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()
, andqFatal()
. 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()
andqRound64()
, which both accept adouble
orfloat
value as their argument returning the value rounded up to the nearest integer and 64-bit integer respectively, theqInstallMessageHandler()
function which installs the givenQtMessageHandler
, and theqVersion()
function which returns the version number of Qt at run-time 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()
, andQT_TRANSLATE_NOOP3()
macros provide the possibility of marking strings for delayed translation.QT_TR_N_NOOP()
,QT_TRANSLATE_N_NOOP()
, andQT_TRANSLATE_N_NOOP3()
are numerator dependent variants of these. TheQ_ASSERT()
andQ_ASSERT_X()
enables warning messages of various level of refinement. TheQ_FOREACH()
andforeach()
macros implement Qt’s foreach loop.The
Q_INT64_C()
andQ_UINT64_C()
macros wrap signed and unsigned 64-bit integer literals in a platform-independent way. TheQ_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 isNone
. TheqPrintable()
andqUtf8Printable()
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
andQT_VERSION_STR
expand to a numeric value or a string, respectively, that specifies the version of Qt that the application is compiled against.See also
<QtAlgorithms>
QSysInfo
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
QT_NO_DEPRECATED_WARNINGS
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 using a future release of Qt 5, set
QT_DISABLE_DEPRECATED_BEFORE=0x050100
to disable functions deprecated in Qt 5.1 and earlier. In any release, setQT_DISABLE_DEPRECATED_BEFORE=0x000000
to enable all functions, including the ones deprecated in Qt 5.0.See also
QT_DEPRECATED_WARNINGS
This macro can be used to suppress deprecation warnings that would otherwise be generated when using deprecated APIs.
See also
QT_DISABLE_DEPRECATED_BEFORE
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.This macro can be used to ensure that the application is run against 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 (e.g., 4.0.2).
The
argc
andargv
parameters are themain()
function’sargc
andargv
parameters. Theversion
parameter is a string literal that specifies which version of Qt the application requires (e.g., “4.0.2”).Example:
#include <QApplication> #include <QMessageBox> int main(int argc, char *argv[]) { QT_REQUIRE_VERSION(argc, argv, "4.0.2") QApplication app(argc, argv); ... return app.exec(); }In general, use of the
Q_DECL_NOEXCEPT
macro is preferred overQ_DECL_NOTHROW
, because it exhibits well-defined behavior and supports the more powerfulQ_DECL_NOEXCEPT_EXPR
variant. However, use ofQ_DECL_NOTHROW
has the advantage that Windows builds benefit on a wide range or compiler versions that do not yet support the C++11 noexcept feature.It may therefore be beneficial to use
Q_DECL_NOTHROW
and emulate the C++11 behavior manually with an embedded try/catch.Qt provides the QT_TERMINATE_ON_EXCEPTION(expr) macro for this purpose. It either expands to
expr
(if Qt is compiled without exception support or the compiler supports C++11 noexcept semantics) or totry { expr; } catch(...) { qTerminate(); }otherwise.
Since this macro expands to just
expr
if the compiler supports C++11 noexcept, expecting the compiler to take over responsibility of calling std::terminate() in that case, it should not be used outsideQ_DECL_NOTHROW
functions.See also
Q_DECL_NOEXCEPT
Q_DECL_NOTHROW
qTerminate()
Marks the UTF-8 encoded string literal
sourceText
for delayed translation in the givencontext
. Thecontext
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()
Internationalization with Qt
Marks the UTF-8 encoded string literal
sourceText
for delayed translation in the givencontext
with the givendisambiguation
. Thecontext
is typically a class and also needs to be specified as a string literal. The string literaldisambiguation
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
anddisambiguation
.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()
Internationalization with Qt
Marks the UTF-8 encoded string literal
sourceText
for numerator dependent delayed translation in the givencontext
. Thecontext
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); }See also
QT_TRANSLATE_NOOP()
QT_TRANSLATE_N_NOOP3()
Internationalization with Qt
Marks the UTF-8 encoded string literal
sourceText
for numerator dependent delayed translation in the givencontext
with the givencomment
. Thecontext
is typically a class and also needs to be specified as a string literal. The string literalcomment
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
andcomment
.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); }See also
QT_TR_NOOP()
QT_TRANSLATE_NOOP()
QT_TRANSLATE_NOOP3()
Internationalization with Qt
The 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()
Internationalization with Qt
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()
Internationalization with Qt
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); }See also
QT_TR_NOOP
Internationalization with Qt
This macro expands a numeric value of the form 0xMMNNPP (MM = major, NN = minor, PP = patch) that specifies Qt’s version number. For example, if you compile your application against Qt 4.1.2, the macro will expand to 0x040102.
You can use to use the latest Qt features where available.
Example:
#if QT_VERSION >= 0x040100 QIcon icon = style()->standardIcon(QStyle::SP_TrashIcon); #else QPixmap pixmap = style()->standardPixmap(QStyle::SP_TrashIcon); QIcon icon(pixmap); #endifSee also
QT_VERSION_STR
qVersion()
Turns the major, minor and patch numbers of a version into an integer, 0xMMNNPP (MM = major, NN = minor, PP = 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> #endifSee also
QT_VERSION
This macro expands to a string that specifies Qt’s version number (for example, “4.1.2”). This is the version against which the application is compiled.
See also
qVersion()
QT_VERSION
Prints a warning message containing the source code file name and line number if
test
isfalse
.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 statement will output the following message using theqFatal()
function:ASSERT: "b != 0" in file div.cpp, line 7See also
Q_ASSERT_X()
qFatal()
Debugging Techniques
Prints the message
what
together with the locationwhere
, the source file name and line number iftest
isfalse
.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 statement will output the following message using theqFatal()
function:ASSERT failure in divide: "division by zero", file div.cpp, line 7See also
Q_ASSERT()
qFatal()
Debugging Techniques
Causes the compiler to assume that
expr
istrue
. 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()
. WhileQ_ASSERT
will abort the program’s execution if the condition isfalse
, 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 constantlyfalse
condition, will tell the compiler that the current code execution cannot be reached. That is, (false) is equivalent toQ_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. tells the compiler that it is the only possibility.See also
Q_ASSERT()
Q_UNREACHABLE()
Q_LIKELY()
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 ... #endifSee also
Q_BYTE_ORDER
Q_LITTLE_ENDIAN
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
orQ_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 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 ... #endifSee also
Q_BIG_ENDIAN
Q_LITTLE_ENDIAN
Defined if the application is compiled using Borland/Turbo C++.
Defined if the application is compiled using Reliant C++.
Defined if the application is compiled using Clang.
Defined if the application is compiled using Comeau C++.
Defined if the application is compiled using DEC C++.
Defined if the application is compiled using Edison Design Group C++.
Defined if the application is compiled using Green Hills Optimizing C++ Compilers.
Defined if the application is compiled using GNU C++.
Defined if the application is compiled using MetaWare High C/C++.
Defined if the application is compiled using HP aC++.
Defined if the application is compiled using Intel C++ for Linux, Intel C++ for Windows.
Defined if the application is compiled using KAI C++.
Defined if the application is compiled using MIPSpro C++.
Defined if the application is compiled using Microsoft Visual C/C++, Intel C++ for Windows.
Defined if the application is compiled using CenterLine C++.
Defined if the application is compiled using Portland Group C++.
Defined if the application is compiled using Forte Developer, or Sun Studio C++.
Defined if the application is compiled using Digital Mars C/C++ (used to be Symantec C++).
Defined if the application is compiled using SCO OUDK and UDK.
Defined if the application is compiled using Watcom C++.
If
pointer
isNone
, 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 throwsstd::bad_alloc
instead if exceptions are enabled.does nothing if
QT_NO_DEBUG
andQT_NO_EXCEPTIONS
were defined during compilation. Therefore you must not use 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()
Debugging Techniques
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 thatType
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_MOVABLE_TYPE
specifies thatType
has a constructor and/or a destructor but can be moved in memory usingmemcpy()
. Note: despite the name, this has nothing to do with move constructors or C++ move semantics.
Q_COMPLEX_TYPE
(the default) specifies thatType
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 thoughQUuid
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 aQUuid
object.Example of a movable 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_MOVABLE_TYPE);Qt will try to detect the class of a type using std::is_trivial or std::is_trivially_copyable. Use this macro to tune the behavior. For instance many types would be candidates for despite not being trivially-copyable. For binary compatibility reasons,
QList
optimizations are only enabled if there is an explicit even for trivially-copyable types.This macro can be used to declare variable that should be constructed at compile-time, or an inline function that can be computed at compile-time.
It expands to “constexpr” if your compiler supports that C++11 keyword, or to nothing otherwise.
See also
Q_DECL_RELAXED_CONSTEXPR
This macro marks a symbol for shared library export (see Creating Shared Libraries).
See also
Q_DECL_IMPORT
This macro can be used to declare an overriding virtual or a class as “final”, with Java semantics. Further-derived classes can then no longer override this virtual function, or inherit from this class, respectively.
It expands to “final”.
The macro goes at the end of the function, usually after the
const
, if any:// more-derived classes no longer permitted to override this: virtual void MyWidget::paintEvent(QPaintEvent*) final;For classes, it goes in front of the
:
in the class definition, if any:class QRect final { // cannot be derived from // ... };See also
Q_DECL_OVERRIDE
This macro declares a symbol to be an import from a shared library (see Creating Shared Libraries).
See also
Q_DECL_EXPORT
This macro marks a function as never throwing. If the function does nevertheless throw, the behaviour is defined: std::terminate() is called.
The macro expands to C++11 noexcept, if available, or to nothing otherwise.
If you need the operator version of C++11 noexcept, use
Q_DECL_NOEXCEPT_EXPR
(x).If you don’t need C++11 noexcept semantics, e.g. because your function can’t possibly throw, don’t use this macro, use
Q_DECL_NOTHROW
instead.See also
Q_DECL_NOTHROW
Q_DECL_NOEXCEPT_EXPR()
This macro marks a function as non-throwing if
x
istrue
. If the function does nevertheless throw, the behaviour is defined: std::terminate() is called.The macro expands to C++11 noexcept(x), if available, or to nothing otherwise.
If you need the always-true version of C++11 noexcept, use
Q_DECL_NOEXCEPT
.If you don’t need C++11 noexcept semantics, e.g. because your function can’t possibly throw, don’t use this macro, use
Q_DECL_NOTHROW
instead.See also
Q_DECL_NOTHROW
Q_DECL_NOEXCEPT
This macro marks a function as never throwing, under no circumstances. If the function does nevertheless throw, the behaviour is undefined.
The macro expands to either “throw()”, if that has some benefit on the compiler, or to C++11 noexcept, if available, or to nothing otherwise.
If you need C++11 noexcept semantics, don’t use this macro, use
Q_DECL_NOEXCEPT
/Q_DECL_NOEXCEPT_EXPR
instead.See also
Q_DECL_NOEXCEPT
Q_DECL_NOEXCEPT_EXPR()
This macro can be used to declare an overriding virtual function. Use of this markup will allow the compiler to generate an error if the overriding virtual function does not in fact override anything.
It expands to “override”.
The macro goes at the end of the function, usually after the
const
, if any:// generate error if this doesn't actually override anything: virtual void MyWidget::paintEvent(QPaintEvent*) override;See also
Q_DECL_FINAL
This macro can be used to declare an inline function that can be computed at compile-time according to the relaxed rules from C++14.
It expands to “constexpr” if your compiler supports C++14 relaxed constant expressions, or to nothing otherwise.
See also
Q_DECL_CONSTEXPR
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.
See also
Q_UNREACHABLE()
Same as foreach(
variable
,container
).This macro is available even when
no_keywords
is specified using the.pro
file’sCONFIG
variable.Note
Since Qt 5.7, the use of this macro is discouraged. It will be removed in a future version of Qt. Please use C++11 range-for, possibly with
qAsConst()
, as needed.See also
qAsConst()
Same as
forever
.This macro is available even when
no_keywords
is specified using the.pro
file’sCONFIG
variable.See also
foreach()
Forward-declares a Core Foundation
type
. This includes the actual type and the ref type. For example, (CFString) declares __CFString and CFStringRef.Forward-declares a mutable Core Foundation
type
. This includes the actual type and the ref type. For example, (CFMutableString) declares __CFMutableString and CFMutableStringRef.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.
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.
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.
Wraps the signed 64-bit integer
literal
in a platform-independent way.Example:
qint64 value = Q_INT64_C(932838457459459);See also
qint64
Q_UINT64_C()
Hints to the compiler that the enclosed condition,
expr
, is likely to evaluate totrue
.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()
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 ... #endifSee also
Q_BYTE_ORDER
Q_BIG_ENDIAN
Defined on AIX.
Defined on Android.
Defined on Any BSD 4.4 system.
Defined on Cygwin.
Defined on Darwin-based operating systems such as macOS, iOS, watchOS, and tvOS.
Defined on FreeBSD.
Defined on HP-UX.
Defined on GNU Hurd.
Defined on iOS.
Defined on Linux.
Defined on LynxOS.
Deprecated synonym for
Q_OS_DARWIN
. Do not use.Defined on macOS.
Defined on NetBSD.
Defined on OpenBSD.
Deprecated synonym for
Q_OS_MACOS
. Do not use.Defined on QNX Neutrino.
Defined on Sun Solaris.
Defined on tvOS.
Defined on Any UNIX BSD/SYSV system.
Defined on Web Assembly.
Defined on watchOS.
Defined on all supported versions of Windows. That is, if
Q_OS_WIN32
,Q_OS_WIN64
, orQ_OS_WINRT
is defined.Defined on 32-bit and 64-bit versions of Windows.
Defined on 64-bit versions of Windows.
This is a synonym for
Q_OS_WIN
.Defined for Windows Runtime (Windows Store apps) on Windows 8, Windows RT, and Windows Phone 8.
Defined if the application is compiled for Alpha processors.
See also
buildCpuArchitecture()
Defined if the application is compiled for ARM processors. Qt currently supports three optional ARM revisions:
Q_PROCESSOR_ARM_V5
,Q_PROCESSOR_ARM_V6
, andQ_PROCESSOR_ARM_V7
.See also
buildCpuArchitecture()
Defined if the application is compiled for ARMv5 processors. The
Q_PROCESSOR_ARM
macro is also defined when is defined.See also
buildCpuArchitecture()
Defined if the application is compiled for ARMv6 processors. The
Q_PROCESSOR_ARM
andQ_PROCESSOR_ARM_V5
macros are also defined when is defined.See also
buildCpuArchitecture()
Defined if the application is compiled for ARMv7 processors. The
Q_PROCESSOR_ARM
,Q_PROCESSOR_ARM_V5
, andQ_PROCESSOR_ARM_V6
macros are also defined when is defined.See also
buildCpuArchitecture()
Defined if the application is compiled for AVR32 processors.
See also
buildCpuArchitecture()
Defined if the application is compiled for Blackfin processors.
See also
buildCpuArchitecture()
Defined if the application is compiled for IA-64 processors. This includes all Itanium and Itanium 2 processors.
See also
buildCpuArchitecture()
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
, andQ_PROCESSOR_MIPS_64
.See also
buildCpuArchitecture()
Defined if the application is compiled for MIPS32 processors. The
Q_PROCESSOR_MIPS
,Q_PROCESSOR_MIPS_I
, andQ_PROCESSOR_MIPS_II
macros are also defined when is defined.See also
buildCpuArchitecture()
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
, andQ_PROCESSOR_MIPS_V
macros are also defined when is defined.See also
buildCpuArchitecture()
Defined if the application is compiled for MIPS-I processors. The
Q_PROCESSOR_MIPS
macro is also defined when is defined.See also
buildCpuArchitecture()
Defined if the application is compiled for MIPS-II processors. The
Q_PROCESSOR_MIPS
andQ_PROCESSOR_MIPS_I
macros are also defined when is defined.See also
buildCpuArchitecture()
Defined if the application is compiled for MIPS-III processors. The
Q_PROCESSOR_MIPS
,Q_PROCESSOR_MIPS_I
, andQ_PROCESSOR_MIPS_II
macros are also defined when is defined.See also
buildCpuArchitecture()
Defined if the application is compiled for MIPS-IV processors. The
Q_PROCESSOR_MIPS
,Q_PROCESSOR_MIPS_I
,Q_PROCESSOR_MIPS_II
, andQ_PROCESSOR_MIPS_III
macros are also defined when is defined.See also
buildCpuArchitecture()
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
, andQ_PROCESSOR_MIPS_IV
macros are also defined when is defined.See also
buildCpuArchitecture()
Defined if the application is compiled for POWER processors. Qt currently supports two Power variants:
Q_PROCESSOR_POWER_32
andQ_PROCESSOR_POWER_64
.See also
buildCpuArchitecture()
Defined if the application is compiled for 32-bit Power processors. The
Q_PROCESSOR_POWER
macro is also defined when is defined.See also
buildCpuArchitecture()
Defined if the application is compiled for 64-bit Power processors. The
Q_PROCESSOR_POWER
macro is also defined when is defined.See also
buildCpuArchitecture()
Defined if the application is compiled for RISC-V processors. Qt currently supports two RISC-V variants:
Q_PROCESSOR_RISCV_32
andQ_PROCESSOR_RISCV_64
.See also
buildCpuArchitecture()
Defined if the application is compiled for 32-bit RISC-V processors. The
Q_PROCESSOR_RISCV
macro is also defined when is defined.See also
buildCpuArchitecture()
Defined if the application is compiled for 64-bit RISC-V processors. The
Q_PROCESSOR_RISCV
macro is also defined when is defined.See also
buildCpuArchitecture()
Defined if the application is compiled for S/390 processors. Qt supports one optional variant of S/390:
Q_PROCESSOR_S390_X
.See also
buildCpuArchitecture()
Defined if the application is compiled for S/390x processors. The
Q_PROCESSOR_S390
macro is also defined when is defined.See also
buildCpuArchitecture()
Defined if the application is compiled for SuperH processors. Qt currently supports one SuperH revision:
Q_PROCESSOR_SH_4A
.See also
buildCpuArchitecture()
Defined if the application is compiled for SuperH 4A processors. The
Q_PROCESSOR_SH
macro is also defined when is defined.See also
buildCpuArchitecture()
Defined if the application is compiled for SPARC processors. Qt currently supports one optional SPARC revision:
Q_PROCESSOR_SPARC_V9
.See also
buildCpuArchitecture()
Defined if the application is compiled for SPARC V9 processors. The
Q_PROCESSOR_SPARC
macro is also defined when is defined.See also
buildCpuArchitecture()
Defined if the application is compiled for x86 processors. Qt currently supports two x86 variants:
Q_PROCESSOR_X86_32
andQ_PROCESSOR_X86_64
.See also
buildCpuArchitecture()
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 is defined.See also
buildCpuArchitecture()
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 is defined.See also
buildCpuArchitecture()
Wraps the unsigned 64-bit integer
literal
in a platform-independent way.Example:
quint64 value = Q_UINT64_C(932838457459459);See also
quint64
Q_INT64_C()
Hints to the compiler that the enclosed condition,
expr
, is likely to evaluate tofalse
.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()
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 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.
See also
Q_ASSERT()
Q_ASSUME()
qFatal()
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.This macro is used to implement Qt’s
foreach
loop. Thevariable
parameter is a variable name or variable definition; thecontainer
parameter is a Qt container whose value type corresponds to the type of the variable. See The foreach Keyword for details.If you’re worried about namespace pollution, you can disable this macro by adding the following line to your
.pro
file:CONFIG += no_keywordsNote
Since Qt 5.7, the use of this macro is discouraged. It will be removed in a future version of Qt. Please use C++11 range-for, possibly with
qAsConst()
, as needed.See also
qAsConst()
This macro is provided for convenience for writing infinite loops.
Example:
forever { ... }It is equivalent to
for (;;)
.If you’re worried about namespace pollution, you can disable this macro by adding the following line to your
.pro
file:CONFIG += no_keywordsSee also
Q_FOREVER
Compares
t
to the 0 of type T and returns the absolute value. Thus if T is double , thent
is compared to (double) 0 .Example:
int absoluteValue; int myValue = -4; absoluteValue = qAbs(myValue); // absoluteValue == 4Returns
t
cast toconst 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 : qAsConst(s)) // ok, no detach attempt process(ch);Of course, in this case, you could (and probably should) have declared
s
asconst
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 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 durationthis would not:
for (QChar ch : qAsConst(funcReturningQString())) process(ch); // ERROR: ch is copied from deleted memoryTo prevent this construct from compiling (and failing at runtime), has a second, deleted, overload which binds to rvalues.
This is an overloaded function.
This overload is deleted to prevent a dangling reference in code like
for (QChar ch : qAsConst(funcReturningQString())) process(ch); // ERROR: ch is copied from deleted memoryReturns
val
bounded bymin
andmax
. This is equivalent toqMax
(min
,qMin
(val
,max
)).Example:
int myValue = 10; int minValue = 2; int maxValue = 6; int boundedValue = qBound(minValue, myValue, maxValue); // boundedValue == 6See also
qMin()
qMax()
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)See also
qOverload
qNonConstOverload
Differences between String-Based and Functor-Based Connections
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()
.See also
qDebug()
qInfo()
qWarning()
qFatal()
qInstallMessageHandler()
Debugging Techniques
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 ifQT_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 theQtDebugMsg
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 run-time, install your own message handler with
qInstallMessageHandler()
.See also
qInfo()
qWarning()
qCritical()
qFatal()
qInstallMessageHandler()
Debugging Techniques
Returns the numerical value of the environment variable
varName
. Ifok
is not null, sets*ok
totrue
orfalse
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
tofalse
.See also
qgetenv()
qEnvironmentVariable()
qEnvironmentVariableIsSet()
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.
See also
qgetenv()
qEnvironmentVariable()
qEnvironmentVariableIsSet()
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.
See also
qgetenv()
qEnvironmentVariable()
qEnvironmentVariableIsEmpty()
Replaces the value of
obj
withnewValue
and returns the old value ofobj
.This is Qt’s implementation of std::exchange(). It differs from std::exchange() only in that it is
constexpr
already in C++14, and available on all supported compilers.Here is how to use 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()/ 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 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 alive for as long as the loop runs, saving the declaration of a temporary variable. Be aware, though, that returns a non-const object, so Qt containers may detach.
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()
Debugging Techniques
Returns the number of representable floating-point numbers between
a
andb
.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
andb
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
orNaN
. You can check for this by callingqIsFinite()
.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 }See also
qFuzzyCompare()
Returns the number of representable floating-point numbers between
a
andb
.This function serves the same purpose as
qFloatDistance(float, float)
, but returns the distance between twodouble
numbers. Since the range is larger than for twofloat
numbers ([-DBL_MAX,DBL_MAX]
), the return type is quint64.See also
qFuzzyCompare()
Generates a formatted string out of the
type
,context
,str
arguments.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.
See also
qInstallMessageHandler()
qSetMessagePattern()
Classifies a floating-point value.
The return values are defined in
<cmath>
: returns one of the following, determined by the floating-point class ofval
:
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
This is an overloaded function.
Compares the floating point value
p1
andp2
and returnstrue
if they are considered equal, otherwisefalse
.Note that comparing values where either
p1
orp2
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, useqFuzzyIsNull
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 trueThe two numbers are compared in a relative way, where the exactness is stronger the smaller the numbers are.
Compares the floating point value
p1
andp2
and returnstrue
if they are considered equal, otherwisefalse
.The two numbers are compared in a relative way, where the exactness is stronger the smaller the numbers are.
Compares the floating point value
p1
andp2
and returnstrue
if they are considered equal, otherwisefalse
.The two numbers are compared in a relative way, where the exactness is stronger the smaller the numbers are.
Returns true if the absolute value of
d
is within 0.000000000001 of 0.0.Returns true if the absolute value of
f
is within 0.00001f of 0.0.Returns the bit pattern for an infinite number as a double.
See also
qIsInf()
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 ifQT_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 theQtInfoMsg
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 run-time, install your own message handler with
qInstallMessageHandler()
.See also
qDebug()
qWarning()
qCritical()
qFatal()
qInstallMessageHandler()
Debugging Techniques
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.
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(); }See also
QtMessageHandler
QtMsgType
qDebug()
qInfo()
qWarning()
qCritical()
qFatal()
Debugging Techniques
Installs a Qt message
handler
which has been defined previously. This method is deprecated, useqInstallMessageHandler
instead.See also
QtMsgHandler
qInstallMessageHandler()
Returns
true
if the doubled
is a finite number.Returns
true
if the floatf
is a finite number.Returns true if the
qfloat16
f
is a finite number.See also
qIsFinite
Returns
true
if the doubled
is equivalent to infinity.See also
qInf()
Returns
true
if the floatf
is equivalent to infinity.See also
qInf()
Returns true if the
qfloat16
f
is equivalent to infinity.See also
qIsInf
Returns
true
if the doubled
is not a number (NaN).Returns
true
if the floatf
is not a number (NaN).Returns true if the
qfloat16
f
is not a number (NaN).See also
qIsNaN
Returns the maximum of
a
andb
.Example:
int myValue = 6; int yourValue = 4; int maxValue = qMax(myValue, yourValue); // maxValue == myValueSee also
qMin()
qBound()
Returns the minimum of
a
andb
.Example:
int myValue = 6; int yourValue = 4; int minValue = qMin(myValue, yourValue); // minValue == yourValueSee also
qMax()
qBound()
Use
std::move
instead.It expands to “std::move”.
takes an rvalue reference to its parameter
x
, and converts it to an xvalue.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)See also
qOverload
qNonConstOverloadDifferences between String-Based and Functor-Based Connections
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
andqNonConstOverload
need to be used.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 .
See also
qConstOverload()
qNonConstOverload()
Differences between String-Based and Functor-Based Connections
Returns
str
as aconst char *
. This is equivalent tostr
.toLocal8Bit().constData().The char pointer will be invalid after the statement in which is used. This is because the array returned by
toLocal8Bit()
will fall out of scope.Note
qDebug()
,qInfo()
,qWarning()
,qCritical()
,qFatal()
expect %s arguments to be UTF-8 encoded, while converts to local 8-bit encoding. ThereforeqUtf8Printable()
should be used for logging strings instead of .See also
qUtf8Printable()
Returns the bit pattern of a quiet NaN as a double.
See also
qIsNaN()
Rounds
d
to the nearest integer.Rounds half up (e.g. 0.5 -> 1, -0.5 -> 0).
Example:
double valueA = 2.3; double valueB = 2.7; int roundedValueA = qRound(valueA); // roundedValueA = 2 int roundedValueB = qRound(valueB); // roundedValueB = 3Rounds
d
to the nearest integer.Rounds half up (e.g. 0.5f -> 1, -0.5f -> 0).
Example:
float valueA = 2.3; float valueB = 2.7; int roundedValueA = qRound(valueA); // roundedValueA = 2 int roundedValueB = qRound(valueB); // roundedValueB = 3Rounds
value
to the nearest integer.See also
qRound
Rounds
d
to the nearest 64-bit integer.Rounds half up (e.g. 0.5 -> 1, -0.5 -> 0).
Example:
double valueA = 42949672960.3; double valueB = 42949672960.7; qint64 roundedValueA = qRound64(valueA); // roundedValueA = 42949672960 qint64 roundedValueB = qRound64(valueB); // roundedValueB = 42949672961Rounds
d
to the nearest 64-bit integer.Rounds half up (e.g. 0.5f -> 1, -0.5f -> 0).
Example:
float valueA = 42949672960.3; float valueB = 42949672960.7; qint64 roundedValueA = qRound64(valueA); // roundedValueA = 42949672960 qint64 roundedValueB = qRound64(valueB); // roundedValueB = 42949672961Rounds
value
to the nearest 64-bit integer.See also
qRound64
Returns the bit pattern of a signalling NaN as a double.
Changes the output of the default message handler.
Allows to tweak the output of
qDebug()
,qInfo()
,qWarning()
,qCritical()
, andqFatal()
. The category logging output ofqCDebug()
,qCInfo()
,qCWarning()
, andqCCritical()
is formatted, too.Following placeholders are supported:
Placeholder
Description
%{appname}
applicationName()
%{category}
Logging category
%{file}
Path to source file
%{function}
Function
%{line}
Line in source file
%{message}
The actual message
%{pid}
applicationPid()
%{threadid}
The system-wide ID of current thread (if it can be obtained)
%{qthreadptr}
A pointer to the current
QThread
(result ofcurrentThread()
)
%{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
msecsSinceReference()
).
%{time [format]}
system time when the message occurred, formatted by passing the
format
totoString()
. If the format is not specified, the format ofISODate
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 optionalseparator
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, useQMAKE_LFLAGS += -rdynamic
. 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 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 takepattern
into account.See also
qInstallMessageHandler()
QLoggingCategory
Returns
str
as aconst ushort *
, but cast to aconst wchar_t *
to avoid warnings. This is equivalent tostr
.utf16() plus some casting.The only useful thing you can do with the return value of this macro is to pass it to
asprintf()
for use in a%ls
conversion. In particular, the return value is not a validconst wchar_t*
!In general, the pointer will be invalid after the statement in which 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));See also
qPrintable()
qDebug()
qInfo()
qWarning()
qCritical()
qFatal()
Returns
str
as aconst char *
. This is equivalent tostr
.toUtf8().constData().The char pointer will be invalid after the statement in which is used. This is because the array returned by
toUtf8()
will fall out of scope.Example:
qWarning("%s: %s", qUtf8Printable(key), qUtf8Printable(value));See also
qPrintable()
qDebug()
qInfo()
qWarning()
qCritical()
qFatal()
Returns the version number of Qt at run-time as a string (for example, “4.1.2”). This may be a different version than the version the application was compiled against.
See also
QT_VERSION_STR
version()
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 ifQT_NO_WARNING_OUTPUT
was defined during compilation; it exits if at the nth warning corresponding to the counter in environment variableQT_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()
.See also
qDebug()
qInfo()
qCritical()
qFatal()
qInstallMessageHandler()
Debugging Techniques
Uses
Q_CHECK_PTR
onp
, then returnsp
.This can be used as an inline version of
Q_CHECK_PTR
.Returns the value of the environment variable with name
varName
as aQByteArray
. If no variable by that name is found in the environment, this function returns a default-constructedQByteArray
.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
usefromLocal8Bit()
.Note
on desktop Windows, 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.See also
qputenv()
qEnvironmentVariable()
qEnvironmentVariableIsSet()
qEnvironmentVariableIsEmpty()
This function sets the
value
of the environment variable namedvarName
. 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
was introduced because putenv() from the standard C library was deprecated in VC2005 (and later versions). uses the replacement function in VC, and calls the standard C library’s implementation on all other platforms.
See also
qgetenv()
qEnvironmentVariable()
Thread-safe version of the standard C++
rand()
function.Returns a value between 0 and
RAND_MAX
(defined in<cstdlib>
and<stdlib.h>
), the next number in the current sequence of pseudo-random integers.Use
qsrand()
to initialize the pseudo-random number generator with a seed value. Seeding must be performed at least once on each thread. If that step is skipped, then the sequence will be pre-seeded with a constant value.Note
This function is deprecated. In new applications, use
QRandomGenerator
instead.See also
qsrand()
QRandomGenerator
Thread-safe version of the standard C++
srand()
function.Sets the argument
seed
to be used to generate a new random number sequence of pseudo random integers to be returned byqrand()
.The sequence of random numbers generated is deterministic per thread. For example, if two threads call qsrand(1) and subsequently call
qrand()
, the threads will get the same random number sequence.Note
This function is deprecated. In new applications, use
QRandomGenerator
instead.See also
qrand()
QRandomGenerator
The 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 ofn
. In addition, depending onn
‘s value, the translation text may vary.Meta data and comments can be passed as documented for
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 thelrelease
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.
See also
tr()
translate()
Internationalization with Qt
This function deletes the variable
varName
from the environment.Returns
true
on success.See also
qputenv()
qgetenv()
qEnvironmentVariable()
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
Description
QtDebugMsg
A message generated by the
qDebug()
function.QtInfoMsg
A message generated by the
qInfo()
function.QtWarningMsg
A message generated by the
qWarning()
function.QtCriticalMsg
A message generated by the
qCritical()
function.QtFatalMsg
A message generated by the
qFatal()
function.QtSystemMsg
QtInfoMsg
was added in Qt 5.5.See also
QtMessageHandler
qInstallMessageHandler()
This is a typedef for
void (*)()
, a pointer to a function that takes no arguments and returns void.This is a typedef for a pointer to a function with the following signature:
void myMessageHandler(QtMsgType, const QMessageLogContext &, const QString &);See also
QtMsgType
qInstallMessageHandler()
This is a typedef for a pointer to a function with the following signature:
void myMsgHandler(QtMsgType, const char *);This typedef is deprecated, you should use
QtMessageHandler
instead.See also
QtMsgType
QtMessageHandler
qInstallMsgHandler()
qInstallMessageHandler()
Typedef for
signed short
. This type is guaranteed to be 16-bit on all platforms supported by Qt.Typedef for
signed int
. This type is guaranteed to be 32-bit on all platforms supported by Qt.Typedef for
long long int
(__int64
on Windows). 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
qlonglong
Typedef for
signed char
. This type is guaranteed to be 8-bit on all platforms supported by Qt.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.
See also
qptrdiff
qint32
qint64
Typedef for
long long int
(__int64
on Windows). This is the same asqint64
.See also
qulonglong
qint64
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.
See also
quintptr
qint32
qint64
Typedef for
double
unless Qt is configured with the-qreal float
option.Typedef for
unsigned short
. This type is guaranteed to be 16-bit on all platforms supported by Qt.Typedef for
unsigned int
. This type is guaranteed to be 32-bit on all platforms supported by Qt.Typedef for
unsigned long long int
(unsigned __int64
on Windows). 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
qulonglong
Typedef for
unsigned char
. This type is guaranteed to be 8-bit on all platforms supported by Qt.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.
See also
qptrdiff
quint32
quint64
Typedef for
unsigned long long int
(unsigned __int64
on Windows). This is the same asquint64
.See also
quint64
qlonglong
Convenience typedef for
unsigned char
.Convenience typedef for
unsigned int
.Convenience typedef for
unsigned long
.Convenience typedef for
unsigned short
.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.See also
qptrdiff
© 2022 The Qt Company Ltd. Documentation contributions included herein are the copyrights of their respective owners. The documentation provided herein is licensed under the terms of the GNU Free Documentation License version 1.3 as published by the Free Software Foundation. Qt and respective logos are trademarks of The Qt Company Ltd. in Finland and/or other countries worldwide. All other trademarks are property of their respective owners.