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

MyClass(MyClass &&other)
  : m_pointer{qExchange(other.m_pointer, nullptr)},
    m_int{qExchange(other.m_int, 0)},
    m_vector{std::move(other.m_vector)},
    ...

for (auto &e : qExchange(collection, {})
    doSomethingWith(e);

{
    auto tmp = std::move(collection);
    collection = {};                    // or collection.clear()
    for (auto &e : tmp)
        doSomethingWith(e);
}                                       // destroys 'tmp'

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

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

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*) 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, всегда возвращающая true, используйте Q_DECL_NOEXCEPT.

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

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

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

Q_DECL_NOTHROW

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

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

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

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

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

Q_DECL_OVERRIDE

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

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

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

    // generate error if this doesn't actually override anything:
    virtual void MyWidget::paintEvent(QPaintEvent*) 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(переменная, контейнер)

То же, что и foreach(переменная, контейнер).

Эта макрос доступна даже тогда, когда 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(тип)

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

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

Q_FORWARD_DECLARE_MUTABLE_CF_TYPE(тип)

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

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

Q_FORWARD_DECLARE_OBJC_CLASS(имя_класса)

Предварительно объявляет класс Objective-C имя_класса таким образом, что его можно скомпилировать как 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(литерал)

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

Пример:

qint64 value = Q_INT64_C(932838457459459);

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

Q_LIKELY(выражение)

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

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

Пример:

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

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

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

Q_LITTLE_ENDIAN

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

#if Q_BYTE_ORDER == Q_LITTLE_ENDIAN
...
#endif

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

Q_OS_AIX

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

Q_OS_ANDROID

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

Q_OS_BSD4

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

Q_OS_CYGWIN

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

Q_OS_DARWIN

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

Q_OS_FREEBSD

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

Q_OS_HPUX

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

Q_OS_HURD

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

Q_OS_IOS

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

Q_OS_LINUX

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

Q_OS_LYNX

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

Q_OS_MAC

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

Q_OS_MACOS

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

Q_OS_NETBSD

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

Q_OS_OPENBSD

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

Q_OS_OSX

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

Q_OS_QNX

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

Q_OS_SOLARIS

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

Q_OS_TVOS

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

Q_OS_UNIX

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

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

Определяется, если приложение скомпилировано для процессоров RISC-V. Qt в настоящее время поддерживает два варианта RISC-V: Q_PROCESSOR_RISCV_32 и Q_PROCESSOR_RISCV_64.

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

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

Q_PROCESSOR_RISCV_32

Определяется, если приложение скомпилировано для 32-битных процессоров RISC-V. Макрос Q_PROCESSOR_RISCV также определён, когда определён Q_PROCESSOR_RISCV_32.

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

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

Q_PROCESSOR_RISCV_64

Определяется, если приложение скомпилировано для 64-битных процессоров RISC-V. Макрос Q_PROCESSOR_RISCV также определён, когда определён Q_PROCESSOR_RISCV_64.

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

См. также 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. Пожалуйста, используйте цикл 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, она завершится на 1-ом сообщении; если она содержит значение 10, она завершится на 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(), и Методы отладки.