<QtGlobal> - Глобальные объявления Qt

Заголовочный файл <QtGlobal> содержит основные глобальные объявления. Он включается в большинство других заголовочных файлов Qt. Подробнее...

• Устаревшие члены

Типы

Функции

Макросы

Глобальные объявления включают типы, функции и макросы.

Определения типов частично являются определениями удобства для основных типов (некоторые из которых гарантируют определённые битовые размеры на всех платформах, поддерживаемых Qt), частично типы, связанные с обработкой сообщений Qt. Функции связаны с генерированием сообщений, обработкой версии Qt, сравнением и настройкой значений объектов. И, наконец, некоторые из объявленных макросов позволяют программистам добавлять код, специфичный для компилятора или платформы, в свои приложения, в то время как другие являются макросами удобства для более крупных операций.

Типы

В заголовочном файле объявляются несколько определений типов, которые гарантируют указанный битовый размер на всех платформах, поддерживаемых Qt, для различных основных типов, например, qint8, который представляет собой знаковый char, гарантированный в 8 бит на всех платформах, поддерживаемых Qt. В заголовочном файле также объявляется определение типа qlonglong для long long int (__int64 в Windows).

Определены несколько удобных типов: qreal для double, uchar для unsigned char, uint для unsigned int, ulong для unsigned long и ushort для unsigned short.

Наконец, определение QtMsgType идентифицирует различные сообщения, которые могут быть сгенерированы и отправлены обработчику сообщений Qt; QtMessageHandler — это тип определения указателя на функцию с сигнатурой void myMessageHandler(QtMsgType, const QMessageLogContext &, const char *). Класс QMessageLogContext содержит строку, файл и функцию, в которых было записано сообщение. Эта информация создается классом QMessageLogger.

Функции

Заголовочный файл <QtGlobal> содержит несколько функций сравнения и изменения значения объекта. Эти функции принимают тип шаблона в качестве аргумента: Вы можете получить абсолютное значение объекта, используя функцию qAbs(), и вы можете ограничить значение данного объекта заданными минимальными и максимальными значениями, используя функцию qBound(). Вы можете получить минимальное и максимальное значение двух данных объектов, используя соответственно qMin() и qMax(). Все эти функции возвращают соответствующий тип шаблона; типы шаблонов могут быть заменены любым другим типом.

Пример:

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

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

<QtGlobal> также содержит функции, которые генерируют сообщения из заданного строкового аргумента: qDebug(), qInfo(), qWarning(), qCritical() и qFatal(). Эти функции вызывают обработчик сообщений с заданным сообщением.

Пример:

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

Остальные функции — это qRound() и qRound64(), которые обе принимают double или float значение в качестве аргумента, возвращая значение, округлённое до ближайшего целого и 64-битного целого соответственно, функция qInstallMessageHandler(), которая устанавливает заданный QtMessageHandler, и функция qVersion(), которая возвращает номер версии Qt во время выполнения в виде строки.

Макросы

Заголовочный файл <QtGlobal> предоставляет ряд макросов (Q_CC_*), которые определены, если приложение скомпилировано с использованием указанных платформ. Например, макрос Q_CC_SUN определен, если приложение скомпилировано с использованием Forte Developer или Sun Studio C++. Заголовочный файл также объявляет ряд макросов (Q_OS_*), которые определены для указанных платформ. Например, Q_OS_UNIX, который определен для систем на базе Unix.

Цель этих макросов — предоставить программистам возможность добавления специфичного для компилятора или платформы кода в их приложение.

Остальные макросы являются удобными макросами для более крупных операций: Макросы QT_TRANSLATE_NOOP() и QT_TR_NOOP() предоставляют возможность помечать текст для динамического перевода, то есть перевода без изменения хранящегося исходного текста. Макросы Q_ASSERT() и Q_ASSERT_X() позволяют отображать предупреждения разной степени детализации. Макросы Q_FOREACH() и foreach() реализуют цикл foreach Qt.

Макросы Q_INT64_C() и Q_UINT64_C() оборачивают целочисленные литералы 64-битных со знаком и без знака соответственно независимым от платформы способом. Макрос Q_CHECK_PTR() выводит предупреждение, содержащее имя файла и номер строки исходного кода, указывая, что программа выделила недостаточно памяти, если указатель равен 0. Макросы qPrintable() и qUtf8Printable() представляют собой простой способ вывода текста.

Наконец, макрос QT_POINTER_SIZE расширяется до размера указателя в байтах, а макросы QT_VERSION и QT_VERSION_STR соответственно расширяются до числового значения или строки, указывающей номер версии Qt, т. е. версии, с которой скомпилировано приложение.

См. также <QtAlgorithms> и QSysInfo.

Документация типов

typedef QFunctionPointer

Это typedef для void (*)(), указателя на функцию, которая не принимает аргументы и возвращает void.

typedef QtMessageHandler

Это typedef для указателя на функцию со следующей сигнатурой:

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

Этот typedef был введён в Qt 5.0.

См. также QtMsgType и qInstallMessageHandler().

enum QtMsgType

Этот перечисление описывает сообщения, которые могут быть отправлены обработчику сообщений (QtMessageHandler). Вы можете использовать перечисление для идентификации и сопоставления различных типов сообщений с соответствующими действиями.

QtInfoMsg был добавлен в Qt 5.5.

См. также QtMessageHandler и qInstallMessageHandler().

typedef qint8

Тип-синоним для signed char. Этот тип гарантированно имеет 8 бит на всех платформах, поддерживаемых Qt.

typedef qint16

Тип-синоним для signed short. Этот тип гарантированно имеет 16 бит на всех платформах, поддерживаемых Qt.

typedef qint32

Тип-синоним для signed int. Этот тип гарантированно имеет 32 бита на всех платформах, поддерживаемых Qt.

typedef qint64

Тип-синоним для long long int (__int64 на Windows). Этот тип гарантированно имеет 64 бита на всех платформах, поддерживаемых Qt.

Литералы этого типа могут быть созданы с помощью макроса Q_INT64_C:

qint64 value = Q_INT64_C(932838457459459);

См. также Q_INT64_C(), quint64 и qlonglong.

typedef qintptr

Целочисленный тип для представления указателей в виде целого со знаком (полезно для хэширования и т. д.).

Тип-синоним для qint32 или qint64. Этот тип гарантированно имеет тот же размер, что и указатель, на всех платформах, поддерживаемых Qt. В системах с 32-битными указателями qintptr является синонимом для qint32; в системах с 64-битными указателями qintptr является синонимом для qint64.

Обратите внимание, что qintptr со знаком. Используйте quintptr для беззнаковых значений.

См. также qptrdiff, qint32 и qint64.

typedef qlonglong

Тип-синоним для long long int (__int64 на Windows). Это то же самое, что и qint64.

См. также qulonglong и qint64.

typedef qptrdiff

Целочисленный тип для представления разностей указателей.

Тип-синоним для qint32 или qint64. Этот тип гарантированно имеет тот же размер, что и указатель, на всех платформах, поддерживаемых Qt. В системах с 32-битными указателями quintptr является синонимом для quint32; в системах с 64-битными указателями quintptr является синонимом для quint64.

Обратите внимание, что qptrdiff со знаком. Используйте quintptr для беззнаковых значений.

См. также quintptr, qint32 и qint64.

typedef qreal

Тип-синоним для double за исключением случаев, когда Qt сконфигурирован с опцией -qreal float.

typedef quint8

Тип-синоним для unsigned char. Этот тип гарантированно имеет 8 бит на всех платформах, поддерживаемых Qt.

typedef quint16

Тип-синоним для unsigned short. Этот тип гарантированно имеет 16 бит на всех платформах, поддерживаемых Qt.

typedef quint32

Тип-синоним для unsigned int. Этот тип гарантированно имеет 32 бита на всех платформах, поддерживаемых Qt.

typedef quint64

Тип-синоним для unsigned long long int (unsigned __int64 на Windows). Этот тип гарантированно имеет 64 бита на всех платформах, поддерживаемых Qt.

Литералы этого типа могут быть созданы с помощью макроса Q_UINT64_C:

quint64 value = Q_UINT64_C(932838457459459);

См. также Q_UINT64_C(), qint64 и qulonglong.

typedef quintptr

Целочисленный тип для представления указателей в виде беззнакового целого числа (полезно для хэширования и т. п.).

