3.5 Параметры, управляющие диалектом C++ ¶

В этом разделе описаны параметры командной строки, которые имеют смысл только для программ на C++. Вы также можете использовать большинство параметров компилятора GNU независимо от языка вашей программы. Например, вы можете скомпилировать файл firstClass.C следующим образом:

g++ -g -fstrict-enums -O -c firstClass.C

В этом примере только -fstrict-enums является параметром, предназначенным только для программ на C++; вы можете использовать другие параметры с любым языком, поддерживаемым GCC.

Некоторые параметры для компиляции программ на C, такие как -std, также актуальны для программ на C++. См. Параметры, управляющие диалектом C.

Вот список параметров, только для компиляции программ на C++:

-fabi-version=n

Использовать версию n C++ ABI. По умолчанию используется версия 0.

Версия 0 соответствует версии C++ ABI, наиболее точно следующей спецификации C++ ABI. Поэтому ABI, полученная с помощью версии 0, будет меняться в разных версиях G++, по мере исправления ошибок в ABI.

Версия 1 — версия C++ ABI, впервые появившаяся в G++ 3.2.

Версия 2 — версия C++ ABI, впервые появившаяся в G++ 3.4, и была по умолчанию до G++ 4.9.

Версия 3 исправляет ошибку в формировании имени константного адреса как аргумента шаблона.

Версия 4, впервые появившаяся в G++ 4.5, реализует стандартную формирование имени для векторизованных типов.

Версия 5, впервые появившаяся в G++ 4.6, исправляет формирование имени атрибутов const/volatile для типов указателей на функции, decltype простого decl и использование параметра функции в объявлении другого параметра.

Версия 6, впервые появившаяся в G++ 4.7, исправляет поведение продвижения C++11 scoped перечислений и формирование имен пакетов аргументов шаблонов, const/static_cast, префиксные ++ и –, и функцию области класса, используемую как аргумент шаблона.

Версия 7, впервые появившаяся в G++ 4.8, обрабатывает nullptr_t как встроенный тип и исправляет формирование имени лямбда-выражений в области аргумента по умолчанию.

Версия 8, впервые появившаяся в G++ 4.9, исправляет поведение подстановки типов функций с функциями-cv-квалификаторами.

Версия 9, впервые появившаяся в G++ 5.2, исправляет выравнивание nullptr_t.

Версия 10, впервые появившаяся в G++ 6.1, добавляет формирование имени атрибутов, которые влияют на идентичность типа, таких как атрибуты вызова ia32 (например, ‘stdcall’).

Версия 11, появившаяся в G++ 7, исправляет формирование имен выражений sizeof... и имён операторов. Для нескольких сущностей с одинаковым именем внутри функции, объявленных в разных областях, формирование имени теперь изменяется, начиная с двенадцатого появления. Также подразумевает -fnew-inheriting-ctors.

Версия 12, впервые появившаяся в G++ 8, исправляет правила вызова для пустых классов на целевом x86_64 и для классов, имеющих только удалённые конструкторы копирования/перемещения. Случайно меняет правила вызова для классов с удалённым конструктором копирования и тривиальным конструктором перемещения.

Версия 13, появившаяся в G++ 8.2, исправляет случайную ошибку в версии 12.

Версия 14, появившаяся в G++ 10, исправляет формирование имени выражения nullptr.

Версия 15, появившаяся в G++ 11, изменяет формирование имени __alignof__ на отличное от alignof, и зависимых имён операторов.

См. также -Wabi.

-fabi-compat-version=n

На целевых платформах, поддерживающих сильные псевдонимы, G++ обходит изменения в формировании имени, создавая псевдоним с правильным сформированным именем при определении символа с неправильным сформированным именем. Этот переключатель указывает, какую версию ABI использовать для псевдонима.

С -fabi-version=0 (по умолчанию), это по умолчанию 11 (совместимость с GCC 7). Если явно выбрана другая версия ABI, это по умолчанию 0. Для совместимости с версиями GCC от 3.2 до 4.9, используйте -fabi-compat-version=2.

Если этот параметр не указан, но -Wabi=n указан, эта версия используется для совместимых псевдонимов. Если этот параметр указан вместе с -Wabi (без версии), версия из этого параметра используется для предупреждений.

-fno-access-control

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

-faligned-new

Включить поддержку C++17 new типов, требующих большего выравнивания, чем void* ::operator new(std::size_t) предоставляет. Числовой аргумент, такой как -faligned-new=32, может использоваться для указания количества выравнивания (в байтах), предоставляемого этой функцией, но мало кто захочет переопределять значение по умолчанию alignof(std::max_align_t).

Этот флаг включён по умолчанию для -std=c++17.

-fchar8_t

-fno-char8_t

Включить поддержку char8_t как это принято для C++20. Это включает добавление нового char8_t фундаментального типа, изменения типов UTF-8 строк и символьных литералов, новые сигнатуры для пользовательских литералов, соответствующие обновления библиотеки стандартной, и новые __cpp_char8_t и __cpp_lib_char8_t макросы проверки возможностей.

Этот параметр позволяет перегружать функции для обычных и UTF-8 строк:

int f(const char *);    // #1
int f(const char8_t *); // #2
int v1 = f("text");     // Calls #1
int v2 = f(u8"text");   // Calls #2

и вводит новые сигнатуры для пользовательских литералов:

int operator""_udl1(char8_t);
int v3 = u8'x'_udl1;
int operator""_udl2(const char8_t*, std::size_t);
int v4 = u8"text"_udl2;
template<typename T, T...> int operator""_udl3();
int v5 = u8"text"_udl3;

Изменение типов UTF-8 строк и символьных литералов вводит несовместимости со стандартами ISO C++11 и более поздними. Например, следующий код является корректным в ISO C++11, но некорректным, когда указан -fchar8_t.

char ca[] = u8"xx";     // error: char-array initialized from wide
                        //        string
const char *cp = u8"xx";// error: invalid conversion from
                        //        `const char8_t*' to `const char*'
int f(const char*);
auto v = f(u8"xx");     // error: invalid conversion from
                        //        `const char8_t*' to `const char*'
std::string s{u8"xx"};  // error: no matching function for call to
                        //        `std::basic_string<char>::basic_string()'
