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 ABI C++. По умолчанию используется версия 0.

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

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

Версия 2 — версия ABI C++, впервые появившаяся в 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 перечислений со областью видимости и обработку пакетов шаблонов аргументов, 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++ 10.3, исправляет регрессию тега ABI G++ 10.

Версия 16, впервые появившаяся в G++ 11, изменяет обработку __alignof__ для того, чтобы она отличалась от alignof, и зависимых имен операторов.

Версия 17, впервые появившаяся в G++ 12, исправляет расположение классов, которые наследуются от агрегатных классов со значениями по умолчанию для членов в C++14 и более поздних версиях.

Версия 18, впервые появившаяся в G++ 13, исправляет обработку лямбда-выражений, имеющих дополнительный контекст.

Версия 19, впервые появившаяся в G++ 14, исправляет обработку структурированных связей, чтобы включить теги ABI.

См. также -Wabi.

-fabi-compat-version=n

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

С -fabi-version=0 (по умолчанию) это по умолчанию 13 (совместимость с GCC 8.2). Если явно выбрана другая версия 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.

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

-fconcepts

-fconcepts-ts

Включить поддержку функции C++ Concepts для ограничения параметров шаблонов. С -std=c++20 и выше Concepts являются частью стандартного языка, поэтому -fconcepts по умолчанию включен.

Некоторые конструкции, которые были разрешены предыдущими расширениями C++ для технической спецификации Concepts, ISO 19217 (2015), но не вошли в стандарт, могут быть дополнительно включены с помощью -fconcepts-ts. Параметр -fconcepts-ts был устаревшим в GCC 14 и может быть удален в GCC 15; ожидается, что пользователи преобразуют свой код в C++20 концепции.

-fconstexpr-depth=n

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

-fconstexpr-cache-depth=n

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

-fconstexpr-fp-except

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

constexpr float inf = 1./0.; // OK with -fconstexpr-fp-except

-fconstexpr-loop-limit=n

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

-fconstexpr-ops-limit=n

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

-fcontracts

Включить экспериментальную поддержку функции C++ Contracts, кратко добавленной, а затем удаленной из рабочей версии C++20 (N4820). Реализация также включает предлагаемые улучшения из документов P1290, P1332 и P1429. Эта функциональность предназначена в основном для тех, кто заинтересован в экспериментах по доработке функции для её адаптации к будущему стандарту C++.

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

void
handle_contract_violation (const std::experimental::contract_violation&);

Существуют различные наборы дополнительных флагов, которые могут использоваться вместе для указания, какие контракты будут проверяться и как, для контрактов N4820, контрактов P1332 или контрактов P1429; эти наборы не могут использоваться вместе.

-fcontract-mode=[on|off]

Управляет наличием любой семантики у контрактов. По умолчанию включено.

-fcontract-assumption-mode=[on|off]

[N4820] Управляет тем, должны ли контракты уровня «axiom» иметь семантику assume. По умолчанию включено.

-fcontract-build-level=[off|default|audit]

[N4820] Указывает уровень контрактов, для которых будут генерироваться проверки. По умолчанию «default».

-fcontract-continuation-mode=[on|off]

[N4820] Управляет тем, может ли программа продолжить выполнение после нарушения контракта. То есть, имеют ли проверенные контракты семантику «maybe», описанную ниже, вместо семантики «never». По умолчанию выключено.

-fcontract-role=<name>:<default>,<audit>,<axiom>

[P1332] Указывает конкретную семантику для каждого уровня контракта определённого типа контракта.

-fcontract-semantic=[default|audit|axiom]:<semantic>

[P1429] Указывает конкретную семантику для определённого уровня контракта.

-fcontract-strict-declarations=[on|off]

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

Возможные конкретные семантики, которые можно указать с помощью «-fcontract-role» или «-fcontract-semantic», следующие:

ignore

Этот контракт не оказывает никакого эффекта.

assume

Этот контракт обрабатывается как C++23 [[assume]].

check_never_continue

never

abort