Тип-псевдоним для quint32 или quint64. Этот тип гарантированно имеет тот же размер, что и указатель, на всех платформах, поддерживаемых Qt. На системах с 32-битными указателями quintptr — это псевдоним для quint32; на системах с 64-битными указателями quintptr — это псевдоним для quint64.

Обратите внимание, что quintptr — беззнаковый тип. Используйте qptrdiff для знаковых значений.

См. также qptrdiff, quint32 и quint64.

typedef qulonglong

Тип-псевдоним для unsigned long long int (unsigned __int64 в Windows). Это то же самое, что quint64.

См. также quint64 и qlonglong.

typedef uchar

Удобный тип-псевдоним для unsigned char.

typedef uint

Удобный тип-псевдоним для unsigned int.

typedef ulong

Удобный тип-псевдоним для unsigned long.

typedef ushort

Удобный тип-псевдоним для unsigned short.

Документация функций

T qAbs(const T &value)

Сравнивает value с 0 типа T и возвращает абсолютное значение. Таким образом, если T — double, то value сравнивается с (double) 0.

Пример:

int absoluteValue;
int myValue = -4;

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

QtPrivate::QAddConst<T>::Type &qAsConst(T &t)

Возвращает t, преобразованное к const T.

Эта функция является реализацией Qt функции C++17 std::as_const(), функции преобразования, подобной std::move(). Но в то время как std::move() преобразует lvalues в rvalues, эта функция преобразует неконстантные lvalues в константные lvalues. Как и std::as_const(), она не работает с rvalues, так как не может быть эффективно реализована для rvalues без оставления висячих ссылок.

Основное применение в Qt — предотвратить отсоединение неявно разделяемых контейнеров Qt:

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

Конечно, в этом случае вы могли бы (и, вероятно, должны были бы) объявить s как const с самого начала:

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

но часто это нелегко сделать.

Важно отметить, что qAsConst() не копирует свой аргумент, она просто выполняет const_cast<const T&>(t). Это также причина, по которой она предназначена для работы с rvalues: возвращаемая ссылка станет недействительной слишком рано. Итак, в то время как это работает (но отсоединяет возвращаемый объект):

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

это не сработает:

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

Чтобы предотвратить компиляцию этого конструкта (и неудачу во время выполнения), qAsConst() имеет вторую, удаленную перегрузку, которая связывается с rvalues.

Эта функция была добавлена в Qt 5.7.

const T &qBound(const T &min, const T &value, const T &max)

Возвращает value, ограниченное значениями min и max. Это эквивалентно qMax(min, qMin(value, max)).

Пример:

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

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

См. также qMin() и qMax().

auto qConstOverload(T memberFunctionPointer)

Возвращает указатель memberFunctionPointer на константный член-функцию:

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

Эта функция была добавлена в Qt 5.7.

См. также qOverload, qNonConstOverload и Различия между строковыми и функторными соединениями.

int qEnvironmentVariableIntValue(const char *varName, bool *ok = Q_NULLPTR)

Возвращает числовое значение переменной окружения varName. Если ok не равен нулю, устанавливает *ok в true или false в зависимости от успеха преобразования.

Эквивалентно

qgetenv(varName).toInt(ok, 0)

за исключением того, что она намного быстрее и не может выбрасывать исключения.

Примечание: есть ограничение на длину значения, которого достаточно для всех допустимых значений int, не считая ведущих нулей или пробелов. Значения, которые слишком длинные, будут усечены или эта функция установит ok в false.

Эта функция была добавлена в Qt 5.5.

См. также qgetenv() и qEnvironmentVariableIsSet().

bool qEnvironmentVariableIsEmpty(const char *varName)

Возвращает значение true, если переменная окружения varName пустая.

Эквивалентно

qgetenv(varName).isEmpty()

за исключением того, что она потенциально намного быстрее и не может выбрасывать исключения.

Эта функция была добавлена в Qt 5.1.

См. также qgetenv() и qEnvironmentVariableIsSet().

bool qEnvironmentVariableIsSet(const char *varName)

Возвращает значение true, если переменная окружения varName установлена.

Эквивалентно

!qgetenv(varName).isNull()

за исключением того, что она потенциально намного быстрее и не может выбрасывать исключения.

Эта функция была добавлена в Qt 5.1.

См. также qgetenv() и qEnvironmentVariableIsEmpty().

quint32 qFloatDistance(float a, float b)

Возвращает количество представимых чисел с плавающей точкой между a и b.

Эта функция предоставляет альтернативный способ приближённого сравнения чисел с плавающей точкой, подобный qFuzzyCompare(). Однако она возвращает расстояние между двумя числами, что даёт вызывающей стороне возможность выбрать допустимую ошибку. Ошибки являются относительными, поэтому, например, расстояние между 1.0E-5 и 1.00001E-5 будет 110, а расстояние между 1.0E36 и 1.00001E36 будет 127.

Эта функция полезна, если сравнение чисел с плавающей точкой требует определённой точности. Таким образом, если a и b равны, она вернёт 0. Максимальное значение, которое она вернёт для 32-битных чисел с плавающей точкой, составляет 4 278 190 078. Это расстояние между -FLT_MAX и +FLT_MAX.

Функция не даёт осмысленных результатов, если любой из аргументов является Infinite или NaN. Проверить это можно, вызвав qIsFinite().

Возвращаемое значение можно рассматривать как «ошибку», поэтому, например, если вам нужно сравнить два 32-битных числа с плавающей точкой и вам нужна приблизительная точность 24 бит, вы можете использовать эту функцию так:

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

Эта функция была добавлена в Qt 5.2.

См. также qFuzzyCompare().

quint64 qFloatDistance(double a, double b)

Возвращает количество представимых чисел с плавающей точкой между a и b.

Эта функция выполняет ту же функцию, что и qFloatDistance(float, float), но возвращает расстояние между двумя double числами. Поскольку диапазон больше, чем для двух float чисел ([-DBL_MAX,DBL_MAX]), тип возвращаемого значения — quint64.

Эта функция была добавлена в Qt 5.2.

См. также qFuzzyCompare().

QString qFormatLogMessage(QtMsgType type, const QMessageLogContext &context, const QString &str)

Генерирует отформатированную строку из аргументов type, context, str.

qFormatLogMessage возвращает QString, отформатированный в соответствии с текущим шаблоном сообщений. Его можно использовать пользовательскими обработчиками сообщений для форматирования вывода, аналогично стандартному обработчику Qt.

Функция потокобезопасна.

Эта функция была добавлена в Qt 5.4.

См. также qInstallMessageHandler() и qSetMessagePattern().

[static] bool qFuzzyCompare(double p1, double p2)

Сравнивает значения чисел с плавающей точкой p1 и p2 и возвращает true , если они считаются равными, в противном случае false.

Обратите внимание, что сравнение значений, где p1 или p2 равно 0.0, не работает, так же как и сравнение значений, где одно из значений — NaN или бесконечность. Если одно из значений всегда равно 0.0, используйте qFuzzyIsNull вместо этого. Если одно из значений, вероятно, будет равно 0.0, одним из решений является добавление 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

Два числа сравниваются по отношению друг к другу, где точность выше, чем меньше числа.

Примечание: Эта функция потокобезопасна.

Эта функция была добавлена в Qt 4.4.

[static] bool qFuzzyCompare(float p1, float p2)

Сравнивает значения чисел с плавающей точкой p1 и p2 и возвращает true , если они считаются равными, в противном случае false.

Два числа сравниваются по отношению друг к другу, где точность выше, чем меньше числа.

Примечание: Эта функция потокобезопасна.

Эта функция была добавлена в Qt 4.4.

[static] bool qFuzzyIsNull(double d)

Возвращает true, если абсолютное значение d находится в пределах 0.000000000001 от 0.0.

Примечание: Эта функция является потокобезопасной.

Эта функция была представлена в Qt 4.4.

[static] bool qFuzzyIsNull(float f)

Возвращает true, если абсолютное значение f находится в пределах 0.00001f от 0.0.

Примечание: Эта функция является потокобезопасной.

Эта функция была представлена в Qt 4.4.

double qInf()

Возвращает битовое представление бесконечного числа в формате double.

QtMessageHandler qInstallMessageHandler(QtMessageHandler handler)

Устанавливает обработчик сообщений Qt, который был определён ранее. Возвращает указатель на предыдущий обработчик сообщений.