using namespace std::literals;
s = u8"xx"s;            // error: conversion from
                        //        `basic_string<char8_t>' to non-scalar
                        //        type `basic_string<char>' requested

-fcheck-new

Проверить, что указатель, возвращённый operator new, не равен нулю, прежде чем пытаться изменить выделенное хранилище. Эта проверка обычно не нужна, потому что стандарт C++ определяет, что operator new возвращает 0 только если он объявлен throw(), в этом случае компилятор всегда проверяет возвращаемое значение даже без этого параметра. Во всех остальных случаях, когда у operator new есть непустая спецификация исключений, исчерпание памяти сигнализируется путём выброса std::bad_alloc. См. также ‘new (nothrow)’.

-fconcepts

-fconcepts-ts

До -std=c++20, -fconcepts включает поддержку C++ Extensions for Concepts Technical Specification, ISO 19217 (2015).

С -std=c++20 и выше, Концепции являются частью стандартного языка, поэтому -fconcepts по умолчанию включено. Но стандартное описание Концепций значительно отличается от TS, поэтому некоторые конструкции, которые допускались в TS, но не вошли в стандарт, по-прежнему можно включить с помощью -fconcepts-ts.

-fconstexpr-depth=n

Установить максимальную глубину вложенной оценки для C++11 constexpr функций на n. Необходим лимит для обнаружения бесконечной рекурсии во время оценки константных выражений. Минимальное значение, указанное в стандарте, — 512.

-fconstexpr-cache-depth=n

Установить максимальный уровень вложенной глубины оценки для C++11 constexpr функций, которые будут кэшироваться на n. Это эвристика, которая балансирует скорость компиляции (когда кэш избегает повторных вычислений) с потреблением памяти (когда кэш становится очень большим из-за сильно рекурсивных оценок). По умолчанию значение 8. Вероятно, очень мало пользователей захотят его изменить, но если ваш код выполняет интенсивные constexpr вычисления, вы можете поэкспериментировать, чтобы найти значение, которое лучше всего подходит для вас.

-fconstexpr-loop-limit=n

Установить максимальное число итераций цикла для C++14 constexpr функций на n. Требуется ограничение для обнаружения бесконечных циклов при оценке константных выражений. По умолчанию — 262144 (1<<18).

-fconstexpr-ops-limit=n

Установить максимальное число операций во время одной constexpr оценки. Даже когда число итераций одного цикла ограничено вышеуказанным лимитом, если есть несколько вложенных циклов, и каждый из них имеет много итераций, но всё ещё меньше вышеуказанного лимита, или если в теле какого-либо цикла или даже вне цикла необходимо оценить слишком много выражений, результирующая constexpr оценка может занять слишком много времени. По умолчанию — 33554432 (1<<25).

-fcoroutines

Включить поддержку расширения C++ корутин (экспериментальное).

-fno-elide-constructors

Стандарт C++ допускает, чтобы реализация не создавала временную переменную, используемую только для инициализации другого объекта того же типа. Указание этого параметра отключает эту оптимизацию и заставляет G++ вызывать конструктор копирования во всех случаях. Этот параметр также заставляет G++ вызывать тривиальные члены-функции, которые в противном случае были бы встроены.

В C++17 компилятор обязан исключить эти временные переменные, но этот параметр по-прежнему влияет на тривиальные члены-функции.

-fno-enforce-eh-specs

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

-fextern-tls-init

-fno-extern-tls-init

Стандарты C++11 и OpenMP допускают, что переменные thread_local и threadprivate могут иметь динамическую (во время выполнения) инициализацию. Для поддержки этого любое использование такой переменной проходит через функцию-обёртку, которая выполняет любую необходимую инициализацию. Когда использование и определение переменной находятся в одном файле трансляции, эта дополнительная нагрузка может быть оптимизирована, но когда использование находится в другом файле трансляции, есть значительная дополнительная нагрузка, даже если переменная фактически не нуждается в динамической инициализации. Если программист может быть уверен, что ни одно использование переменной в не определяющем файле трансляции не должно инициировать динамическую инициализацию (либо потому, что переменная статически инициализирована, либо использование переменной в определяющем файле трансляции будет выполнено до любого использования в другом файле трансляции), они могут избежать этой дополнительной нагрузки с помощью параметра -fno-extern-tls-init.

На целевых платформах, поддерживающих псевдонимы символов, по умолчанию включено -fextern-tls-init. На целевых платформах, не поддерживающих псевдонимы символов, по умолчанию включено -fno-extern-tls-init.

-fno-gnu-keywords

Не распознавать typeof как ключевое слово, так что код может использовать это слово как идентификатор. Вы можете использовать ключевое слово __typeof__ вместо этого. Этот параметр подразумевается строгими диалектами ISO C++: -ansi, -std=c++98, -std=c++11 и т. д.

-fno-implicit-templates

Никогда не генерировать код для не-встроенных шаблонов, которые подразумеваются неявно (т.е. по использованию); генерировать код только для явных инстанциаций. Если вы используете этот параметр, вы должны тщательно структурировать свой код, чтобы включать все необходимые явные инстанциации, чтобы избежать неопределённых символов во время линковки. См. Где шаблон? для получения дополнительной информации.

-fno-implicit-inline-templates

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

-fno-implement-inlines

Для экономии места не генерировать внестрочные копии встроенных функций, управляемых #pragma implementation. Это приводит к ошибкам компоновщика, если эти функции не встроены повсюду, где они вызываются.

-fmodules-ts

-fno-modules-ts

Включить поддержку модулей C++20 (см. Модули C++). Флаг -fno-modules-ts обычно не нужен, так как он используется по умолчанию. Несмотря на то, что это функция C++20, она не включается неявно при выборе этой версии стандарта.

-fmodule-header

-fmodule-header=user

-fmodule-header=system

Компилировать заголовочный файл для создания импортируемого заголовочного модуля.

-fmodule-implicit-inline

Члены-функции, определённые в определениях классов, не являются неявно встроенными для модульного кода. Это отличается от традиционного поведения C++, по понятным причинам. Однако это может привести к сложностям при переносе кода. Этот параметр делает такие определения функций неявно встроенными. Однако это генерирует несовместимость ABI, поэтому вы должны использовать его везде или нигде. (Такие определения вне именованного модуля остаются неявно встроенными, независимо от этого).

