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

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

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

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

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

typedef qulonglong

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

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

typedef uchar

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

typedef uint

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

typedef ulong

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

typedef ushort

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

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

Эти функции возвращают значение переменной окружения 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, эта функция преобразует lvalues, не являющиеся константными, в константные lvalues. Как и std::as_const(), она не работает с rvalues, потому что ее нельзя эффективно реализовать для rvalues без оставления висячих ссылок.

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

    QString s = ...;
    for (QChar ch : s) // detaches 's' (performs a deep-copy if 's' was shared)
        process(ch);
    for (QChar ch : qAsConst(s)) // ok, no detach attempt
        process(ch);

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

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

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

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

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

а это нет:

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

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

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

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, const QString &);
        void overloadedFunction(int, const QString &) const;
    };
    ... qConstOverload<int, const QString &>(&Foo::overloadedFunction)
    ... qNonConstOverload<int, const QString &>(&Foo::overloadedFunction)

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

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

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)

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

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

    qgetenv(varName).isEmpty()

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

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

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

bool qEnvironmentVariableIsSet(const char *varName)

Возвращает, установлена ли переменная окружения 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();
    const char *file = context.file ? context.file : "";
    const char *function = context.function ? context.function : "";
    switch (type) {
    case QtDebugMsg:
        fprintf(stderr, "Debug: %s (%s:%u, %s)\n", localMsg.constData(), file, context.line, function);
        break;
    case QtInfoMsg:
        fprintf(stderr, "Info: %s (%s:%u, %s)\n", localMsg.constData(), file, context.line, function);
        break;
    case QtWarningMsg:
        fprintf(stderr, "Warning: %s (%s:%u, %s)\n", localMsg.constData(), file, context.line, function);
        break;
    case QtCriticalMsg:
        fprintf(stderr, "Critical: %s (%s:%u, %s)\n", localMsg.constData(), file, context.line, function);
        break;
    case QtFatalMsg:
        fprintf(stderr, "Fatal: %s (%s:%u, %s)\n", localMsg.constData(), file, context.line, function);
        break;
    }
}

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

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

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

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, const QString &);
        void overloadedFunction(int, const QString &) const;
    };
    ... qConstOverload<int, const QString &>(&Foo::overloadedFunction)
    ... qNonConstOverload<int, const QString &>(&Foo::overloadedFunction)

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

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

auto qOverload(T functionPointer)

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

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

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

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

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

Примечание: Qt определяет необходимую поддержку компилятора C++14 с помощью рекомендаций по тестированию функций из Документа 6 комитета по 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}"

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

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

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

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

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

Эта функция устанавливает значение 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_TRANSLATE_N_NOOP3(context, sourceText, comment)

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

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

Пример:

static { const char * const source; const char * const comment; } status_strings[] = {
    QT_TRANSLATE_N_NOOP3("Message Status", "Hello, you have %n message(s)",
                         "A login message status"),
    QT_TRANSLATE_N_NOOP3("Message status", "You have %n new message(s)",
                         "A new message query status")
};

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

QString global_greeting(int type, int count)
{
    return qApp->translate("Message Status",
                           status_strings[type].source,
                           status_strings[type].comment,
                           count);
}

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

См. также QT_TR_NOOP(), QT_TRANSLATE_NOOP(), QT_TRANSLATE_NOOP3() и Локализация с Qt.

QT_TRANSLATE_N_NOOP(context, sourceText)

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

Макрокоманда сообщает lupdate о необходимости сбора строки и расширяется до самой sourceText.

Пример:

static const char * const greeting_strings[] = {
    QT_TRANSLATE_N_NOOP("Welcome Msg", "Hello, you have %n message(s)"),
    QT_TRANSLATE_N_NOOP("Welcome Msg", "Hi, you have %n message(s)")
};

QString global_greeting(int type, int msgcnt)
{
    return translate("Welcome Msg", greeting_strings[type], nullptr, msgcnt);
}

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

См. также QT_TRANSLATE_NOOP(), QT_TRANSLATE_N_NOOP3() и Локализация с Qt.

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_TR_N_NOOP(sourceText)

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

Макрокоманда сообщает lupdate о необходимости сбора строки и расширяется до самой sourceText.

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

Пример:

static const char * const StatusClass::status_strings[] = {
    QT_TR_N_NOOP("There are %n new message(s)"),
    QT_TR_N_NOOP("There are %n total message(s)")
};

QString StatusClass::status(int type, int count)
{
    return tr(status_strings[type], nullptr, count);
}

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

См. также QT_TR_NOOP и Локализация с 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. Пожалуйста, используйте цикл range-for C++11, возможно, с qAsConst(), по необходимости.

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

Q_FOREVER

То же, что и forever.

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

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

Q_FORWARD_DECLARE_CF_TYPE(type)

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

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

Q_FORWARD_DECLARE_MUTABLE_CF_TYPE(type)

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

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

Q_FORWARD_DECLARE_OBJC_CLASS(classname)

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

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

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

const char*Q_FUNC_INFO

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

Q_FUNC_INFO удобно использовать с qDebug(). Например, эта функция:

template<typename TInputType>
const TInputType &myMin(const TInputType &value1, const TInputType &value2)
{
    qDebug() << Q_FUNC_INFO << "was called with value1:" << value1 << "value2:" << value2;

    if(value1 < value2)
        return value1;
    else
        return value2;
}

при инициализации с целочисленным типом, в компиляторе GCC даст:

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

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

qint64 Q_INT64_C(literal)

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

Пример:

qint64 value = Q_INT64_C(932838457459459);

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

Q_LIKELY(expr)

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

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

Пример:

    // the condition inside the "if" will be successful most of the times
    for (int i = 1; i <= 365; i++) {
        if (Q_LIKELY(isWorkingDay(i))) {
            ...
        }
        ...
    }

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

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

Q_LITTLE_ENDIAN

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

#if Q_BYTE_ORDER == Q_LITTLE_ENDIAN
...
#endif

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

Q_OS_AIX

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

Q_OS_ANDROID

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

Q_OS_BSD4

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

Q_OS_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_WINDOWS

Это синоним для Q_OS_WIN.

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.

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

Q_PROCESSOR_ARM_V6

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

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

Q_PROCESSOR_ARM_V7

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

См. также 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 была удалена, некоторые компиляторы могли бы выдать предупреждение о том, что некоторые значения перечисления не были проверены.

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

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

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

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

Q_UNUSED(name)

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

foreach(variable, container)

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

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

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

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

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

const wchar_t *qUtf16Printable(const QString &str)

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

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

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

Пример:

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

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

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

const char *qUtf8Printable(const QString &str)

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

Указатель на 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 сообщение отправляется отладчику. В QNX сообщение отправляется в slogger2. Эта функция ничего не делает, если QT_NO_WARNING_OUTPUT было определено во время компиляции; она завершается, если на n-ом предупреждении соответствующем счетчику в переменной окружения 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(), и Методы отладки.