Обработчик сообщений — это функция, которая отображает сообщения отладки, предупреждения, критические и фатальные ошибки. Библиотека Qt (режим отладки) содержит сотни сообщений предупреждений, которые выводятся при возникновении внутренних ошибок (обычно некорректных аргументов функций). Библиотека Qt в релизном режиме также содержит такие предупреждения, если при компиляции не были установлены QT_NO_WARNING_OUTPUT и/или QT_NO_DEBUG_OUTPUT. Если вы реализуете свой собственный обработчик сообщений, вы получите полный контроль над этими сообщениями.

По умолчанию обработчик сообщений выводит сообщение в стандартный вывод под X11 или в отладчик под Windows. Если это фатальное сообщение, приложение немедленно завершается.

Может быть определён только один обработчик сообщений, поскольку это обычно делается на уровне приложения для управления выводом сообщений отладки.

Для восстановления обработчика сообщений вызовите 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();
    switch (type) {
    case QtDebugMsg:
        fprintf(stderr, "Debug: %s (%s:%u, %s)\n", localMsg.constData(), context.file, context.line, context.function);
        break;
    case QtInfoMsg:
        fprintf(stderr, "Info: %s (%s:%u, %s)\n", localMsg.constData(), context.file, context.line, context.function);
        break;
    case QtWarningMsg:
        fprintf(stderr, "Warning: %s (%s:%u, %s)\n", localMsg.constData(), context.file, context.line, context.function);
        break;
    case QtCriticalMsg:
        fprintf(stderr, "Critical: %s (%s:%u, %s)\n", localMsg.constData(), context.file, context.line, context.function);
        break;
    case QtFatalMsg:
        fprintf(stderr, "Fatal: %s (%s:%u, %s)\n", localMsg.constData(), context.file, context.line, context.function);
        abort();
    }
}

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(), и Техники отладки.

bool qIsFinite(double d)

Возвращает true , если double d является конечным числом.

bool qIsFinite(float f)

Возвращает true , если float f является конечным числом.

bool qIsInf(double d)

Возвращает true , если double d эквивалентно бесконечности.

bool qIsInf(float f)

Возвращает true , если float f эквивалентно бесконечности.

bool qIsNaN(double d)

Возвращает true , если double d не является числом (NaN).

bool qIsNaN(float f)

Возвращает true , если float f не является числом (NaN).

const T &qMax(const T &value1, const T &value2)

Возвращает максимальное значение из value1 и value2.

Пример:

int myValue = 6;
int yourValue = 4;

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

См. также qMin() и qBound().

const T &qMin(const T &value1, const T &value2)

Возвращает минимальное значение из value1 и value2.

Пример:

int myValue = 6;
int yourValue = 4;

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

См. также qMax() и qBound().

auto qNonConstOverload(T memberFunctionPointer)

Возвращает указатель memberFunctionPointer на неконстантный член-функцию:

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

Эта функция была представлена в Qt 5.7.

См. также qOverload, qNonConstOverload, и Различия между строковыми и функциональными соединениями.

auto qOverload(T functionPointer)

Возвращает указатель на перегруженную функцию. Шаблонный параметр представляет список типов аргументов функции. functionPointer — указатель на (член-)функцию:

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

Если член-функция также перегружена с const, необходимо использовать qConstOverload и qNonConstOverload.

qOverload() требует поддержки C++14. В коде с поддержкой только C++11 можно использовать вспомогательные классы QOverload, QConstOverload и QNonConstOverload напрямую:

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

Эта функция была представлена в Qt 5.7.

См. также qConstOverload(), qNonConstOverload(), и Различия между строковыми и функциональными соединениями.

double qQNaN()

Возвращает битовое представление тихого NaN в формате double.

qint64 qRound64(double value)

Округляет value до ближайшего 64-битного целого числа.

Пример:

double valueA = 42949672960.3;
double valueB = 42949672960.7;

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

qint64 qRound64(float value)

Округляет value до ближайшего 64-битного целого числа.

Пример:

float valueA = 42949672960.3;
float valueB = 42949672960.7;

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

int qRound(double value)

Округляет value до ближайшего целого числа.

Пример:

double valueA = 2.3;
double valueB = 2.7;

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

int qRound(float value)

Округляет value до ближайшего целого числа.

Пример:

float valueA = 2.3;
float valueB = 2.7;

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

double qSNaN()

Возвращает битовое представление сигнализирующего NaN в формате double.

void qSetMessagePattern(const QString &pattern)

Изменяет вывод обработчика сообщений по умолчанию.

Позволяет настроить вывод qDebug(), qInfo(), qWarning(), qCritical() и qFatal(). Форматируется также вывод категорий журналов qCDebug(), qCInfo(), qCWarning() и qCCritical().

Поддерживаются следующие плейсхолдеры:

Вы также можете использовать условные операторы для типа сообщения, используя %{if-debug}, %{if-info} %{if-warning}, %{if-critical} или %{if-fatal} за которым следует %{endif}. Содержимое %{if-*} и %{endif} будет выведено только в том случае, если тип совпадает.

Наконец, текст внутри %{if-category} ... %{endif} выводится только если категория не является стандартной.

Пример:

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}"

Стандартный шаблон — "%{if-category}%{category}: %{endif}%{message}".

Шаблон также можно изменить во время выполнения, задав переменную окружения QT_MESSAGE_PATTERN; если вызов qSetMessagePattern() и установка переменной QT_MESSAGE_PATTERN оба произошли, приоритет имеет переменная окружения.

Пользовательские обработчики сообщений могут использовать qFormatLogMessage(), чтобы учесть шаблон.

Эта функция была добавлена в Qt 5.0.

См. также qInstallMessageHandler(), Методы отладки, и QLoggingCategory.

T *q_check_ptr(T *pointer)

Использует Q_CHECK_PTR для pointer, а затем возвращает pointer.

Это можно использовать как инлайновую версию Q_CHECK_PTR.

QByteArray qgetenv(const char *varName)

Возвращает значение переменной окружения с именем varName. Для получения строкового значения переменной используйте QByteArray::constData(). Для преобразования данных в QString используйте QString::fromLocal8Bit().

Примечание: qgetenv() была добавлена, потому что getenv() из стандартной библиотеки C была устаревшей в VC2005 (и более поздних версиях). qgetenv() использует новую функцию замены в VC и вызывает стандартную реализацию библиотеки C на всех остальных платформах.

Предупреждение: Не используйте qgetenv на Windows, если содержимое может содержать символы, не являющиеся US-ASCII, такие как пути к файлам.

См. также qputenv(), qEnvironmentVariableIsSet(), и qEnvironmentVariableIsEmpty().

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

Эта функция устанавливает значение переменной окружения с именем varName. Она создаёт переменную, если она не существует. Возвращает 0, если переменная не могла быть установлена.

Вызов qputenv с пустым значением удаляет переменную среды на Windows и устанавливает её (но пустой) на Unix. Для полностью переносимого поведения предпочтительнее использовать qunsetenv().

Примечание: qputenv() была добавлена, потому что putenv() из стандартной библиотеки C была устаревшей в VC2005 (и более поздних версиях). qputenv() использует заменяющую функцию в VC и вызывает стандартную реализацию библиотеки C на всех остальных платформах.

См. также qgetenv().

int qrand()

Потокобезопасная версия стандартной C++ rand() функции.

Возвращает значение от 0 до RAND_MAX (определённое в <cstdlib> и <stdlib.h>), следующее число в текущей последовательности псевдослучайных целых чисел.

Используйте qsrand() для инициализации генератора псевдослучайных чисел значением начального числа.

Эта функция была добавлена в Qt 4.2.

См. также qsrand().

void qsrand(uint seed)

Потокобезопасная версия стандартной C++ srand() функции.

Устанавливает аргумент seed для генерации новой последовательности псевдослучайных целых чисел, которые будут возвращаться функцией qrand().

Последовательность сгенерированных случайных чисел является детерминированной для каждого потока. Например, если два потока вызывают qsrand(1), а затем qrand(), потоки получат ту же последовательность случайных чисел.

Эта функция была добавлена в Qt 4.2.

См. также qrand().

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

Функция qtTrId находит и возвращает переведённую строку.

Возвращает переведённую строку, идентифицируемую по id. Если соответствующая строка не найдена, возвращается сам идентификатор. Это не должно происходить в нормальных условиях.

Если n >= 0, все вхождения %n в результирующей строке заменяются десятичным представлением n. Кроме того, в зависимости от значения n, текст перевода может отличаться.