-fno-module-lazy

Отключить ленивый импорт модулей и создание маппера модулей.

-fmodule-mapper=[hostname]:port[?ident]

-fmodule-mapper=|program[?ident] args...

-fmodule-mapper==socket[?ident]

-fmodule-mapper=<>[inout][?ident]

-fmodule-mapper=<in>out[?ident]

-fmodule-mapper=file[?ident]

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

-fmodule-only

Генерировать только интерфейс скомпилированного модуля, не генерируя никакие объектные файлы.

-fms-extensions

Отключить предупреждения Wpedantic о конструкциях, используемых в MFC, таких как неявное использование int и получение указателя на член-функцию с использованием нестандартного синтаксиса.

-fnew-inheriting-ctors

Включить корректировку P0136 к семантике наследования конструкторов C++11. Это часть C++17, но также рассматривается как отчет об ошибке для C++11 и C++14. Этот флаг включен по умолчанию, если не указано -fabi-version=10 или ниже.

-fnew-ttp-matching

Включить решение P0522 для проблемы ядра 150, шаблонов шаблонов и аргументов по умолчанию: это позволяет использовать шаблон с аргументами шаблонов по умолчанию в качестве аргумента для параметра шаблона шаблона с меньшим количеством параметров шаблона. Этот флаг включён по умолчанию для -std=c++17.

-fno-nonansi-builtins

Отключить встроенные объявления функций, которые не предписаны ANSI/ISO C. К ним относятся ffs, alloca, _exit, index, bzero, conjf, и другие связанные функции.

-fnothrow-opt

Обрабатывать спецификацию исключения throw() как спецификацию noexcept, чтобы уменьшить или устранить издержки на размер текста по сравнению с функцией без спецификации исключений. Если функция имеет локальные переменные типов с нетривиальными деструкторами, спецификация исключения фактически уменьшает размер функции, потому что обработку исключений для этих переменных можно оптимизировать. Семантический эффект заключается в том, что исключение, брошенное из функции с такой спецификацией исключений, приводит к вызову terminate вместо unexpected.

-fno-operator-names

Не обрабатывать ключевые слова операторных имен and, bitand, bitor, compl, not, or и xor как синонимы ключевых слов.

-fno-optional-diags

Отключить диагностику, которую стандарт говорит, что компилятор не должен выводить. В настоящее время единственная такая диагностика, выводимая G++, — это диагностика о том, что имя имеет несколько значений в классе.

-fpermissive

Снизить некоторые диагностические сообщения о нестандартном коде с ошибок до предупреждений. Таким образом, использование -fpermissive позволяет компилировать некоторые нестандартные коды.

-fno-pretty-templates

Когда сообщение об ошибке относится к специализации шаблона функции, компилятор обычно выводит сигнатуру шаблона, за которой следуют аргументы шаблона и любые определения типов или имена типов в сигнатуре (например, void f(T) [with T = int] вместо void f(int)), чтобы было понятно, какой шаблон задействован. Когда сообщение об ошибке относится к специализации шаблона класса, компилятор пропускает любые аргументы шаблона, которые соответствуют аргументам шаблона по умолчанию для этого шаблона. Если любое из этих поведений затрудняет понимание сообщения об ошибке, а не облегчает, вы можете использовать -fno-pretty-templates для их отключения.

-fno-rtti

Отключить генерацию информации обо всех классах с виртуальными функциями для использования функциями определения типов во время выполнения C++ (dynamic_cast и typeid). Если вы не используете эти части языка, вы можете сэкономить некоторое место, используя этот флаг. Обратите внимание, что обработка исключений использует ту же информацию, но G++ генерирует её по мере необходимости. Оператор dynamic_cast по-прежнему может использоваться для преобразований, которые не требуют информации о типе во время выполнения, т. е. преобразований к void * или к однозначным базовым классам.

Смешивание кода, скомпилированного с -frtti, с кодом, скомпилированным с -fno-rtti, может не работать. Например, программы могут не пройти компоновку, если класс, скомпилированный с -fno-rtti, используется в качестве базового класса для класса, скомпилированного с -frtti.

-fsized-deallocation

Включить встроенные глобальные объявления

void operator delete (void *, std::size_t) noexcept;
void operator delete[] (void *, std::size_t) noexcept;

как это введено в C++14. Это полезно для пользовательских функций замены удаления, которые, например, используют размер объекта для ускорения удаления. Включен по умолчанию при -std=c++14 и выше. Флаг -Wsized-deallocation предупреждает о местах, где может потребоваться добавление определения.

-fstrict-enums

Разрешить компилятору оптимизировать, предполагая, что значение перечислимого типа может быть только одним из значений перечисления (как определено в стандарте C++; по существу, значение, которое может быть представлено минимальным количеством битов, необходимым для представления всех перечислителей). Это предположение может быть неверным, если программа использует преобразование для преобразования произвольного целочисленного значения в перечислимый тип.

-fstrong-eval-order

Вычислять доступ к членам, индексирование массивов и сдвиги в порядке слева направо, а присваивания — справа налево, как это принято для C++17. Включен по умолчанию с -std=c++17. -fstrong-eval-order=some включает только порядок доступа к членам и сдвигов, и является значением по умолчанию без -std=c++17.

-ftemplate-backtrace-limit=n

Установить максимальное количество заметок об экземпляризации шаблона для одного предупреждения или ошибки на n. Значение по умолчанию равно 10.

-ftemplate-depth=n

Установить максимальную глубину экземпляризации для шаблонов классов на n. Ограничение глубины экземпляризации шаблона необходимо для обнаружения бесконечных рекурсий при экземпляризации шаблона класса. Соответствующие ANSI/ISO C++ программы не должны полагаться на максимальную глубину, большую, чем 17 (изменено на 1024 в C++11). Значение по умолчанию равно 900, так как в некоторых ситуациях компилятор может израсходовать память стека до достижения 1024.

-fno-threadsafe-statics