Этот контракт проверяется. Если он не выполняется, вызывается обработчик нарушения. Если обработчик возвращает значение, std::terminate вызывается.

check_maybe_continue

maybe

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

-fcoroutines

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

-fdiagnostics-all-candidates

Разрешить 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.

-ffold-simple-inlines

-fno-fold-simple-inlines

Разрешить C++ фронтенду сворачивать вызовы std::move, std::forward, std::addressof и std::as_const. В отличие от встраивания, это означает, что никакие данные отладки не будут генерироваться для таких вызовов. Поскольку эти функции редко представляют интерес для отладки, этот флаг включён по умолчанию, если -fno-inline не активен.

-fno-gnu-keywords

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

-fno-immediate-escalation

Не включать немедленное повышение функций, при котором определённые функции могут быть повышены до consteval, как указано в P2564R3. Например:

consteval int id(int i) { return i; }

constexpr int f(auto t)
{
  return t + id(t); // id causes f<int> to be promoted to consteval
}

void g(int i)
{
  f (3);
}

компилируется в C++20: f — это функция немедленного повышения (из-за auto это шаблон функции и объявлена constexpr) и id(t) — это выражение немедленного повышения, поэтому f повышается до consteval. Соответственно, вызов id(t) находится в немедленном контексте, поэтому не должен производить константу (это механизм, позволяющий композицию consteval-функций). Однако с помощью -fno-immediate-escalation f не повышается до consteval, и поскольку вызов consteval-функции id(t) не является константным выражением, компилятор отказывается от кода.

Этот параметр включён по умолчанию; он эффективен только в режиме C++20 или более поздних версий.

-fimplicit-constexpr

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

-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 для проблемы Core 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++, — это диагностика о том, что имя имеет несколько значений в классе.

-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 и будет удалено в C++23. Однако выражение с запятой, заключенное в ( ), не устарело. Пример:

void f(int *a, int b, int c) {
    a[b,c];     // deprecated in C++20, invalid in C++23
    a[(b,c)];   // OK
}

В C++23 допустимо иметь выражения, разделенные запятыми, в индексе, когда перегруженный оператор индексирования найден и поддерживает нужное количество и типы аргументов. G++ будет принимать ранее допустимый синтаксис для кода, который не является допустимым в C++23, но был допустимым и устаревшим в C++20, с педантичным предупреждением, которое можно отключить с помощью -Wno-comma-subscript.

Включено по умолчанию с -std=c++20, за исключением -Wno-deprecated, и с -std=c++23 независимо от -Wno-deprecated.

Это предупреждение повышается до ошибки с помощью -pedantic-errors в режиме C++23 или более поздних версий.

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

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

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

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

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

-Wdangling-reference (C++ and Objective-C++ only)

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

int n = 1;
const int& r = std::max(n - 1, n + 1); // r is dangling

В приведенном примере создаются два временных объекта, по одному для каждого аргумента, и возвращается ссылка на один из временных объектов. Однако оба временных объекта уничтожаются в конце всего выражения, поэтому ссылка r висит в воздухе. Это предупреждение также обнаруживает висячие ссылки в списках инициализаторов членов:

const int& f(const int& i) { return i; }
struct S {
  const int &r; // r is dangling
  S() : r(f(10)) { }
};

Также проверяются методы-члены, но только аргумент объекта:

struct S {
   const S& self () { return *this; }
};
const S& s = S().self(); // s is dangling

Некоторые функции безопасны в этом отношении, например, std::use_facet: они принимают и возвращают ссылку, но не возвращают один из своих аргументов, что может ввести в заблуждение предупреждение. Такие функции можно исключить из предупреждения, заключив их в #pragma:

#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wdangling-reference"
const T& foo (const T&) { … }
#pragma GCC diagnostic pop

#pragma также может окружать класс; в этом случае предупреждение будет отключено для всех методов-членов.

-Wdangling-reference также предупреждает о коде, подобном

auto p = std::minmax(1, 2);

