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

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

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

Типы

Функции

Макросы

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

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

Типы

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

Объявляются несколько удобных определений типов: qreal для double или float, 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_TR_NOOP(), QT_TRANSLATE_NOOP() и QT_TRANSLATE_NOOP3() предоставляют возможность помечать строки для отложенного перевода. Макросы 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().

перечисление 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-битными указателями — для 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-битными указателями — для quint64.

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

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

typedef qreal

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

typedef qsizetype

Целочисленный тип, предоставляющий Posix' ssize_t для всех платформ.

Этот тип гарантированно имеет такой же размер, как size_t на всех платформах, поддерживаемых Qt.

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

Этот typedef был представлен в Qt 5.10.

См. также qptrdiff.

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-битными указателями — для 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.

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

Эти функции возвращают значение переменной среды varName в виде QString. Если переменная varName не найдена в среде, и defaultValue предоставлена, возвращается defaultValue. В противном случае возвращается QString().

Функции Qt для работы с переменными среды являются потокобезопасными, но это требует, чтобы эквивалентные функции C-библиотеки, такие как getenv и putenv, не вызывались напрямую.

Следующая таблица описывает, как выбрать между qgetenv() и qEnvironmentVariable():

Примечание: в системах Unix эта функция может привести к потере данных, если исходная строка содержит произвольные двоичные данные, которые не могут быть декодированы кодеком локальной кодировки. В таком случае используйте qgetenv(). В Windows эта функция не приводит к потере данных.

Примечание: имя переменной varName должно содержать только символы US-ASCII.

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

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

T qAbs(const T &t)

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

Пример:

int absoluteValue;
int myValue = -4;

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

typename std::add_const<T>::type &qAsConst(T &t)

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

Эта функция является реализацией Qt функции C++17 std::as_const(), функции преобразования, похожей на std::move(). Но в то время как std::move() преобразует lvalues в rvalues, эта функция преобразует не-const lvalues в const 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.

void qAsConst(const T &&t)

Это перегруженная функция.

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

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

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

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

Возвращает val, ограниченное min и max. Это эквивалентно qMax(min, qMin(val, 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 и Различия между связями на основе строк и функторов.

QString qEnvironmentVariable(const char *varName)

QString qEnvironmentVariable(const char *varName, const QString &defaultValue)

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

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

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

qgetenv(varName).toInt(ok, 0)

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

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

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

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

bool qEnvironmentVariableIsEmpty(const char *varName)

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

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

qgetenv(varName).isEmpty()

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

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

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

bool qEnvironmentVariableIsSet(const char *varName)

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

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

!qgetenv(varName).isNull()

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

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

См. также qgetenv(), qEnvironmentVariable() и 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().

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.

bool qFuzzyCompare(float p1, float p2)

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

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

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

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

bool qFuzzyIsNull(double d)

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

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

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

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

int main(int argc, char **argv)
{
    qInstallMessageHandler(myMessageOutput);
    QApplication app(argc, argv);
    ...
    return app.exec();
}

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

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

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 &a, const T &b)

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

Пример:

int myValue = 6;
int yourValue = 4;

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

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

const T &qMin(const T &a, const T &b)

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

Пример:

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)

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

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

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

Примечание: Qt определяет необходимую поддержку компилятора C++14 с помощью рекомендаций по проверке возможностей от рабочей группы C++ по рекомендации стандартизации.

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

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

double qQNaN()

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

qint64 qRound64(double d)

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

Округление вверх при равенстве (например, 0,5 -> 1, -0,5 -> 0).

Пример:

double valueA = 42949672960.3;
double valueB = 42949672960.7;

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

qint64 qRound64(float d)

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

Округление вверх при равенстве (например, 0.5f -> 1, -0.5f -> 0).

Пример:

float valueA = 42949672960.3;
float valueB = 42949672960.7;

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

int qRound(double d)

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

Округление вверх при равенстве (например, 0.5 -> 1, -0.5 -> 0).

Пример:

double valueA = 2.3;
double valueB = 2.7;

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

int qRound(float d)

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

Округление вверх при равенстве (например, 0.5f -> 1, -0.5f -> 0).

Пример:

float valueA = 2.3;
float valueB = 2.7;

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

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, переменная окружения имеет приоритет.

