2021-01-27

C\C＋＋宏大全（转）
一、标准预定义宏
The standard predefined macros are specified by the relevant language standards, so they are available with all compilers that implement those standards. Older compilers may not provide all of them. Their names all start with double underscores.
FILE
This macro expands to the name of the current input file, in the form of a C string constant. This is the path by which the preprocessor opened the file, not the short name specified in #include or as the input file name argument. For example, “/usr/local/include/myheader.h” is a possible expansion of this macro.

LINE
This macro expands to the current input line number, in the form of a decimal integer constant. While we call it a predefined macro, it’s a pretty strange macro, since its “definition” changes with each new line of source code.
FILE and LINE are useful in generating an error message to report an inconsistency detected by the program; the message can state the source line at which the inconsistency was detected. For example,

 fprintf (stderr, "Internal error: "
                  "negative string length "
                  "%d at %s, line %d.",
          length, __FILE__, __LINE__);

An #include directive changes the expansions of FILE and LINE to correspond to the included file. At the end of that file, when processing resumes on the input file that contained the #include directive, the expansions of FILE and LINE revert to the values they had before the #include (but LINE is then incremented by one as processing moves to the line after the #include).

A #line directive changes LINE, and may change FILE as well. See Line Control.

C99 introduces func, and GCC has provided FUNCTION for a long time. Both of these are strings containing the name of the current function (there are slight semantic differences; see the GCC manual). Neither of them is a macro; the preprocessor does not know the name of the current function. They tend to be useful in conjunction with FILE and LINE, though.

DATE
This macro expands to a string constant that describes the date on which the preprocessor is being run. The string constant contains eleven characters and looks like “Feb 12 1996”. If the day of the month is less than 10, it is padded with a space on the left.
If GCC cannot determine the current date, it will emit a warning message (once per compilation) and DATE will expand to “??? ?? ???”.

TIME
This macro expands to a string constant that describes the time at which the preprocessor is being run. The string constant contains eight characters and looks like “23:59:01”.
If GCC cannot determine the current time, it will emit a warning message (once per compilation) and TIME will expand to “??:??:??”.

STDC
In normal operation, this macro expands to the constant 1, to signify that this compiler conforms to ISO Standard C. If GNU CPP is used with a compiler other than GCC, this is not necessarily true; however, the preprocessor always conforms to the standard unless the -traditional-cpp option is used.
This macro is not defined if the -traditional-cpp option is used.

On some hosts, the system compiler uses a different convention, where STDC is normally 0, but is 1 if the user specifies strict conformance to the C Standard. CPP follows the host convention when processing system header files, but when processing user files STDC is always 1. This has been reported to cause problems; for instance, some versions of Solaris provide X Windows headers that expect STDC to be either undefined or 1. See Invocation.

STDC_VERSION
This macro expands to the C Standard’s version number, a long integer constant of the form yyyymmL where yyyy and mm are the year and month of the Standard version. This signifies which version of the C Standard the compiler conforms to. Like STDC, this is not necessarily accurate for the entire implementation, unless GNU CPP is being used with GCC.
The value 199409L signifies the 1989 C standard as amended in 1994, which is the current default; the value 199901L signifies the 1999 revision of the C standard. Support for the 1999 revision is not yet complete.

This macro is not defined if the -traditional-cpp option is used, nor when compiling C++ or Objective-C.

STDC_HOSTED
This macro is defined, with value 1, if the compiler’s target is a hosted environment. A hosted environment has the complete facilities of the standard C library available.

__cplusplus
This macro is defined when the C++ compiler is in use. You can use __cplusplus to test whether a header is compiled by a C compiler or a C++ compiler. This macro is similar to STDC_VERSION, in that it expands to a version number. A fully conforming implementation of the 1998 C++ standard will define this macro to 199711L. The GNU C++ compiler is not yet fully conforming, so it uses 1 instead. We hope to complete our implementation in the near future.