Метаданные и комментарии могут быть переданы, как документировано для QObject::tr(). Кроме того, можно передать шаблон исходной строки, как это:

//% <C string>

или

\begincomment% <C string> \endcomment

Пример:

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

Создание файлов QM, пригодных для использования с этой функцией, требует передачи параметра -idbased инструменту lrelease.

Предупреждение: Этот метод является рекурсивным только если все переводчики установлены до вызова этого метода. Установка или удаление переводчиков во время выполнения перевода не поддерживается. Это, вероятно, приведёт к ошибкам или другому нежелательному поведению.

Примечание: Эта функция рекурсивна.

Эта функция была добавлена в Qt 4.6.

См. также QObject::tr(), QCoreApplication::translate(), и Международная поддержка Qt.

bool qunsetenv(const char *varName)

Эта функция удаляет переменную varName из среды.

Возвращает true при успехе.

Эта функция была добавлена в Qt 5.1.

См. также qputenv() и qgetenv().

Документация по макросам

QT_DEPRECATED_WARNINGS

Если этот макрос определён, компилятор сгенерирует предупреждения, если используется API, объявленный устаревшим Qt.

См. также QT_DISABLE_DEPRECATED_BEFORE.

QT_DISABLE_DEPRECATED_BEFORE

Этот макрос можно определить в файле проекта, чтобы отключить функции, устаревшие в указанной версии Qt или в любой более ранней версии. Значение по умолчанию — 5.0, что означает, что функции, устаревшие в или до Qt 5.0, не будут включены.

Примеры: При использовании будущей версии Qt 5, установите QT_DISABLE_DEPRECATED_BEFORE=0x050100, чтобы отключить функции, устаревшие в Qt 5.1 и более ранних версиях. В любой версии установите QT_DISABLE_DEPRECATED_BEFORE=0x000000, чтобы включить любые функции, включая устаревшие в Qt 5.0

См. также QT_DEPRECATED_WARNINGS.

QT_POINTER_SIZE

Расширяется до размера указателя в байтах (4 или 8). Это эквивалентно sizeof(void *) но может быть использовано в препроцессорной директиве.

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

Этот макрос можно использовать, чтобы гарантировать, что приложение запускается на достаточно новой версии Qt. Это особенно полезно, если ваше приложение зависит от конкретного исправления ошибки, внедрённого в выпуск с исправлениями (например, 4.0.2).

Параметры argc и argv — это параметры функций main() — argc и argv соответственно. Параметр version — строковая константа, которая указывает, какую версию Qt требует приложение (например, "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();
}

QT_TRANSLATE_NOOP3(context, sourceText, comment)

Помечает строковую константу sourceText для динамического перевода в заданном context и с comment, то есть хранящаяся sourceText не будет изменена. context обычно является классом и также должен быть указан как строковая константа. Строковая константа comment будет доступна для переводчиков, например, используя Qt Linguist.

Макрос расширяется до анонимной структуры из двух строковых констант, переданных как sourceText и comment.

Пример:

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.

QT_TRANSLATE_NOOP(context, sourceText)

Помечает строковую константу sourceText для динамического перевода в заданном context; то есть хранящаяся sourceText не будет изменена. context обычно является классом и должен быть указан как строковая константа.

Макрос расширяется до 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.

QT_TRID_NOOP(id)

Макрос QT_TRID_NOOP помечает идентификатор для динамического перевода.

Единственная цель этого макроса — предоставить якорь для прикрепления метаданных, например, к qtTrId().

Макрос расширяется до 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.

См. также qtTrId() и Международная поддержка Qt.

QT_TR_NOOP(sourceText)

Помечает строковую константу sourceText для динамического перевода в текущем контексте (классе), то есть хранящаяся sourceText не будет изменена.

Макрос расширяется до sourceText.

Пример:

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

Макрос QT_TR_NOOP_UTF8() идентичен, за исключением того, что он сообщает lupdate о том, что исходная строка закодирована в UTF-8. Соответствующие варианты существуют и в семействе макросов QT_TRANSLATE_NOOP().

См. также QT_TRANSLATE_NOOP() и Международная поддержка Qt.

QT_VERSION

Эта макрос расширяет числовое значение вида 0xMMNNPP (MM = мажорная версия, NN = минорная версия, PP = номер патча), которое определяет номер версии Qt. Например, если вы компилируете своё приложение с Qt 4.1.2, макрос QT_VERSION будет расширяться до 0x040102.

Вы можете использовать QT_VERSION для использования последних функций Qt, где они доступны.

Пример:

#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 и qVersion().

QT_VERSION_CHECK

Преобразует номера мажорной, минорной и патча версии в целое число 0xMMNNPP (MM = мажорная, NN = минорная, PP = патч). Это число можно сравнить с другим идентификатором версии, обработанным аналогичным образом.

Пример:

#include <QtGlobal>

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

См. также QT_VERSION.

QT_VERSION_STR

Эта макрос расширяется до строки, которая определяет номер версии Qt (например, "4.1.2"). Это версия, с которой скомпилировано приложение.

См. также qVersion() и QT_VERSION.

void Q_ASSERT(bool test)

Выводит сообщение об ошибке, содержащее имя файла исходного кода и номер строки, если test равно false.

Q_ASSERT() полезен для проверки предопределённых и пост-условий во время разработки. Он ничего не делает, если QT_NO_DEBUG было определено во время компиляции.

Пример:

// File: div.cpp

#include <QtGlobal>

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

Если b равно нулю, оператор Q_ASSERT выведет следующее сообщение, используя функцию qFatal():

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

См. также Q_ASSERT_X(), qFatal() и Методы отладки.

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

Выводит сообщение what вместе с местоположением where, именем файла и номером строки, если test равно false.

Q_ASSERT_X полезен для проверки предопределённых и пост-условий во время разработки. Он ничего не делает, если QT_NO_DEBUG было определено во время компиляции.

Пример:

// File: div.cpp

#include <QtGlobal>

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

Если b равно нулю, оператор Q_ASSERT_X выведет следующее сообщение, используя функцию qFatal():

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

См. также Q_ASSERT(), qFatal() и Методы отладки.

void Q_ASSUME(bool expr)

Заставляет компилятор предположить, что expr равно true. Эта макрос полезна для улучшения генерации кода, предоставляя компилятору подсказки о условиях, о которых он бы иначе не знал. Однако нет гарантии, что компилятор фактически воспользуется этими подсказками.

Эта макрос можно рассматривать как «более лёгкую» версию Q_ASSERT(). В то время как Q_ASSERT прерывает выполнение программы, если условие false, Q_ASSUME сообщает компилятору не генерировать код для этих условий. Поэтому важно, чтобы предположения всегда были верны, иначе может возникнуть неопределённое поведение.

Если expr является постоянно false условием, Q_ASSUME сообщит компилятору, что текущее выполнение кода недостижимо. То есть, Q_ASSUME(false) эквивалентно Q_UNREACHABLE().

В отладочных сборках условие проверяется с помощью assert для облегчения отладки.

Примечание: Q_LIKELY() сообщает компилятору, что выражение вероятно, но не единственно возможно. Q_ASSUME сообщает компилятору, что это единственная возможность.

Эта функция была добавлена в Qt 5.0.

См. также Q_ASSERT(), Q_UNREACHABLE() и Q_LIKELY().

Q_BIG_ENDIAN

Эта макрос представляет собой значение, которое вы можете сравнить с макросом Q_BYTE_ORDER, чтобы определить порядок байтов вашей системы. В системе с большим порядком байтов наиболее значимый байт хранится по самому низкому адресу. Другие байты следуют в порядке убывания значимости.

#if Q_BYTE_ORDER == Q_BIG_ENDIAN
...
#endif

См. также Q_BYTE_ORDER и Q_LITTLE_ENDIAN.

Q_BYTE_ORDER

Эта макрос может использоваться для определения порядка байтов, используемого вашей системой для хранения данных в памяти. То есть, является ли ваша система little-endian или big-endian. Она устанавливается Qt в одно из значений макросов Q_LITTLE_ENDIAN или Q_BIG_ENDIAN. Обычно вам не нужно беспокоиться о порядке байтов, но вы можете, например, если вам нужно знать, какой байт целого числа или символа UTF-16 хранится по самому низкому адресу. Порядок байтов важен в сетях, где компьютеры с различными значениями Q_BYTE_ORDER должны передавать данные друг другу.

