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

Версия 6, впервые появившаяся в G++ 4.7, исправляет поведение продвижения C++11 scoped enums, и обработку шаблонов аргументов, 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, исправляет обработку лямбда-функций с дополнительным контекстом.

См. также -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 Extensions, ISO 19217 (2015), но не вошли в стандарт, дополнительно могут быть включены -fconcepts-ts.

-fconstexpr-depth=n

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

-fconstexpr-cache-depth=n

Установите максимальный уровень вложенной глубины вычисления для C++11 constexpr функций, которые будут кэшированы до 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

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

-fconstexpr-ops-limit=n

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

-fcontracts

END_OF_DOCUMENT_MARKER

Включить экспериментальную поддержку функции 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 (экспериментальная).

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

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

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

-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, т.е. для типов, разработанных для поддержки 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

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

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

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

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

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

Предупреждать, когда функция никогда не создаёт константное выражение. В C++20 и ранее для каждой функции и шаблона функции должно быть по крайней мере одно множество аргументов функций в по крайней мере одной реализации, такой что вызов функции или конструктора может быть вычисленным подвыражением основного константного выражения. 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 предотвращает устранение копирования. Типичный сценарий, когда происходит устранение копирования, — возврат в функции с типом возврата класса, когда выражение, возвращаемое, является именем непеременного автоматического объекта, не является параметром функции и имеет тот же тип, что и тип возвращаемого значения функции.

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

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

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

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

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

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

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

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

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++-программе используется старое (C-стиля) приведение типов к типу, отличном от void. Новые стили приведений типов (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
};

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

B* b;
b->f();

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

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

-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 допускает как расширения для совместимости со старым кодом.

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

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

-Wcatch-value

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

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

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

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

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

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

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

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

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

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

struct A { int a; };

struct B : A { };

struct C : B, A { };

-Wno-inherited-variadic-ctor

Подавить предупреждения об использовании конструкторов, унаследованных в C++11, когда у базового класса, от которого унаследовано, есть C-конструктор с переменным числом аргументов; предупреждение включено по умолчанию, потому что многоточие не наследуется.

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

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

struct S { };
void g (S&&);
void f (S&& arg)
{
  g (S(arg)); // make arg prvalue so that it can bind to S&&
}

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

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

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