Не генерировать дополнительный код для использования процедур, указанных в C++ ABI, для безопасной по отношению к потокам инициализации локальных статических переменных. Вы можете использовать этот параметр для незначительного уменьшения размера кода в коде, который не должен быть безопасным по отношению к потокам.

-fuse-cxa-atexit

Регистрировать деструкторы для объектов со статическим сроком хранения с функцией __cxa_atexit вместо функции atexit. Этот параметр требуется для полного соответствия стандарту обработки статических деструкторов, но работает только если ваша библиотека C поддерживает __cxa_atexit.

-fno-use-cxa-get-exception-ptr

Не использовать процедуру времени выполнения __cxa_get_exception_ptr. Это приводит к некорректности std::uncaught_exception, но необходимо, если процедура времени выполнения недоступна.

-fvisibility-inlines-hidden

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

Это означает, что GCC может фактически пометить встроенные методы с __attribute__ ((visibility ("hidden"))), чтобы они не появлялись в таблице экспорта DSO и не требовали косвенного обращения через PLT при использовании внутри DSO. Включение этого параметра может существенно повлиять на время загрузки и компоновки DSO, так как это значительно уменьшает размер динамической таблицы экспорта, когда библиотека активно использует шаблоны.

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

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

Явно экземпляризованные встроенные методы не затрагиваются этим параметром, так как их связь может иначе пересекать границу разделяемой библиотеки. См. Где шаблон?.

-fvisibility-ms-compat

Этот флаг пытается использовать параметры видимости, чтобы сделать модель связи C++ GCC совместимой с моделью Microsoft Visual Studio.

Флаг вносит такие изменения в модель связи GCC:

1. Он устанавливает видимость по умолчанию на hidden, как -fvisibility=hidden.
2. Типы, но не их члены, не скрываются по умолчанию.
3. Правило одной дефиниции ослаблено для типов без явного указания видимости, которые определены более чем в одном разделяемом объекте: эти объявления разрешены, если они разрешены при отсутствии этого параметра.

В новом коде лучше использовать -fvisibility=hidden и экспортировать те классы, которые должны быть видимы извне. К сожалению, возможно, что код может полагаться, возможно, случайно, на поведение Visual Studio.

Среди последствий этих изменений — то, что статические члены данных одного и того же типа с одинаковыми именами, но определённые в разных разделяемых объектах, являются различными, поэтому изменение одного не изменяет другое; и то, что указатели на члены функций, определённые в разных разделяемых объектах, могут не быть равны. Когда данный флаг указан, нарушается правило одной дефиниции при определении типов с одинаковым именем по-разному.

-fno-weak

Не использовать поддержку слабых символов, даже если она предоставляется линковщиком. По умолчанию G++ использует слабые символы, если они доступны. Этот параметр существует только для тестирования и не должен использоваться конечными пользователями; он приводит к худшему коду и не имеет преимуществ. Этот параметр может быть удален в будущих выпусках G++.

-fext-numeric-literals (C++ and Objective-C++ only)

Принимать числовые суффиксы для мнимых, фиксированных или машинно-определённых литералов как расширения GNU. Когда этот параметр выключен, эти суффиксы обрабатываются как числовые суффиксы пользовательских литералов C++11. По умолчанию включен для всех диалектов до C++11 и всех диалектов GNU: -std=c++98, -std=gnu++98, -std=gnu++11, -std=gnu++14. Этот параметр выключен по умолчанию для ISO C++11 и более поздних версий (-std=c++11, ...).

-nostdinc++

Не искать заголовочные файлы в стандартных директориях, специфичных для C++, но продолжать поиск в других стандартных директориях. (Этот параметр используется при построении библиотеки C++.)

-flang-info-include-translate

-flang-info-include-translate-not

-flang-info-include-translate=header

Сообщать об событиях трансляции включений. Первый сообщит о принятых трансляциях включений, второй — о отклоненных трансляциях включений. Формат header сообщит о трансляциях включений, относящихся к этому конкретному заголовочному файлу. Если header имеет вид "user" или <system>, он будет разрешен до конкретного пользовательского или системного заголовочного файла с помощью пути включений.

-flang-info-module-cmi

-flang-info-module-cmi=module

Сообщать о именах путей интерфейса скомпилированного модуля. Первый сообщит обо всех прочитанных именах путей CMI. Формат module не будет читать CMI конкретного модуля. module может быть именованным модулем или блоком заголовков (последнее указано либо путем, содержащим разделители каталогов, либо заключённым в <> или "").

-stdlib=libstdc++,libc++

Когда G++ сконфигурирован для поддержки этого параметра, он позволяет указать альтернативные библиотеки времени выполнения C++. Доступны два варианта: libstdc++ (по умолчанию, родная библиотека времени выполнения C++ для G++) и libc++, которая является библиотекой времени выполнения C++, установленной на некоторых операционных системах (например, версии Darwin с Darwin11 и выше). Параметр переключает G++ на использование заголовков из указанной библиотеки и генерирует -lstdc++ или -lc++ соответственно, когда для линковки требуется библиотека времени выполнения C++.

Кроме того, эти параметры предупреждений имеют значение только для программ C++:

-Wabi-tag (C++ and Objective-C++ only)

Предупреждение при использовании типа с тегом ABI в контексте, не имеющем этого тега ABI. Смотрите Атрибуты переменных, функций и типов в C++ для получения дополнительной информации о тегах ABI.

-Wcomma-subscript (C++ and Objective-C++ only)

Предупреждение об использовании выражения с запятой в выражении индексирования. Это использование было устаревшим в C++20. Однако выражение с запятой, заключенное в ( ), не устарело. Пример:

void f(int *a, int b, int c) {
    a[b,c];     // deprecated
    a[(b,c)];   // OK
}

Включено по умолчанию с -std=c++20.

-Wctad-maybe-unsupported (C++ and Objective-C++ only)

Предупреждение при выполнении вывода шаблонов аргументов класса (CTAD) для типа без явно указанных руководств по выводу. Это предупреждение укажет случаи, когда CTAD выполнился только потому, что компилятор синтезировал неявные руководства по выводу, что, возможно, не соответствовало намерениям программиста. Некоторые руководства по стилю допускают CTAD только для типов, которые явно «поддерживают» CTAD; т. е. для типов, предназначенных для поддержки CTAD. Это предупреждение можно подавить с помощью следующего шаблона:

struct allow_ctad_t; // any name works
template <typename T> struct S {
  S(T) { }
};
S(allow_ctad_t) -> S<void>; // guide with incomplete parameter type will never be considered

-Wctor-dtor-privacy (C++ and Objective-C++ only)

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

-Wdelete-non-virtual-dtor (C++ and Objective-C++ only)

Предупреждение при использовании delete для уничтожения экземпляра класса, имеющего виртуальные функции и невиртуальный деструктор. Небезопасно удалять экземпляр производного класса через указатель на базовый класс, если базовый класс не имеет виртуального деструктора. Это предупреждение включено по умолчанию с -Wall.

-Wdeprecated-copy (C++ and Objective-C++ only)

Предупреждение о том, что неявное объявление конструктора копирования или оператора присваивания копирования устарело, если класс имеет пользовательский конструктор копирования или оператор присваивания копирования, начиная с C++11. Это предупреждение включено по умолчанию с -Wextra. С -Wdeprecated-copy-dtor, также устаревает, если у класса есть пользовательский деструктор.

-Wno-deprecated-enum-enum-conversion (C++ and Objective-C++ only)

Отключение предупреждения о случае, когда обычные арифметические преобразования применяются к операндам, где один — типа перечисления, а другой — другого типа перечисления. Это преобразование было устаревшим в C++20. Например:

enum E1 { e };
enum E2 { f };
int k = f - e;

-Wdeprecated-enum-enum-conversion включено по умолчанию с -std=c++20. В диалектах до C++20 это предупреждение можно включить с помощью -Wenum-conversion.

-Wno-deprecated-enum-float-conversion (C++ and Objective-C++ only)

Отключение предупреждения о случае, когда обычные арифметические преобразования применяются к операндам, где один — типа перечисления, а другой — типа с плавающей точкой. Это преобразование было устаревшим в C++20. Например:

enum E1 { e };
enum E2 { f };
bool b = e <= 3.7;

-Wdeprecated-enum-float-conversion включено по умолчанию с -std=c++20. В диалектах до C++20 это предупреждение можно включить с помощью -Wenum-conversion.

-Wno-init-list-lifetime (C++ and Objective-C++ only)

Не выдавать предупреждения об использовании std::initializer_list, которые, вероятно, приведут к висящим указателям. Поскольку базовый массив для initializer_list обрабатывается как обычный временный объект C++, легко непреднамеренно сохранить указатель на массив после окончания срока действия массива. Например:

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

  // li's initial underlying array lives as long as li
  std::initializer_list<int> li = { 1,2,3 };
  // assignment changes li to point to a temporary array
  li = { 4, 5 };
  // now the temporary is gone and li has a dangling pointer
  int i = li.begin()[0] // undefined behavior

• Когда конструктор списка хранит указатель begin из аргумента initializer_list, это не продлевает срок действия массива, поэтому если переменная класса создается из временного initializer_list, указатель становится висящим к концу оператора объявления переменной.

-Winvalid-imported-macros

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

-Wno-literal-suffix (C++ and Objective-C++ only)

Не выводить предупреждения, когда строковый или символьный литерал следует за постфиксом ud, который не начинается с подчеркивания. Как согласующееся расширение, GCC обрабатывает такие постфиксы как отдельные токены предварительной обработки, чтобы сохранить обратную совместимость с кодом, использующим макросы форматирования из <inttypes.h>. Например:

#define __STDC_FORMAT_MACROS
#include <inttypes.h>
#include <stdio.h>

int main() {
  int64_t i64 = 123;
  printf("My int64: %" PRId64"\n", i64);
}

В этом случае PRId64 обрабатывается как отдельный токен предварительной обработки.

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

Эти предупреждения включены по умолчанию.

-Wno-narrowing (C++ and Objective-C++ only)

Для стандартов C++11 и более поздних версий сужающие преобразования диагностируются по умолчанию, как требуется стандартом. Сужающее преобразование из константы приводит к ошибке, а сужающее преобразование из неконстанты — к предупреждению, но -Wno-narrowing подавляет диагностику. Обратите внимание, что это не влияет на смысл корректного кода; сужающие преобразования по-прежнему считаются неправильными в контекстах SFINAE.

С -Wnarrowing в C++98 предупреждает при возникновении запрещенного C++11 сужающего преобразования в «{ }», например:

int i = { 2.2 }; // error: narrowing from double to int

Этот флаг входит в -Wall и -Wc++11-compat.

-Wnoexcept (C++ and Objective-C++ only)

Предупреждение, если выражение noexcept оценивается как ложь из-за вызова функции, которая не имеет спецификации исключения без бросания (т. е. throw() или noexcept) , но компилятор знает, что она никогда не бросит исключение.

-Wnoexcept-type (C++ and Objective-C++ only)

Предупреждение, если функция C++17, делающая noexcept частью типа функции, изменяет закодированное имя символа по отношению к C++14. Включено с -Wabi и -Wc++17-compat.

Например:

template <class T> void f(T t) { t(); };
void g() noexcept;
void h() { f(g); }

В C++14, f вызывает f<void(*)()>, но в C++17 — f<void(*)()noexcept>.

-Wclass-memaccess (C++ and Objective-C++ only)

Предупреждение, если получатель вызова функции для необработанной памяти, например memset или memcpy, является объектом типа класса, и при записи в такой объект может быть пропущен нетривиальный или удаленный конструктор или оператор присваивания копирования класса, нарушена корректность const или инкапсуляция, или повреждены указатели на виртуальные таблицы. Изменение представления таких объектов может нарушить инварианты, поддерживаемые функциями-членами класса. Например, вызов memset ниже неопределён, потому что он изменяет объект класса нетривиального типа и поэтому диагностируется. Безопасный способ инициализации или очистки хранилища объектов таких типов — использование соответствующего конструктора или оператора присваивания, если он доступен.

std::string str = "abc";
memset (&str, 0, sizeof str);

Параметр -Wclass-memaccess включён по умолчанию с -Wall. Явное приведение указателя на объект класса к void * или типу, который может безопасно получить доступ к функции необработанной памяти, подавляет предупреждение.