Используйте эту макрос, как в следующих примерах.

#if Q_BYTE_ORDER == Q_BIG_ENDIAN
...
#endif

or

#if Q_BYTE_ORDER == Q_LITTLE_ENDIAN
...
#endif

См. также Q_BIG_ENDIAN и Q_LITTLE_ENDIAN.

Q_CC_BOR

Определён, если приложение скомпилировано с использованием Borland/Turbo C++.

Q_CC_CDS

Определён, если приложение скомпилировано с использованием Reliant C++.

Q_CC_CLANG

Определён, если приложение скомпилировано с использованием Clang.

Q_CC_COMEAU

Определён, если приложение скомпилировано с использованием Comeau C++.

Q_CC_DEC

Определён, если приложение скомпилировано с использованием DEC C++.

Q_CC_EDG

Определён, если приложение скомпилировано с использованием Edison Design Group C++.

Q_CC_GHS

Определён, если приложение скомпилировано с использованием Green Hills Optimizing C++ Compilers.

Q_CC_GNU

Определён, если приложение скомпилировано с использованием GNU C++.

Q_CC_HIGHC

Определён, если приложение скомпилировано с использованием MetaWare High C/C++.

Q_CC_HPACC

Определён, если приложение скомпилировано с использованием HP aC++.

Q_CC_INTEL

Определён, если приложение скомпилировано с использованием Intel C++ для Linux, Intel C++ для Windows.

Q_CC_KAI

Определён, если приложение скомпилировано с использованием KAI C++.

Q_CC_MIPS

Определён, если приложение скомпилировано с использованием MIPSpro C++.

Q_CC_MSVC

Определён, если приложение скомпилировано с использованием Microsoft Visual C/C++, Intel C++ для Windows.

Q_CC_OC

Определён, если приложение скомпилировано с использованием CenterLine C++.

Q_CC_PGI

Определён, если приложение скомпилировано с использованием Portland Group C++.

Q_CC_SUN

Определён, если приложение скомпилировано с использованием Forte Developer или Sun Studio C++.

Q_CC_SYM

Определён, если приложение скомпилировано с использованием Digital Mars C/C++ (ранее Symantec C++).

Q_CC_USLC

Определён, если приложение скомпилировано с использованием SCO OUDK и UDK.

Q_CC_WAT

Определён, если приложение скомпилировано с использованием Watcom C++.

void Q_CHECK_PTR(void *pointer)

Если pointer равен 0, выводит сообщение, содержащее имя файла исходного кода и номер строки, говорящее о том, что программа испытывает недостаток памяти, и прерывает выполнение программы. Бросает std::bad_alloc если включены исключения.

Q_CHECK_PTR ничего не делает, если QT_NO_DEBUG и QT_NO_EXCEPTIONS были определены во время компиляции. Поэтому вы не должны использовать Q_CHECK_PTR для проверки успешного выделения памяти, потому что проверка будет отключена в некоторых случаях.

Пример:

int *a;

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

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

См. также qWarning() и Методы отладки.

Q_DECLARE_TYPEINFO(Type, Flags)

Вы можете использовать эту макрос для указания информации о пользовательском типе Type. С точной информацией о типе контейнеры Qt могут выбирать соответствующие методы хранения и алгоритмы.

Flags может быть одним из следующих:

• Q_PRIMITIVE_TYPE указывает, что Type — это тип POD (простой тип данных) без конструктора или деструктора, или тип, где каждый битовый шаблон является допустимым объектом, и memcpy() создаёт действительную независимую копию объекта.
• Q_MOVABLE_TYPE указывает, что Type имеет конструктор и/или деструктор, но может быть перемещён в памяти с использованием memcpy(). Примечание: несмотря на название, это не имеет ничего общего с move-конструкторами или семантикой перемещения в C++.
• Q_COMPLEX_TYPE (по умолчанию) указывает, что Type имеет конструкторы и/или деструктор, и что он не может быть перемещён в памяти.

Пример «примитивного» типа:

struct Point2D
{
    int x;
    int y;
};

Q_DECLARE_TYPEINFO(Point2D, Q_PRIMITIVE_TYPE);

Пример не-POD «примитивного» типа — QUuid: даже если у QUuid есть конструкторы (и, следовательно, он не POD), каждый битовый шаблон всё ещё представляет допустимый объект, и memcpy() может использоваться для создания действительной независимой копии объекта 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);

Q_DECL_CONSTEXPR

Эта макрос может использоваться для объявления переменной, которая должна быть сконструирована во время компиляции, или для инлайнового метода, который может быть вычислен во время компиляции.

Он расширяется до "constexpr", если ваш компилятор поддерживает ключевое слово C++11, или до ничего в противном случае.

См. также Q_DECL_RELAXED_CONSTEXPR.

Q_DECL_EXPORT

Эта макрос помечает символ для экспорта из библиотеки совместного использования (см. Создание библиотек совместного использования).

См. также Q_DECL_IMPORT.

Q_DECL_FINAL

Этот макрос можно использовать для объявления переопределяющей виртуальной функции или класса как «final» с семантикой Java. Далее производные классы не смогут переопределить эту виртуальную функцию или унаследовать от этого класса соответственно.

Он расширяется до «final», если ваш компилятор поддерживает контекстный ключевое слово C++11, или до чего-то нестандартного, если ваш компилятор поддерживает что-то достаточно близкое к семантике C++11, или до ничего в противном случае.

Макрос размещается в конце функции, обычно после const, если таковой имеется:

// more-derived classes no longer permitted to override this:
virtual void MyWidget::paintEvent(QPaintEvent*) Q_DECL_FINAL;

Для классов он размещается перед : в определении класса, если таковой имеется:

class QRect Q_DECL_FINAL { // cannot be derived from
    // ...
};

Эта функция была введена в Qt 5.0.

См. также Q_DECL_OVERRIDE.

Q_DECL_IMPORT

Этот макрос объявляет символ как импорт из динамической библиотеки (см. Создание динамических библиотек).

См. также Q_DECL_EXPORT.

Q_DECL_NOEXCEPT

Этот макрос отмечает функцию как никогда не выбрасывающую исключения. Если функция всё же выбрасывает исключение, поведение определено: вызывается std::terminate().

Макрос расширяется до C++11 noexcept, если доступно, или до ничего в противном случае.

Если вам нужна операторная версия C++11 noexcept, используйте Q_DECL_NOEXCEPT_EXPR(x).

Если вам не нужна семантика C++11 noexcept, например, потому что ваша функция, возможно, не может выбрасывать исключение, не используйте этот макрос, используйте Q_DECL_NOTHROW вместо этого.

Эта функция была введена в Qt 5.0.

См. также Q_DECL_NOTHROW и Q_DECL_NOEXCEPT_EXPR().

Q_DECL_NOEXCEPT_EXPR(x)

Этот макрос отмечает функцию как не выбрасывающую исключение, если x является true. Если функция всё же выбрасывает исключение, поведение определено: вызывается std::terminate().

Макрос расширяется до C++11 noexcept(x), если доступно, или до ничего в противном случае.

Если вам нужна версия C++11 noexcept, всегда возвращающая true, используйте Q_DECL_NOEXCEPT.

Если вам не нужна семантика C++11 noexcept, например, потому что ваша функция, возможно, не может выбрасывать исключение, не используйте этот макрос, используйте Q_DECL_NOTHROW вместо этого.

Эта функция была введена в Qt 5.0.

См. также Q_DECL_NOTHROW и Q_DECL_NOEXCEPT.

Q_DECL_NOTHROW

Этот макрос отмечает функцию как никогда не выбрасывающую исключение ни при каких обстоятельствах. Если функция всё же выбрасывает исключение, поведение не определено.

Макрос расширяется до «throw()», если это приносит пользу компилятору, или до C++11 noexcept, если доступно, или до ничего в противном случае.

Если вам нужна семантика C++11 noexcept, не используйте этот макрос, используйте Q_DECL_NOEXCEPT/Q_DECL_NOEXCEPT_EXPR вместо этого.

Эта функция была введена в Qt 5.0.

См. также Q_DECL_NOEXCEPT и Q_DECL_NOEXCEPT_EXPR().

Q_DECL_OVERRIDE

Этот макрос можно использовать для объявления переопределяющей виртуальной функции. Использование этой разметки позволит компилятору сгенерировать ошибку, если переопределяющая виртуальная функция фактически ничего не переопределяет.

