Implementation defined behavior control
Implementation defined behavior is controlled by #pragma directive.
Syntax
#pragma pragma_params
|
(1) | ||||||||
_Pragma ( string-literal )
|
(2) | (since C99) | |||||||
\" with " and each \\ with \, then tokenizes the result (as in translation stage 3), and then uses the result as if the input to #pragma in (1)
Explanation
The pragma directive controls implementation-specific behavior of the compiler, such as disabling compiler warnings or changing alignment requirements. Any pragma that is not recognized is ignored.
Standard pragmas
The following three pragmas are defined by the language standard:
#pragma STDC FENV_ACCESS arg
|
(1) | (since C99) | |||||||
#pragma STDC FP_CONTRACT arg
|
(2) | (since C99) | |||||||
#pragma STDC CX_LIMITED_RANGE arg
|
(3) | (since C99) | |||||||
where arg is either ON or OFF or DEFAULT.
ON, informs the compiler that the program will access or modify floating-point environment
OFF
ON
+v2
), and |x+iy| = √x2
+y2
, despite the possibility of intermediate overflow. In other words, the programmer guarantees that the range of the values that will be passed to those function is limited. The default value is
OFF
Note: compilers that do not support these pragmas may provide equivalent compile-time options, such as gcc's -fcx-limited-range and -ffp-contract.
Non-standard pragmas
#pragma once
#pragma once is a non-standard pragma that is supported by the vast majority of modern compilers
Standard approach to preventing multiple inclusion of the same header is by using include guards:
#ifndef LIBRARY_FILENAME_H #define LIBRARY_FILENAME_H // contents of the header #endif /* LIBRARY_FILENAME_H */
So that all but the first inclusion of the header in any translation unit are excluded from compilation. All modern compilers record the fact that a header file uses an include guard and do not re-parse the file if it is encountered again, as long as the guard is still defined (see e.g. gcc
With #pragma once, the same header appears as
#pragma once // contents of the header
Unlike header guards, this pragma makes it impossible to erroneously use the same macro name in more than one file. On the other hand, since with #pragma once
#pragma pack
This family of pragmas control the maximum alignment for subsequently defined structure and union members.
#pragma pack(arg)
|
(1) | ||||||||
#pragma pack()
|
(2) | ||||||||
#pragma pack(push)
|
(3) | ||||||||
#pragma pack(push, arg)
|
(4) | ||||||||
#pragma pack(pop)
|
(5) | ||||||||
where arg is a small power of two and specifies the new alignment in bytes.
#pragma pack may decrease the alignment of a structure, however, it cannot make a structure overaligned.
See also specific details for GCC and MSVC
| This section is incomplete Reason: Explain the effects of this pragmas on data members and also the pros and cons of using them. Sources for reference: |
| This section is incomplete Reason: no example |
References
- C17 standard (ISO/IEC 9899:2018):
- 6.10.6 Pragma directive (p: 127)
- 6.10.9 Pragma operator (p: 129)
- C11 standard (ISO/IEC 9899:2011):
- 6.10.6 Pragma directive (p: 174)
- 6.10.9 Pragma operator (p: 178)
- C99 standard (ISO/IEC 9899:1999):
- 6.10.6 Pragma directive (p: 159)
- 6.10.9 Pragma operator (p: 161-162)
- C89/C90 standard (ISO/IEC 9899:1990):
- 3.8.6 Pragma directive
See also
C++ documentation for Implementation defined behavior control
|
External links
| 1. | C++ pragmas in Visual Studio 2019 |
| 2. | Pragmas accepted by GCC |
| 3. | Individual pragma descriptions and Standard pragmas |
| 4. | Appendix B. Pragmas in Sun Studio 11 C++ User's Guide |
| 5. | Intel C++ compiler pragmas |
| 6. | HP aCC compiler pragmas |