-Wnon-virtual-dtor (C++ and Objective-C++ only)

Предупреждение, если класс имеет виртуальные функции и доступный невиртуальный деструктор сам по себе или в доступном полиморфном базовом классе, в этом случае возможно, но небезопасно, удалять экземпляр производного класса через указатель на сам класс или базовый класс. Это предупреждение автоматически включается, если указан -Weffc++.

-Wregister (C++ and Objective-C++ only)

Предупреждение об использовании спецификатора класса хранения register, за исключением случаев, когда он является частью расширения GNU Переменные в указанных регистрах. Использование ключевого слова register в качестве спецификатора класса хранения устарело в C++11 и удалено в C++17. Включено по умолчанию с -std=c++17.

-Wreorder (C++ and Objective-C++ only)

Предупреждение, если порядок инициализаторов членов, указанный в коде, не соответствует порядку их выполнения. Например:

struct A {
  int i;
  int j;
  A(): j (0), i (1) { }
};

Компилятор переупорядочивает инициализаторы членов для i и j для соответствия порядку объявления членов, выдав предупреждение об этом. Это предупреждение включено с -Wall.

-Wno-pessimizing-move (C++ and Objective-C++ only)

Это предупреждение выдаётся, когда вызов std::move препятствует устранению копирования. Типичный сценарий, когда может произойти устранение копирования, — это возврат в функции с типом возврата класса, когда выражение, возвращаемое в функцию, является именем непеременного автоматического объекта и не является параметром функции и имеет тот же тип, что и тип возвращаемого значения функции.

struct T {
…
};
T fn()
{
  T t;
  …
  return std::move (t);
}

Но в этом примере вызов std::move препятствует устранению копирования.

Это предупреждение включено по умолчанию с -Wall.

-Wno-redundant-move (C++ and Objective-C++ only)

Это предупреждение предупреждает о лишних вызовах std::move; то есть, когда операция перемещения была бы выполнена даже без вызова std::move. Это происходит потому, что компилятор вынужден рассматривать объект как если бы он был rvalue в некоторых ситуациях, таких как возврат локальной переменной, где устранение копирования неприменимо. Рассмотрим:

struct T {
…
};
T fn(T t)
{
  …
  return std::move (t);
}

Здесь вызов std::move избыточен. Поскольку G++ реализует проблему ядра 1579, другим примером является:

struct T { // convertible to U
…
};
struct U {
…
};
U fn()
{
  T t;
  …
  return std::move (t);
}

В этом примере устранение копирования неприменимо, потому что тип выражения, возвращаемого в функцию, и тип возвращаемого значения функции отличаются, но G++ обрабатывает возвращаемое значение так, как будто оно обозначено rvalue.

Это предупреждение включено по умолчанию с -Wextra.

-Wrange-loop-construct (C++ and Objective-C++ only)

Это предупреждение срабатывает, когда цикл C++ for-each с диапазоном создаёт ненужную копию. Это может произойти, когда объявление диапазона не является ссылкой, но, вероятно, должно быть. Например:

struct S { char arr[128]; };
void fn () {
  S arr[5];
  for (const auto x : arr) { … }
}

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

Это предупреждение также срабатывает, когда переменная цикла в цикле for-each инициализируется значением другого типа, что приводит к копированию. Например:

void fn() {
  int arr[10];
  for (const double &x : arr) { … }
}

В примере выше, в каждой итерации цикла создаётся и уничтожается временное значение типа double, к которому привязана ссылка const double &.

Это предупреждение включается параметром -Wall.

-Wredundant-tags (C++ and Objective-C++ only)

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

struct foo;
struct foo *p;   // warn that keyword struct can be eliminated

С другой стороны, в этом примере предупреждение отсутствует:

struct foo;
void foo ();   // "hides" struct foo
void bar (struct foo&);  // no warning, keyword struct is necessary

-Wno-subobject-linkage (C++ and Objective-C++ only)

Не выводить предупреждение, если тип класса имеет базовый или поле, тип которого использует анонимный namespace или зависит от типа без связи. Если тип A зависит от типа B без или с внутренней связью, его определение в нескольких единицах трансляции будет нарушением ODR, поскольку значение B отличается в каждой единице трансляции. Если A встречается только в одной единице трансляции, лучший способ отключить предупреждение – присвоить ему внутреннюю связь, поместив его также в анонимный namespace. Компилятор не выдаёт это предупреждение для типов, определённых в главном файле .C, так как для них маловероятно множественное определение. -Wsubobject-linkage включён по умолчанию.

-Weffc++ (C++ and Objective-C++ only)

Предупреждать о нарушениях следующих рекомендаций по стилю из серии книг Скотта Майерса «Effective C++»:

• Определять конструктор копирования и оператор присваивания для классов с динамически выделенной памятью.
• Предпочитать инициализацию присваиванию в конструкторах.
• Функция operator= должна возвращать ссылку на *this.
• Не пытаться возвращать ссылку, когда необходимо возвращать объект.
• Различать префиксные и постфиксные формы операторов инкремента и декремента.
• Никогда не перегружать операторы &&, ||, или ,.

Этот параметр также включает -Wnon-virtual-dtor, который также является одной из рекомендаций Effective C++. Однако проверка расширена, чтобы предупреждать об отсутствии виртуального деструктора в доступных неполиморфных базовых классах.

При выборе этого параметра имейте в виду, что заголовочные файлы стандартной библиотеки не следуют всем этим рекомендациям; используйте ‘grep -v’ для фильтрации этих предупреждений.

-Wno-exceptions (C++ and Objective-C++ only)

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

-Wstrict-null-sentinel (C++ and Objective-C++ only)

Предупреждать об использовании необработанного NULL в качестве стоп-значения. При компиляции только с GCC это допустимое стоп-значение, так как NULL определено как __null. Хотя это константа нулевого указателя, а не нулевой указатель, гарантируется, что она имеет тот же размер, что и указатель. Но это использование не переносимо между разными компиляторами.

-Wno-non-template-friend (C++ and Objective-C++ only)

