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

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

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

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

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

qint64 value = Q_INT64_C(932838457459459);

quint64 value = Q_UINT64_C(932838457459459);

int absoluteValue;
int myValue = -4;

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

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

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

    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

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

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

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

    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)

    qgetenv(varName).toInt(ok, 0)

    qgetenv(varName).isEmpty()

    !qgetenv(varName).isNull()

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

// 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

#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();
}

int myValue = 6;
int yourValue = 4;

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

int myValue = 6;
int yourValue = 4;

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

    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)

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

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

double valueA = 42949672960.3;
double valueB = 42949672960.7;

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

float valueA = 42949672960.3;
float valueB = 42949672960.7;

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

double valueA = 2.3;
double valueB = 2.7;

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

float valueA = 2.3;
float valueB = 2.7;

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

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

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

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

QT_DEPRECATED_WARNINGS

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

См. также QT_DISABLE_DEPRECATED_BEFORE и QT_NO_DEPRECATED_WARNINGS.

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_NO_DEPRECATED_WARNINGS

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

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

См. также QT_DISABLE_DEPRECATED_BEFORE.

QT_POINTER_SIZE

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

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

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

Параметры argc и argv — это параметры функции main() и argc . Параметр version — это строковая константа, которая указывает, какая версия Qt требуется для приложения (например, "4.0.2").

Пример:

#include <QApplication>
#include <QMessageBox>

int main(int argc, char *argv[])
{
    QT_REQUIRE_VERSION(argc, argv, "4.0.2")

    QApplication app(argc, argv);
    ...
    return app.exec();
}

QT_TRANSLATE_NOOP3(context, sourceText, 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(test)

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

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(test, const char *where, const char *what)

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

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

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

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

#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( *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 (plain old data) без конструктора или деструктора, или же тип, где каждый бит-паттерн является допустимым объектом, и memcpy() создаёт допустимую независимую копию объекта.
• Q_MOVABLE_TYPE указывает, что Type имеет конструктор и/или деструктор, но может быть перемещён в памяти с помощью memcpy(). Примечание: несмотря на название, это никак не связано с move-конструкторами или C++ move-семантикой.
• 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);

Qt попытается определить класс типа с помощью std::is_trivial или std::is_trivially_copyable. Используйте эту макрокоманду для настройки поведения. Например, многие типы могли бы претендовать на Q_MOVABLE_TYPE, несмотря на то, что они не trivially-copyable. По причинам бинарной совместимости оптимизации QList включаются только тогда, когда существует явное Q_DECLARE_TYPEINFO, даже для trivially-copyable типов.

Q_DECL_CONSTEXPR

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

Она расширяется до "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*) final;

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

    class QRect 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, если доступна, или до ничего в противном случае.

Если вам нужны семантика noexcept C++11, не используйте эту макрос, используйте 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*) 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_WASM

Определено на Web Assembly.

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

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

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

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

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

Q_UNUSED(name)

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

foreach(variable, container)

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

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

CONFIG += no_keywords

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

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

forever

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

Пример:

forever {
    ...
}

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

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

CONFIG += no_keywords

См. такжеQ_FOREVER.

qCritical(const char *message, ...)

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

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

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

Пример:

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

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

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

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

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

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

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

qDebug(const char *message, ...)

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

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

Пример:

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

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

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

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

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

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

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

qFatal(const char *message, ...)

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

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

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

Пример:

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

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

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

qInfo(const char *message, ...)

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

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

Пример:

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

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

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

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

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

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

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

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

qMove(x)

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

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

const char *qPrintable(const QString &str)

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

Указатель 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(), и Методы отладки.