<QtGlobal> - Global Qt Declarations

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

• Obsolete members
• Compatibility members

Types

Functions

Macros

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

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

See also<QtAlgorithms> andQSysInfo.

Type Documentation

typedefQtMsgHandler

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

void myMsgHandler(QtMsgType,constchar*);

See alsoQtMsgType andqInstallMsgHandler().

enumQtMsgType

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

See alsoQtMsgHandler andqInstallMsgHandler().

typedefqint8

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

typedefqint16

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

typedefqint32

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

typedefqint64

Typedef forlong 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 theQ_INT64_C() macro:

qint64 value=Q_INT64_C(932838457459459);

See alsoQ_INT64_C(),quint64, andqlonglong.

typedefqlonglong

Typedef forlong long int (__int64 on Windows). This is the same asqint64.

See alsoqulonglong andqint64.

typedefqptrdiff

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 alsoquintptr,qint32, andqint64.

typedefqreal

Typedef fordouble on all platforms except for those using CPUs with ARM architectures. On ARM-based platforms,qreal is a typedef forfloat for performance reasons.

typedefquint8

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

typedefquint16

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

typedefquint32

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

typedefquint64

Typedef forunsigned 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 theQ_UINT64_C() macro:

quint64 value=Q_UINT64_C(932838457459459);

See alsoQ_UINT64_C(),qint64, andqulonglong.

typedefquintptr

