<QtGlobal> 頭文件包括基礎全局聲明。它被包括在大多數其它 Qt 頭文件中。 更多...
| 頭： | #include <QtGlobal> |
| typedef | QFunctionPointer |
| typedef | QtMessageHandler |
| enum | QtMsgType { QtDebugMsg, QtInfoMsg, QtWarningMsg, QtCriticalMsg, QtFatalMsg, QtSystemMsg } |
| typedef | qint8 |
| typedef | qint16 |
| typedef | qint32 |
| typedef | qint64 |
| typedef | qintptr |
| typedef | qlonglong |
| typedef | qptrdiff |
| typedef | qreal |
| (alias) | qsizetype |
| typedef | quint8 |
| typedef | quint16 |
| typedef | quint32 |
| typedef | quint64 |
| typedef | quintptr |
| typedef | qulonglong |
| typedef | uchar |
| typedef | uint |
| typedef | ulong |
| typedef | ushort |
| T | qAbs (const T & t ) |
| typename std::add_const<T>::type & | qAsConst (T & t ) |
| void | qAsConst (const T && t ) |
| const T & | qBound (const T & min , const T & val , const T & max ) |
| auto | qConstOverload (T memberFunctionPointer ) |
| QString | qEnvironmentVariable (const char * varName ) |
| QString | qEnvironmentVariable (const char * varName , const QString & defaultValue ) |
| int | qEnvironmentVariableIntValue (const char * varName , bool * ok = nullptr) |
| bool | qEnvironmentVariableIsEmpty (const char * varName ) |
| bool | qEnvironmentVariableIsSet (const char * varName ) |
| T | qExchange (T & obj , U && newValue ) |
| quint32 | qFloatDistance (float a , float b ) |
| quint64 | qFloatDistance (double a , double b ) |
| QString | qFormatLogMessage (QtMsgType type , const QMessageLogContext & context , const QString & str ) |
| int | qFpClassify (double val ) |
| bool | qFuzzyCompare (double p1 , double p2 ) |
| bool | qFuzzyCompare (float p1 , float p2 ) |
| bool | qFuzzyIsNull (double d ) |
| bool | qFuzzyIsNull (float f ) |
| double | qInf () |
| QtMessageHandler | qInstallMessageHandler (QtMessageHandler handler ) |
| bool | qIsFinite (double d ) |
| bool | qIsFinite (float f ) |
| bool | qIsInf (double d ) |
| bool | qIsInf (float f ) |
| bool | qIsNaN (double d ) |
| bool | qIsNaN (float f ) |
| const T & | qMax (const T & a , const T & b ) |
| const T & | qMin (const T & a , const T & b ) |
| auto | qNonConstOverload (T memberFunctionPointer ) |
| auto | qOverload (T functionPointer ) |
| double | qQNaN () |
| qint64 | qRound64 (double d ) |
| qint64 | qRound64 (float d ) |
| int | qRound (double d ) |
| int | qRound (float d ) |
| double | qSNaN () |
| void | qSetMessagePattern (const QString & pattern ) |
| const char * | qVersion () |
| T * | q_check_ptr (T * p ) |
| QByteArray | qgetenv (const char * varName ) |
| bool | qputenv (const char * varName , const QByteArray & value ) |
| QString | qtTrId (const char * id , int n = -1) |
| bool | qunsetenv (const char * varName ) |
類型定義是基本類型的部分方便定義 (其中一些保證 Qt 支持的所有平颱的某些位尺寸)，部分類型有關 Qt 消息處理。函數有關生成消息、Qt 版本處理及比較/調節對象值。最後，某些聲明宏使程序員能夠嚮其應用程序添加編譯器或平颱特定代碼，而其它的是用於更大操作的方便宏。
The header file declares several type definitions that guarantee a specified bit-size on all platforms supported by Qt for various basic types, for example
qint8
which is a signed char guaranteed to be 8-bit on all platforms supported by Qt. The header file also declares the
qlonglong
type definition for
long long int
(
__int64
在 Windows)。
Several convenience type definitions are declared:
qreal
for
double
or
float
,
uchar
for
unsigned
char,
uint
for
unsigned
int,
ulong
for
unsigned
long and
ushort
for
unsigned
short.
Finally, the
QtMsgType
definition identifies the various messages that can be generated and sent to a Qt message handler;
QtMessageHandler
is a type definition for a pointer to a function with the signature
void myMessageHandler(QtMsgType, const QMessageLogContext &, const char *)
.
QMessageLogContext
class contains the line, file, and function the message was logged at. This information is created by the
QMessageLogger
類。
The <QtGlobal> header file contains several functions comparing and adjusting an object's value. These functions take a template type as argument: You can retrieve the absolute value of an object using the qAbs () function, and you can bound a given object's value by given minimum and maximum values using the qBound () function. You can retrieve the minimum and maximum of two given objects using qMin () 和 qMax () respectively. All these functions return a corresponding template type; the template types can be replaced by any other type.
範例：
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 ()，和 qFatal (). These functions call the message handler with the given message.
範例：
if (!driver()->isOpen() || driver()->isOpenError()) { qWarning("QSqlQuery::exec: database not open"); return false; }
The remaining functions are
qRound
() 和
qRound64
(), which both accept a
double
or
float
value as their argument returning the value rounded up to the nearest integer and 64-bit integer respectively, the
qInstallMessageHandler
() function which installs the given
QtMessageHandler
，和
qVersion
() function which returns the version number of Qt at run-time as a string.
<QtGlobal> 頭文件提供一係列定義宏 (Q_CC_*) 若使用指定平颱編譯應用程序。例如， Q_CC_SUN 定義宏，若使用 Forte Developer 或 Sun Studio C++ 編譯應用程序。頭文件還為指定平颱聲明瞭一係列定義宏 (Q_OS_*)。例如， Q_OS_UNIX 是為基於 Unix 的係統定義的。
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 ()，和 QT_TRANSLATE_NOOP3 () macros provide the possibility of marking strings for delayed translation. QT_TR_N_NOOP (), QT_TRANSLATE_N_NOOP ()，和 QT_TRANSLATE_N_NOOP3 () are numerator dependent variants of these. The Q_ASSERT () 和 Q_ASSERT_X () enables warning messages of various level of refinement. The Q_FOREACH () 和 foreach () macros implement Qt's foreach loop.
The
Q_INT64_C
() 和
Q_UINT64_C
() macros wrap signed and unsigned 64-bit integer literals in a platform-independent way. The
Q_CHECK_PTR
() macro prints a warning containing the source code's file name and line number, saying that the program ran out of memory, if the pointer is
nullptr
。
qPrintable
() 和
qUtf8Printable
() macros represent an easy way of printing text.
The QT_POINTER_SIZE macro expands to the size of a pointer in bytes.
The macros QT_VERSION and QT_VERSION_STR expand to a numeric value or a string, respectively, that specifies the version of Qt that the application is compiled against.
另請參閱 <QtAlgorithms> and QSysInfo .
這是 typedef 對於
void (*)()
, a pointer to a function that takes no arguments and returns void.
這是采用以下簽名的函數指針的 typedef：
void myMessageHandler(QtMsgType, const QMessageLogContext &, const QString &);
該 typedef 在 Qt 5.0 引入。
另請參閱 QtMsgType and qInstallMessageHandler ().
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.
| 常量 | 值 | 描述 |
|---|---|---|
QtDebugMsg
|
0
|
消息的生成是通過 qDebug () 函數。 |
QtInfoMsg
|
4
|
消息的生成是通過 qInfo () 函數。 |
QtWarningMsg
|
1
|
消息的生成是通過 qWarning () 函數。 |
QtCriticalMsg
|
2
|
消息的生成是通過 qCritical () 函數。 |
QtFatalMsg
|
3
|
消息的生成是通過 qFatal () 函數。 |
QtSystemMsg
|
QtCriticalMsg
|
QtInfoMsg
在 Qt 5.5 添加。
另請參閱 QtMessageHandler and qInstallMessageHandler ().
typedef 對於
signed char
。此類型保證在 Qt 支持的所有平颱為 8 位。
typedef 對於
signed short
。此類型保證在 Qt 支持的所有平颱為 16 位。
typedef 對於
signed int
。此類型保證在 Qt 支持的所有平颱為 32 位。
typedef 對於
long long int
(
__int64
在 Windows)。此類型保證在由 Qt 支持的所有平颱都為 64 位。
可以創建此類型的文字使用 Q_INT64_C () 宏：
qint64 value = Q_INT64_C(932838457459459);
另請參閱 Q_INT64_C (), quint64 ，和 qlonglong .
用於以有符號整數錶示指針的整型 (對哈希等有用)。
typedef 為 qint32 或 qint64。此類型保證在 Qt 支持的所有平颱，指針的大小相同。在采用 32 位指針的係統中，qintptr typedef 為 qint32；在采用 64 位指針的係統中，qintptr typedef 為 qint64。
注意，qintptr 有符號。使用 quintptr 對於無符號值。
另請參閱 qptrdiff , qint32 ，和 qint64 .
typedef 對於
long long int
(
__int64
在 Windows)。這如同
qint64
.
另請參閱 qulonglong and qint64 .
用於錶示指針差異的整型。
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.
注意：qptrdiff 是有符號的。使用 quintptr 為無符號值。
另請參閱 quintptr , qint32 ，和 qint64 .
typedef 對於
double
除非配置 Qt 采用
-qreal float
選項。
[alias]
qsizetype
This is a type alias for QIntegerForSizeof<std::size_t>::Signed.
整型類型提供 POSIX
ssize_t
對於所有平颱。
此類型保證相同大小如
size_t
在 Qt 支持的所有平颱。
注意：qsizetype 無符號。使用
size_t
對於無符號值。
This alias was introduced in Qt 5.10.
另請參閱 qptrdiff .
typedef 對於
unsigned char
。此類型保證在 Qt 支持的所有平颱為 8 位。
typedef 對於
unsigned short
。此類型保證在 Qt 支持的所有平颱為 16 位。
typedef 對於
無符號 int
。此類型保證在 Qt 支持的所有平颱為 32 位。
typedef 對於
unsigned long long int
(
unsigned __int64
在 Windows)。此類型保證在由 Qt 支持的所有平颱都為 64 位。
可以創建此類型的文字使用 Q_UINT64_C () 宏：
quint64 value = Q_UINT64_C(932838457459459);
另請參閱 Q_UINT64_C (), qint64 ，和 qulonglong .
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.
另請參閱 qptrdiff , quint32 ，和 quint64 .
typedef 對於
unsigned long long int
(
unsigned __int64
在 Windows)。這如同
quint64
.
方便 typedef 對於
unsigned char
.
方便 typedef 對於
無符號 int
.
方便 typedef 對於
unsigned long
.
方便 typedef 對於
unsigned short
.
These functions return the value of the environment variable, varName , as a QString . If no variable varName is found in the environment and defaultValue is provided, defaultValue is returned. Otherwise QString() is returned.
The Qt environment manipulation functions are thread-safe, but this requires that the C library equivalent functions like getenv and putenv are not directly called.
The following table describes how to choose between qgetenv () 和 qEnvironmentVariable ():
| Condition | Recommendation |
|---|---|
| Variable contains file paths or user text | qEnvironmentVariable () |
| Windows-specific code | qEnvironmentVariable () |
| Unix-specific code, destination variable is not QString and/or is used to interface with non-Qt APIs | qgetenv () |
| Destination variable is a QString | qEnvironmentVariable () |
| Destination variable is a QByteArray or std::string | qgetenv () |
注意： on Unix systems, this function may produce data loss if the original string contains arbitrary binary data that cannot be decoded by the locale codec. Use qgetenv () instead for that case. On Windows, this function is lossless.
注意： the variable name varName must contain only US-ASCII characters.
該函數在 Qt 5.10 引入。
另請參閱 qputenv (), qgetenv (), qEnvironmentVariableIsSet ()，和 qEnvironmentVariableIsEmpty ().
比較 t to the 0 of type T and returns the absolute value. Thus if T is double ，那麼 t is compared to (double) 0 .
範例：
int absoluteValue; int myValue = -4; absoluteValue = qAbs(myValue); // absoluteValue == 4
返迴
t
cast to
const T
.
This function is a Qt implementation of C++17's std::as_const(), a cast function like std::move(). But while std::move() turns lvalues into rvalues, this function turns non-const lvalues into const lvalues. Like std::as_const(), it doesn't work on rvalues, because it cannot be efficiently implemented for rvalues without leaving dangling references.
Its main use in Qt is to prevent implicitly-shared Qt containers from detaching:
QString s = ...;
for (QChar ch : s) // detaches 's' (performs a deep-copy if 's' was shared)
process(ch);
for (QChar ch : qAsConst(s)) // ok, no detach attempt
process(ch);
Of course, in this case, you could (and probably should) have declared
s
as
const
in the first place:
const QString s = ...;
for (QChar ch : s) // ok, no detach attempt on const objects
process(ch);
but often that is not easily possible.
It is important to note that qAsConst() does not copy its argument, it just performs a
const_cast<const T&>(t)
. This is also the reason why it is designed to fail for rvalues: The returned reference would go stale too soon. So while this works (but detaches the returned object):
for (QChar ch : funcReturningQString())
process(ch); // OK, the returned object is kept alive for the loop's duration
this would not:
for (QChar ch : qAsConst(funcReturningQString()))
process(ch); // ERROR: ch is copied from deleted memory
To prevent this construct from compiling (and failing at runtime), qAsConst() has a second, deleted, overload which binds to rvalues.
該函數在 Qt 5.7 引入。
這是重載函數。
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 memory
該函數在 Qt 5.7 引入。
返迴 val bounded by min and max 。這相當於 qMax ( min , qMin ( val , max )).
範例：
int myValue = 10; int minValue = 2; int maxValue = 6; int boundedValue = qBound(minValue, myValue, maxValue); // boundedValue == 6
返迴 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)
該函數在 Qt 5.7 引入。
另請參閱 qOverload , qNonConstOverload ，和 基於字符串的連接和基於函子的連接之間的差異 .
Returns the numerical value of the environment variable
varName
。若
ok
is not null, sets
*ok
to
true
or
false
depending on the success of the conversion.
相當於
qgetenv(varName).toInt(ok, 0)
except that it's much faster, and can't throw exceptions.
注意：
there's a limit on the length of the value, which is sufficient for all valid values of int, not counting leading zeroes or spaces. Values that are too long will either be truncated or this function will set
ok
to
false
.
該函數在 Qt 5.5 引入。
另請參閱 qgetenv (), qEnvironmentVariable ()，和 qEnvironmentVariableIsSet ().
Returns whether the environment variable varName is empty.
相當於
qgetenv(varName).isEmpty()
except that it's potentially much faster, and can't throw exceptions.
該函數在 Qt 5.1 引入。
另請參閱 qgetenv (), qEnvironmentVariable ()，和 qEnvironmentVariableIsSet ().
Returns whether the environment variable varName 有設置。
相當於
!qgetenv(varName).isNull()
except that it's potentially much faster, and can't throw exceptions.
該函數在 Qt 5.1 引入。
另請參閱 qgetenv (), qEnvironmentVariable ()，和 qEnvironmentVariableIsEmpty ().
Replaces the value of obj with newValue and returns the old value of obj .
This is Qt's implementation of std::exchange(). It differs from std::exchange() only in that it is
constexpr
already in C++14, and available on all supported compilers.
Here is how to use qExchange() to implement move constructors:
MyClass(MyClass &&other) : m_pointer{qExchange(other.m_pointer, nullptr)}, m_int{qExchange(other.m_int, 0)}, m_vector{std::move(other.m_vector)}, ...
For members of class type, we can use std::move(), as their move-constructor will do the right thing. But for scalar types such as raw pointers or integer type, move is the same as copy, which, particularly for pointers, is not what we expect. So, we cannot use std::move() for such types, but we can use std::exchange()/qExchange() to make sure the source object's member is already reset by the time we get to the initialization of our next data member, which might come in handy if the constructor exits with an exception.
Here is how to use qExchange() to write a loop that consumes the collection it iterates over:
for (auto &e : qExchange(collection, {}) doSomethingWith(e);
Which is equivalent to the following, much more verbose code:
{
auto tmp = std::move(collection);
collection = {}; // or collection.clear()
for (auto &e : tmp)
doSomethingWith(e);
} // destroys 'tmp'
This is perfectly safe, as the for-loop keeps the result of qExchange() alive for as long as the loop runs, saving the declaration of a temporary variable. Be aware, though, that qExchange() returns a non-const object, so Qt containers may detach.
該函數在 Qt 5.14 引入。
Returns the number of representable floating-point numbers between a and b .
This function provides an alternative way of doing approximated comparisons of floating-point numbers similar to qFuzzyCompare (). However, it returns the distance between two numbers, which gives the caller a possibility to choose the accepted error. Errors are relative, so for instance the distance between 1.0E-5 and 1.00001E-5 will give 110, while the distance between 1.0E36 and 1.00001E36 will give 127.
This function is useful if a floating point comparison requires a certain precision. Therefore, if
a
and
b
are equal it will return 0. The maximum value it will return for 32-bit floating point numbers is 4,278,190,078. This is the distance between
-FLT_MAX
and
+FLT_MAX
.
The function does not give meaningful results if any of the arguments are
Infinite
or
NaN
. You can check for this by calling
qIsFinite
().
The return value can be considered as the "error", so if you for instance want to compare two 32-bit floating point numbers and all you need is an approximated 24-bit precision, you can use this function like this:
if (qFloatDistance(a, b) < (1 << 7)) { // The last 7 bits are not
// significant
// precise enough
}
該函數在 Qt 5.2 引入。
另請參閱 qFuzzyCompare ().
Returns the number of representable floating-point numbers between a and b .
This function serves the same purpose as
qFloatDistance(float, float)
, but returns the distance between two
double
numbers. Since the range is larger than for two
float
numbers (
[-DBL_MAX,DBL_MAX]
), the return type is quint64.
該函數在 Qt 5.2 引入。
另請參閱 qFuzzyCompare ().
Generates a formatted string out of the type , context , str 自變量。
qFormatLogMessage returns a QString that is formatted according to the current message pattern. It can be used by custom message handlers to format output similar to Qt's default message handler.
The function is thread-safe.
該函數在 Qt 5.4 引入。
另請參閱 qInstallMessageHandler () 和 qSetMessagePattern ().
分類浮點值。
返迴值的定義在
<cmath>
: returns one of the following, determined by the floating-point class of
val
:
比較浮點值
p1
and
p2
並返迴
true
若它們被認為相等，否則
false
.
Note that comparing values where either p1 or p2 is 0.0 will not work, nor does comparing values where one of the values is NaN or infinity. If one of the values is always 0.0, use qFuzzyIsNull instead. If one of the values is likely to be 0.0, one solution is to add 1.0 to both values.
// Instead of comparing with 0.0 qFuzzyCompare(0.0, 1.0e-200); // This will return false // Compare adding 1 to both values will fix the problem qFuzzyCompare(1 + 0.0, 1 + 1.0e-200); // This will return true
The two numbers are compared in a relative way, where the exactness is stronger the smaller the numbers are.
注意： 此函數是 綫程安全 .
該函數在 Qt 4.4 引入。
比較浮點值
p1
and
p2
並返迴
true
若它們被認為相等，否則
false
.
The two numbers are compared in a relative way, where the exactness is stronger the smaller the numbers are.
注意： 此函數是 綫程安全 .
該函數在 Qt 4.4 引入。
Returns true if the absolute value of d is within 0.000000000001 of 0.0.
注意： 此函數是 綫程安全 .
該函數在 Qt 4.4 引入。
Returns true if the absolute value of f is within 0.00001f of 0.0.
注意： 此函數是 綫程安全 .
該函數在 Qt 4.4 引入。
Returns the bit pattern for an infinite number as a double.
另請參閱 qIsInf ().
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)
.
範例：
#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(); }
該函數在 Qt 5.0 引入。
另請參閱 QtMessageHandler , QtMsgType , qDebug (), qInfo (), qWarning (), qCritical (), qFatal ()，和 調試技術 .
返迴
true
if the double
d
是有限數。
返迴
true
if the float
f
是有限數。
返迴
true
if the double
d
相當於無窮大。
另請參閱 qInf ().
返迴
true
if the float
f
相當於無窮大。
另請參閱 qInf ().
返迴
true
if the double
d
是 NaN (非數字)。
返迴
true
if the float
f
是 NaN (非數字)。
Returns the maximum of a and b .
範例：
int myValue = 6; int yourValue = 4; int maxValue = qMax(myValue, yourValue); // maxValue == myValue
Returns the minimum of a and b .
範例：
int myValue = 6; int yourValue = 4; int minValue = qMin(myValue, yourValue); // minValue == yourValue
返迴 memberFunctionPointer 指針指嚮非常量成員函數：
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)
該函數在 Qt 5.7 引入。
另請參閱 qOverload ，qNonConstOverload，和 基於字符串的連接和基於函子的連接之間的差異 .
返迴重載函數指針。 模闆參數是函數的自變量類型列錶。 functionPointer 是指針指嚮 (成員) 函數：
struct Foo {
void overloadedFunction();
void overloadedFunction(int, const QString &);
};
... qOverload<>(&Foo::overloadedFunction)
... qOverload<int, const QString &>(&Foo::overloadedFunction)
若成員函數也是重載常量 qConstOverload and qNonConstOverload 需要用到。
qOverload() 要求啓用 C++14。在僅 C++11 代碼中，可以直接使用幫手類 QOverload、QConstOverload 及 QNonConstOverload：
... QOverload<>::of(&Foo::overloadedFunction)
... QOverload<int, const QString &>::of(&Foo::overloadedFunction)
注意： Qt 檢測必要 C++ 14 編譯器支持，通過特徵測試推薦從 C++ 委員會標準文檔 6 .
該函數在 Qt 5.7 引入。
另請參閱 qConstOverload (), qNonConstOverload ()，和 基於字符串的連接和基於函子的連接之間的差異 .
Returns the bit pattern of a quiet NaN as a double.
另請參閱 qIsNaN ().
圓整 d 到最近 64 位整數。
Rounds half up (e.g. 0.5 -> 1, -0.5 -> 0).
範例：
double valueA = 42949672960.3; double valueB = 42949672960.7; qint64 roundedValueA = qRound64(valueA); // roundedValueA = 42949672960 qint64 roundedValueB = qRound64(valueB); // roundedValueB = 42949672961
圓整 d 到最近 64 位整數。
Rounds half up (e.g. 0.5f -> 1, -0.5f -> 0).
範例：
float valueA = 42949672960.3; float valueB = 42949672960.7; qint64 roundedValueA = qRound64(valueA); // roundedValueA = 42949672960 qint64 roundedValueB = qRound64(valueB); // roundedValueB = 42949672961
圓整 d 到最近整數。
Rounds half up (e.g. 0.5 -> 1, -0.5 -> 0).
範例：
double valueA = 2.3; double valueB = 2.7; int roundedValueA = qRound(valueA); // roundedValueA = 2 int roundedValueB = qRound(valueB); // roundedValueB = 3
圓整 d 到最近整數。
Rounds half up (e.g. 0.5f -> 1, -0.5f -> 0).
範例：
float valueA = 2.3; float valueB = 2.7; int roundedValueA = qRound(valueA); // roundedValueA = 2 int roundedValueB = qRound(valueB); // roundedValueB = 3
Returns the bit pattern of a signalling NaN as a double.
改變默認消息處理程序的輸齣。
Allows to tweak the output of qDebug (), qInfo (), qWarning (), qCritical ()，和 qFatal (). The category logging output of qCDebug (), qCInfo (), qCWarning ()，和 qCCritical () is formatted, too.
Following placeholders are supported:
| 占位符 | 描述 |
|---|---|
%{appname}
|
QCoreApplication::applicationName () |
%{category}
|
Logging category |
%{file}
|
Path to source file |
%{function}
|
函數 |
%{line}
|
Line in source file |
%{message}
|
The actual message |
%{pid}
|
QCoreApplication::applicationPid () |
%{threadid}
|
The system-wide ID of current thread (if it can be obtained) |
%{qthreadptr}
|
A pointer to the current QThread (result of QThread::currentThread ()) |
%{type}
|
"debug", "warning", "critical" or "fatal" |
%{time process}
|
time of the message, in seconds since the process started (the token "process" is literal) |
%{time boot}
|
the time of the message, in seconds since the system boot if that can be determined (the token "boot" is literal). If the time since boot could not be obtained, the output is indeterminate (see QElapsedTimer::msecsSinceReference ()). |
%{time [format]}
|
system time when the message occurred, formatted by passing the
format
to
QDateTime::toString
(). If the format is not specified, the format of
Qt::ISODate
被使用。
|
%{backtrace [depth=N] [separator="..."]}
|
A backtrace with the number of frames specified by the optional
depth
parameter (defaults to 5), and separated by the optional
separator
parameter (defaults to "|"). This expansion is available only on some platforms (currently only platfoms using glibc). Names are only known for exported functions. If you want to see the name of every function in your application, use
QMAKE_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.
範例：
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}"
默認 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.
注意：
The message pattern only applies to unstructured logging, such as the default
stderr
output. Structured logging such as systemd will record the message as is, along with as much structured information as can be captured.
Custom message handlers can use qFormatLogMessage () to take pattern into account.
該函數在 Qt 5.0 引入。
另請參閱 qInstallMessageHandler (), 調試技術 ，和 QLoggingCategory .
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.
另請參閱 QT_VERSION_STR and QLibraryInfo::version ().
Uses Q_CHECK_PTR on p , then returns p .
This can be used as an inline version of Q_CHECK_PTR .
Returns the value of the environment variable with name varName 作為 QByteArray . If no variable by that name is found in the environment, this function returns a default-constructed QByteArray .
The Qt environment manipulation functions are thread-safe, but this requires that the C library equivalent functions like getenv and putenv are not directly called.
To convert the data to a QString 使用 QString::fromLocal8Bit ().
注意： on desktop Windows, qgetenv() may produce data loss if the original string contains Unicode characters not representable in the ANSI encoding. Use qEnvironmentVariable () instead. On Unix systems, this function is lossless.
注意： 此函數是 綫程安全 .
另請參閱 qputenv (), qEnvironmentVariable (), qEnvironmentVariableIsSet ()，和 qEnvironmentVariableIsEmpty ().
此函數設置 value of the environment variable named varName . It will create the variable if it does not exist. It returns 0 if the variable could not be set.
Calling qputenv with an empty value removes the environment variable on Windows, and makes it set (but empty) on Unix. Prefer using qunsetenv () for fully portable behavior.
注意： 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.
另請參閱 qgetenv () 和 qEnvironmentVariable ().
The qtTrId function finds and returns a translated string.
Returns a translated string identified by id . If no matching string is found, the id itself is returned. This should not happen under normal conditions.
若
n
>= 0, all occurrences of
%n
in the resulting string are replaced with a decimal representation of
n
. In addition, depending on
n
's value, the translation text may vary.
Meta data and comments can be passed as documented for QObject::tr (). In addition, it is possible to supply a source string template like that:
//% <C string>
or
\begincomment% <C string> \endcomment
範例：
//% "%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
選項到
lrelease
工具。
警告： 此方法纔可重入若有安裝所有翻譯器 before 調用此方法。不支持在履行翻譯時，安裝或移除翻譯器。這樣做可能會導緻崩潰或其它不期望行為。
注意： 此函數是 可重入 .
該函數在 Qt 4.6 引入。
另請參閱 QObject::tr (), QCoreApplication::translate ()，和 Qt 國際化 .
This function deletes the variable varName from the environment.
返迴
true
當成功時。
該函數在 Qt 5.1 引入。
另請參閱 qputenv (), qgetenv ()，和 qEnvironmentVariable ().
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.
另請參閱 QT_DISABLE_DEPRECATED_BEFORE and 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, set
QT_DISABLE_DEPRECATED_BEFORE=0x000000
to enable all functions, including the ones deprecated in Qt 5.0.
另請參閱 QT_DEPRECATED_WARNINGS .
This macro can be used to suppress deprecation warnings that would otherwise be generated when using deprecated APIs.
該函數在 Qt 5.13 引入。
另請參閱 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
and
argv
parameters are the
main()
function's
argc
and
argv
parameters. The
version
parameter is a string literal that specifies which version of Qt the application requires (e.g., "4.0.2").
範例：
#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(); }
標記 UTF-8 編碼的字符串文字 sourceText for delayed translation in the given context 采用給定 disambiguation 。 context is typically a class and also needs to be specified as a string literal. The string literal disambiguation should be a short semantic tag to tell apart otherwise identical strings.
The macro tells lupdate to collect the string, and expands to an anonymous struct of the two string literals passed as sourceText and disambiguation .
範例：
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); }
該函數在 Qt 4.4 引入。
另請參閱 QT_TR_NOOP (), QT_TRANSLATE_NOOP ()，和 Qt 國際化 .
標記 UTF-8 編碼的字符串文字 sourceText for delayed translation in the given context 。 context is typically a class name and also needs to be specified as a string literal.
The macro tells lupdate to collect the string, and expands to sourceText 本身。
範例：
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]); }
另請參閱 QT_TR_NOOP (), QT_TRANSLATE_NOOP3 ()，和 Qt 國際化 .
標記 UTF-8 編碼的字符串文字 sourceText for numerator dependent delayed translation in the given context 采用給定 comment 。 context is typically a class and also needs to be specified as a string literal. The string literal comment should be a short semantic tag to tell apart otherwise identical strings.
The macro tells lupdate to collect the string, and expands to an anonymous struct of the two string literals passed as sourceText and comment .
範例：
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); }
該函數在 Qt 5.12 引入。
另請參閱 QT_TR_NOOP (), QT_TRANSLATE_NOOP (), QT_TRANSLATE_NOOP3 ()，和 Qt 國際化 .
標記 UTF-8 編碼的字符串文字 sourceText for numerator dependent delayed translation in the given context 。 context is typically a class name and also needs to be specified as a string literal.
The macro tells lupdate to collect the string, and expands to sourceText 本身。
範例：
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); }
該函數在 Qt 5.12 引入。
另請參閱 QT_TRANSLATE_NOOP (), QT_TRANSLATE_N_NOOP3 ()，和 Qt 國際化 .
The QT_TRID_NOOP macro marks an id for dynamic translation.
The only purpose of this macro is to provide an anchor for attaching meta data like to qtTrId ().
The macro expands to id .
範例：
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); }
該函數在 Qt 4.6 引入。
標記 UTF-8 編碼的字符串文字 sourceText for delayed translation in the current context (class).
The macro tells lupdate to collect the string, and expands to sourceText 本身。
範例：
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.
另請參閱 QT_TRANSLATE_NOOP () 和 Qt 國際化 .
標記 UTF-8 編碼的字符串文字 sourceText for numerator dependent delayed translation in the current context (class).
The macro tells lupdate to collect the string, and expands to sourceText 本身。
The macro expands to sourceText .
範例：
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); }
該函數在 Qt 5.12 引入。
另請參閱 QT_TR_NOOP and 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 QT_VERSION macro will expand to 0x040102.
You can use QT_VERSION to use the latest Qt features where available.
範例：
#if QT_VERSION >= 0x040100 QIcon icon = style()->standardIcon(QStyle::SP_TrashIcon); #else QPixmap pixmap = style()->standardPixmap(QStyle::SP_TrashIcon); QIcon icon(pixmap); #endif
另請參閱 QT_VERSION_STR and 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.
範例：
#include <QtGlobal> #if (QT_VERSION >= QT_VERSION_CHECK(5, 0, 0)) #include <QtWidgets> #else #include <QtGui> #endif
另請參閱 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.
另請參閱 qVersion () 和 QT_VERSION .
Prints a warning message containing the source code file name and line number if
test
is
false
.
Q_ASSERT() is useful for testing pre- and post-conditions during development. It does nothing if
QT_NO_DEBUG
was defined during compilation.
範例：
// File: div.cpp #include <QtGlobal> int divide(int a, int b) { Q_ASSERT(b != 0); return a / b; }
若
b
is zero, the Q_ASSERT statement will output the following message using the
qFatal
() 函數：
ASSERT: "b != 0" in file div.cpp, line 7
另請參閱 Q_ASSERT_X (), qFatal ()，和 調試技術 .
Prints the message
what
together with the location
where
, the source file name and line number if
test
is
false
.
Q_ASSERT_X is useful for testing pre- and post-conditions during development. It does nothing if
QT_NO_DEBUG
was defined during compilation.
範例：
// File: div.cpp #include <QtGlobal> int divide(int a, int b) { Q_ASSERT_X(b != 0, "divide", "division by zero"); return a / b; }
若
b
is zero, the Q_ASSERT_X statement will output the following message using the
qFatal
() 函數：
ASSERT failure in divide: "division by zero", file div.cpp, line 7
另請參閱 Q_ASSERT (), qFatal ()，和 調試技術 .
Causes the compiler to assume that
expr
is
true
. This macro is useful for improving code generation, by providing the compiler with hints about conditions that it would not otherwise know about. However, there is no guarantee that the compiler will actually use those hints.
This macro could be considered a "lighter" version of
Q_ASSERT
(). While
Q_ASSERT
will abort the program's execution if the condition is
false
, Q_ASSUME will tell the compiler not to generate code for those conditions. Therefore, it is important that the assumptions always hold, otherwise undefined behaviour may occur.
若
expr
is a constantly
false
condition, Q_ASSUME will tell the compiler that the current code execution cannot be reached. That is, Q_ASSUME(false) is equivalent to
Q_UNREACHABLE
().
In debug builds the condition is enforced by an assert to facilitate debugging.
注意： Q_LIKELY () tells the compiler that the expression is likely, but not the only possibility. Q_ASSUME tells the compiler that it is the only possibility.
該函數在 Qt 5.0 引入。
另請參閱 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 ... #endif
另請參閱 Q_BYTE_ORDER and 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 or Q_BIG_ENDIAN . You normally won't need to worry about endian-ness, but you might, for example if you need to know which byte of an integer or UTF-16 character is stored in the lowest address. Endian-ness is important in networking, where computers with different values for Q_BYTE_ORDER must pass data back and forth.
Use this macro as in the following examples.
#if Q_BYTE_ORDER == Q_BIG_ENDIAN ... #endif or #if Q_BYTE_ORDER == Q_LITTLE_ENDIAN ... #endif
另請參閱 Q_BIG_ENDIAN and 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++.
若
pointer
is
nullptr
, prints a message containing the source code's file name and line number, saying that the program ran out of memory and aborts program execution. It throws
std::bad_alloc
instead if exceptions are enabled.
Q_CHECK_PTR does nothing if
QT_NO_DEBUG
and
QT_NO_EXCEPTIONS
were defined during compilation. Therefore you must not use Q_CHECK_PTR to check for successful memory allocations because the check will be disabled in some cases.
範例：
int *a; Q_CHECK_PTR(a = new int[80]); // WRONG! a = new (nothrow) int[80]; // Right Q_CHECK_PTR(a);
You can use this macro to specify information about a custom type Type . With accurate type information, Qt's generic containers can choose appropriate storage methods and algorithms.
Flags can be one of the following:
Q_PRIMITIVE_TYPE
specifies that
Type
is a POD (plain old data) type with no constructor or destructor, and for which memcpy()ing creates a valid independent copy of the object.
Q_MOVABLE_TYPE
specifies that
Type
has a constructor and/or a destructor but can be moved in memory using
memcpy()
. Note: despite the name, this has nothing to do with move constructors or C++ move semantics.
Q_COMPLEX_TYPE
(the default) specifies that
Type
has constructors and/or a destructor and that it may not be moved in memory.
Example of a "primitive" type:
struct Point2D { int x; int y; }; Q_DECLARE_TYPEINFO(Point2D, Q_PRIMITIVE_TYPE);
An example of a non-POD "primitive" type is QUuid : Even though QUuid has constructors (and therefore isn't POD), every bit pattern still represents a valid object, and memcpy() can be used to create a valid independent copy of a QUuid 對象。
可移動類型範例：
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 Q_MOVABLE_TYPE despite not being trivially-copyable. For binary compatibility reasons, QList optimizations are only enabled if there is an explicit Q_DECLARE_TYPEINFO 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.
另請參閱 Q_DECL_RELAXED_CONSTEXPR .
This macro marks a symbol for shared library export (see 創建共享庫 ).
另請參閱 Q_DECL_IMPORT .
This macro declares a symbol to be an import from a shared library (see 創建共享庫 ).
另請參閱 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 代替。
該函數在 Qt 5.0 引入。
另請參閱 Q_DECL_NOTHROW and Q_DECL_NOEXCEPT_EXPR ().
This macro marks a function as non-throwing if
x
is
true
. 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 代替。
該函數在 Qt 5.0 引入。
另請參閱 Q_DECL_NOTHROW and 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 代替。
該函數在 Qt 5.0 引入。
另請參閱 Q_DECL_NOEXCEPT and Q_DECL_NOEXCEPT_EXPR ().
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.
另請參閱 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.
該函數在 Qt 5.8 引入。
另請參閱 Q_UNREACHABLE ().
如同 foreach( variable , container ).
此宏可用，甚至
no_keywords
的指定是使用
.pro
文件的
CONFIG
變量。
注意： 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.
另請參閱 qAsConst ().
如同 forever .
此宏可用，甚至
no_keywords
的指定是使用
.pro
文件的
CONFIG
變量。
另請參閱 foreach ().
Forward-declares a Core Foundation type . This includes the actual type and the ref type. For example, Q_FORWARD_DECLARE_CF_TYPE(CFString) declares __CFString and CFStringRef.
該函數在 Qt 5.2 引入。
Forward-declares a mutable Core Foundation type . This includes the actual type and the ref type. For example, Q_FORWARD_DECLARE_MUTABLE_CF_TYPE(CFMutableString) declares __CFMutableString and CFMutableStringRef.
該函數在 Qt 5.2 引入。
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.
該函數在 Qt 5.2 引入。
Expands to a string that describe the function the macro resides in. How this string looks more specifically is compiler dependent. With GNU GCC it is typically the function signature, while with other compilers it might be the line and column number.
Q_FUNC_INFO can be conveniently used with qDebug ()。例如，此函數：
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.
包裹有符號 64 位整數 literal 以獨立於平颱的方式。
範例：
qint64 value = Q_INT64_C(932838457459459);
另請參閱 qint64 and Q_UINT64_C ().
Hints to the compiler that the enclosed condition,
expr
, is likely to evaluate to
true
.
Use of this macro can help the compiler to optimize the code.
範例：
// the condition inside the "if" will be successful most of the times
for (int i = 1; i <= 365; i++) {
if (Q_LIKELY(isWorkingDay(i))) {
...
}
...
}
該函數在 Qt 4.8 引入。
另請參閱 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 ... #endif
另請參閱 Q_BYTE_ORDER and 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
。不使用。
Defined on macOS.
Defined on NetBSD.
Defined on OpenBSD.
Deprecated synonym for
Q_OS_MACOS
。不使用。
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 32-bit and 64-bit versions of Windows.
Defined on 64-bit versions of Windows.
Defined on all supported versions of Windows. That is, if Q_OS_WIN32 , Q_OS_WIN64 ，或 Q_OS_WINRT 有定義。
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 x86 processors. Qt currently supports two x86 variants: Q_PROCESSOR_X86_32 and Q_PROCESSOR_X86_64 .
另請參閱 QSysInfo::buildCpuArchitecture ().
Defined if the application is compiled for S/390 processors. Qt supports one optional variant of S/390: Q_PROCESSOR_S390_X .
另請參閱 QSysInfo::buildCpuArchitecture ().
Defined if the application is compiled for Alpha processors.
另請參閱 QSysInfo::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 ，和 Q_PROCESSOR_ARM_V7 .
另請參閱 QSysInfo::buildCpuArchitecture ().
Defined if the application is compiled for ARMv5 processors. The Q_PROCESSOR_ARM macro is also defined when Q_PROCESSOR_ARM_V5 is defined.
另請參閱 QSysInfo::buildCpuArchitecture ().
Defined if the application is compiled for ARMv6 processors. The Q_PROCESSOR_ARM and Q_PROCESSOR_ARM_V5 macros are also defined when Q_PROCESSOR_ARM_V6 is defined.
另請參閱 QSysInfo::buildCpuArchitecture ().
Defined if the application is compiled for ARMv7 processors. The Q_PROCESSOR_ARM , Q_PROCESSOR_ARM_V5 ，和 Q_PROCESSOR_ARM_V6 macros are also defined when Q_PROCESSOR_ARM_V7 is defined.
另請參閱 QSysInfo::buildCpuArchitecture ().
Defined if the application is compiled for AVR32 processors.
另請參閱 QSysInfo::buildCpuArchitecture ().
Defined if the application is compiled for Blackfin processors.
另請參閱 QSysInfo::buildCpuArchitecture ().
Defined if the application is compiled for IA-64 processors. This includes all Itanium and Itanium 2 processors.
另請參閱 QSysInfo::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 ，和 Q_PROCESSOR_MIPS_64 .
另請參閱 QSysInfo::buildCpuArchitecture ().
Defined if the application is compiled for MIPS32 processors. The Q_PROCESSOR_MIPS , Q_PROCESSOR_MIPS_I ，和 Q_PROCESSOR_MIPS_II macros are also defined when Q_PROCESSOR_MIPS_32 is defined.
另請參閱 QSysInfo::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 ，和 Q_PROCESSOR_MIPS_V macros are also defined when Q_PROCESSOR_MIPS_64 is defined.
另請參閱 QSysInfo::buildCpuArchitecture ().
Defined if the application is compiled for MIPS-I processors. The Q_PROCESSOR_MIPS macro is also defined when Q_PROCESSOR_MIPS_I is defined.
另請參閱 QSysInfo::buildCpuArchitecture ().
Defined if the application is compiled for MIPS-II processors. The Q_PROCESSOR_MIPS and Q_PROCESSOR_MIPS_I macros are also defined when Q_PROCESSOR_MIPS_II is defined.
另請參閱 QSysInfo::buildCpuArchitecture ().
Defined if the application is compiled for MIPS-III processors. The Q_PROCESSOR_MIPS , Q_PROCESSOR_MIPS_I ，和 Q_PROCESSOR_MIPS_II macros are also defined when Q_PROCESSOR_MIPS_III is defined.
另請參閱 QSysInfo::buildCpuArchitecture ().
Defined if the application is compiled for MIPS-IV processors. The Q_PROCESSOR_MIPS , Q_PROCESSOR_MIPS_I , Q_PROCESSOR_MIPS_II ，和 Q_PROCESSOR_MIPS_III macros are also defined when Q_PROCESSOR_MIPS_IV is defined.
另請參閱 QSysInfo::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 ，和 Q_PROCESSOR_MIPS_IV macros are also defined when Q_PROCESSOR_MIPS_V is defined.
另請參閱 QSysInfo::buildCpuArchitecture ().
Defined if the application is compiled for POWER processors. Qt currently supports two Power variants: Q_PROCESSOR_POWER_32 and Q_PROCESSOR_POWER_64 .
另請參閱 QSysInfo::buildCpuArchitecture ().
Defined if the application is compiled for 32-bit Power processors. The Q_PROCESSOR_POWER macro is also defined when Q_PROCESSOR_POWER_32 is defined.
另請參閱 QSysInfo::buildCpuArchitecture ().
Defined if the application is compiled for 64-bit Power processors. The Q_PROCESSOR_POWER macro is also defined when Q_PROCESSOR_POWER_64 is defined.
另請參閱 QSysInfo::buildCpuArchitecture ().
Defined if the application is compiled for RISC-V processors. Qt currently supports two RISC-V variants: Q_PROCESSOR_RISCV_32 and Q_PROCESSOR_RISCV_64 .
該函數在 Qt 5.13 引入。
另請參閱 QSysInfo::buildCpuArchitecture ().
Defined if the application is compiled for 32-bit RISC-V processors. The Q_PROCESSOR_RISCV macro is also defined when Q_PROCESSOR_RISCV_32 is defined.
該函數在 Qt 5.13 引入。
另請參閱 QSysInfo::buildCpuArchitecture ().
Defined if the application is compiled for 64-bit RISC-V processors. The Q_PROCESSOR_RISCV macro is also defined when Q_PROCESSOR_RISCV_64 is defined.
該函數在 Qt 5.13 引入。
另請參閱 QSysInfo::buildCpuArchitecture ().
Defined if the application is compiled for S/390x processors. The Q_PROCESSOR_S390 macro is also defined when Q_PROCESSOR_S390_X is defined.
另請參閱 QSysInfo::buildCpuArchitecture ().
Defined if the application is compiled for SuperH processors. Qt currently supports one SuperH revision: Q_PROCESSOR_SH_4A .
另請參閱 QSysInfo::buildCpuArchitecture ().
Defined if the application is compiled for SuperH 4A processors. The Q_PROCESSOR_SH macro is also defined when Q_PROCESSOR_SH_4A is defined.
另請參閱 QSysInfo::buildCpuArchitecture ().
Defined if the application is compiled for SPARC processors. Qt currently supports one optional SPARC revision: Q_PROCESSOR_SPARC_V9 .
另請參閱 QSysInfo::buildCpuArchitecture ().
Defined if the application is compiled for SPARC V9 processors. The Q_PROCESSOR_SPARC macro is also defined when Q_PROCESSOR_SPARC_V9 is defined.
另請參閱 QSysInfo::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 Q_PROCESSOR_X86_32 is defined.
另請參閱 QSysInfo::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 Q_PROCESSOR_X86_64 is defined.
另請參閱 QSysInfo::buildCpuArchitecture ().
包裹無符號 64 位整數 literal 以獨立於平颱的方式。
範例：
quint64 value = Q_UINT64_C(932838457459459);
另請參閱 quint64 and Q_INT64_C ().
Hints to the compiler that the enclosed condition,
expr
, is likely to evaluate to
false
.
Use of this macro can help the compiler to optimize the code.
範例：
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; }
該函數在 Qt 4.8 引入。
另請參閱 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 Q_UNREACHABLE() at that point is that the compiler is told not to generate code for a shape variable containing that value. If the macro is missing, the compiler will still generate the necessary comparisons for that value. If the case label were removed, some compilers could produce a warning that some enum values were not checked.
By using this macro in impossible conditions, code coverage may be improved as dead code paths may be eliminated.
In debug builds the condition is enforced by an assert to facilitate debugging.
該函數在 Qt 5.0 引入。
另請參閱 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.
此宏用於實現 Qt 的
foreach
循環。
variable
parameter is a variable name or variable definition; the
container
parameter is a Qt container whose value type corresponds to the type of the variable. See
foreach 關鍵字
瞭解細節。
If you're worried about namespace pollution, you can disable this macro by adding the following line to your
.pro
文件：
CONFIG += no_keywords
注意： 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.
另請參閱 qAsConst ().
This macro is provided for convenience for writing infinite loops.
範例：
forever {
...
}
它相當於
for (;;)
.
If you're worried about namespace pollution, you can disable this macro by adding the following line to your
.pro
文件：
CONFIG += no_keywords
另請參閱 Q_FOREVER .
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.
範例：
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 ().
注意： 此函數是 綫程安全 .
另請參閱 qDebug (), qInfo (), qWarning (), qFatal (), qInstallMessageHandler ()，和 調試技術 .
Calls the message handler with the debug message
message
. If no message handler has been installed, the message is printed to stderr. Under Windows the message is sent to the console, if it is a console application; otherwise, it is sent to the debugger. On QNX, the message is sent to slogger2. This function does nothing if
QT_NO_DEBUG_OUTPUT
was defined during compilation.
If you pass the function a format string and a list of arguments, it works in similar way to the C printf() function. The format should be a Latin-1 string.
範例：
qDebug("Items in list: %d", myList.size());
If you include
<QtDebug>
, a more convenient syntax is also available:
qDebug() << "Brush:" << myQBrush << "Other value:" << i;
采用此句法，函數返迴 QDebug object that is configured to use the QtDebugMsg message type. It automatically puts a single space between each item, and outputs a newline at the end. It supports many C++ and Qt types.
To suppress the output at run-time, install your own message handler with qInstallMessageHandler ().
注意： 此函數是 綫程安全 .
另請參閱 qInfo (), qWarning (), qCritical (), qFatal (), qInstallMessageHandler ()，和 調試技術 .
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.
若正使用 默認消息處理程序 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.
範例：
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 ().
另請參閱 qDebug (), qInfo (), qWarning (), qCritical (), qInstallMessageHandler ()，和 調試技術 .
Calls the message handler with the informational message
message
. If no message handler has been installed, the message is printed to stderr. Under Windows, the message is sent to the console, if it is a console application; otherwise, it is sent to the debugger. On QNX the message is sent to slogger2. This function does nothing if
QT_NO_INFO_OUTPUT
was defined during compilation.
If you pass the function a format string and a list of arguments, it works in similar way to the C printf() function. The format should be a Latin-1 string.
範例：
qInfo("Items in list: %d", myList.size());
If you include
<QtDebug>
, a more convenient syntax is also available:
qInfo() << "Brush:" << myQBrush << "Other value:" << i;
采用此句法，函數返迴 QDebug object that is configured to use the QtInfoMsg message type. It automatically puts a single space between each item, and outputs a newline at the end. It supports many C++ and Qt types.
To suppress the output at run-time, install your own message handler with qInstallMessageHandler ().
注意： 此函數是 綫程安全 .
該函數在 Qt 5.5 引入。
另請參閱 qDebug (), qWarning (), qCritical (), qFatal (), qInstallMessageHandler ()，和 調試技術 .
返迴
str
作為
const char *
。這相當於
str
.toLocal8Bit().constData().
The char pointer will be invalid after the statement in which qPrintable() is used. This is because the array returned by QString::toLocal8Bit () will fall out of scope.
注意： qDebug (), qInfo (), qWarning (), qCritical (), qFatal () expect %s arguments to be UTF-8 encoded, while qPrintable() converts to local 8-bit encoding. Therefore qUtf8Printable () should be used for logging strings instead of qPrintable().
另請參閱 qUtf8Printable ().
返迴
str
作為
const ushort *
，但鑄造成
const wchar_t *
以避免警告。這相當於
str
.utf16() plus some casting.
The only useful thing you can do with the return value of this macro is to pass it to
QString::asprintf
() for use in a
%ls
conversion. In particular, the return value is
not
有效
const wchar_t*
!
In general, the pointer will be invalid after the statement in which qUtf16Printable() is used. This is because the pointer may have been obtained from a temporary expression, which will fall out of scope.
範例：
qWarning("%ls: %ls", qUtf16Printable(key), qUtf16Printable(value));
該函數在 Qt 5.7 引入。
另請參閱 qPrintable (), qDebug (), qInfo (), qWarning (), qCritical ()，和 qFatal ().
返迴
str
作為
const char *
。這相當於
str
.toUtf8().constData().
The char pointer will be invalid after the statement in which qUtf8Printable() is used. This is because the array returned by QString::toUtf8 () will fall out of scope.
範例：
qWarning("%s: %s", qUtf8Printable(key), qUtf8Printable(value));
該函數在 Qt 5.4 引入。
另請參閱 qPrintable (), qDebug (), qInfo (), qWarning (), qCritical ()，和 qFatal ().
調用消息處理程序采用警告消息
message
. If no message handler has been installed, the message is printed to stderr. Under Windows, the message is sent to the debugger. On QNX the message is sent to slogger2. This function does nothing if
QT_NO_WARNING_OUTPUT
was defined during compilation; it exits if at the nth warning corresponding to the counter in environment variable
QT_FATAL_WARNINGS
. That is, if the environment variable contains the value 1, it will exit on the 1st message; if it contains the value 10, it will exit on the 10th message. Any non-numeric value is equivalent to 1.
This function takes a format string and a list of arguments, similar to the C printf() function. The format should be a Latin-1 string.
範例：
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 ().
注意： 此函數是 綫程安全 .
另請參閱 qDebug (), qInfo (), qCritical (), qFatal (), qInstallMessageHandler ()，和 調試技術 .