где std::minmax возвращает std::pair<const int&, const int&>, и обе ссылки висят в воздухе после окончания всего выражения, содержащего вызов std::minmax.

Предупреждение не предупреждает для классов типа std::span. Мы рассматриваем классы вида:

template<typename T>
struct Span {
  T* data_;
  std::size len_;
};

как классы типа std::span; то есть класс является классом без объединения, у которого есть указатель на член данных и тривиальный деструктор.

Предупреждение можно отключить, используя атрибут gnu::no_dangling (см. Атрибуты переменных, функций и типов в C++).

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

-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-elaborated-enum-base

Для C++11 и выше предупреждать, если используется дополнительный enum-базовый элемент (некорректно) в описателе типа с детализацией. То есть, если перечисление с заданным базовым типом и без списка перечислителей используется в объявлении, отличном от простого объявления перечисления. Включено по умолчанию. Это предупреждение повышается до ошибки с помощью -pedantic-errors.

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

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

• Если функция возвращает временный массив initializer_list, или локальную initializer_list переменную, срок жизни массива заканчивается в конце оператора return, поэтому возвращаемое значение имеет висящий указатель.
• Если выражение 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-constexpr

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

Это предупреждение включено по умолчанию как педантичное предупреждение в C++20 и ранее. В C++23 -Winvalid-constexpr можно включить, в этом случае это будет обычное предупреждение. Например:

void f (int& i);
constexpr void
g (int& i)
{
  // Warns by default in C++20, in C++23 only with -Winvalid-constexpr.
  f(i);
}

-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++. Опция -Wdelete-non-virtual-dtor (включенная с помощью -Wall) предпочтительнее, так как она предупреждает об опасных случаях без ложных срабатываний.

-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 препятствует удалению копирования. Типичный сценарий, когда может произойти удаление копирования, — это возвращение в функции с типом возвращаемого значения класса, когда выражение, возвращаемое в функцию, является именем не-volatile автоматического объекта, не являющегося параметром функции, и имеет тот же тип, что и тип возвращаемого значения функции.

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++ реализует Core Issue 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++ для диапазонов. Это может произойти, когда объявление диапазона не является ссылкой, но, вероятно, должно быть. Например:

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

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

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

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)

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

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

Предупреждать о нарушениях следующих руководств по стилю из серии книг Scott Meyers «Effective C++»:

• Определить конструктор копирования и оператор присваивания для классов с динамически выделенной памятью.
• Предпочитать инициализацию присваиванию в конструкторах.
• Возвращать ссылку на *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)

-Woverloaded-virtual=n

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

struct A {
  virtual void f();
};

struct B: public A {
  void f(int); // does not override
};

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

B* b;
b->f();

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

В случаях, когда различные сигнатуры не являются случайностью, наилучшим решением является добавление использования объявления в производный класс, чтобы раскрыть базовые функции, например, добавление using A::f; к B.

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

struct C {
  virtual void f();
  virtual void f(int);
};

struct D: public C {
  void f(int); // does override
}

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

На уровне 1 это предупреждение не срабатывает, на уровне 2 — срабатывает. -Woverloaded-virtual сам по себе выбирает уровень 2. Уровень 1 включен в -Wall.

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

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

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

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

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

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

-Wmismatched-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 включён в -Wall.

-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-template-id-cdtor (C++ and Objective-C++ only)

Отключить предупреждение о применении simple-template-id в качестве declarator-id конструктора или деструктора, что стало недопустимым в C++20 через DR 2237. Например:

template<typename T> struct S {
  S<T>(); // should be S();
  ~S<T>();  // should be ~S();
};

-Wtemplate-id-cdtor включён по умолчанию с -std=c++20; он также включён параметром -Wc++20-compat.

-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’ используется как константа указателя null. Это может быть полезно для облегчения перехода к 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-global-module (C++ and 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, когда у базового класса, от которого наследовался, есть конструктор с переменным числом аргументов; предупреждение включено по умолчанию, потому что эллипсис не наследуется.

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

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

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

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

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.

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

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