Integral type for representing a pointers (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 alsoqptrdiff,quint32, andquint64.

typedefqulonglong

Typedef forunsigned long long int (unsigned __int64 on Windows). This is the same asquint64.

See alsoquint64 andqlonglong.

typedefuchar

Convenience typedef forunsigned char.

typedefuint

Convenience typedef forunsigned int.

typedefulong

Convenience typedef forunsigned long.

typedefushort

Convenience typedef forunsigned short.

Function Documentation

TqAbs(constT & value)

Comparesvalue to the 0 of type T and returns the absolute value. Thus if T isdouble, thenvalue is compared to(double) 0.

Example:

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

constT &qBound(constT & min, constT & value, constT & max)

Returnsvalue bounded bymin andmax. This is equivalent toqMax(min,qMin(value,max)).

Example:

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

See alsoqMin() andqMax().

voidqCritical(constchar * msg, ...)

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

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(constQString&fileName){QFile file(fileName);if (!file.exists())        qCritical("File '%s' does not exist!",qPrintable(fileName));}

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

qCritical()<<"Brush:"<< myQBrush<<"Othervalue:"<< 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 withqInstallMsgHandler().

See alsoqDebug(),qWarning(),qFatal(),qInstallMsgHandler(), andDebugging Techniques.

voidqDebug(constchar * msg, ...)

Calls the message handler with the debug messagemsg. 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. 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 aQDebug 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 withqInstallMsgHandler().

See alsoqWarning(),qCritical(),qFatal(),qInstallMsgHandler(), andDebugging Techniques.

voidqFatal(constchar * msg, ...)

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

If you are using thedefault message handler this function will abort on Unix systems 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 withqInstallMsgHandler().

See alsoqDebug(),qCritical(),qWarning(),qInstallMsgHandler(), andDebugging Techniques.

[static]boolqFuzzyCompare(double p1,double p2)

Compares the floating point valuep1 andp2 and returnstrue if they are considered equal, otherwisefalse.

Note that comparing values where eitherp1 orp2 is 0.0 will not work. The solution to this is to compare against values greater than or equal to 1.0.

// 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 isthread-safe.

This function was introduced in Qt 4.4.

[static]boolqFuzzyCompare(float p1,float p2)

Compares the floating point valuep1 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.

Note: This function isthread-safe.

This function was introduced in Qt 4.4.

QtMsgHandlerqInstallMsgHandler(QtMsgHandler handler)

Installs a Qt messagehandler which has been defined previously. Returns a pointer to the previous message handler (which may be 0).

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, callqInstallMsgHandler(0).

Example:

#include <qapplication.h>#include <stdio.h>#include <stdlib.h>void myMessageOutput(QtMsgType type,constchar*msg){switch (type) {caseQtDebugMsg:        fprintf(stderr,"Debug: %s\n", msg);break;caseQtWarningMsg:        fprintf(stderr,"Warning: %s\n", msg);break;caseQtCriticalMsg:        fprintf(stderr,"Critical: %s\n", msg);break;caseQtFatalMsg:        fprintf(stderr,"Fatal: %s\n", msg);        abort();    }}int main(int argc,char**argv){    qInstallMsgHandler(myMessageOutput);QApplication app(argc, argv);...return app.exec();}

See alsoqDebug(),qWarning(),qCritical(),qFatal(),QtMsgType, andDebugging Techniques.

intqMacVersion()

UseQSysInfo::MacintoshVersion instead.

See alsoQSysInfo.

constT &qMax(constT & value1, constT & value2)

Returns the maximum ofvalue1 andvalue2.

Example:

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

See alsoqMin() andqBound().

constT &qMin(constT & value1, constT & value2)

Returns the minimum ofvalue1 andvalue2.

Example:

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

See alsoqMax() andqBound().

qint64qRound64(qreal value)

Roundsvalue to the nearest 64-bit integer.

Example:

qreal valueA=42949672960.3;qreal valueB=42949672960.7;int roundedValueA=qRound(valueA);// roundedValueA = 42949672960int roundedValueB=qRound(valueB);// roundedValueB = 42949672961

intqRound(qreal value)

Roundsvalue to the nearest integer.

Example:

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

constchar *qVersion()

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 alsoQT_VERSION_STR.

voidqWarning(constchar * msg, ...)

Calls the message handler with the warning messagemsg. If no message handler has been installed, the message is printed to stderr. Under Windows, the message is sent to the debugger. This function does nothing ifQT_NO_WARNING_OUTPUT was defined during compilation; it exits if the environment variableQT_FATAL_WARNINGS is defined.

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 withqInstallMsgHandler().

See alsoqDebug(),qCritical(),qFatal(),qInstallMsgHandler(), andDebugging Techniques.

T *q_check_ptr(T * pointer)

UsersQ_CHECK_PTR onpointer, then returnspointer.

This can be used as an inline version ofQ_CHECK_PTR.

QByteArrayqgetenv(constchar * varName)

Returns the value of the environment variable with namevarName. To get the variable string, useQByteArray::constData().

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

See alsoqputenv().

boolqputenv(constchar * varName, constQByteArray & value)

This function sets thevalue 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.

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 alsoqgetenv().

intqrand()

Thread-safe version of the standard C++rand() function.

Returns a value between 0 andRAND_MAX (defined in<cstdlib> and<stdlib.h>), the next number in the current sequence of pseudo-random integers.

Useqsrand() to initialize the pseudo-random number generator with a seed value.

This function was introduced in Qt 4.2.

See alsoqsrand().

voidqsrand(uint seed)

Thread-safe version of the standard C++srand() function.

Sets the argumentseed 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 callsqrand(), the threads will get the same random number sequence.

This function was introduced in Qt 4.2.

See alsoqrand().

QStringqtTrId(constchar * id,int n = -1)

The qtTrId function finds and returns a translated string.

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

Ifn >= 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 forQObject::tr(). In addition, it is possible to supply a source string template like that:

//% <C string>

or

/*% <C string>*/

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 installedbefore 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 isreentrant.

This function was introduced in Qt 4.6.

See alsoQObject::tr(),QCoreApplication::translate(), andInternationalization with Qt.

voidqt_set_sequence_auto_mnemonic(bool on)

Enables automatic mnemonics on Mac ifon is true; otherwise this feature is disabled.

Note that this function is only available on Mac where mnemonics are disabled by default.

To access to this function, use an extern declaration: extern void qt_set_sequence_auto_mnemonic(bool b);

See alsoQShortcut.

intqt_symbian_exception2Error(conststd::exception & aThrow)

Convert a caught standard C++ exceptionaThrow to a Symbian error code

Warning: This function is only available on Symbian.

See alsoqt_symbian_throwIfError() andqt_symbian_exception2LeaveL().

voidqt_symbian_exception2LeaveL(conststd::exception & aThrow)

Convert a caught standard C++ exceptionaThrow to a Symbian leave

Warning: This function is only available on Symbian.

See alsoqt_symbian_throwIfError() andqt_symbian_exception2Error().

voidqt_symbian_throwIfError(int error)

Throws an exception if theerror parameter is a symbian error code. This is the exception throwing equivalent of Symbian's User::LeaveIfError.

Warning: This function is only available on Symbian.

See alsoqt_symbian_exception2LeaveL() andqt_symbian_exception2Error().

Macro Documentation

QT_POINTER_SIZE

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

QT_REQUIRE_VERSION(int argc,char ** argv, constchar * version)

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).