Он расширяется до «override», если ваш компилятор поддерживает это контекстное ключевое слово C++11, или до ничего в противном случае.

Макрос размещается в конце функции, обычно после const, если таковой имеется:

// generate error if this doesn't actually override anything:
virtual void MyWidget::paintEvent(QPaintEvent*) Q_DECL_OVERRIDE;

Эта функция была введена в Qt 5.0.

См. также Q_DECL_FINAL.

Q_DECL_RELAXED_CONSTEXPR

Этот макрос можно использовать для объявления инлайновой функции, которая может быть вычислена во время компиляции в соответствии с ослабленными правилами из C++14.

Он расширяется до «constexpr», если ваш компилятор поддерживает ослабленные константные выражения C++14, или до ничего в противном случае.

См. также Q_DECL_CONSTEXPR.

void Q_FALLTHROUGH()

Может использоваться в операторах switch в конце блока case, чтобы сообщить компилятору и другим разработчикам, что отсутствие оператора break является преднамеренным.

Это полезно, так как отсутствие оператора break часто является ошибкой, и некоторые компиляторы могут быть настроены на выдачу предупреждений, если он не найден.

Эта функция была введена в Qt 5.8.

См. также Q_UNREACHABLE().

Q_FOREACH(variable, container)

То же, что и foreach(variable, container).

Этот макрос доступен даже тогда, когда no_keywords указан с помощью .pro файла CONFIG переменной.

Примечание: С Qt 5.7 использование этого макроса не рекомендуется. Он будет удалён в будущих версиях Qt. Пожалуйста, используйте цикл range-for C++11, возможно, с qAsConst(), по мере необходимости.

См. также qAsConst().

Q_FOREVER

То же, что и forever.

Этот макрос доступен даже тогда, когда no_keywords указан с помощью .pro файла CONFIG переменной.

См. также foreach().

Q_FORWARD_DECLARE_CF_TYPE(type)

Предварительно объявляет тип Core Foundation type. Это включает сам тип и тип ссылки. Например, Q_FORWARD_DECLARE_CF_TYPE(CFString) объявляет __CFString и CFStringRef.

Эта функция была введена в Qt 5.2.

Q_FORWARD_DECLARE_MUTABLE_CF_TYPE(type)

Предварительно объявляет изменяемый тип Core Foundation type. Это включает сам тип и тип ссылки. Например, Q_FORWARD_DECLARE_MUTABLE_CF_TYPE(CFMutableString) объявляет __CFMutableString и CFMutableStringRef.

Эта функция была введена в Qt 5.2.

Q_FORWARD_DECLARE_OBJC_CLASS(classname)

Предварительно объявляет класс Objective-C classname таким образом, чтобы его можно было компилировать как Objective-C, так и как C++.

Это в первую очередь предназначено для использования в заголовочных файлах, которые могут включаться как файлами Objective-C, так и файлами C++.

Эта функция была введена в Qt 5.2.

const char *Q_FUNC_INFO()

Расширяется до строки, описывающей функцию, в которой находится макрос. Более конкретный вид этой строки зависит от компилятора. В GNU GCC это обычно подпись функции, а в других компиляторах это может быть номер строки и столбца.

Q_FUNC_INFO удобно использовать с 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;
}

при экземпляризации с типом целых чисел с компилятором GCC будет выдавать:

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

Если этот макрос используется вне функции, поведение не определено.

qint64 Q_INT64_C(literal)

Оборачивает целое 64-битное целое число literal независимым от платформы способом.

Пример:

qint64 value = Q_INT64_C(932838457459459);

См. также qint64 и Q_UINT64_C().

Q_LIKELY(expr)

Подсказывает компилятору, что заданное условие expr, скорее всего, приведёт к true.

Использование этого макроса может помочь компилятору оптимизировать код.

Пример:

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

Q_LITTLE_ENDIAN

Этот макрос представляет значение, которое можно сравнить с макросом Q_BYTE_ORDER, чтобы определить порядок байтов вашей системы. В системе с прямым порядком байтов наименее значащий байт хранится по самому низкому адресу. Остальные байты следуют в порядке возрастания значимости.

#if Q_BYTE_ORDER == Q_LITTLE_ENDIAN
...
#endif

См. также Q_BYTE_ORDER и Q_BIG_ENDIAN.

Q_OS_AIX

Определяется на AIX.

Q_OS_ANDROID

Определяется на Android.

Q_OS_BSD4

Определяется на любой системе BSD 4.4.

Q_OS_BSDI

Определяется на BSD/OS.

Q_OS_CYGWIN

Определяется на Cygwin.

Q_OS_DARWIN

Определяется на операционных системах на базе Darwin, таких как macOS, iOS, watchOS и tvOS.

Q_OS_DGUX

Определяется на DG/UX.

Q_OS_DYNIX

Определяется на DYNIX/ptx.

Q_OS_FREEBSD

Определяется на FreeBSD.

Q_OS_HPUX

Определяется на HP-UX.

Q_OS_HURD

Определяется на GNU Hurd.

Q_OS_IOS

Определяется на iOS.

Q_OS_IRIX

Определяется на SGI Irix.

Q_OS_LINUX

Определяется на Linux.

Q_OS_LYNX

Определяется на LynxOS.

Q_OS_MAC

Устаревшее синоним для Q_OS_DARWIN. Не использовать.

Q_OS_MACOS

Определяется на macOS.

Q_OS_NETBSD

Определяется на NetBSD.

Q_OS_OPENBSD

Определяется на OpenBSD.

Q_OS_OSF

Определяется на HP Tru64 UNIX.

Q_OS_OSX

Устаревшее синоним для Q_OS_MACOS. Не использовать.

Q_OS_QNX

Определяется на QNX Neutrino.

Q_OS_RELIANT

Определяется на Reliant UNIX.

Q_OS_SCO

Определено на SCO OpenServer 5.

Q_OS_SOLARIS

Определено на Sun Solaris.

Q_OS_TVOS

Определено на tvOS.

Q_OS_ULTRIX

Определено на DEC Ultrix.

Q_OS_UNIX

Определено на любой системе UNIX BSD/SYSV.

Q_OS_UNIXWARE

Определено на UnixWare 7, Open UNIX 8.

Q_OS_WATCHOS

Определено на watchOS.

Q_OS_WIN32

Определено на 32-разрядных и 64-разрядных версиях Windows.

Q_OS_WIN64

Определено на 64-разрядных версиях Windows.

Q_OS_WIN

Определено на всех поддерживаемых версиях Windows. То есть, если определено Q_OS_WIN32, Q_OS_WIN64 или Q_OS_WINRT.

Q_OS_WINRT

Определено для Windows Runtime (приложений Магазина Windows) на Windows 8, Windows RT и Windows Phone 8.

Q_PROCESSOR_X86

Определяется, если приложение скомпилировано для процессоров x86. Qt в настоящее время поддерживает два варианта x86: Q_PROCESSOR_X86_32 и Q_PROCESSOR_X86_64.

См. также QSysInfo::buildCpuArchitecture().

Q_PROCESSOR_S390

Определяется, если приложение скомпилировано для процессоров S/390. Qt поддерживает один необязательный вариант S/390: Q_PROCESSOR_S390_X.

См. также QSysInfo::buildCpuArchitecture().

Q_PROCESSOR_ALPHA

Определяется, если приложение скомпилировано для процессоров Alpha.

См. также QSysInfo::buildCpuArchitecture().

Q_PROCESSOR_ARM

Определяется, если приложение скомпилировано для процессоров ARM. Qt в настоящее время поддерживает три необязательных варианта ARM: Q_PROCESSOR_ARM_V5, Q_PROCESSOR_ARM_V6 и Q_PROCESSOR_ARM_V7.

См. также QSysInfo::buildCpuArchitecture().

Q_PROCESSOR_ARM_V5

Определяется, если приложение скомпилировано для процессоров ARMv5. Макрос Q_PROCESSOR_ARM также определен, когда определен Q_PROCESSOR_ARM_V5.

См. также QSysInfo::buildCpuArchitecture().

Q_PROCESSOR_ARM_V6

Определяется, если приложение скомпилировано для процессоров ARMv6. Макросы Q_PROCESSOR_ARM и Q_PROCESSOR_ARM_V5 также определены, когда определен Q_PROCESSOR_ARM_V6.