OBJC
This macro is defined, with value 1, when the Objective-C compiler is in use. You can use OBJC to test whether a header is compiled by a C compiler or a Objective-C compiler.

ASSEMBLER
This macro is defined with value 1 when preprocessing assembly language.

GCC 中普通预定义宏
GNUC
GNUC_MINOR
GNUC_PATCHLEVEL
These macros are defined by all GNU compilers that use the C preprocessor: C, C++, and Objective-C. Their values are the major version, minor version, and patch level of the compiler, as integer constants. For example, GCC 3.2.1 will define GNUC to 3, GNUC_MINOR to 2, and GNUC_PATCHLEVEL to 1. They are defined only when the entire compiler is in use; if you invoke the preprocessor directly, they are not defined.
GNUC_PATCHLEVEL is new to GCC 3.0; it is also present in the widely-used development snapshots leading up to 3.0 (which identify themselves as GCC 2.96 or 2.97, depending on which snapshot you have).

If all you need to know is whether or not your program is being compiled by GCC, you can simply test GNUC. If you need to write code which depends on a specific version, you must be more careful. Each time the minor version is increased, the patch level is reset to zero; each time the major version is increased (which happens rarely), the minor version and patch level are reset. If you wish to use the predefined macros directly in the conditional, you will need to write it like this:

      /* Test for GCC > 3.2.0 */
      #if __GNUC__ > 3 || \
          (__GNUC__ == 3 && (__GNUC_MINOR__ > 2 || \
                             (__GNUC_MINOR__ == 2 && \
                              __GNUC_PATCHLEVEL__ > 0))

Another approach is to use the predefined macros to calculate a single number, then compare that against a threshold:

      #define GCC_VERSION (__GNUC__ * 10000 \
                           + __GNUC_MINOR__ * 100 \
                           + __GNUC_PATCHLEVEL__)
      ...
      /* Test for GCC > 3.2.0 */
      #if GCC_VERSION > 30200

Many people find this form easier to understand.

GNUG
The GNU C++ compiler defines this. Testing it is equivalent to testing (GNUC && __cplusplus).

STRICT_ANSI
GCC defines this macro if and only if the -ansi switch, or a -std switch specifying strict conformance to some version of ISO C, was specified when GCC was invoked. It is defined to 1. This macro exists primarily to direct GNU libc’s header files to restrict their definitions to the minimal set found in the 1989 C standard.

BASE_FILE
This macro expands to the name of the main input file, in the form of a C string constant. This is the source file that was specified on the command line of the preprocessor or C compiler.

INCLUDE_LEVEL
This macro expands to a decimal integer constant that represents the depth of nesting in include files. The value of this macro is incremented on every #include directive and decremented at the end of every included file. It starts out at 0, it’s value within the base file specified on the command line.

ELF
This macro is defined if the target uses the ELF object format.

VERSION
This macro expands to a string constant which describes the version of the compiler in use. You should not rely on its contents having any particular form, but it can be counted on to contain at least the release number.

OPTIMIZE
OPTIMIZE_SIZE
NO_INLINE
These macros describe the compilation mode. OPTIMIZE is defined in all optimizing compilations. OPTIMIZE_SIZE is defined if the compiler is optimizing for size, not speed. NO_INLINE is defined if no functions will be inlined into their callers (when not optimizing, or when inlining has been specifically disabled by -fno-inline).
These macros cause certain GNU header files to provide optimized definitions, using macros or inline functions, of system library functions. You should not use these macros in any way unless you make sure that programs will execute with the same effect whether or not they are defined. If they are defined, their value is 1.

CHAR_UNSIGNED
GCC defines this macro if and only if the data type char is unsigned on the target machine. It exists to cause the standard header file limits.h to work correctly. You should not use this macro yourself; instead, refer to the standard macros defined in limits.h.

WCHAR_UNSIGNED
Like CHAR_UNSIGNED, this macro is defined if and only if the data type wchar_t is unsigned and the front-end is in C++ mode.

