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

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

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

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

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

Установить максимальную вложенную глубину оценки для функций 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).

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

-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 и т. д.

-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 для проблемы ядра 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:

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

В новом коде лучше использовать -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). Первый сообщит обо всех прочитанных путях 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. Дополнительную информацию о тегах ABI см. в разделе Атрибуты C++.

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

-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) { }
};
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) в определенных ситуациях, таких как возврат локальной переменной, где удаление копирования (copy elision) неприменимо. Рассмотрим пример:

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)

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

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

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

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

-Wuse-after-free

-Wuse-after-free=n

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

-Wuse-after-free=1

На уровне 1 предупреждение пытается диагностировать только безусловные использования указателей, которые стали неопределёнными вызовом функции освобождения или успешным вызовом realloc, независимо от того, повлек ли вызов фактическую перераспределение памяти. Это включает двойные free вызовы, а также использование в арифметических и реляционных выражениях. Несмотря на неопределённость, использование неопределённых указателей в выражениях равенства (или неравенства) не диагностируется на этом уровне.

-Wuse-after-free=2

На уровне 2, помимо безусловных применений, предупреждение также диагностирует условные применения указателей, которые стали неопределёнными в результате вызова функции освобождения. Как и на уровне 2, применения в выражениях равенства (или неравенства) не диагностируются. Например, второй вызов free в следующей функции диагностируется на этом уровне:

struct A { int refcount; void *data; };

void release (struct A *p)
{
  int refcount = --p->refcount;
  free (p);
  if (refcount == 0)
    free (p->data);   // warning: p may be used after free
}

-Wuse-after-free=3

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

void adjust_pointers (int**, int);

void grow (int **p, int n)
{
  int **q = (int**)realloc (p, n *= 2);
  if (q == p)
    return;
  adjust_pointers ((int**)q, n);
}

Чтобы избежать предупреждения на этом уровне, храните смещения в памяти, выделенной под объект, вместо указателей. Этот подход не требует корректировки сохранённых указателей после перераспределения.

-Wuse-after-free=2 включено в -Wall.

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

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

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

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

Далее: Параметры диалекта Objective-C и Objective-C++, Предыдущий: Параметры диалекта C, Вверх: Вызов GCC [Содержание][Индекс]

© Free Software Foundation
Licensed under the GNU Free Documentation License, Version 1.3.
https://gcc.gnu.org/onlinedocs/gcc-12.2.0/gcc/C_002b_002b-Dialect-Options.html