См. также QSysInfo::buildCpuArchitecture().

Q_PROCESSOR_ARM_V7

Определяется, если приложение скомпилировано для процессоров ARMv7. Макросы Q_PROCESSOR_ARM, Q_PROCESSOR_ARM_V5 и Q_PROCESSOR_ARM_V6 также определены, когда определен Q_PROCESSOR_ARM_V7.

См. также QSysInfo::buildCpuArchitecture().

Q_PROCESSOR_AVR32

Определяется, если приложение скомпилировано для процессоров AVR32.

См. также QSysInfo::buildCpuArchitecture().

Q_PROCESSOR_BLACKFIN

Определяется, если приложение скомпилировано для процессоров Blackfin.

См. также QSysInfo::buildCpuArchitecture().

Q_PROCESSOR_IA64

Определяется, если приложение скомпилировано для процессоров IA-64. Это включает все процессоры Itanium и Itanium 2.

См. также QSysInfo::buildCpuArchitecture().

Q_PROCESSOR_MIPS

Определяется, если приложение скомпилировано для процессоров MIPS. Qt в настоящее время поддерживает семь вариантов MIPS: 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().

Q_PROCESSOR_MIPS_32

Определяется, если приложение скомпилировано для процессоров MIPS32. Макросы Q_PROCESSOR_MIPS, Q_PROCESSOR_MIPS_I и Q_PROCESSOR_MIPS_II также определены, когда определен Q_PROCESSOR_MIPS_32.

См. также QSysInfo::buildCpuArchitecture().

Q_PROCESSOR_MIPS_64

Определяется, если приложение скомпилировано для процессоров MIPS64. Макросы Q_PROCESSOR_MIPS, Q_PROCESSOR_MIPS_I, Q_PROCESSOR_MIPS_II, Q_PROCESSOR_MIPS_III, Q_PROCESSOR_MIPS_IV и Q_PROCESSOR_MIPS_V также определены, когда определен Q_PROCESSOR_MIPS_64.

См. также QSysInfo::buildCpuArchitecture().

Q_PROCESSOR_MIPS_I

Определяется, если приложение скомпилировано для процессоров MIPS-I. Макрос Q_PROCESSOR_MIPS также определен, когда определен Q_PROCESSOR_MIPS_I.

См. также QSysInfo::buildCpuArchitecture().

Q_PROCESSOR_MIPS_II

Определяется, если приложение скомпилировано для процессоров MIPS-II. Макросы Q_PROCESSOR_MIPS и Q_PROCESSOR_MIPS_I также определены, когда определен Q_PROCESSOR_MIPS_II.

См. также QSysInfo::buildCpuArchitecture().

Q_PROCESSOR_MIPS_III

Определяется, если приложение скомпилировано для процессоров MIPS-III. Макросы Q_PROCESSOR_MIPS, Q_PROCESSOR_MIPS_I и Q_PROCESSOR_MIPS_II также определены, когда определен Q_PROCESSOR_MIPS_III.

См. также QSysInfo::buildCpuArchitecture().

Q_PROCESSOR_MIPS_IV

Определяется, если приложение скомпилировано для процессоров MIPS-IV. Макросы Q_PROCESSOR_MIPS, Q_PROCESSOR_MIPS_I, Q_PROCESSOR_MIPS_II и Q_PROCESSOR_MIPS_III также определены, когда определен Q_PROCESSOR_MIPS_IV.

См. также QSysInfo::buildCpuArchitecture().

Q_PROCESSOR_MIPS_V

Определяется, если приложение скомпилировано для процессоров MIPS-V. Макросы Q_PROCESSOR_MIPS, Q_PROCESSOR_MIPS_I, Q_PROCESSOR_MIPS_II, Q_PROCESSOR_MIPS_III и Q_PROCESSOR_MIPS_IV также определены, когда определен Q_PROCESSOR_MIPS_V.

См. также QSysInfo::buildCpuArchitecture().

Q_PROCESSOR_POWER

Определяется, если приложение скомпилировано для процессоров POWER. Qt в настоящее время поддерживает два варианта Power: Q_PROCESSOR_POWER_32 и Q_PROCESSOR_POWER_64.

См. также QSysInfo::buildCpuArchitecture().

Q_PROCESSOR_POWER_32

Определяется, если приложение скомпилировано для 32-разрядных процессоров Power. Макрос Q_PROCESSOR_POWER также определен, когда определен Q_PROCESSOR_POWER_32.

См. также QSysInfo::buildCpuArchitecture().

Q_PROCESSOR_POWER_64

Определяется, если приложение скомпилировано для 64-разрядных процессоров Power. Макрос Q_PROCESSOR_POWER также определен, когда определен Q_PROCESSOR_POWER_64.

См. также QSysInfo::buildCpuArchitecture().

Q_PROCESSOR_S390_X

Определяется, если приложение скомпилировано для процессоров S/390x. Макрос Q_PROCESSOR_S390 также определен, когда определен Q_PROCESSOR_S390_X.

См. также QSysInfo::buildCpuArchitecture().

Q_PROCESSOR_SH

Определяется, если приложение скомпилировано для процессоров SuperH. Qt в настоящее время поддерживает одну версию SuperH: Q_PROCESSOR_SH_4A.

См. также QSysInfo::buildCpuArchitecture().

Q_PROCESSOR_SH_4A

Определяется, если приложение скомпилировано для процессоров SuperH 4A. Макрос Q_PROCESSOR_SH также определен, когда определен Q_PROCESSOR_SH_4A.

См. также QSysInfo::buildCpuArchitecture().

Q_PROCESSOR_SPARC

Определяется, если приложение скомпилировано для процессоров SPARC. Qt в настоящее время поддерживает одну необязательную ревизию SPARC: Q_PROCESSOR_SPARC_V9.

См. также QSysInfo::buildCpuArchitecture().

Q_PROCESSOR_SPARC_V9

Определяется, если приложение скомпилировано для процессоров SPARC V9. Макрос Q_PROCESSOR_SPARC также определяется, когда определён Q_PROCESSOR_SPARC_V9.

См. также QSysInfo::buildCpuArchitecture().

Q_PROCESSOR_X86_32

Определяется, если приложение скомпилировано для 32-битных процессоров x86. Это включает все процессоры i386, i486, i586 и i686. Макрос Q_PROCESSOR_X86 также определяется, когда определён Q_PROCESSOR_X86_32.

См. также QSysInfo::buildCpuArchitecture().

Q_PROCESSOR_X86_64

Определяется, если приложение скомпилировано для 64-битных процессоров x86. Это включает все процессоры AMD64, Intel 64 и другие процессоры x86_64/x64. Макрос Q_PROCESSOR_X86 также определяется, когда определён Q_PROCESSOR_X86_64.

См. также QSysInfo::buildCpuArchitecture().

quint64 Q_UINT64_C(literal)

Оборачивает целое беззнаковое 64-битное число literal независимым от платформы способом.

Пример:

quint64 value = Q_UINT64_C(932838457459459);

См. также quint64 и Q_INT64_C().

Q_UNLIKELY(expr)

Подсказывает компилятору, что указанное условие expr, вероятно, приведёт к значению false.

Использование этого макроса может помочь компилятору оптимизировать код.

Пример:

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

void Q_UNREACHABLE()

Сообщает компилятору, что текущую точку кода нельзя достичь, поэтому он может оптимизировать все пути выполнения, ведущие сюда, а также код, продолжающийся отсюда, как неиспользуемый.

Этот макрос полезен для обозначения невозможных условий. Например, приведённый перечислении:

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

Можно написать таблицу переключателей следующим образом:

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

Преимущества вставки Q_UNREACHABLE() в этом месте состоит в том, что компилятору сообщается о том, что не нужно генерировать код для переменной типа, содержащей это значение. Если макрос отсутствует, компилятор всё равно сгенерирует необходимые сравнения для этого значения. Если метка case была бы удалена, некоторые компиляторы могли бы выдать предупреждение о том, что некоторые значения перечисления не были проверены.

Использование этого макроса в невозможных условиях может повысить покрытие кода, так как пути выполнения неиспользуемого кода могут быть удалены.

В отладочных сборках условие проверяется с помощью утверждения для удобства отладки.

Эта функция была добавлена в Qt 5.0.

См. также Q_ASSERT(), Q_ASSUME(), и qFatal().

Q_UNUSED(name)