REGISTER_PREFIX
This macro expands to a single token (not a string constant) which is the prefix applied to CPU register names in assembly language for this target. You can use it to write assembly that is usable in multiple environments. For example, in the m68k-aout environment it expands to nothing, but in the m68k-coff environment it expands to a single %.

USER_LABEL_PREFIX
This macro expands to a single token which is the prefix applied to user labels (symbols visible to C code) in assembly. For example, in the m68k-aout environment it expands to an _, but in the m68k-coff environment it expands to nothing.
This macro will have the correct definition even if -f(no-)underscores is in use, but it will not be correct if target-specific options that adjust this prefix are used (e.g. the OSF/rose -mno-underscores option).

SIZE_TYPE
PTRDIFF_TYPE
WCHAR_TYPE
WINT_TYPE
These macros are defined to the correct underlying types for the size_t, ptrdiff_t, wchar_t, and wint_t typedefs, respectively. They exist to make the standard header files stddef.h and wchar.h work correctly. You should not use these macros directly; instead, include the appropriate headers and use the typedefs.

CHAR_BIT
Defined to the number of bits used in the representation of the char data type. It exists to make the standard header given numerical limits work correctly. You should not use this macro directly; instead, include the appropriate headers.

SCHAR_MAX
WCHAR_MAX
SHRT_MAX
INT_MAX
LONG_MAX
LONG_LONG_MAX
Defined to the maximum value of the signed char, wchar_t, signed short, signed int, signed long, and signed long long types respectively. They exist to make the standard header given numerical limits work correctly. You should not use these macros directly; instead, include the appropriate headers.

USING_SJLJ_EXCEPTIONS
This macro is defined, with value 1, if the compiler uses the old mechanism based on setjmp and longjmp for exception handling.

NEXT_RUNTIME
This macro is defined, with value 1, if (and only if) the NeXT runtime (as in -fnext-runtime) is in use for Objective-C. If the GNU runtime is used, this macro is not defined, so that you can use this macro to determine which runtime (NeXT or GNU) is being used.

LP64
_LP64
These macros are defined, with value 1, if (and only if) the compilation is for a target where long int and pointer both use 64-bits and int uses 32-bit.

VC的宏定义
VC的标准宏
The compiler recognizes 10 predefined ANSI C macros, and the Microsoft C++ implementation provides several more. These macros take no arguments and cannot be redefined. Their value, except for LINE and FILE, must be constant throughout compilation. Some of the predefined macros listed below are defined with multiple values. See the following tables for more information.

ANSI-Compliant Predefined Macros

Macro Description
DATE The compilation date of the current source file. The date is a string literal of the form Mmm dd yyyy. The month name Mmm is the same as for dates generated by the library function asctime declared in TIME.H.

FILE The name of the current source file. FILE expands to a string surrounded by double quotation marks.
You can create your own wide string version of FILE as follows:

#include <stdio.h>
#define WIDEN2(x) L ## x
#define WIDEN(x) WIDEN2(x)
#define WFILE WIDEN(FILE)
wchar_t *pwsz = WFILE;

int main()
{
}

LINE The line number in the current source file. The line number is a decimal integer constant. It can be altered with a #line directive.

STDC Indicates full conformance with the ANSI C standard. Defined as the integer constant 1 only if the /Za compiler option is given and you are not compiling C++ code; otherwise is undefined.

TIME The most recent compilation time of the current source file. The time is a string literal of the form hh:mm:ss.

TIMESTAMP The date and time of the last modification of the current source file, expressed as a string literal in the form Ddd Mmm Date hh:mm:ss yyyy, where Ddd is the abbreviated day of the week and Date is an integer from 1 to 31.

微软的VC宏
_ATL_VER Defines the ATL version.

_CHAR_UNSIGNED Default char type is unsigned. Defined when /J is specified.