Theargc 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();}

QT_TRANSLATE_NOOP3( context, sourceText, comment)

Marks the string literalsourceText for dynamic translation in the givencontext and withcomment, i.e the storedsourceText will not be altered. Thecontext is typically a class and also needs to be specified as string literal. The string literalcomment will be available for translators using e.g. Qt Linguist.

The macro expands to anonymous struct of the two string literals passed assourceText andcomment.

Example:

static {constchar*source;constchar*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);}

This function was introduced in Qt 4.4.

See alsoQT_TR_NOOP(),QT_TRANSLATE_NOOP(), andInternationalization with Qt.

QT_TRANSLATE_NOOP( context, sourceText)

Marks the string literalsourceText for dynamic translation in the givencontext; i.e, the storedsourceText will not be altered. Thecontext is typically a class and also needs to be specified as string literal.

The macro expands tosourceText.

Example:

staticconstchar*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 alsoQT_TR_NOOP(),QT_TRANSLATE_NOOP3(), andInternationalization with Qt.

QT_TRAP_THROWING( function)

TRAP leaves from Symbianfunction and throws an appropriate standard C++ exception instead. This must be used when calling Symbian OS leaving functions from inside Qt or standard C++ code, so that the code can respond correctly to the exception.

Warning: This macro is only available on Symbian.

Example:

// A Symbian leaving function is being called within a Qt function.// Any leave must be converted to an exceptionCAknTitlePane* titlePane= S60->titlePane();if (titlePane) {    TPtrC captionPtr(qt_QString2TPtrC(caption));    QT_TRAP_THROWING(titlePane->SetTextL(captionPtr));}

See alsoQT_TRYCATCH_ERROR() andQT_TRYCATCH_LEAVING().

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 toqtTrId().

The macro expands toid.

Example:

staticconstchar*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)newQLabel(qtTrId(ids[i]),this);}

This function was introduced in Qt 4.6.

See alsoqtTrId() andInternationalization with Qt.

QT_TRYCATCH_ERROR( error, function)

Catch standard C++ exceptions from afunction and convert them to a Symbian OSerror code, orKErrNone if there is no exception. This must be used inside Qt or standard C++ code when using exception throwing code (practically anything) and returning an error code to Symbian OS.

Warning: This macro is only available on Symbian.

Example:

// An exception might be thrown in this Symbian TInt error returning function.// It is caught and translated to an error codeTIntQServerApp::Connect(constQString&serverName){    TPtrC name;    TInt err;    QT_TRYCATCH_ERROR(err, name.Set(qt_QString2TPtrC(serverName)));if (err!= KErrNone)return err;return iServer.Connect(name);}

}

See alsoQT_TRYCATCH_LEAVING() andQT_TRAP_THROWING().

QT_TRYCATCH_LEAVING( function)

Catch standard C++ exceptions fromfunction and convert them to Symbian OS leaves. This must be used inside Qt or standard C++ code when using exception throwing code (practically anything) and returning to Symbian OS from a leaving function. For example inside a Symbian active object'sRunL function implemented with Qt code.

Warning: This macro is only available on Symbian.

Example:

// This active object signals Qt code// Exceptions from the Qt code must be converted to Symbian OS leaves for the active schedulervoidQWakeUpActiveObject::RunL(){    iStatus= KRequestPending;    SetActive();    QT_TRYCATCH_LEAVING(m_dispatcher->wakeUpWasCalled());}

See alsoQT_TRAP_THROWING() andQT_TRYCATCH_ERROR().

QT_TR_NOOP( sourceText)

Marks the string literalsourceText for dynamic translation in the current context (class), i.e the storedsourceText will not be altered.

The macro expands tosourceText.

Example:

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

The macro QT_TR_NOOP_UTF8() is identical except that it tells lupdate that the source string is encoded in UTF-8. Corresponding variants exist in theQT_TRANSLATE_NOOP() family of macros, too. Note that using these macros is not required ifCODECFORTR is already set to UTF-8 in the qmake project file.

