<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(), которые обе принимают значение qreal в качестве аргумента, возвращая значение, округлённое до ближайшего целого числа и 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

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

typedef qint16

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

typedef qint32

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

typedef qint64

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

Литералы этого типа можно создать, используя макрос Q_INT64_C():

qint64 value = Q_INT64_C(932838457459459);

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

typedef qintptr

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

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

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

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

typedef qlonglong

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

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

typedef qptrdiff

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

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

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

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

typedef qreal

Typedef для double если Qt не сконфигурирован с опцией -qreal float.

typedef quint8

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

typedef quint16

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

typedef quint32

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

typedef quint64

Typedef для 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

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

Typedef для quint32 или quint64. Этот тип гарантированно имеет такой же размер, как указатель, на всех платформах, поддерживаемых Qt. В системе с 32-битными указателями quintptr является typedef для quint32; в системе с 64-битными указателями quintptr является typedef для 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

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

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

Возвращает числовое значение переменной среды varName. Если ok не равно null, устанавливает *ok в true или false в зависимости от успешности преобразования.

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

qgetenv(varName).toInt()

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

Эта функция была добавлена в 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.

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

double qQNaN()

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

qint64 qRound64(qreal value)

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

Пример:

qreal valueA = 42949672960.3;
qreal valueB = 42949672960.7;

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

int qRound(qreal value)

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

Пример:

qreal valueA = 2.3;
qreal 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}"

По умолчанию pattern — это "%{if-category}%{category}: %{endif}%{message}".

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

Пользовательские обработчики сообщений могут использовать qFormatLogMessage() для учёта pattern.

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

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

const char *qVersion()

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

См. также QT_VERSION_STR.

T *q_check_ptr(T *pointer)

Применяет Q_CHECK_PTR к pointer, затем возвращает pointer.

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

QByteArray qgetenv(const char *varName)

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

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

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

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

Эта функция устанавливает значение 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. Если соответствующая строка не найдена, возвращается сам 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_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_POINTER_SIZE

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

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

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

Параметры argc и argv — это параметры функций main() и argc. Параметр 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().

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

Примечание: 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_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(). Примечание: несмотря на название, это не имеет ничего общего с переместительными конструкторами или семантикой перемещения 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, используйте 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.

Q_FOREACH(variable, container)

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

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

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

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.

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_ULTRIX

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

Q_OS_UNIX

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

Q_OS_UNIXWARE

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

Q_OS_WIN32

Определено на 32-битных и 64-битных версиях Windows (не на Windows CE).

Q_OS_WIN64

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

Q_OS_WIN

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

Q_OS_WINCE

Определено на Windows CE.

Q_OS_WINPHONE

Определено на Windows Phone 8.

Q_OS_WINRT

Определено для Windows Runtime (приложения Windows Store) на 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() в этом месте заключается в том, что компилятору сообщается, что не нужно генерировать код для переменной shape, содержащей это значение. Если макрос отсутствует, компилятор по-прежнему будет генерировать необходимые сравнения для этого значения. Если метка 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

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

forever

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

Пример:

forever {
    ...
}

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

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

CONFIG += no_keywords

См. также Q_FOREVER.

qCritical(const char *message, ...)

Вызывает обработчик сообщений с критическим сообщением message. Если обработчик сообщений не установлен, сообщение выводится в stderr. Под Windows сообщение отправляется в отладчик. На Blackberry сообщение отправляется в 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 сообщение отправляется в консоль, если это консольное приложение; в противном случае оно отправляется отладчику. На устройствах Blackberry сообщение отправляется в 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 сообщение отправляется отладчику. На устройствах Blackberry сообщение отправляется в slogger2.

Если вы используете по умолчанию обработчик сообщений, эта функция прервет работу на системах Unix, чтобы создать дамп ядра. В 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 сообщение отправляется в консоль, если это консольное приложение; в противном случае оно отправляется отладчику. На устройствах Blackberry сообщение отправляется в 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().

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

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

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

const char *qUtf8Printable(const QString &str)

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

Указатель char будет недействительным после оператора, в котором используется 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 сообщение отправляется отладчику. На устройствах Blackberry сообщение отправляется в 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(), и Способы отладки.