COUNTER Expands to an integer starting with 0 and incrementing by 1 every time it is used in a compiland. COUNTER remembers its state when using precompiled headers. If the last COUNTER value was 4 after building a precompiled header (PCH), it will start with 5 on each PCH use.
COUNTER lets you generate unique variable names. You can use token pasting with a prefix to make a unique name. For example:

#include <stdio.h>
#define FUNC2(x,y) x##y
#define FUNC1(x,y) FUNC2(x,y)
#define FUNC(x) FUNC1(x,COUNTER)

int FUNC(my_unique_prefix);
int FUNC(my_unique_prefix);

int main() {
my_unique_prefix0 = 0;
printf("\n%d",my_unique_prefix0);
my_unique_prefix0++;
printf("\n%d",my_unique_prefix0);
}

__cplusplus Defined for C++ programs only.
_CPPLIB_VER Defined if you include any of the C++ Standard Library headers; reports which version of the Dinkumware header files are present.

_CPPRTTI Defined for code compiled with /GR (Enable Run-Time Type Information).

_CPPUNWIND Defined for code compiled with /GX (Enable Exception Handling).

_DEBUG Defined when compiling with /LDd, /MDd, /MLd, and /MTd.

_DLL Defined when /MD or /MDd (Multithread DLL) is specified.

FUNCDNAME Valid only within a function and returns the decorated name of the enclosing function (as a string). FUNCDNAME is not expanded if you use the /EP or /P compiler option.

FUNCSIG Valid only within a function and returns the signature of the enclosing function (as a string). FUNCSIG is not expanded if you use the /EP or /P compiler option.

FUNCTION Valid only within a function and returns the undecorated name of the enclosing function (as a string). FUNCTION is not expanded if you use the /EP or /P compiler option.

_M_ALPHA Defined for DEC ALPHA platforms. It is defined as 1 by the ALPHA compiler, and it is not defined if another compiler is used.

_M_IX86 Defined for x86 processors. See values for _M_IX86 for more details.

_M_IA64 Defined for 64-bit processors.

_M_MPPC Defined for Power Macintosh platforms (no longer supported).

_M_MRX000 Defined for MIPS platforms (no longer supported).

_M_PPC Defined for PowerPC platforms (no longer supported).

_MANAGED Defined to be 1 when /clr is specified.

_MFC_VER Defines the MFC version. For example, 0x0700 represents MFC version 7.

_MSC_EXTENSIONS This macro is defined when compiling with the /Ze compiler option (the default). Its value, when defined, is 1.

_MSC_VER Defines the major and minor versions of the compiler. For example, 1300 for Microsoft Visual C++ .NET. 1300 represents version 13 and no point release. This represents the fact that there have been a total of 13 releases of the compiler.
If you type cl /? at the command line, you will see the full version for the compiler you are using.

__MSVC_RUNTIME_CHECKS Defined when one of the /RTC compiler options is specified.
_MT Defined when /MD or /MDd (Multithreaded DLL) or /MT or /MTd (Multithreaded) is specified.
_WCHAR_T_DEFINED
and

_NATIVE_WCHAR_T_DEFINED
Defined when wchar_t is defined. Typically, wchar_t is defined when you use /Zc:wchar_t or when typedef unsigned short wchar_t; is executed in code.

_WIN32 Defined for applications for Win32 and Win64. Always defined.

_WIN64 Defined for applications for Win64.

_Wp64 Defined when specifying /Wp64.

As shown in following table, the compiler generates a value for the preprocessor identifiers that reflect the processor option specified.

values for _M_IX86

Option in Development Environment Command-Line Option Resulting value
Blend /GB _M_IX86 = 600 (Default. Future compilers will emit a different value to reflect the dominant processor.)
Pentium /G5 _M_IX86 = 500
Pentium Pro, Pentium II, and Pentium III /G6 _M_IX86 = 600
80386 /G3 _M_IX86 = 300
80486 /G4 _M_IX86 = 400