Прагма это в программировании

Директивы pragma и ключевые __pragma слова и _Pragma

Директивы Pragma указывают функции компилятора, относящиеся к конкретному компьютеру или операционной системе. Строка, начинающаяся с #pragma , указывает директиву pragma . Ключевое слово майкрософт __pragma позволяет кодировать pragma директивы в определениях макросов. Стандартный _Pragma оператор препроцессора, представленный в C99 и принятый на C++11, аналогичен.

Синтаксис

#pragma строка токена
__pragma( строка ) токена два символа подчеркивания в начале — расширение, относящееся к Корпорации Майкрософт
_Pragma( строковый литерал ) C99

Комментарии

Каждая реализация C и C++ поддерживает некоторые возможности, уникальные для хост-компьютера или операционной системы. Некоторые программы, например, должны осуществлять точный контроль над расположением данных в памяти или управлять способом получения параметров определенными функциями. Директивы #pragma предоставляют каждому компилятору способ предоставления функций компьютера и операционной системы, сохраняя при этом общую совместимость с языками C и C++.

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

Строка токена представляет собой ряд символов, представляющих определенную инструкцию компилятора и аргументы, если таковые есть. Числовой знак ( # ) должен быть первым символом, не содержащим пробела, в строке pragma, содержащей . Символы пробела могут разделять знак цифры и слово «pragma». После #pragma напишите любой текст, который переводчик может проанализировать как маркеры предварительной обработки. Аргумент для #pragma подвержен расширению макросов.

Строковый литерал является входными данными для _Pragma . Удаляются внешние кавычки, начальные и конечные пробелы. \» заменяется на » и \\ заменяется \ на .

Компилятор выдает предупреждение, когда находит pragma объект , который он не распознает, и продолжает компиляцию.

Компиляторы Microsoft C и C++ распознают следующие pragma директивы:

1 Поддерживается только компилятором C++.

Директивы pragma и параметры компилятора

Некоторые pragma директивы предоставляют те же функции, что и параметры компилятора. При достижении в исходном pragma коде он переопределяет поведение, заданное параметром компилятора. Например, если вы указали /Zp8 , этот параметр компилятора можно переопределить для определенных разделов кода с помощью pack :

// some_file.cpp - packing is 8 // . #pragma pack(push, 1) - packing is now 1 // . #pragma pack(pop) - packing is 8 again // . 

Ключевое слово __pragma .

Компилятор также поддерживает специальные ключевое слово Майкрософт __pragma , которые имеют те же функции, что и директива #pragma . Разница заключается в том __pragma , что ключевое слово можно использовать в определении макроса. Директива #pragma не используется в определении макроса, так как компилятор интерпретирует символ числового знака (‘#’) в директиве как оператор stringizing (#).

В следующем примере кода показано, как __pragma можно использовать ключевое слово в макросе. Этот код извлекается из заголовка mfcdual.h в примере ACDUAL в разделе Примеры поддержки компилятора COM:

#define CATCH_ALL_DUAL \ CATCH(COleException, e) \ < \ _hr = e->m_sc; \ > \ AND_CATCH_ALL(e) \ < \ __pragma(warning(push)) \ __pragma(warning(disable:6246)) /*disable _ctlState prefast warning*/ \ AFX_MANAGE_STATE(pThis->m_pModuleState); \ __pragma(warning(pop)) \ _hr = DualHandleException(_riidSource, e); \ > \ END_CATCH_ALL \ return _hr; \ 

Оператор _Pragma предварительной обработки

_Pragma аналогичен ключевое слово майкрософт __pragma . Он был введен в стандарт C в C99 и стандарт C++ в C++11. Он доступен в C только при указании /std:c11 параметра или /std:c17 . Для C++ он доступен во всех /std режимах, включая режим по умолчанию.

В отличие от #pragma позволяет _Pragma помещать pragma директивы в определение макроса. Строковый литерал должен быть тем, что вы в противном случае поместили бы после #pragma оператора . Пример:

#pragma message("the #pragma way") _Pragma ("message( \"the _Pragma way\")") 

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

В следующем примере кода показано, как _Pragma можно использовать ключевое слово в макросе, похожем на утверждение. Он создает директиву pragma , которая подавляет предупреждение, если выражение условия оказывается константным.

Определение макроса использует идиому do . while(0) для макросов с несколькими операторами, чтобы его можно было использовать, как если бы это был один оператор. Дополнительные сведения см. в разделе Многострочный макрос C в Stack Overflow. Оператор _Pragma в примере применяется только к следующей за ней строке кода.

// Compile with /W4 #include #include #define MY_ASSERT(BOOL_EXPRESSION) \ do < \ _Pragma("warning(suppress: 4127)") /* C4127 conditional expression is constant */ \ if (!(BOOL_EXPRESSION)) < \ printf("MY_ASSERT FAILED: \"" #BOOL_EXPRESSION "\" on %s(%d)", __FILE__, __LINE__); \ exit(-1); \ >\ > while (0) int main()

Источник

Pragma directives and the __pragma and _Pragma keywords

Pragma directives specify machine-specific or operating system-specific compiler features. A line that starts with #pragma specifies a pragma directive. The Microsoft-specific __pragma keyword enables you to code pragma directives within macro definitions. The standard _Pragma preprocessor operator, introduced in C99 and adopted by C++11, is similar.

Syntax

#pragma token-string
__pragma( token-string ) // two leading underscores — Microsoft-specific extension
_Pragma( string-literal ) // C99

Remarks

Each implementation of C and C++ supports some features unique to its host machine or operating system. Some programs, for example, must exercise precise control over the location of data in memory, or control the way certain functions receive parameters. The #pragma directives offer a way for each compiler to offer machine- and operating system-specific features, while maintaining overall compatibility with the C and C++ languages.

Pragma directives are machine-specific or operating system-specific by definition, and are typically different for every compiler. A pragma can be used in a conditional directive, to provide new preprocessor functionality. Or, use one to provide implementation-defined information to the compiler.

The token-string is a series of characters representing a specific compiler instruction and arguments, if any. The number sign ( # ) must be the first non-white-space character on the line that contains the pragma. White-space characters can separate the number sign and the word «pragma». Following #pragma , write any text that the translator can parse as preprocessing tokens. The argument to #pragma is subject to macro expansion.

The string-literal is the input to _Pragma . Outer quotes and leading/trailing whitespace are removed. \» is replaced with » and \\ is replaced with \ .

The compiler issues a warning when it finds a pragma that it doesn’t recognize, and continues compilation.

The Microsoft C and C++ compilers recognize the following pragma directives:

1 Supported only by the C++ compiler.

Pragma directives and compiler options

Some pragma directives provide the same functionality as compiler options. When a pragma is reached in source code, it overrides the behavior specified by the compiler option. For example, if you specified /Zp8 , you can override this compiler setting for specific sections of the code with pack :

// some_file.cpp - packing is 8 // . #pragma pack(push, 1) - packing is now 1 // . #pragma pack(pop) - packing is 8 again // . 

The __pragma keyword

The compiler also supports the Microsoft-specific __pragma keyword, which has the same functionality as the #pragma directive. The difference is, the __pragma keyword is usable inline in a macro definition. The #pragma directive isn’t usable in a macro definition, because the compiler interprets the number sign character (‘#’) in the directive as the stringizing operator (#).

The following code example demonstrates how the __pragma keyword can be used in a macro. This code is excerpted from the mfcdual.h header in the ACDUAL sample in «Compiler COM Support Samples»:

#define CATCH_ALL_DUAL \ CATCH(COleException, e) \ < \ _hr = e->m_sc; \ > \ AND_CATCH_ALL(e) \ < \ __pragma(warning(push)) \ __pragma(warning(disable:6246)) /*disable _ctlState prefast warning*/ \ AFX_MANAGE_STATE(pThis->m_pModuleState); \ __pragma(warning(pop)) \ _hr = DualHandleException(_riidSource, e); \ > \ END_CATCH_ALL \ return _hr; \ 

The _Pragma preprocessing operator

_Pragma is similar to the Microsoft-specific __pragma keyword. It was introduced into the C standard in C99, and the C++ standard in C++11. It’s available in C only when you specify the /std:c11 or /std:c17 option. For C++, it’s available in all /std modes, including the default.

Unlike #pragma , _Pragma allows you to put pragma directives into a macro definition. The string literal should be what you would otherwise put following a #pragma statement. For example:

#pragma message("the #pragma way") _Pragma ("message( \"the _Pragma way\")") 

Quotation marks and back-slashes should be escaped, as shown above. A pragma string that isn’t recognized is ignored.

The following code example demonstrates how the _Pragma keyword could be used in an assert-like macro. It creates a pragma directive that suppresses a warning when the condition expression happens to be constant.

The macro definition uses the do . while(0) idiom for multi-statement macros so that it can be used as though it were one statement. For more information, see C multi-line macro on Stack Overflow. The _Pragma statement in the example only applies to the line of code that follows it.

// Compile with /W4 #include #include #define MY_ASSERT(BOOL_EXPRESSION) \ do < \ _Pragma("warning(suppress: 4127)") /* C4127 conditional expression is constant */ \ if (!(BOOL_EXPRESSION)) < \ printf("MY_ASSERT FAILED: \"" #BOOL_EXPRESSION "\" on %s(%d)", __FILE__, __LINE__); \ exit(-1); \ >\ > while (0) int main()

Источник

section pragma

Термины сегмент и раздел имеют одинаковое значение в этой статье.

После определения раздела он остается действительным до конца компиляции. Однако необходимо использовать __declspec(allocate) , иначе в разделе ничего не помещается.

section-name — обязательный параметр, который становится именем раздела. Имя не должно конфликтовать со стандартными именами раздела. См /SECTION . список имен, которые не следует использовать при создании раздела.

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

attribute	Описание
read	Позволяет выполнять операции чтения данных.
write	Позволяет выполнять операции записи данных.
execute	Позволяет выполнять код.
shared	Предоставляет совместный доступ к разделу всем процессам, загружающим образ.
nopage	Помечает раздел как не доступный для страницы. Полезно для драйверов устройств Win32.
nocache	Помечает раздел как не кэшируемый. Полезно для драйверов устройств Win32.
discard	Помечает раздел как отменяемый. Полезно для драйверов устройств Win32.
remove	Помечает раздел как не резидентный в памяти. Только для драйверов виртуальных устройств (VxD).

Если атрибуты не указаны, раздел содержит read атрибуты и write .

Пример

В этом примере первый раздел pragma определяет раздел и его атрибуты. Целое число j не помещает в mysec , так как оно не было объявлено с помощью __declspec(allocate) . Вместо этого j перейдите в раздел данных. Целое число i действительно входит в mysec из-за его __declspec(allocate) атрибута класса хранения.

// pragma_section.cpp #pragma section("mysec",read,write) int j = 0; __declspec(allocate("mysec")) int i = 0; int main()<> 

Источник