Отключать предупреждения, когда нешаблонные дружественные функции объявлены внутри шаблона. В очень старых версиях GCC, предшествовавших реализации ISO-стандарта, объявления, такие как ‘friend int foo(int)’, где имя друга является unqualified-id, могли интерпретироваться как конкретная специализация шаблонной функции; предупреждение предназначено для диагностики проблем совместимости и включено по умолчанию.

-Wold-style-cast (C++ and Objective-C++ only)

Предупреждать, если используется старое (C-стилевое) приведение типов к типу, отличному от void, в C++ программе. Новые стили приведений (dynamic_cast, static_cast, reinterpret_cast, и const_cast) менее уязвимы к непреднамеренным последствиям и намного легче искать.

-Woverloaded-virtual (C++ and Objective-C++ only)

Предупреждать, когда объявление функции скрывает виртуальные функции из базового класса. Например, в:

struct A {
  virtual void f();
};

struct B: public A {
  void f(int);
};

версия класса A функции f скрыта в B, и код, подобный:

B* b;
b->f();

не скомпилируется.

-Wno-pmf-conversions (C++ and Objective-C++ only)

Отключать диагностику преобразования связанного указателя на член функции в обычный указатель.

-Wsign-promo (C++ and Objective-C++ only)

Предупреждать, когда разрешение перегрузки выбирает преобразование от беззнакового или перечислимого типа к знакомому типу вместо преобразования к беззнаковому типу того же размера. Предыдущие версии G++ пытались сохранить беззнаковость, но стандарт предписывает текущее поведение.

-Wtemplates (C++ and Objective-C++ only)

Предупреждать, когда встречается объявление основного шаблона. Некоторые правила кодирования запрещают шаблоны, и это может использоваться для их соблюдения. Предупреждение неактивно внутри системного заголовочного файла, такого как STL, поэтому STL можно по-прежнему использовать. Также можно создавать экземпляры или специализировать шаблоны.

-Wno-mismatched-new-delete (C++ and Objective-C++ only)

Предупреждать о несоответствиях между вызовами operator new или operator delete и соответствующим вызовом функции выделения или освобождения памяти. Это включает вызовы C++ operator delete с указателями, возвращёнными от несоответствующих форм operator new, или от других функций, которые выделяют объекты, для которых operator delete не является подходящим деаллокаторомом, а также вызовы других функций освобождения памяти с указателями, возвращёнными из operator new для которых функция освобождения памяти не подходит.

Например, выражение delete в функции ниже диагностируется, потому что оно не соответствует массивной форме выражения new из которого был возвращён указатель аргумента. Аналогично, вызов free также диагностируется.

void f ()
{
  int *a = new int[n];
  delete a;   // warning: mismatch in array forms of expressions

  char *p = new char[n];
  free (p);   // warning: mismatch between new and free
}

Связанный параметр -Wmismatched-dealloc диагностирует несоответствия, связанные с функциями выделения и освобождения памяти, отличными от operator new и operator delete.

-Wmismatched-new-delete включён по умолчанию.

-Wmismatched-tags (C++ and Objective-C++ only)

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

Например, объявление struct Object в списке аргументов draw вызывает предупреждение. Чтобы избежать этого, либо удалите лишний ключ класса struct, либо замените его на class, чтобы он соответствовал определению.

class Object {
public:
  virtual ~Object () = 0;
};
void draw (struct Object*);

Неправильно объявлять класс с ключом класса struct, как показано в примере выше. Параметр -Wmismatched-tags предназначен для обеспечения согласованного стиля объявлений классов. В коде, предназначенном для переноса в компиляторы на базе Windows, предупреждение помогает предотвратить неразрешённые ссылки из-за различий в формировании символов, объявленных с разными ключами класса. Параметр может использоваться как самостоятельно, так и в сочетании с -Wredundant-tags.

-Wmultiple-inheritance (C++ and Objective-C++ only)

Предупреждать, когда класс определяется с несколькими прямыми базовыми классами. Некоторые правила кодирования запрещают множественное наследование, и это может использоваться для их соблюдения. Предупреждение неактивно внутри системного заголовочного файла, такого как STL, поэтому STL можно по-прежнему использовать. Также можно определить классы, которые косвенно используют множественное наследование.

-Wvirtual-inheritance

Предупреждать, когда класс определяется с виртуальным прямым базовым классом. Некоторые правила кодирования запрещают множественное наследование, и это может использоваться для их соблюдения. Предупреждение неактивно внутри системного заголовочного файла, такого как STL, поэтому STL можно по-прежнему использовать. Также можно определять классы, которые косвенно используют виртуальное наследование.

-Wno-virtual-move-assign

Подавлять предупреждения об унаследовании от виртуального базового класса с нетривиальным оператором перемещения C++11. Это опасно, потому что если к виртуальному базовому классу есть доступ по нескольким путям, он перемещается несколько раз, что может означать, что оба объекта окажутся в перемещённом состоянии. Если оператор перемещения написан так, чтобы избежать перемещения из перемещённого объекта, это предупреждение можно отключить.

-Wnamespaces

Предупреждать, когда открывается определение области имён. Некоторые правила кодирования запрещают области имён, и это может использоваться для их соблюдения. Предупреждение неактивно внутри системного заголовочного файла, такого как STL, поэтому STL можно по-прежнему использовать. Также можно использовать директивы using и квалифицированные имена.

-Wno-terminate (C++ and Objective-C++ only)

Отключать предупреждение об выражении throw, которое мгновенно приведёт к вызову terminate.

-Wno-vexing-parse (C++ and Objective-C++ only)

Предупреждать о наиболее запутанной синтаксической неоднозначности разбора. Это предупреждает о случаях, когда объявление похоже на определение переменной, но язык C++ требует интерпретировать его как объявление функции. Например:

void f(double a) {
  int i();        // extern int i (void);
  int n(int(a));  // extern int n (int);
}

Другой пример:

struct S { S(int); };
void f(double a) {
  S x(int(a));   // extern struct S x (int);
  S y(int());    // extern struct S y (int (*) (void));
  S z();         // extern struct S z (void);
}

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

Это предупреждение включено по умолчанию.

-Wno-class-conversion (C++ and Objective-C++ only)

Не предупреждать, когда функция преобразования преобразует объект в тот же тип, в базовый класс этого типа или в void; такая функция преобразования никогда не будет вызвана.