Указывает компилятору, что параметр с указанным именем name не используется в теле функции. Это может быть использовано для подавления предупреждений компилятора, при этом позволяя определять функции с осмысленными именами параметров в их сигнатурах.

foreach(variable, container)

Этот макрос используется для реализации цикла Qt foreach. Параметр variable — имя переменной или определение переменной; параметр container — контейнер Qt, тип значения которого соответствует типу переменной. Подробности см. в Разделе "Ключевое слово foreach".

Если вы обеспокоены загрязнением пространства имён, вы можете отключить этот макрос, добавив следующую строку в свой .pro файл:

CONFIG += no_keywords

Примечание: Начиная с Qt 5.7, использование этого макроса не рекомендуется. Он будет удалён в будущих версиях Qt. Пожалуйста, используйте range-for C++11, возможно, с qAsConst(), по мере необходимости.

См. также qAsConst().

forever

Этот макрос предоставляется для удобства написания бесконечных циклов.

Пример:

forever {
    ...
}

Он эквивалентен for (;;).

Если вы обеспокоены загрязнением пространства имён, вы можете отключить этот макрос, добавив следующую строку в свой .pro файл:

CONFIG += no_keywords

См. также Q_FOREVER.

qCritical(const char *message, ...)

Вызывает обработчик сообщений с критическим сообщением message. Если обработчик сообщений не установлен, сообщение выводится в stderr. В Windows сообщение отправляется в отладчик. В QNX сообщение отправляется в slogger2

Выход из приложения, если переменная окружения QT_FATAL_CRITICALS не пуста.

Функция принимает строку формата и список аргументов, аналогично функции C printf(). Формат должен быть строкой Latin-1.

Пример:

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

Если вы включили <QtDebug>, доступен более удобный синтаксис:

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

Пробел вставляется между элементами, а в конце добавляется новая строка.

Чтобы подавить вывод во время выполнения, установите собственный обработчик сообщений с помощью qInstallMessageHandler().

Примечание: Эта функция безопасна для потоков.

См. также qDebug(), qInfo(), qWarning(), qFatal(), qInstallMessageHandler(), и Методы отладки.

qDebug(const char *message, ...)

Вызывает обработчик сообщений с отладочным сообщением message. Если обработчик сообщений не установлен, сообщение выводится в stderr. В Windows сообщение отправляется в консоль, если это консольное приложение; в противном случае — в отладчик. В QNX сообщение отправляется в slogger2. Эта функция ничего не делает, если QT_NO_DEBUG_OUTPUT было определено во время компиляции.

Если вы передаёте функции строку формата и список аргументов, она работает аналогично функции C printf(). Формат должен быть строкой Latin-1.

Пример:

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

Если вы включили <QtDebug>, доступен более удобный синтаксис:

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

С этим синтаксисом функция возвращает объект QDebug, настроенный для использования типа сообщения QtDebugMsg. Она автоматически вставляет один пробел между каждым элементом и выводит новую строку в конце. Поддерживает множество типов C++ и Qt.

Чтобы подавить вывод во время выполнения, установите собственный обработчик сообщений с помощью qInstallMessageHandler().

Примечание: Эта функция безопасна для потоков.

См. также qInfo(), qWarning(), qCritical(), qFatal(), qInstallMessageHandler(), и Методы отладки.

qFatal(const char *message, ...)

Вызывает обработчик сообщений со смертельным сообщением message. Если обработчик сообщений не установлен, сообщение выводится в stderr. В Windows сообщение отправляется в отладчик. В QNX сообщение отправляется в slogger2

Если используется стандартный обработчик сообщений, эта функция прерывает выполнение программы, чтобы создать дамп ядра. В Windows, для отладочных сборках, эта функция сообщит об ошибке _CRT_ERROR, что позволит подключить отладчик к приложению.

Функция принимает строку формата и список аргументов, аналогично функции C printf().

Пример:

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

Чтобы подавить вывод во время выполнения, установите собственный обработчик сообщений с помощью qInstallMessageHandler().

См. также qDebug(), qInfo(), qWarning(), qCritical(), qInstallMessageHandler(), и Методы отладки.

qInfo(const char *message, ...)

Вызывает обработчик сообщений с информационным сообщением message. Если обработчик сообщений не установлен, сообщение выводится в stderr. В Windows сообщение отправляется в консоль, если это консольное приложение; в противном случае — в отладчик. В QNX сообщение отправляется в slogger2. Эта функция ничего не делает, если QT_NO_INFO_OUTPUT было определено во время компиляции.

Если вы передаёте функции строку формата и список аргументов, она работает аналогично функции C printf(). Формат должен быть строкой Latin-1.

Пример:

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

Если вы включили <QtDebug>, доступен более удобный синтаксис:

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

С этим синтаксисом функция возвращает объект QDebug, настроенный для использования типа сообщения QtInfoMsg. Она автоматически вставляет один пробел между каждым элементом и выводит новую строку в конце. Поддерживает множество типов C++ и Qt.

Чтобы подавить вывод во время выполнения, установите собственный обработчик сообщений с помощью qInstallMessageHandler().

Примечание: Эта функция безопасна для потоков.

Эта функция была добавлена в Qt 5.5.

См. также qDebug(), qWarning(), qCritical(), qFatal(), qInstallMessageHandler(), и Методы отладки.

qMove(x)

Расширяется до "std::move", если компилятор поддерживает эту функцию C++11, или до ничего в противном случае.

qMove принимает rvalue-ссылку на свой параметр x и преобразует его в xvalue.

const char *qPrintable(const QString &str)

Возвращает str в виде const char *. Это эквивалентно str.toLocal8Bit().constData().

Указатель на символ станет недействительным после оператора, в котором используется qPrintable(). Это происходит потому, что массив, возвращаемый QString::toLocal8Bit(), выходит из области видимости.

Примечание: qDebug(), qInfo(), qWarning(), qCritical(), qFatal() ожидают аргументы %s в кодировке UTF-8, в то время как qPrintable() преобразует в локальную кодировку 8 бит. Поэтому для протоколирования строк следует использовать qUtf8Printable(), а не qPrintable().

См. также qUtf8Printable().

const wchar_t *qUtf16Printable(const QString &str)

Возвращает str в виде const ushort *, но приводится к типу const wchar_t *, чтобы избежать предупреждений. Это эквивалентно str.utf16() плюс некоторые преобразования.

Единственное полезное действие, которое можно выполнить с возвращаемым значением этого макроса, — это передать его в QString::asprintf() для использования в %ls преобразовании. В частности, возвращаемое значение не является допустимым const wchar_t*!

В общем случае указатель станет недействительным после оператора, в котором используется qUtf16Printable(). Это происходит потому, что указатель мог быть получен из временного выражения, которое выходит из области видимости.

Пример:

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

Эта функция была добавлена в Qt 5.7.

См. также qPrintable(), qDebug(), qInfo(), qWarning(), qCritical(), и qFatal().

const char *qUtf8Printable(const QString &str)

Возвращает str в виде const char *. Это эквивалентно str.toUtf8().constData().

Указатель на символ станет недействительным после оператора, в котором используется qUtf8Printable(). Это происходит потому, что массив, возвращаемый QString::toUtf8(), выходит из области видимости.

Пример:

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

Эта функция была добавлена в Qt 5.4.

См. также qPrintable(), qDebug(), qInfo(), qWarning(), qCritical(), и qFatal().

qWarning(const char *message, ...)

Вызывает обработчик сообщений с предупреждающим сообщением message. Если обработчик сообщений не установлен, сообщение выводится в stderr. В Windows сообщение отправляется в отладчик. В QNX сообщение отправляется в slogger2. Эта функция ничего не делает, если QT_NO_WARNING_OUTPUT было определено во время компиляции; она завершается, если переменная окружения QT_FATAL_WARNINGS не пустая.

Эта функция принимает строку формата и список аргументов, аналогично функции C printf(). Формат должен быть строкой в кодировке Latin-1.

Пример:

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

Если вы включите <QtDebug>, доступен более удобный синтаксис:

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

Этот синтаксис вставляет пробел между каждым элементом и добавляет новую строку в конце.

Чтобы подавить вывод во время выполнения, установите собственный обработчик сообщений с помощью qInstallMessageHandler().

Примечание: Эта функция безопасна для многопоточных приложений.

См. также qDebug(), qInfo(), qCritical(), qFatal(), qInstallMessageHandler(), и Методы отладки.