See alsoQT_TRANSLATE_NOOP() andInternationalization with Qt.

QT_VERSION

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, theQT_VERSION macro will expand to 0x040102.

You can useQT_VERSION to use the latest Qt features where available.

Example:

#if QT_VERSION >= 0x040100QIcon icon= style()->standardIcon(QStyle::SP_TrashIcon);#elseQPixmap pixmap= style()->standardPixmap(QStyle::SP_TrashIcon);QIcon icon(pixmap);#endif

See alsoQT_VERSION_STR andqVersion().

QT_VERSION_CHECK

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.

See alsoQT_VERSION.

QT_VERSION_STR

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 alsoqVersion() andQT_VERSION.

voidQ_ASSERT(bool test)

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

Q_ASSERT() is useful for testing pre- and post-conditions during development. It does nothing ifQT_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;}

Ifb is zero, the Q_ASSERT statement will output the following message using theqFatal() function:

ASSERT:"b == 0" in file div.cpp, line7

See alsoQ_ASSERT_X(),qFatal(), andDebugging Techniques.

voidQ_ASSERT_X(bool test, constchar * where, constchar * what)

Prints the messagewhat together with the locationwhere, the source file name and line number iftest is false.

Q_ASSERT_X is useful for testing pre- and post-conditions during development. It does nothing ifQT_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;}

Ifb is zero, the Q_ASSERT_X statement will output the following message using theqFatal() function:

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

See alsoQ_ASSERT(),qFatal(), andDebugging Techniques.

Q_BIG_ENDIAN

This macro represents a value you can compare to the macroQ_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 alsoQ_BYTE_ORDER andQ_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 macrosQ_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 Q_BYTE_ORDER must pass data back and forth.

Use this macro as in the following examples.

#if Q_BYTE_ORDER == Q_BIG_ENDIAN...#endifor#if Q_BYTE_ORDER == Q_LITTLE_ENDIAN...#endif

See alsoQ_BIG_ENDIAN andQ_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_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_INTEL

Defined if the application is compiled using Intel C++ for Linux, Intel C++ for Windows.

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_MWERKS

Defined if the application is compiled using Metrowerks CodeWarrior.

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++.

voidQ_CHECK_PTR(void * pointer)

Ifpointer is 0, prints a warning message containing the source code's file name and line number, saying that the program ran out of memory.

Q_CHECK_PTR does nothing ifQT_NO_DEBUG was defined during compilation.

Example:

int*a;Q_CHECK_PTR(a=newint[80]);// WRONG!a=new (nothrow)int[80];// RightQ_CHECK_PTR(a);

See alsoqWarning() andDebugging Techniques.

Q_DECLARE_TYPEINFO( Type, Flags)

You can use this macro to specify information about a custom typeType. With accurate type information, Qt'sgeneric 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.
• Q_MOVABLE_TYPE specifies thatType has a constructor and/or a destructor but can be moved in memory usingmemcpy().
• 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);

Example of a movable type:

class Point2D{public:    Point2D() { data=newint[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);

Q_DECL_EXPORT

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

See alsoQ_DECL_IMPORT.

Q_DECL_IMPORT

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

See alsoQ_DECL_EXPORT.

Q_FOREACH( variable, container)

Same as foreach(variable,container).

This macro is available even whenno_keywords is specified using the.pro file'sCONFIG variable.

See alsoforeach().

Q_FOREVER

Same asforever.

This macro is available even whenno_keywords is specified using the.pro file'sCONFIG variable.

See alsoforeach().

constchar *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 withqDebug(). 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;elsereturn 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.

qint64Q_INT64_C( literal)

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

Example:

qint64 value= Q_INT64_C(932838457459459);

See alsoqint64 andQ_UINT64_C().

Q_LIKELY( expr)

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 timesfor (int i=1; i<=365; i++) {if (Q_LIKELY(isWorkingDay(i))) {...        }...    }

This function was introduced in Qt 4.8.

See alsoQ_UNLIKELY().

Q_LITTLE_ENDIAN

This macro represents a value you can compare to the macroQ_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 alsoQ_BYTE_ORDER andQ_BIG_ENDIAN.

Q_OS_AIX

Defined on AIX.

Q_OS_BSD4

Defined on Any BSD 4.4 system.

Q_OS_BSDI

Defined on BSD/OS.

Q_OS_CYGWIN

Defined on Cygwin.

Q_OS_DARWIN

Defined on Darwin OS (synonym forQ_OS_MAC).

Q_OS_DGUX

Defined on DG/UX.

Q_OS_DYNIX

Defined on DYNIX/ptx.

Q_OS_FREEBSD

Defined on FreeBSD.

Q_OS_HPUX

Defined on HP-UX.

Q_OS_HURD

Defined on GNU Hurd.

Q_OS_IRIX

Defined on SGI Irix.

Q_OS_LINUX

Defined on Linux.

Q_OS_LYNX

Defined on LynxOS.

Q_OS_MAC

Defined on MAC OS (synonym for Darwin).

Q_OS_MSDOS

Defined on MS-DOS and Windows.

Q_OS_NETBSD

Defined on NetBSD.

Q_OS_OS2

Defined on OS/2.

Q_OS_OPENBSD

Defined on OpenBSD.

Q_OS_OS2EMX

Defined on XFree86 on OS/2 (not PM).

Q_OS_OSF

Defined on HP Tru64 UNIX.

Q_OS_QNX

Defined on QNX Neutrino.

Q_OS_RELIANT

Defined on Reliant UNIX.

Q_OS_SCO

Defined on SCO OpenServer 5.

Q_OS_SOLARIS

Defined on Sun Solaris.

Q_OS_SYMBIAN

Defined on Symbian.

Q_OS_ULTRIX

Defined on DEC Ultrix.

Q_OS_UNIX

Defined on Any UNIX BSD/SYSV system.

Q_OS_UNIXWARE

Defined on UnixWare 7, Open UNIX 8.

Q_OS_WIN32

Defined on all supported versions of Windows.

Q_OS_WINCE

Defined on Windows CE.

quint64Q_UINT64_C( literal)

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

Example:

quint64 value= Q_UINT64_C(932838457459459);

See alsoquint64 andQ_INT64_C().

Q_UNLIKELY( expr)

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(constQFile&file){// We expect to be asked to read an existing fileif (Q_UNLIKELY(!file.exists())) {qWarning()<<"File not found";returnfalse;    }...returntrue;}

This function was introduced in Qt 4.8.

See alsoQ_LIKELY().

Q_UNUSED( name)

Indicates to the compiler that the parameter with the specifiedname 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.

Q_WS_S60

Defined on S60 with the Avkon UI framework.

See alsoQ_WS_MAC,Q_WS_WIN,Q_WS_X11, andQ_WS_QWS.

Q_WS_X11

Defined on X11.

See alsoQ_WS_MAC,Q_WS_WIN,Q_WS_QWS,Q_WS_QPA, andQ_WS_S60.

Q_WS_MAC

Defined on Mac OS X.

See alsoQ_WS_WIN,Q_WS_X11,Q_WS_QWS,Q_WS_QPA, andQ_WS_S60.

Q_WS_QPA

Defined on Qt for Embedded Linux, Lite version.

See alsoQ_WS_MAC,Q_WS_WIN,Q_WS_X11,Q_WS_QWS, andQ_WS_S60.

Q_WS_QWS

Defined on Qt for Embedded Linux.

See alsoQ_WS_MAC,Q_WS_WIN,Q_WS_X11,Q_WS_QPA, andQ_WS_S60.

Q_WS_WIN

Defined on Windows.

See alsoQ_WS_MAC,Q_WS_X11,Q_WS_QWS,Q_WS_QPA, andQ_WS_S60.

foreach( variable, container)

This macro is used to implement Qt'sforeach 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. SeeThe 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_keywords

See alsoQ_FOREACH().

forever

This macro is provided for convenience for writing infinite loops.

Example:

forever {...}

It is equivalent tofor (;;).

If you're worried about namespace pollution, you can disable this macro by adding the following line to your.pro file:

CONFIG+= no_keywords

See alsoQ_FOREVER.

constchar *qPrintable(constQString & str)

Returnsstr as aconst char *. This is equivalent tostr.toLocal8Bit().constData().

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

Example:

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

See alsoqDebug(),qWarning(),qCritical(), andqFatal().