-Wvolatile (C++ and Objective-C++ only)

Предупреждать о устаревшем использовании квалификатора volatile. Это включает постфиксные и префиксные ++ и -- выражения volatile-квалифицированных типов, использование простых присваиваний, где левый операнд является volatile-квалифицированным неклассовым типом для его значения, составных присваиваний, где левый операнд является volatile-квалифицированным неклассовым типом, volatile-квалифицированный тип возвращаемого значения функции, volatile-квалифицированный тип параметра и структурированные связи типа volatile. Это использование было устаревшим в C++20.

Включено по умолчанию с -std=c++20.

-Wzero-as-null-pointer-constant (C++ and Objective-C++ only)

Предупреждать, когда литерал ‘0’ используется как константа нулевого указателя. Это может быть полезно для облегчения преобразования в nullptr в C++11.

-Waligned-new

Предупреждать о выражениях new для типов, требующих большего выравнивания, чем alignof(std::max_align_t), но использующих функцию выделения памяти без явного параметра выравнивания. Этот параметр включен в -Wall.

Обычно это предупреждение относится только к глобальным функциям выделения памяти, но -Waligned-new=all также предупреждает о функциях выделения памяти для членов класса.

-Wno-placement-new

-Wplacement-new=n

Предупреждать об выражениях placement new с неопределённым поведением, например, при конструировании объекта в буфере, меньшем размера типа объекта. Например, выражение placement new ниже диагностируется, так как оно пытается создать массив из 64 целых чисел в буфере размером всего в 64 байта.

char buf [64];
new (buf) int[64];

Это предупреждение включено по умолчанию.

-Wplacement-new=1

Это уровень предупреждений по умолчанию для -Wplacement-new. На этом уровне предупреждение не выдаётся для некоторых строгих неопределённых конструкций, которые GCC допускает как расширения для совместимости со старым кодом. Например, следующее new выражение не диагностируется на этом уровне, даже несмотря на то, что оно имеет неопределённое поведение согласно стандарту C++, поскольку оно записывает за пределы одноэлементного массива.

struct S { int n, a[1]; };
S *s = (S *)malloc (sizeof *s + 31 * sizeof s->a[0]);
new (s->a)int [32]();

-Wplacement-new=2

На этом уровне, помимо диагностики всех тех же конструкций, что и на уровне 1, также выдаётся диагностика для выражений placement new, которые создают объект в последнем члене структуры, тип которой является массивом из одного элемента, а размер которого меньше размера конструируемого объекта. Хотя предыдущий пример будет диагностироваться, следующая конструкция использует расширение гибкого массива членов, чтобы избежать предупреждения на уровне 2.

struct S { int n, a[]; };
S *s = (S *)malloc (sizeof *s + 32 * sizeof s->a[0]);
new (s->a)int [32]();

-Wcatch-value

-Wcatch-value=n (C++ and Objective-C++ only)

Предупреждать о обработчиках catch, которые не производят захват по ссылке. С -Wcatch-value=1 (или -Wcatch-value для краткости) предупреждать о полиморфных типах класса, которые захватываются по значению. С -Wcatch-value=2 предупреждать обо всех типах классов, которые захватываются по значению. С -Wcatch-value=3 предупреждать обо всех типах, которые не захватываются по ссылке. -Wcatch-value включено в -Wall.

-Wconditionally-supported (C++ and Objective-C++ only)

Предупреждать о условно-поддерживаемых (C++11 [intro.defs]) конструкциях.

-Wno-delete-incomplete (C++ and Objective-C++ only)

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

-Wextra-semi (C++, Objective-C++ only)

Предупреждать о лишних точках с запятой после определений функций внутри класса.

-Wno-inaccessible-base (C++, Objective-C++ only)

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

struct A { int a; };

struct B : A { };

struct C : B, A { };

-Wno-inherited-variadic-ctor

Отключить предупреждения об использовании наследования конструкторов C++11, когда у базового класса есть конструктор с переменным числом аргументов (C-style variadic); предупреждение включено по умолчанию, так как эллипсис не наследуется.

-Wno-invalid-offsetof (C++ and Objective-C++ only)

Отключать предупреждения от применения макроса offsetof к типу, не являющемуся POD. Согласно стандарту ISO C++ 2014, применение offsetof к типу, не имеющему стандартной компоновки, неопределённо. Однако в существующих реализациях C++, offsetof обычно даёт осмысленные результаты. Этот флаг предназначен для пользователей, которые понимают, что они пишут непереносимый код, и сознательно решили игнорировать предупреждение об этом.

Ограничения на offsetof могут быть ослаблены в будущей версии стандарта C++.

-Wsized-deallocation (C++ and Objective-C++ only)

Предупреждать о определении функции deallocation без размера

void operator delete (void *) noexcept;
void operator delete[] (void *) noexcept;

без определения соответствующей функции deallocation с размером

void operator delete (void *, std::size_t) noexcept;
void operator delete[] (void *, std::size_t) noexcept;

или наоборот. Включается параметрами -Wextra вместе с -fsized-deallocation.

-Wsuggest-final-types

Предупреждать о типах с виртуальными методами, где качество кода улучшилось бы, если бы тип был объявлен с спецификатором C++11 final, или, если возможно, объявлен в анонимном пространстве имён. Это позволяет GCC более агрессивно девиртуализировать полиморфные вызовы.

-Wsuggest-final-methods

Предупреждать о виртуальных методах, где качество кода улучшилось бы, если бы метод был объявлен со спецификатором C++11 final, или, если возможно, его тип был объявлен в анонимном пространстве имён или со спецификатором final. Это предупреждение более эффективно при оптимизации на этапе линковки, где информация о графе иерархии класса более полна. Рекомендуется сначала рассмотреть предложения -Wsuggest-final-types, а затем перестроить с новыми аннотациями.

-Wsuggest-override

Предупреждать об переопределении виртуальных функций, которые не помечены ключевым словом override.

-Wuseless-cast (C++ and Objective-C++ only)

Предупреждать, когда выражение приводится к своему собственному типу.

-Wno-conversion-null (C++ and Objective-C++ only)

Не выдавать предупреждений для преобразований между NULL и не-указательными типами. -Wconversion-null включено по умолчанию.