Примечание: шаблон сообщения применяется только к неструктурированному логированию, например, к стандартному выводу stderr. Структурированное логирование, например, systemd, записывает сообщение как есть, а также как можно больше структурированной информации.

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

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

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

const char *qVersion()

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

См. также QT_VERSION_STR и QLibraryInfo::version().

T *q_check_ptr(T *p)

Использует Q_CHECK_PTR на p, а затем возвращает p.

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

QByteArray qgetenv(const char *varName)

Возвращает значение переменной среды с именем varName в виде QByteArray. Если переменная с таким именем не найдена в среде, эта функция возвращает QByteArray по умолчанию.

Функции Qt для управления средой являются потокобезопасными, но это требует, чтобы эквивалентные функции C-библиотеки, такие как getenv и putenv, не вызывались напрямую.

Для преобразования данных в QString используйте QString::fromLocal8Bit().

Примечание: в настольных приложениях Windows функция qgetenv() может привести к потере данных, если исходная строка содержит символы Юникода, которые не могут быть представлены в кодировке ANSI. Используйте qEnvironmentVariable() вместо неё. В системах Unix эта функция без потерь.

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

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

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

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

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

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

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

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

Функция 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() и qEnvironmentVariable().

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

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, disambiguation)

Помечает строковую константу UTF-8 sourceText для отложенного перевода в заданном context с заданным disambiguation. context обычно является именем класса и также должен быть указан в виде строковой константы. Строковая константа disambiguation должна быть коротким семантическим тегом для различения идентичных строк.

Макрос сообщает lupdate о сборе строки и расширяется до анонимной структуры двух строковых констант, переданных как sourceText и disambiguation.

Пример:

static { const char *source; const char *comment; } greeting_strings[] =
{
    QT_TRANSLATE_NOOP3("FriendlyConversation", "Hello",
                       "A really friendly hello"),
    QT_TRANSLATE_NOOP3("FriendlyConversation", "Goodbye",
                       "A really friendly goodbye")
};

QString FriendlyConversation::greeting(int type)
{
    return tr(greeting_strings[type].source,
              greeting_strings[type].comment);
}

QString global_greeting(int type)
{
    return qApp->translate("FriendlyConversation",
                           greeting_strings[type].source,
                           greeting_strings[type].comment);
}

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

См. также QT_TR_NOOP(), QT_TRANSLATE_NOOP() и Международная локализация с Qt.

QT_TRANSLATE_NOOP(context, sourceText)

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

Макрос сообщает lupdate о сборе строки и расширяется до самой строки 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)

Помечает строковую константу UTF-8 sourceText для отложенного перевода в текущем контексте (классе).

Макрос сообщает lupdate о сборе строки и расширяется до самой строки 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() идентичен и устарел; это относится ко всем другим макросам _UTF8.

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

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. Пожалуйста, используйте C++11 циклы range-for, возможно, с 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-битное число со знаком литерал независимо от платформы.

Пример:

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, чтобы определить порядок байтов в системе. В системе с прямым порядком байтов (little-endian) наименее значимый байт хранится по самому низкому адресу. Остальные байты следуют в порядке возрастания значимости.

#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_CYGWIN

Определено для Cygwin.

Q_OS_DARWIN

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

Q_OS_FREEBSD

Определено для FreeBSD.

Q_OS_HPUX

Определено для HP-UX.

Q_OS_HURD

Определено для GNU Hurd.

Q_OS_IOS

Определено для iOS.

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_OSX

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

Q_OS_QNX

Определено для QNX Neutrino.

Q_OS_SOLARIS

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

Q_OS_TVOS

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

Q_OS_UNIX

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

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

Примечание: начиная с Qt 5.7, использование этого макроса не рекомендуется. Он будет удален в будущей версии Qt. Пожалуйста, используйте цикл диапазона 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 бит. Поэтому для регистрации строк вместо qPrintable() следует использовать qUtf8Printable().

См. также 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, достигает заданного значения. То есть, если переменная среды содержит значение 1, выполнение завершится после первого сообщения; если содержит 10, после десятого сообщения. Любое нечисловое значение эквивалентно 1.

Эта функция принимает строку формата и список аргументов, аналогично функции 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(), и Методы отладки.