C/C++ 中宏与预处理使用方法大全 (VC)

时间  2019-11-06
标签 c++ 预处理 使用方法 大全 栏目 C&C++ 繁體版
原文   原文链接

VC 中的宏使用方法参考 MSDN: Macros (C/C++)php

C/C++ 预约义宏^

__LINE__: 当前源文件的行号，整数
__FILE__: 当前源文件名，char 字符串，使用 /FC 选项产生全路径
__DATE__: 当前编译日期，char 字符串，格式 Aug 28 2011
__TIME__: 当前编译时间，char 字符串，格式 06:43:59
__STDC__: 整数 1，表示兼容 ANSI/ISO C 标准，配合 #if 使用
__TIMESTAMP__: 最后一次修改当前文件的时间戳，char 字符串，格式 Sun Aug 28 06:43:57 2011
__cplusplus: 以 C++ 方式而非 C 语言方式编译时定义，VC 2005 中定义为 199711L，配合 #ifdef 使用程序员

例子：C/C++ 预约义宏的取值^web

源码打印？正则表达式

  1. // MacroTest.h  编程

  2. void PrintSourceInfo()  api

  3. {  安全

  4.     const _TCHAR* pszstdc;  网络

  5.     const _TCHAR* pszcpp;  多线程

  6.   

  7. #if __STDC__  并发

  8.     pszstdc = _T("YES");  

  9. #else  

  10.     pszstdc = _T("NO");  

  11. #endif  

  12.   

  13. #ifdef __cplusplus  

  14.     pszcpp = _T("YES");  

  15. #else  

  16.     pszcpp = _T("NO");  

  17. #endif  

  18.   

  19.     _tprintf(_T("File: %s, Line: %d, Date: %s, Time: %s, Timestamp: %s, ANSI/ISO C: %s, C++: %s\n"),  

  20.              _T(__FILE__), __LINE__, _T(__DATE__), _T(__TIME__), _T(__TIMESTAMP__), pszstdc, pszcpp);  

  21. }  

  22.   

  23. // 宏化的 PrintSourceInfo()  

  24. #define PRINT_SOURCE_INFO() \  

  25.     _tprintf(_T("File: %s, Line: %d, Date: %s, Time: %s, Timestamp: %s\n"), \  

  26.              _T(__FILE__), __LINE__, _T(__DATE__), _T(__TIME__), _T(__TIMESTAMP__));  

MacroTest.h 中定义函数 PrintSourceInfo() 和 PRINT_SOURCE_INFO()，在 MacroTest.cpp include=> MacroTest.h，并调用它们

输出结果：

(1). 使用函数 PrintSourceInfo()，不管 Debug/Release 方式编译，不管是否 inline 化 PrintSourceInfo()，输出结果相同，均是 MacroTest.h 的信息：

File: d:\source\macrotest\macrotest.h, Line: 64, Date: Aug 28 2011, Time: 06:43:59, Timestamp: Sun Aug 28 06:43:57 2011, ANSI/ISO C: NO, C++: YES

(2). 使用宏 PRINT_SOURCE_INFO()，Debug/Release 方式编译输出结果大体相同，均是 MacroTest.cpp 的信息，只是 Debug 输出的 __FILE__ 是全路径，而 Release 输出的是相对路径：

File: d:\source\macrotest\macrotest.cpp, Line: 14, Date: Aug 28 2011, Time: 07:42:30, Timestamp: Sun Aug 28 07:38:25 2011

说明：

(1). __FILE__、__DATE__、__TIME__ 是 char 字符串，而不是 wchar_t 宽字符字符串，需配合 _T()、_t 系列函数使用

(2). 若是在函数 PrintSourceInfo() 中使用宏，则 __FILE__、__LINE__、__TIME__ 等表示的是 PrintSourceInfo() 所在文件，即例 1 中的 MacroTest.h 的信息；若是在宏 PRINT_SOURCE_INFO() 中使用宏，由于宏 PRINT_SOURCE_INFO() 嵌套展开的缘故，__FILE__ 等表示的是 PRINT_SOURCE_INFO() 展开所在文件，即 MacroTest.cpp 的信息

(3). 不管使用 PrintSourceInfo() 仍是 PRINT_SOURCE_INFO()，__LINE__ 老是文件 .h/.cpp 的固有行号，而非 [MacroTest.cpp include=> MacroTest.h] 预处理展开后的行号

(4). 在 VC 2005 中，上述编译方式下没有定义 __STDC__，要使 __STDC__ = 1，应同时知足如下条件：

  • (a). 以 C 方式编译

  • (b). 使用编译选项 /Za，表示禁止 Microsoft C/C++ 语言扩展，从而兼容 ANSI C/C++

C/C++ 预约义宏用途：诊断与调试输出^

参考 VC CRT 和 MFC 的代码，注意：须要在宏中使用 __FILE__、__LINE__，缘由见上面“说明 (2)”

CRT 的诊断与调试输出：assert, _ASSERT/_ASSERTE, _RPTn/_RPTFn/_RPTWn/_RPTFWn^

CRT 的诊断宏 assert()、_ASSERT()/_ASSERTE()

源码打印？

  1. // assert.h  

  2.   

  3. _CRTIMP void __cdecl _wassert(__in_z const wchar_t * _Message, __in_z const wchar_t *_File, __in unsigned _Line);  

  4.   

  5. #define assert(_Expression) (void)( (!!(_Expression)) || (_wassert(_CRT_WIDE(#_Expression), _CRT_WIDE(__FILE__), __LINE__), 0) )  

  6.   

  7. // crtdbg.h  

  8.   

  9. #define _ASSERT_EXPR(expr, msg) \  

  10.         (void) ((!!(expr)) || \  

  11.                 (1 != _CrtDbgReportW(_CRT_ASSERT, _CRT_WIDE(__FILE__), __LINE__, NULL, msg)) || \  

  12.                 (_CrtDbgBreak(), 0))  

  13.   

  14. #ifndef _ASSERT  

  15. #define _ASSERT(expr)   _ASSERT_EXPR((expr), NULL)  

  16. #endif  

  17.   

  18. #ifndef _ASSERTE  

  19. #define _ASSERTE(expr)  _ASSERT_EXPR((expr), _CRT_WIDE(#expr))  

  20. #endif  

CRT 的调试输出宏 _RPTn()/_RPTFn()，n: 0 ~ 5
_RPTWn()/_RPTFWn() 是宽字符版

源码打印？

  1. // crtdbg.h  

  2.   

  3. #define _RPT_BASE(args) \  

  4.         (void) ((1 != _CrtDbgReport args) || \  

  5.                 (_CrtDbgBreak(), 0))  

  6.   

  7. #define _RPTF0(rptno, msg) \  

  8.         _RPT_BASE((rptno, __FILE__, __LINE__, NULL, "%s", msg))  

MFC 的诊断与调试输出：ASSERT/VERIFY, ASSERT_VALID, TRACE/TRACEn^

MFC 的诊断宏 ASSERT()/VERIFY()、ASSERT_VALID()

源码打印？

  1. // afx.h  

  2.   

  3. #define ASSERT(f)          DEBUG_ONLY((void) ((f) || !::AfxAssertFailedLine(THIS_FILE, __LINE__) || (AfxDebugBreak(), 0)))  

  4. #define ASSERT_VALID(pOb)  DEBUG_ONLY((::AfxAssertValidObject(pOb, THIS_FILE, __LINE__)))  

MFC 的调试输出宏 TRACE()/TRACEn()，n: 0 ~ 3

源码打印？

  1. // atltrace.h  

  2.   

  3. #ifndef ATLTRACE  

  4. #define ATLTRACE ATL::CTraceFileAndLineInfo(__FILE__, __LINE__)  

  5. #define ATLTRACE2 ATLTRACE  

  6. #endif  

  7.   

  8. // afx.h  

  9.   

  10. #include <atltrace.h>  

  11. #define TRACE ATLTRACE  

  12.   

  13. #define THIS_FILE          __FILE__  

  14. #define VERIFY(f)          ASSERT(f)  

  15. #define DEBUG_ONLY(f)      (f)  

  16.   

  17. #define TRACE0(sz)              TRACE(_T("%s"), _T(sz))  

  18. #define TRACE1(sz, p1)          TRACE(_T(sz), p1)  

  19. #define TRACE2(sz, p1, p2)      TRACE(_T(sz), p1, p2)  

  20. #define TRACE3(sz, p1, p2, p3)  TRACE(_T(sz), p1, p2, p3)  

MFC 的调试版 new^

源码打印？

  1. // afx.h  

  2.   

  3. void* AFX_CDECL operator new(size_t nSize, LPCSTR lpszFileName, int nLine);  

  4. #define DEBUG_NEW new(THIS_FILE, __LINE__)  

  5.   

  6. // 用户代码  

  7.   

  8. // 调试版 new  

  9. #ifdef _DEBUG  

  10. #define new DEBUG_NEW  

  11. #endif  

CRT 和 C 标准库中的宏^

VC CRT 和 C 标准库中的宏参考 MSDN: Global Constants

NULL 空指针^

NULL 在 stddef.h, stdio.h, stdlib.h 等多个头文件中定义，是地址/指针类型的 0，以下：

源码打印？

  1. #ifdef __cplusplus  

  2. #define NULL    0  

  3. #else  

  4. #define NULL    ((void *)0)  

  5. #endif  

C++ 中的 0 是类型自动的，因此用 0 定义 NULL；而 C 中 0 是肯定的 int 类型，因此须要强制

C++ 中，当 NULL 的相关操做数，如：对比操做 ptr == NULL，或函数的形参是指针类型时，或者可以“从指针类型隐式转换”时，0 被自动转换为指针类型

例子：NULL 隐式转换和 0 是类型自动的^

源码打印？

  1. // baby pointer wrapper  

  2. class Pointer  

  3. {  

  4. public:  

  5.     // 非 explicit 构造函数，说明 Pointer 能够从指针类型 void* 隐式转换  

  6.     Pointer(void* p) : m_Ptr(p)  

  7.     {}  

  8.   

  9.     bool IsNull() const  

  10.     {  

  11.         return (m_Ptr == NULL);  

  12.     }  

  13.   

  14. private:  

  15.     void*    m_Ptr;  

  16. };  

  17.   

  18. // 形参能够从指针类型 void* 隐式转换  

  19. void TestPointer(Pointer ptr)  

  20. {  

  21.     _tprintf(_T("ptr is %sNULL\n"), ptr.IsNull() ? _T("") : _T("NOT "));  

  22. }  

  23.   

  24. // 用户代码  

  25. TestPointer(0);         // OK，0 是类型自动的，0 被自动转换为 void*，再次隐式转换为 Pointer  

  26. TestPointer(NULL);      // OK，NULL 就是 0，同上  

  27. TestPointer(1);         // Error，C++ 中 1 不一样于 0，它是肯定的 int 类型，  

  28.                         // 只能提高转换到 float/double 类型，不能自动转换为指针  

  29. TestPointer((int*)1);   // OK，强制转换 1 为 int*，int* 自动转换为 void*，再次隐式转换为 Pointer  

  30.                         // 注意：void* 到 int* 不能自动转换，须要强制，参考 malloc() 的返回值  

limits.h 整数类型常量^

在 limits.h 中定义，定义了各类 int 类型 (unsigned, char, short, long, __int64) 的最小、最大值，如 SCHAR_MAX (signed char MAX)、UCHAR_MAX (unsigned char MAX)、USHRT_MAX (unsigned short MAX) 等。编译时，若是 int 字面量超出这些范围，会编译出错

参考 MSDN: Integer Limits

float.h 浮点类型常量^

在 float.h 中定义，定义各类浮点类型 (float, double, long double) 的极限值，如最小、最大值，最小浮点差量 (epsilon) 等

参考 MSDN: Floating Limits

例子：浮点数极限值：判断浮点数是否相等^

源码打印？

  1. // 对比一个 double 是否为 0  

  2. inline  

  3. bool double_equal0(double n)  

  4. {  

  5.     return (n >= 0 ? n < DBL_MIN : n > -DBL_MIN);  

  6. }  

  7.   

  8. // 对比两个 double 是否相等  

  9. inline  

  10. bool double_equal(double l, double r)  

  11. {  

  12.     return (l >= r ? l - r < DBL_EPSILON : r - l < DBL_EPSILON);  

  13. }  

  14.   

  15. // 打印函数的结果  

  16. #define TEST_BOOL_FUNC(func) _tprintf(_T("%s: %s\n"), _TSTRINGIZE(func), func ? _T("TRUE") : _T("FALSE"))  

  17.   

  18. // 用户代码  

  19. // 对比 double 是否为 0 时，double_equal0() 更精确  

  20. // 对比两个 double 是否相等时，最好用 double_equal()  

  21.   

  22. TEST_BOOL_FUNC(double_equal0(0));                       // TRUE  

  23. TEST_BOOL_FUNC(double_equal0(DBL_EPSILON));             // FALSE  

  24. TEST_BOOL_FUNC(double_equal0(-DBL_EPSILON));            // FALSE  

  25. TEST_BOOL_FUNC(double_equal0(DBL_MIN));                 // FALSE  

  26. TEST_BOOL_FUNC(double_equal0(-DBL_MIN));                // FALSE  

  27.   

  28. TEST_BOOL_FUNC(double_equal(0, 0));                     // TRUE  

  29. TEST_BOOL_FUNC(double_equal(DBL_EPSILON, 0));           // FALSE  

  30. TEST_BOOL_FUNC(double_equal(DBL_MIN, 0));               // TRUE  

  31. TEST_BOOL_FUNC(double_equal(1.0, 1.0 + DBL_EPSILON));   // FALSE  

  32. TEST_BOOL_FUNC(double_equal(1.0, 1.0 - DBL_EPSILON));   // FALSE  

  33. TEST_BOOL_FUNC(double_equal(1.0, 1.0 + DBL_MIN));       // TRUE  

  34. TEST_BOOL_FUNC(double_equal(1.0, 1.0 - DBL_MIN));       // TRUE  

math.h 数学常量^

数学计算经常使用的浮点数常量，如 M_PI (pi), M_E (e), M_SQRT2 (sqrt(2)) 等。这些数学常量不是标准 C/C++ 的一部分，而是 Microsoft 的扩展，使用前须要定义 _USE_MATH_DEFINES：

源码打印？

  1. #define _USE_MATH_DEFINES  

  2. #include <math.h>  

EOF 常量^

EOF (end-of-file) 常量，定义为 (-1)，有宽字符版 WEOF ((wint_t)(0xFFFF))，EOF 和 WEOF 在 stdio.h 中定义，还有 _TCHAR 版 _TEOF，在 tchar.h 中定义。EOF 在流、I/O 操做中表示到达流、文件末尾（EOF 条件），也用来表示发生错误状况

例子：标准输入的 EOF^

源码打印？

  1. // 设置 locale  

  2. // 定义宽字符流与控制台 I/O 字符之间的转换字符集编码为系统 ANSI 字符集  

  3. // 这样在中文 Windows 上可输入、显示中文字符  

  4. _tsetlocale(LC_ALL, _T(""));  

  5.   

  6. // 要用存储空间 >= _gettchar() 返回值类型的变量保存其返回值  

  7. // 而不要用 char ch = _getchar()，那样会截断其返回值类型  

  8. int ch;  

  9. while ((ch = _gettchar()) != _TEOF)  

  10.     _tprintf(_T("[%c]"), (_TCHAR)ch);  

  11.   

  12. _tprintf(_T("\nread stdin: %s\n"), (feof(stdin) ? _T("EOF") : _T("Error")));  

测试输出，用 Ctrl + Z 产生 EOF 信号：

abc汉字
[a][b][/c][汉][字][
]^Z

read stdin: EOF

errno.h 错误代码^

在 errno.h 中定义，是测试全局量 errno 的值，errno 在 VC 中实现为线程安全的函数，而非全局变量。错误代码以 E 打头如 EINVAL：不合法的参数错误

错误代码具体值参考 MSDN: errno Constants 和 errno, _doserrno, _sys_errlist, and _sys_nerr

locale 类别^

locale 类别 (Categories)，在 locale.h 中定义，如 LC_ALL、LC_CTYPE

_MAX_PATH 等文件名与路径长度限制^

包括全路径与各部分路径的限制，即 FILENAME_MAX、_MAX_PATH、_MAX_DRIVE、_MAX_EXT、_MAX_FNAME、_MAX_DIR，在 stdlib.h 中定义。最大全路径长度限制在 260，和 Windows 的 MAX_PATH 相同，这是为了兼容 Windows 98 FAT32 文件系统。CRT 支持 32767 长度的文件名，方法和 Windows API 相同，即便用 "\\?\" 路径前缀，并调用 Unicode 宽字符版的 CRT 函数

RAND_MAX 随机数最大值^

在 stdlib.h 中定义为 32767，rand() 函数会产生 0 ~ RAND_MAX 之间的伪随机 int 值

例子：用 RAND_MAX 产生某个范围内的随机数^

源码打印？

  1. template<bool seed, typename Type>  

  2. inline  

  3. Type get_rand(Type min, Type max)  

  4. {  

  5.     _ASSERT(max >= min);  

  6.   

  7.     if (seed)       // Release 方式编译时，这个判断语句会被优化掉  

  8.         srand((unsigned int) time(NULL));  

  9.   

  10.     return (Type) (((double) rand() / (double) RAND_MAX) * (max - min) + min);  

  11. }  

  12.   

  13. template<typename Type>  

  14. inline  

  15. Type get_rand_seed(Type min, Type max)  

  16. {  

  17.     return get_rand<true>(min, max);  

  18. }  

  19.   

  20. template<typename Type>  

  21. inline  

  22. Type get_rand_noseed(Type min, Type max)  

  23. {  

  24.     return get_rand<false>(min, max);  

  25. }  

  26.   

  27. // 用户代码  

  28. #define RANGE_MIN   10  

  29. #define RANGE_MAX   100  

  30.   

  31. int randnum;  

  32. randnum = get_rand_seed(RANGE_MIN, RANGE_MAX);  

  33. randnum = get_rand_noseed(RANGE_MIN, RANGE_MAX);  

va_arg/va_start/va_end 访问变长函数参数^

用于访问相似 printf(const char* format, ...) 等变长函数参数的辅助宏，在 stdarg.h 中声明，参考 MSDN:va_arg, va_end, va_start

宏实现的 CRT 函数^

在 VC CRT 中有些函数以宏和函数两种方式实现，如 getchar()，并优先使用宏版本，

强制使用函数版的方法：

(1). 调用时给函数名加括号，如 (getchar)()
(2). 调用前，取消宏版本的定义，如 #undef getchar

两种实现方式的比较见 MSDN: Recommendations for Choosing Between Functions and Macros

Microsoft 预约义宏^

VC C/C++ 和 Microsoft 预约义宏参考 MSDN: Predefined Macros

这些宏能够分类以下：

平台与系统类^

_M_IX86: IA32/x86 平台
_M_IA64: IA64/IPF (Itanium Processor Family) 64bit 平台
_M_X64: x64/x86-64/AMD64 平台
WIN32, _WIN32: Win32 和 Win64 程序开发都会定义
_WIN64: Win64 程序开发
_CONSOLE: 控制台 Windows 程序开发，连接 Console 子系统：/SUBSYSTEM:CONSOLE
_WINDOWS: 非控制台 Windows 程序开发，连接 Windows 子系统：/SUBSYSTEM:WINDOWS

版本号类^

一般定义为数字，配合 #if (XXX >= 1000) 使用，启动、禁用特定部分的代码、特性

_MSC_VER: VC 编译器 cl 版本号。VC 2003 编译器版本号 13.10 (_MSC_VER = 1310)，VC 2005 编译器版本号 14.00 (_MSC_VER = 1400)。用 cl /? 查看编译器版本号
_MFC_VER: MFC 版本号
_ATL_VER: ATL 版本号
__CLR_VER: CLR 版本号
WINVER: 目标 Windows 版本号
_WIN32_WINNT: 目标 Windows NT 版本号
_WIN32_WINDOWS: 目标 Windows 9x 版本号
_WIN32_IE: 目标 IE 版本号

工程配置管理类^

_DEBUG, NDEBUG: Debug/Release 编译方式
UNICODE, _UNICODE, _MBCS: ANSI/UNICODE/MBCS 字符集支持
_AFXDLL: 动态连接 MFC (DLL)
_ATL_STATIC_REGISTRY, _ATL_DLL: 静态/动态连接 ATL
_DLL: 动态连接 CRT (DLL)，对应 /MD、/MDd 编译选项
_MT: CRT 多线程支持，目前 4 种 CRT 连接方式 /MD、/MDd、/MT、/MTd 都支持多线程（VC 2005 已没有单线程版 CRT），加上建立 DLL 模块的 /LD、/LDd，都定义 _MT
_MANAGED: 以 /clr、/clr:pure、/clr:safe 托管方式编译时，定义为 1
__cplusplus_cli: 以 /clr、/clr:pure、/clr:safe 方式编译时定义，VC 2005 中定义为 200406L

上面 一、二、3 类宏一般和条件编译预处理指令 #if/#ifdef/#ifndef 配合使用

辅助类^

__VA_ARGS__: 在函数式宏中，表明变长部分参数 (...)，参考 MSDN: Variadic Macros

__COUNTER__: include 展开编译单元后，编译时第一次遇到 __COUNTER__ 替换为 0，之后在这个编译每遇到一次 __COUNTER__ 自增一。不一样的编译单元之间 __COUNTER__ 不互相积累叠加，均从 0 开始计数，但预编译头 .pch 文件会记录 __COUNTER__ 的历史值，则每一个编译单元均从历史值 + 1 开始计数。__COUNTER__ 支持宏的嵌套展开

__FUNCTION__, __FUNCDNAME__, __FUNCSIG__: 表示所在函数的函数名的 char 字符串。例如，对于 void test_funcname_macro() 函数原型，它们的值以下：

(1). __FUNCTION__ = test_funcname_macro: 函数的原始名/非修饰名 (undecorated)
(2). __FUNCDNAME__ = ?test_funcname_macro@@YAXXZ: 函数的修饰名 (decorated)，可用工具 undname "decorated_name" 得出函数原型和调用规范，即 __FUNCSIG__ 所表示的
(3). __FUNCSIG__ = void __cdecl test_funcname_macro(void): 函数的 signature 名，即调用约定、返回值类型、参数类型

例子：用 __VA_ARGS__ 打印跟踪函数调用^

这个 CALL_TRACE 功能不实用，只为说明 __VA_ARGS__ 用法：

源码打印？

  1. // 针对参数不为 void，且须要保存返回值的函数  

  2. #define CALL_TRACE(func, ret, ...)      { _tprintf(_T("call: %s\n"), _TSTRINGIZE(func)); ret = func(__VA_ARGS__); }  

  3. // 针对返回值为 void 或不关心返回值的函数  

  4. #define CALL_TRACE_VOID(func, ...)      { _tprintf(_T("call: %s\n"), _TSTRINGIZE(func)); func(__VA_ARGS__); }  

  5.   

  6. // 针对参数为 void 的函数  

  7. // NOTE: 函数 func() 使用 func(__VA_ARGS__) 展开时，会影响前面的变长参数函数 _tprintf()，  

  8. // 致使运行时缓冲区访问违例（Debug 方式产生保护中断），因此不能用前两版带 func(__VA_ARGS__) 的 CALL_TRACE  

  9. #define CALL_TRACE_VOIDPARM(func, ret)  { _tprintf(_T("call: %s\n"), _TSTRINGIZE(func)); ret = func(); }  

  10.   

  11. // 针对返回值、参数均为 void 的函数  

  12. #define CALL_TRACE_VOID_VOIDPARM(func)  { _tprintf(_T("call: %s\n"), _TSTRINGIZE(func)); func(); }  

  13.   

  14. // 用户代码  

  15. // Unicode 方式编译时，输出 call: CreateFileW，并将返回值传给 hFile  

  16. CALL_TRACE_RET(CreateFile, hFile, _T("bbb"), 0, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);  

例子：用 __VA_ARGS__ 格式化 std::string^

源码打印？

  1. namespace std  

  2. {  

  3. typedef std::basic_string<_TCHAR>   _tstring;  

  4. }  

  5.   

  6. #define FORMAT_STRING(str, buf, sz, ...)    { sprintf_s(buf, sz, __VA_ARGS__); str = buf; }  

  7. #define FORMAT_WSTRING(str, buf, sz, ...)   { swprintf_s(buf, sz, __VA_ARGS__); str = buf; }  

  8. #define FORMAT_TSTRING(str, buf, sz, ...)   { _stprintf_s(buf, sz, __VA_ARGS__); str = buf; }  

  9.   

  10. // 用户代码  

  11. _TCHAR buf[512];  

  12. _tstring str;  

  13. FORMAT_TSTRING(str, buf, _countof(buf), _T("%s is: %f"), _T("Pi"), M_PI);  

例子：用 __COUNTER__ 计数值定义掩码常量^

这种方法限制不少，并不实用，如 MyMask 以后再定义另外一个掩码列举型时，会从 __COUNTER__ 的历史值而非 0 开始：

源码打印？

  1. // 保证 MAKE_MASK 在全部其它使用 __COUNTER__ 代码以前，这样才能  

  2. // 保证第一次 MAKE_MASK 时，产生 2 << 0  

  3. #define MAKE_MASK0(maskname)    maskname = 1  

  4. #define MAKE_MASK(maskname)     maskname = (2 << __COUNTER__)   // 说明 __COUNTER__ 是支持嵌套展开的  

  5.   

  6. // 用户代码  

  7. enum MyMask  

  8. {  

  9.     MAKE_MASK0(MASK_0), //  2^0:    1  

  10.     MAKE_MASK(MASK_1),  //  2^1:    2 << 0  

  11.     MAKE_MASK(MASK_2),  //  2^2:    2 << 1  

  12.     MAKE_MASK(MASK_3),  //  2^3:    2 << 2  

  13.     MAKE_MASK(MASK_4)   //  2^4:    2 << 3  

  14.     // 最大 MASK = MASK_31  2^31:   2 << 30  

  15. };  

例子：用 __FUNCTION__ 打印跟踪函数调用^

源码打印？

  1. #define BEGIN_FUNC  _tprintf(_T("%s BEGIN\n"), _T(__FUNCTION__));  

  2. #define END_FUNC    _tprintf(_T("%s END\n"), _T(__FUNCTION__));  

  3.   

  4. // 用户代码  

  5. void test_funcname_macro()  

  6. {  

  7.     BEGIN_FUNC  

  8.     // 函数的功能代码  

  9.     END_FUNC  

  10. }  

Windows API 中的注释性宏^

注释性宏，便是否使用它们不影响编译结果，一般定义为空

目的：

(1). 在源代码中起到注解 (annotation) 和标注 (marker) 做用，便于阅读和理解代码功能
(2). 指导 lint 等静态代码检查工具检查代码缺陷
(3). 指导文档自动生成工具扫描源文件，生成类、函数/API 参考文档

如 WinDef.h 中定义的 IN、OUT、OPTIONAL 用来讲明函数参数或类型成员的传入、传出、可选性质

sal.h 中有更完整和复杂的注释性宏，SAL (Source code Annotation Language) 参考 sal.h 源文件和 MSDN: SAL Annotations

Windows API 和 CRT 都用 SAL 注释，几个经常使用的以下：

__in: 传入参数
__out: 传出参数
__inout: 传入且传出参数
__in_opt, __out_opt, __inout_opt: 可选参数，能够为 NULL

如 CreateFileW() 的声明：

源码打印？

  1. // WinBase.h  

  2.   

  3. WINBASEAPI  

  4. __out  

  5. HANDLE  

  6. WINAPI  

  7. CreateFileW(  

  8.     __in     LPCWSTR lpFileName,  

  9.     __in     DWORD dwDesiredAccess,  

  10.     __in     DWORD dwShareMode,  

  11.     __in_opt LPSECURITY_ATTRIBUTES lpSecurityAttributes,  

  12.     __in     DWORD dwCreationDisposition,  

  13.     __in     DWORD dwFlagsAndAttributes,  

  14.     __in_opt HANDLE hTemplateFile  

  15.     );  

Windows API 中的经常使用宏^

Windows API 包含大量旗标、掩码、状态码、错误码等常量式宏

函数式宏最经常使用的有：

类型辅助类^

BYTE    HIBYTE(WORD wValue)
BYTE    LOBYTE(WORD wValue)

WORD    HIWORD(DWORD dwValue)
WORD    LOWORD(DWORD dwValue)
WORD    MAKEWORD(BYTE bLow, BYTE bHigh)

LONG    MAKELONG(WORD wLow, WORD wHigh)
LRESULT MAKELRESULT(WORD wLow, WORD wHigh)
LPARAM  MAKELPARAM(WORD wLow, WORD wHigh)
WPARAM  MAKEWPARAM(WORD wLow, WORD wHigh)

GDI 类^

DWORD       MAKEROP4(DWORD fore, DWORD back): used in MaskBlt()

LONG        DIBINDEX(WORD wColorTableIndex)
COLORREF    PALETTEINDEX(WORD wPaletteIndex)

COLORREF    PALETTERGB(BYTE bRed, BYTE bGreen, BYTE bBlue)
COLORREF    RGB(BYTE byRed, BYTE byGreen, BYTE byBlue)

BYTE        GetBValue(DWORD rgb)
BYTE        GetGValue(DWORD rgb)
BYTE        GetRValue(DWORD rgb)

POINTS      MAKEPOINTS(DWORD dwValue)

另外，BITMAP_WIDTHBYTES(bits) 不在 Windows API 中，但比较经常使用于位图：

源码打印？

  1. // 输入：位图图像中一行的逻辑位数 = 位图像素宽 x 每像素位数  

  2. // 输出：位图图像中一行占用的字节数，按 4 Bytes 对齐  

  3. #define BITMAP_WIDTHBYTES(bits)     (((bits) + 31) >> 5 << 2)  

错误处理类^

标记没有使用的参数、变量辅助宏^

UNREFERENCED_PARAMETER(P)
DBG_UNREFERENCED_PARAMETER(P)
DBG_UNREFERENCED_LOCAL_VARIABLE(V)

让没有使用的参数、变量不产生编译警告，而且关闭 lint 缺陷检查报告

错误码、状态码^

Windows 有三大错误码、状态码空间：

(1). Win32 状态码：GetLastError() 所返回，DWORD 类型，WinError.h 中定义
(2). COM 状态码：COM 函数用，HRESULT 类型，WinError.h 中定义
(3). 内核状态码：内核函数和低级 API 用，NTSTATUS 类型，ntstatus.h 中定义

状态码有关的宏：

MAKE_HRESULT(sev, fac, code): 将 severity、facility、code 合并为 HRESULT
HRESULT_CODE(hr): 取得 HRESULT 的 code 部分
HRESULT_FACILITY(hr): 取得 HRESULT 的 facility 部分
HRESULT_SEVERITY(hr): 取得 HRESULT 的 severity 位

HRESULT_FROM_NT(nt_stat): 从 NTSTATUS 变换到 HRESULT
HRESULT_FROM_WIN32(win_err): 从 Win32 状态码变换到 HRESULT

SUCCEEDED(hr): HRESULT 是否表示成功
FAILED(hr): HRESULT 是否表示失败
IS_ERROR(hr): HRESULT 是否表示一个错误

Win32 状态码没有相似 MAKE_HRESULT 的宏，自定义 Win32 状态码时能够用 mc (Message Compiler) 工具处理 .mc 脚本，自动生成含自定义 Win32 状态码的头文件，同时生成用于 FormatMessage() 的状态码文本描述，参考 MSDN:Message Compiler

也能够自定义用于 Win32 状态码的 MAKE_WINERR()：

源码打印？

  1. //  copy from WinError.h  

  2. //  

  3. //  Values are 32 bit values layed out as follows:  

  4. //  

  5. //   3 3 2 2 2 2 2 2 2 2 2 2 1 1 1 1 1 1 1 1 1 1  

  6. //   1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0  

  7. //  +---+-+-+-----------------------+-------------------------------+  

  8. //  |Sev|C|R|     Facility          |               Code            |  

  9. //  +---+-+-+-----------------------+-------------------------------+  

  10. //  

  11. //  where  

  12. //  

  13. //      Sev - is the severity code  

  14. //  

  15. //          00 - Success  

  16. //          01 - Informational  

  17. //          10 - Warning  

  18. //          11 - Error  

  19. //  

  20. //      C - is the Customer code flag  

  21. //  

  22. //      R - is a reserved bit  

  23. //  

  24. //      Facility - is the facility code  

  25. //  

  26. //      Code - is the facility's status code  

  27. //  

  28.   

  29. // Win32 状态码的各部分起始位、位掩码和位长度  

  30.   

  31. #define WINERR_SEVERITY_BIT_LOW         30  

  32. #define WINERR_SEVERITY_MASK            0xC0000000  

  33. #define WINERR_SEVERITY_BIT_LEN         2  

  34. #define WINERR_SEVERITY_VALUE(val)      (((val) << WINERR_SEVERITY_BIT_LOW) & WINERR_SEVERITY_MASK)  

  35.   

  36. #define WINERR_CUSTOM_DEFINE_BIT_LOW    29  

  37. #define WINERR_CUSTOM_DEFINE_MASK       0x20000000  

  38. #define WINERR_CUSTOM_DEFINE_BIT_LEN    1  

  39. #define WINERR_CUSTOM_DEFINE_FLAG       (1 << WINERR_CUSTOM_DEFINE_BIT_LOW)  

  40.   

  41. #define WINERR_FACILITY_BIT_LOW         16  

  42. #define WINERR_FACILITY_MASK            0x0FFF0000  

  43. #define WINERR_FACILITY_BIT_LEN         12  

  44. #define WINERR_FACILITY_VALUE(val)      (((val) << WINERR_FACILITY_BIT_LOW) & WINERR_FACILITY_MASK)  

  45.   

  46. #define WINERR_CODE_BIT_LOW             0  

  47. #define WINERR_CODE_MASK                0x0000FFFF  

  48. #define WINERR_CODE_BIT_LEN             16  

  49. #define WINERR_CODE_VALUE(val)          (val) & WINERR_CODE_MASK  

  50.   

  51. // Win32 状态码中的严重级别 severity  

  52.   

  53. #define WINERR_SEVERITY_SUCCESS         0  

  54. #define WINERR_SEVERITY_INFORM          1  

  55. #define WINERR_SEVERITY_WARNING         2  

  56. #define WINERR_SEVERITY_ERROR           3  

  57. #define WINERR_SEVERITY_NOT_CARE        3  

  58.   

  59. // 自定义 Win32 状态码的宏  

  60. #define MAKE_WINERR(sev, fac, code)     \  

  61.     ((DWORD)(WINERR_SEVERITY_VALUE(sev) | WINERR_CUSTOM_DEFINE_FLAG | WINERR_FACILITY_VALUE(fac) | WINERR_CODE_VALUE(code)))  

调用规范类^

调用规范/约定参考 MSDN: Calling Conventions

Windows API 使用的调用规范名称宏，在 WinDef.h 中定义：

源码打印？

  1. #define CALLBACK    __stdcall  

  2. #define WINAPI      __stdcall  

  3. #define WINAPIV     __cdecl  

  4. #define APIENTRY    WINAPI  

  5. #define APIPRIVATE  __stdcall  

  6. #define PASCAL      __stdcall  

COM 经常使用的调用规范辅助宏：

EXTERN_C: C 连接约定

STDAPI: __stdcall，C 连接约定，返回 HRESULT
STDAPI_(type): __stdcall，C 连接约定，返回 type 类型

STDMETHOD(method): __stdcall，返回 HRESULT 的类成员虚函数
STDMETHOD_(type, method): __stdcall，返回 type 类型的类成员虚函数
STDMETHODIMP: __stdcall，返回 HRESULT，对应 STDMETHOD(method) 实现
STDMETHODIMP_(type): __stdcall，返回 type 类型，对应 STDMETHOD_(type, method) 实现

国际化类^

WORD    LANGIDFROMLCID(LCID lcid)
WORD    MAKELANGID(USHORT primaryLang, USHORT subLang)
DWORD   MAKELCID(WORD langID, WORD sortID)
DWORD   MAKESORTLCID(WORD langID, WORD sortID, WORD sortVersion)
WORD    PRIMARYLANGID(WORD lgid)
WORD    SORTIDFROMLCID(LCID lcid)
WORD    SORTVERSIONFROMLCID(LCID lcid)
WORD    SUBLANGID(WORD lgid)

资源类^

LPTSTR  MAKEINTRESOURCE(WORD wInt)
BOOL    IS_INTRESOURCE(WORD wInt)

网络类^

LPARAM  MAKEIPADDRESS(BYTE b0, BYTE b1, BYTE b2, BYTE b3)
BYTE    FIRST_IPADDRESS(LPARAM lParam)
BYTE    SECOND_IPADDRESS(LPARAM lParam)
BYTE    THIRD_IPADDRESS(LPARAM lParam)
BYTE    FOURTH_IPADDRESS(LPARAM lParam)
LPARAM  MAKEIPRANGE(BYTE low, BYTE high)

字符串化操做符 #^

将代码中某个名字转换为字符串字面量，即“加引号”，参考 MSDN: Stringizing Operator

用 # 操做构造字符串化宏 STRINGIZE^

源码打印？

  1. #define __STRINGIZE(x)  # x  

  2. #define _STRINGIZE(x)   __STRINGIZE(x)  

  3. #define _TSTRINGIZE(x)  _T(_STRINGIZE(x))  

说明：

(1). # x 产生的是 char 字符串，非 wchar_t 字符串，需配合 _T() 使用

(2). _MACRO() 再次调用 __MACRO() 是一种针对 # 和 ## 操做的经常使用编写技巧。由于 #、## 操做比较特殊，当它处于宏体中时，不会进行嵌套展开，如 __TSTRINGIZE(NULL) 展开为 "NULL" 而非 "0"，要想嵌套展开，再定义一层 _STRINGIZE() 调用 __STRINGIZE() 便可，_TSTRINGIZE(NULL) 展开为 "0"

CRT 中的 STRINGIZE 定义^

CRT 中有相似上面的 STRINGIZE()，以及宽字符化字面量宏 _CRT_WIDE() 的定义：

源码打印？

  1. // crtdefs.h  

  2. #ifndef _CRT_STRINGIZE  

  3. #define __CRT_STRINGIZE(_Value) #_Value  

  4. #define _CRT_STRINGIZE(_Value) __CRT_STRINGIZE(_Value)  

  5. #endif  

  6.   

  7. #ifndef _CRT_WIDE  

  8. #define __CRT_WIDE(_String) L ## _String  

  9. #define _CRT_WIDE(_String) __CRT_WIDE(_String)  

  10. #endif  

STRINGIZE 的展开规则^

1. 若是 _STRINGIZE() 的参数是宏，那么宏表明的实际值也将被展开，即嵌套展开

例子：用 STRINGIZE 查看宏的展开结果^

查看某个宏在当前编译配置 (Debug/Release, ANSI/Unicode) 下，实际表示的东西，如某个 _t 系列函数、Windows API 究竟表示哪一个函数，能够利用 _STRINGIZE()：

源码打印？

  1. // 将输出实际的行号、数字，而非字符串 "__LINE__"、"MAX_PATH"  

  2. _tprintf(_T("Line: %s\n"), _TSTRINGIZE(__LINE__));  

  3. _tprintf(_T("MAX_PATH: %s\n"), _TSTRINGIZE(MAX_PATH));  

  4.   

  5. // 判断宏的当前值、调用了哪一个版本的 _t 系列函数、Windows API  

  6. _tprintf(_T("_DEBUG: %s, _UNICODE: %s\n"), _TSTRINGIZE(_DEBUG), _TSTRINGIZE(_UNICODE));  

  7. _tprintf(_T("_tprintf: %s\n"), _TSTRINGIZE(_tprintf));  

  8. _tprintf(_T("CreateFile: %s\n"), _TSTRINGIZE(CreateFile));  

输出结果：

Line: 24
MAX_PATH: 260
_DEBUG: 1, _UNICODE: 1
_tprintf: wprintf
CreateFile: CreateFileW

2. 若是 _STRINGIZE() 的参数单纯的变量、函数、类型、const、enum 常量，那么只是将 _STRINGIZE() 括号中的东西加引号而已，以下：

源码打印？

  1. // 非 const、其它内部类型 double、char，结果都同样  

  2. const int val = 260;  

  3.   

  4. // 枚举常量  

  5. enum MUSIC_STATE  

  6. {  

  7.     ST_STOP,  

  8.     ST_PLAY,  

  9.     ST_PAUSE,  

  10.     ST_BUTT  

  11. };  

  12.   

  13. // 自定义结构、类  

  14. ClassTest obj;  

  15.   

  16. // 函数  

  17. void func(int a);  

  18.   

  19. // 下面输出 _TSTRINGIZE() 括号中名字加上引号获得的字符串，而非实际变量值  

  20. _tprintf(_T("int: %s, val: %s\n"), _TSTRINGIZE(int), _TSTRINGIZE(val));  

  21. _tprintf(_T("MUSIC_STATE: %s, ST_STOP: %s\n"), _TSTRINGIZE(MUSIC_STATE), _TSTRINGIZE(ST_STOP));  

  22. _tprintf(_T("ClassTest: %s, obj: %s\n"), _TSTRINGIZE(ClassTest), _TSTRINGIZE(obj));  

  23. _tprintf(_T("func: %s\n"), _TSTRINGIZE(func));  

输出结果：

int: int, val: val
MUSIC_STATE: MUSIC_STATE, ST_STOP: ST_STOP
ClassTest: ClassTest, obj: obj
func: func

拼接操做符 ##^

将代码中两个名字拼接到一块儿，造成一个名字。## 操做“不加引号”，参考 MSDN: Token-Pasting Operator

源码打印？

  1. #define __CONCAT(x, y)  x ## y  

  2. #define _CONCAT(x, y)   __CONCAT(x, y)  

## 与 # 同样对其操做数不进行嵌套展开，因此 __CONCAT(aaa, __CONCAT(bbb, ccc)) 的展开结果是 aaa__CONCAT(bbb, ccc)，而 _CONCAT(aaa, _CONCAT(bbb, ccc)) 的展开结果是 aaabbbccc。## 的结果是名字拼接，而不是字符串字面量，即不是 "aaabbbccc"

一般用 ## 操做拼接构造类型、变量、函数的名字

例子：_T() 的定义^

源码打印？

  1. // tchar.h  

  2. #ifdef _UNICODE  

  3. #define __T(x)      L ## x  

  4. #else  

  5. #define __T(x)      x  

  6.   

  7. #define _T(x)       __T(x)  

例子：Windows API 通用句柄类型的定义^

源码打印？

  1. // winnt.h  

  2. typedef void *HANDLE;  

  3. #define DECLARE_HANDLE(name) struct name##__ { int unused; }; typedef struct name##__ *name  

  4.   

  5. // 所以多数 Windows 句柄是指向桩结构的指针，如 HWND：  

  6.   

  7. // windef.h  

  8. DECLARE_HANDLE  (HWND);  

  9.   

  10. // HWND 定义展开后是：  

  11. struct HWND__  

  12. {  

  13.     int unused;  

  14. };  

  15. typedef struct HWND__ *HWND;  

例子：用 ## 构造函数名^

源码打印？

  1. // 音乐播放状态常量  

  2. enum MUSIC_STATE  

  3. {  

  4.     ST_STOP,  

  5.     ST_PLAY,  

  6.     ST_PAUSE,  

  7.     ST_BUTT  

  8. };  

  9.   

  10. // 音乐播放状态结构  

  11. // 里面有一个用于处理特定状态的回调函数 stat_proc  

  12. typedef struct _MusicState  

  13. {  

  14.     MUSIC_STATE     stat;  

  15.     const _TCHAR*   stat_name;  

  16.     int             (*stat_proc)(void*);  

  17. } MusicState;  

  18.   

  19. // 处理特定音乐播放状态的函数  

  20. // 函数名的统一形式 proc_ ## stat，stat 是状态常量的名字  

  21. int proc_ST_STOP(void*);  

  22. int proc_ST_PLAY(void*);  

  23. int proc_ST_PAUSE(void*);  

  24.   

  25. // 初始化音乐播放状态结构  

  26. #define INIT_MUSIC_STATE(stat)  {stat, _TSTRINGIZE(stat), proc_ ## stat}  

  27.   

  28. MusicState g_MusicState[ST_BUTT] =  

  29. {  

  30.     INIT_MUSIC_STATE(ST_STOP),  

  31.     INIT_MUSIC_STATE(ST_PLAY),  

  32.     INIT_MUSIC_STATE(ST_PAUSE)  

  33. };  

TCHAR 统一字符类型和处理^

_TCHAR、_T()、_t 系列函数等东西叫作 Generic-Text Mapping，即便用宏进行统一字符类型编写，在不一样的字符集编码工程配置 ANSI/UNICODE/MBCS 下替换为不一样的实际函数或类型，参考 MSDN:Generic-Text Mappings,Using Generic-Text Mappings, Using TCHAR.H Data Types with _MBCS

工程的字符集配置的宏定义：

ANSI (SBCS, ASCII): _UNICODE 和 _MBCS 均未定义，使用 char 单字节字符集编码
UNICODE: _UNICODE 定义，使用 wchar_t 宽字符集编码，VC 默认 wchar_t 2 字节
MBCS: _MBCS 定义，使用 char 变长字符集编码，一个字符占一个或多个 char

_TCHAR, _TEXT()/_T(), _t 系列函数^

根据 _UNICODE、_MBCS 的定义，调用 ANSI/UNICODE/MBCS 不一样字符集版本的 CRT 函数，或产生字面量，多在 tchar.h 中声明。_t 字符操做函数参考 MSDN:String Manipulation (CRT)

TCHAR, LPTSTR/LPCTSTR, TEXT(), A/W 版本 Windows API^

根据 UNICODE 的定义，调用 ANSI/UNICODE 不一样字符集版本的 Windows API，或产生字面量，多在 WinBase.h、Windows.h 中声明

不成文约定：带 _ 前缀的代码，一般对应 CRT，而不带 _ 前缀的东西，一般对应 Windows API。A/W 版本 API 都是接收字符串参数的函数，但并不是全部接收字符串的 API 都有 A/W 两个版本，如 GetProcAddress() 只是 A 版本函数，由于 DLL 中的导出符号用 ASCII 英文足够了

宏的缺点和替代方法^

宏是预编译行为，所作的是名字替换，它的缺点和替代方法以下：

宏难于调试^

编译时，宏不会产生用于调试的名字符号。如 #define MAX_PATH 260，在调试时，没法找到其符号名 MAX_PATH，而只是 260 数字

常量式宏能够用 const 和 enum 代替，在调试中能够查看 const、enum 的符号名，而且 const、enum 和宏的运行时开销是相同的（有使用 const、enum 时才会分配内存）：

源码打印？

  1. const char* DEF_FILENAME = "default.txt";  

  2.   

  3. enum BUF_SIZE  

  4. {  

  5.     BUF_SIZE_SMALL      = 64,  

  6.     BUF_SIZE_MEDIUM     = 256,  

  7.     BUF_SIZE_LARGE      = 1024  

  8. };  

另外，在 VC 2005 中，进行 C/C++ 源码级别调试时，函数式宏没法像 inline 或普通函数同样使用 Step into 进入宏定义体的代码，宏调用被视为一条语句，只能使用 Go To Definition (F12) 跳转到宏定义处查看代码，而不能调试

宏的使用缺陷^

(1). 宏以字面形式展开，有反作用，典型的有两种：

(a). 宏参数不加括号展开时改变逻辑，如 #define RECT_AREA(x, y) (x * y)

解决方法：定义宏时给参数的使用加上括号，如 #define RECT_AREA(x, y) ((x) * (y))

(b). 宏体为多行语句，若是放到判断语句中，而且不加 {} 包起来，只有第一句在判断语句下执行，其它在判断语句外，以下例：

源码打印？

  1. #define SWAP(v1, v2, tmp)   \  

  2.     tmp = v1;               \  

  3.     v1 = v2;                \  

  4.     v2 = tmp;  

  5.   

  6. // 用户代码  

  7. if (condition)  

  8.     SWAP(a, b, t);  // 逻辑问题  

  9.   

  10. if (condition) {  

  11.     SWAP(a, b, t);  // OK  

  12. }  

解决方法：定义宏时用 {} 或 do {} while(0) 包起来，以下：

源码打印？

  1. #define SWAP(v1, v2, tmp)   \  

  2.     do {                    \  

  3.         tmp = v1;           \  

  4.         v1 = v2;            \  

  5.         v2 = tmp;           \  

  6.     } while (0)  

(2). 宏对参数没有类型检查，宏的返回也不具备类型

(3). 函数式宏，不是函数，不能将其宏名做为函数指针，即不能进行函数回调；也不能进行递归调用

函数式宏大多能用 inline 函数 + 函数 template 的方式代替，并保持相同的运行时开销。但由于 inline 函数是一种 尽力而为 (Try My Best) 的编译器指示（inline 函数不必定 inline 化，inline 化的程度也不一样），实际的开销根据 inline 函数调用复杂程度（是否有递归、做为函数指针）、不一样编译器、不一样的工程配置（Debug/Release、编译选项、编译优化级别），inline 化有所不一样

参考 MSDN: Inline Functions versus Macros

宏形成全局名字空间污染^

宏是全局名字空间的，容易形成名字污染、干扰，可用 const、enum、inline 解决。以下：

源码打印？

  1. class TestClass1  

  2. {  

  3. private:  

  4.     int m_Val;  

  5.   

  6. // private 限制对宏 MACRO_DEF_VAL 不起做用  

  7. #define MACRO_DEF_VAL   128  

  8.   

  9. public:  

  10.     static const int CONST_DEF_VAL = 128;  

  11.     enum { ENUM_DEF_VAL = 128 };  

  12. };  

  13.   

  14. class TestClass2  

  15. {  

  16. private:  

  17.     int m_Val;  

  18.   

  19. // 产生 C4005 警告：MACRO_DEF_VAL 被重复定义  

  20. #define MACRO_DEF_VAL   256  

  21.   

  22. public:  

  23.     static const int CONST_DEF_VAL = 256;  

  24.     enum { ENUM_DEF_VAL = 256 };  

  25. };  

  26.   

  27. // 用户代码  

  28.   

  29. // 宏 MACRO_DEF_VAL 是全局的，不能写为 TestClass1::MACRO_DEF_VAL  

  30. _tprintf(_T("TestClass1: %d, %d, %d\n"), MACRO_DEF_VAL, TestClass1::CONST_DEF_VAL, TestClass1::ENUM_DEF_VAL);  

  31. _tprintf(_T("TestClass2: %d, %d, %d\n"), MACRO_DEF_VAL, TestClass2::CONST_DEF_VAL, TestClass2::ENUM_DEF_VAL);  

输出结果：

后面定义的宏 MACRO_DEF_VAL 的值将前面的覆盖了：

TestClass1: 256, 128, 128
TestClass2: 256, 256, 256

优先使用宏的状况^

不是全部的宏都能用 const、enum、inline 函数代替：

(1). 对于一些不对应单个函数、变量、常量，而且编码量大、结构重复的整块代码，宏是最合适的选择，如 MFC 的 RTTI 支持和消息映射结构

(2). 如 例子：C/C++ 预约义宏的取值 “说明 (2)”中所示，须要嵌套展开 __FILE__、__LINE__、__FUNCTION__ 等预约义宏的状况，必需用宏，而不能用 inline 函数

条件编译^

#if/#else/#elif/#ifdef/#ifndef/#if defined/#if !defined

#ifdef XXX 等价于 #if defined (XXX)
#ifndef XXX 等价于 #if !defined (XXX)

参考 MSDN: The #if, #elif, #else, and #endif Directives

例子：注释大量代码^

源码打印？

  1. #if 0  

  2. XXXXXXXXX  

  3. #endif  

  4.   

  5. #if FALSE  

  6. XXXXXXXXX  

  7. #endif  

例子：MFC 中的调试版代码示例^

见上文“MFC 的调试版 new”

AssertValid() 参考 MSDN: MFC ASSERT_VALID and CObject::AssertValid

源码打印？

  1. // FrameWindow、Doc、View 等类都可覆盖如下用于调试的诊断函数  

  2. // 而后能够用 ASSERT_VALID() 诊断其对象状态是否有效  

  3.   

  4. #ifdef _DEBUG  

  5.     virtual void AssertValid() const;  

  6.     virtual void Dump(CDumpContext& dc) const;  

  7. #endif  

  8.   

  9. // Release 版本的 GetDocument() 是 inline 的  

  10. #ifndef _DEBUG  

  11. inline CMyDoc* CMyView::GetDocument() const  

  12. {  

  13.     return reinterpret_cast<CMyDoc*>(m_pDocument);  

  14. }  

  15. #endif  

例子：DLL 工程导出符号^

工程 DllProj 中导出符号（变量、函数、类）的方法：在工程中定义宏 DLLPROJ_EXPORTS (/D "DLLPROJ_EXPORTS")，并在使用工程中保证没有定义 DLLPROJ_EXPORTS

DllProj 导出符号的声明文件 DllProj.h 以下，在使用工程中 #include 该文件：

源码打印？

  1. // DllProj.h  

  2.   

  3. #ifndef _DLLPROJ_H_  

  4. #define _DLLPROJ_H_  

  5.   

  6. #ifdef DLLPROJ_EXPORTS  

  7. #define DLLPROJ_API __declspec(dllexport)  

  8. #else  

  9. #define DLLPROJ_API __declspec(dllimport)  

  10. #endif  

  11.   

  12. #ifdef __cplusplus  

  13. #define EXTERN_C        extern "C"  

  14. #define EXTERN_C_BEGIN  extern "C" {  

  15. #define EXTERN_C_END    }  

  16. #else   // __cplusplus defined  

  17. #define EXTERN_C        extern  

  18. #define EXTERN_C_BEGIN  

  19. #define EXTERN_C_END  

  20. #endif  // __cplusplus NOT defined  

  21.   

  22. // 导出类  

  23. class DLLPROJ_API TestClass  

  24. {  

  25. public:  

  26.     TestClass();  

  27. };  

  28.   

  29. // 导出全局变量，以 C 的连接方式（修饰名、调用约定）  

  30. EXTERN_C DLLPROJ_API int g_TestVal;  

  31.   

  32. // 导出函数  

  33. DLLPROJ_API int TestFunc();  

  34.   

  35. #endif  // _DLLPROJ_H_  

例子：用 #undef 解决 wxWidgets 自定义事件连接 BUG^

BUG 参考：wxEvent derived event,Custom Events

BUG 触发条件：以 DLL 方式使用 wxWidgets Windows 版本，即定义了 WXUSINGDLL，使用 DECLARE_EVENT_TYPE() 定义自定事件

BUG 表现：以 __declspec(dllimport) 修饰事件标识，实际上事件标识应该是一个模块内变量，而非导入变量，出现连接问题。MinGW GCC 4 报连接错误，VC 2005 报连接警告：warning C4273: inconsistent dll linkage。BUG 的具体缘由请跟踪 wxWidgets 源码 event.h 中的 DECLARE_EVENT_TYPE() 和 dlimpexp.h 中的 WXDLLIMPEXP_CORE 定义

BUG 典型工程：开源下载器 MultiGet svn version 3

BUG 解决方法：

方法 1. 不使用旧的 DECLARE_EVENT_TYPE() 而使用 DECLARE_LOCAL_EVENT_TYPE() 定义自定事件
方法 2. 使用 DECLARE_EVENT_TYPE() 先后包含 undefine_WXDLLIMPEXP_CORE.h、redefine_WXDLLIMPEXP_CORE.h 头文件，以便取消和重定义 WXDLLIMPEXP_CORE

方法 2 中的 undefine_WXDLLIMPEXP_CORE.h、redefine_WXDLLIMPEXP_CORE.h 以及使用方法以下：

源码打印？

  1. // undefine_WXDLLIMPEXP_CORE.h  

  2.   

  3. // 不要用 #pragma once 等包含一次技巧，由于一个源文件中可能有多个  

  4. // BEGIN_DECLARE_EVENT_TYPES 自定义事件块，这时要屡次包含本文件  

  5.   

  6. #ifdef WXDLLIMPEXP_CORE  

  7. #   define REMOVE_WXDLLIMPEXP_CORE  

  8. #   undef WXDLLIMPEXP_CORE      // 先取消 WXDLLIMPEXP_CORE 定义  

  9. #   define WXDLLIMPEXP_CORE     // 再将其定义为空  

  10. #endif  

源码打印？

  1. // redefine_WXDLLIMPEXP_CORE.h  

  2.   

  3. // 不要用 #pragma once 等包含一次技巧  

  4.   

  5. #ifdef REMOVE_WXDLLIMPEXP_CORE  

  6. #   undef WXDLLIMPEXP_CORE  

  7. // 如下块拷贝自 wx-2.8.10 dlimpexp.h，用于恢复 WXDLLIMPEXP_CORE 的原有定义  

  8. // BEGIN  

  9. #   ifdef WXMAKINGDLL_CORE  

  10. #       define WXDLLIMPEXP_CORE WXEXPORT  

  11. #       define WXDLLIMPEXP_DATA_CORE(type) WXEXPORT type  

  12. #   elif defined(WXUSINGDLL)  

  13. #       define WXDLLIMPEXP_CORE WXIMPORT  

  14. #       define WXDLLIMPEXP_DATA_CORE(type) WXIMPORT type  

  15. #   else /* not making nor using DLL */  

  16. #       define WXDLLIMPEXP_CORE  

  17. #       define WXDLLIMPEXP_DATA_CORE(type) type  

  18. #   endif  

  19. // END  

  20. #   undef REMOVE_WXDLLIMPEXP_CORE  

  21. #endif  

源码打印？

  1. // 用户代码  

  2.   

  3. // 定义 WXDLLIMPEXP_CORE 为空  

  4. #include <undefine_WXDLLIMPEXP_CORE.h>  

  5.   

  6. // 自定义事件  

  7. BEGIN_DECLARE_EVENT_TYPES()  

  8.     DECLARE_EVENT_TYPE(wxEVENT_TEST_TRIGGERED, wxID_ANY)  

  9.     // DECLARE_LOCAL_EVENT_TYPE(wxEVENT_TEST_TRIGGERED, wxID_ANY)   // 用这个不会有 BUG  

  10. END_DECLARE_EVENT_TYPES()  

  11.   

  12. // 重定义 WXDLLIMPEXP_CORE  

  13. #include <redefine_WXDLLIMPEXP_CORE.h>  

说明：

(1). #undef 是 #define 的反操做，取消宏定义，而不是将宏定义为空。取消后的宏名能够再次定义，而不产生重定义问题
(2). 大量嵌套的 #if 条件编译结构，可以使用这种预处理缩进方法

预编译头文件^

预编译头文件 PCH (Precompiled Header) 是对某个编译单元的编译结果 (.pch)，一般这个编译单元命名为 [stdafx.cpp include => stdafx.h]（VC 工程标准）或 [common.cpp include => common.h]。与常规的编译结果 (.obj) 不一样的是，若是 .pch 的编译单元源码在两次工程编译期间不改变，则从新编译工程时，不会从新编译 .pch

PCH 的特色使它的源码如 stdafx.h，适合放入不多更改的代码，如标准库、运行时库、系统 API、第三方库的头文件，以及工程全局的设置和名字符号，在从新编译工程时，这些代码便不会从新编译，以加快编译速度

使用 PCH 的编译命令^

以 VC 工程标准的 [stdafx.cpp include => stdafx.h] 预编译头文件编译单元为例，产生、使用 PCH 的编译命令选项以下：

  • 对除了 stdafx.cpp 以外的其它编译单元 .c/.cpp（没有 .h/.hpp，.h/.hpp 是经过 #include 展开到 .c/.cpp 造成编译单元的），使用以下编译选项（Debug 工程配置），若是使用 VC IDE 则在工程属性页中设置：

    /Yu"stdafx.h" /Fp"Debug\ProjName.pch"

    /Yu 表示经过 stdafx.h 使用 PCH，/Fp 指定使用的 PCH 路径为 Debug\ProjName.pch

  • 对 stdafx.cpp，若是使用 VC IDE 则在 stdafx.cpp 的属性页中设置，使用以下编译选项：

    /Yc"stdafx.h" /Fp"Debug\ProjName.pch"

    /Yc 表示经过 stdafx.h 产生 PCH，/Fp 指定产生的 PCH 路径为 Debug\ProjName.pch

PCH 的详细方法参考 MSDN: Creating Precompiled Header Files

例子：典型的 MFC 工程预编译头 stdafx.h 代码^

源码打印？

  1. ////////////////////////////////////////////////////////////////////////////////  

  2. ///  

  3. /// @file       stdafx.h  

  4. /// @brief      Windows 标准预编译头文件  

  5. ///  

  6. /// 将标准库、运行时库、基本库、Windows API、第三方库的头文件在这里包含，生成  

  7. /// 预编译头文件 MFCBasic.pch  

  8. ///  

  9. /// 若是不修改 stdafx.h，增量编译时便不会从新编译 stdafx.h 中包含的头文件，这样  

  10. /// 加快了编译速度  

  11. ///  

  12. /// @version    <version>  

  13. /// @author     <author>  

  14. /// @date       2011-07  

  15. ///  

  16. /// Copyright (c) 2011, <company>  

  17. /// All rights reserved.  

  18. ///  

  19. ////////////////////////////////////////////////////////////////////////////////  

  20.   

  21. // 典型的“只包含一次”条件编译技巧  

  22. // VC cl 编译器版本 10 以上 (_MSC_VER > 1000) 也可使用 #pragma once 指令  

  23. #ifndef _STDAFX_H_  

  24. #define _STDAFX_H_  

  25.   

  26. // 排除不多使用的 Windows 头文件  

  27.   

  28. #define WIN32_LEAN_AND_MEAN     // 适用于 Windows API  

  29.   

  30. #ifndef VC_EXTRALEAN  

  31. #define VC_EXTRALEAN            // 适用于 MFC  

  32. #endif  

  33.   

  34. // 指定目标系统和环境 (Windows, IE) 的版本号  

  35.   

  36. #ifndef WINVER  

  37. #define WINVER          0x0501  // 目标系统具备 Windows XP 及以上特性  

  38. #endif  

  39.   

  40. #ifndef _WIN32_WINNT  

  41. #define _WIN32_WINNT    0x0501  // 目标系统具备 Windows XP 及以上特性  

  42. #endif  

  43.   

  44. #ifndef _WIN32_WINDOWS  

  45. #define _WIN32_WINDOWS  0x0410  // 目标系统具备 Windows 98 及以上特性  

  46. #endif  

  47.   

  48. #ifndef _WIN32_IE  

  49. #define _WIN32_IE       0x0600  // 目标系统具备 IE 6.0 及以上特性  

  50. #endif  

  51.   

  52. ////////////////////////////////////////////////////////////////////////////////  

  53. /// Include Header  

  54. ////////////////////////////////////////////////////////////////////////////////  

  55.   

  56. // C 标准库与运行时库 (CRT)  

  57. // BEGIN  

  58. //  

  59. #define _CRT_SECURE_NO_DEPRECATE    // 使用废弃 (deprecated) 的 CRT 函数时，不产生编译警告  

  60. #define _CRT_SECURE_NO_WARNINGS     // 典型的废弃函数有不带缓冲区大小检查的 strcpy()、strcat()、sprintf() 等  

  61.   

  62. #include <stdlib.h>  

  63. #include <tchar.h>  

  64. #include <crtdbg.h>  

  65. #include <string.h>  

  66. //  

  67. // END  

  68.   

  69. // C++ 标准库  

  70. // BEGIN  

  71. //  

  72. #include <exception>  

  73. #include <typeinfo>  

  74. //  

  75. // END  

  76.   

  77. // MFC 库  

  78. // BEGIN  

  79. //  

  80. #ifndef _SECURE_ATL  

  81. #define _SECURE_ATL 1                       // ATL/MFC 的安全设置  

  82. #endif  

  83.   

  84. #define _ATL_CSTRING_EXPLICIT_CONSTRUCTORS  // 使 ATL/MFC 的 CString 具备显式地构造函数 (explicit)  

  85.   

  86. #define _AFX_ALL_WARNINGS                   // 打开 MFC 的全部警告，包括通常能够安全忽略的警告  

  87.   

  88. #include <afxwin.h>     // MFC 核心和标准支持  

  89. #include <afxext.h>     // MFC 扩展支持  

  90.   

  91. #ifndef _AFX_NO_OLE_SUPPORT  

  92. #include <afxdtctl.h>   // MFC 的 IE 4 通用控件支持  

  93. #endif  

  94.   

  95. #ifndef _AFX_NO_AFXCMN_SUPPORT  

  96. #include <afxcmn.h>     // MFC 的 Windows 通用控件支持  

  97. #endif  

  98. //  

  99. // END  

  100.   

  101. // Windows API  

  102. // BEGIN  

  103. //  

  104. // #include <Windows.h>     // 使用 MFC 库时不要包含 Windows.h，MFC 头文件中已包含  

  105. #include <Winsock2.h>  

  106. //  

  107. // END  

  108.   

  109. // Windows 通用控件 ComCtl32.dll 版本 6.0 的内嵌 manifest  

  110. // BEGIN  

  111. //  

  112. #ifdef _UNICODE  

  113. #if defined _M_IX86  

  114. #pragma comment(linker, "/manifestdependency:\"type='win32' name='Microsoft.Windows.Common-Controls' version='6.0.0.0' processorArchitecture='x86' publicKeyToken='6595b64144ccf1df' language='*'\"")  

  115. #elif defined _M_IA64  

  116. #pragma comment(linker, "/manifestdependency:\"type='win32' name='Microsoft.Windows.Common-Controls' version='6.0.0.0' processorArchitecture='ia64' publicKeyToken='6595b64144ccf1df' language='*'\"")  

  117. #elif defined _M_X64  

  118. #pragma comment(linker, "/manifestdependency:\"type='win32' name='Microsoft.Windows.Common-Controls' version='6.0.0.0' processorArchitecture='amd64' publicKeyToken='6595b64144ccf1df' language='*'\"")  

  119. #else  

  120. #pragma comment(linker, "/manifestdependency:\"type='win32' name='Microsoft.Windows.Common-Controls' version='6.0.0.0' processorArchitecture='*' publicKeyToken='6595b64144ccf1df' language='*'\"")  

  121. #endif  

  122. #endif  // _UNICODE  

  123. //  

  124. // END  

  125.   

  126. #endif  // _STDAFX_H_  

经常使用预处理指令^

VC 支持的预处理指令参考 MSDN: Preprocessor Directives

#error 产生人工编译错误^

#error 产生 fatal error，编译器输出 #error 后的提示文本。指示该源文件必需使用 C++ 方式编译，以下：

源码打印？

  1. // test.cpp  

  2. #ifndef __cplusplus  

  3. #error MUST use C++ compilation  

  4. #endif  

以 C 语言方式编译上面源文件 (/Tc test.cpp) 时报错：

fatal error C1189: #error :  MUST use C++ compilation

#line 改变行号和源文件名^

#line 改变 __FILE__ 和 __LINE__ 的取值，例如：

源码打印？

  1. // 实际文件名：test_01.cpp  

  2. #line 1 "test_02.cpp"  

  3.     _tprintf(_T("File: %s, Line: %d\n"), _T(__FILE__), __LINE__);   // 实际第 200 行  

输出：

File: test_02.cpp, Line: 1

# 空指令^

没有做用的合法预处理指令行正则表达式：[\t ]*#[\t ]*

#pragma 预处理指令^

#pragma 是一组编译器特定的预处理指令，每种编译器的 #pragma 的子指令都有所不一样。VC 的 #pragma 指令参考 MSDN: Pragma Directives and the __Pragma Keyword

经常使用的 #pragma 指令以下：

#pragma once 只包含一次头文件^

对头文件只包含一次，以下：

源码打印？

  1. // test.h  

  2. #if _MSC_VER > 1000  

  3. #pragma once  

  4. #endif  

  5.   

  6. // 头文件中的代码  

它和传统的 #ifndef 只包含一次技巧的功能相同：

源码打印？

  1. // test.h  

  2. #ifndef _TEST_H_  

  3. #define _TEST_H_  

  4.   

  5. // 头文件中的代码  

  6.   

  7. #endif  // _TEST_H_  

在源文件中屡次 #include 包含 test.h 时，不会出现 redefinition 错误

#pragma message 编译时输出消息^

#pragma message 在编译过程当中，向标准输出或 VC 的 Output 窗口打印指定消息，做用：(1) 告知程序员代码编译和使用的注意事项 (2) 用于查看和诊断实际的编译代码

例子：用 #pragma message 和 STRINGIZE 查看宏的展开结果^

例 11 是用 STRINGIZE 在运行时输出宏的展开结果，其实在编译时也能够用 #pragma message 输出，诊断编译的实际代码：

源码打印？

  1. // 将输出实际的行号、数字，而非字符串 "__LINE__"、"MAX_PATH"  

  2. #pragma message("Line: " _STRINGIZE(__LINE__))  

  3. #pragma message("MAX_PATH: " _STRINGIZE(MAX_PATH))  

  4.   

  5. // 判断宏的当前值、调用了哪一个版本的 _t 系列函数、Windows API  

  6. #pragma message("_DEBUG: " _STRINGIZE(_DEBUG) ", _UNICODE: " _STRINGIZE(_UNICODE))  

  7. #pragma message("_tprintf: " _STRINGIZE(_tprintf))  

  8. #pragma message("CreateFile: " _STRINGIZE(CreateFile))  

在标准输出或 VC 的 Output 窗口输出：

Line: 209
MAX_PATH: 260
_DEBUG: 1, _UNICODE: 1
_tprintf: wprintf
CreateFile: CreateFileW

#pragma push_macro/pop_macro 保存和恢复宏定义^

#pragma push_macro/pop_macro 用来解决宏命名冲突问题，以下：

源码打印？

  1. // 保存来自 windef.h 的 MAX_PATH 定义  

  2. #pragma message("MAX_PATH: " _STRINGIZE(MAX_PATH))  

  3. #pragma push_macro("MAX_PATH")  

  4.   

  5. // 对 MAX_PATH 进行新的定义  

  6. // 即便以前没有定义 MAX_PATH，#undef MAX_PATH 也不会报错  

  7. #undef MAX_PATH  

  8. #define MAX_PATH    512  

  9. #pragma message("MAX_PATH: " _STRINGIZE(MAX_PATH))  

  10.   

  11. // 使用新的 MAX_PATH  

  12.   

  13. // 恢复 windef.h 的 MAX_PATH 定义  

  14. #pragma pop_macro("MAX_PATH")  

  15. #pragma message("MAX_PATH: " _STRINGIZE(MAX_PATH))  

#pragma message 输出以下：

MAX_PATH: 260
MAX_PATH: 512
MAX_PATH: 260

#pragma warning 禁用和启用编译警告^

例子：

源码打印？

  1. // 禁用 C450七、C4034 警告（VC 的 warning 编号从 C4001 开始）  

  2. // 只报告一次 C4385 警告  

  3. // 将 C4164 警告做为编译错误  

  4. #pragma warning(disable: 4507 34; once: 4385; error: 164)  

  5.   

  6. #pragma warning(push)           // 保存当前的警告设置：全局警告级别和 disable 的  

  7. #pragma warning(disable: 4705)  // 禁用某些警告  

  8. #pragma warning(disable: 4706)  

  9. #pragma warning(disable: 4707)  

  10.   

  11. // 会产生 C470五、C470六、C4707 警告的代码  

  12. #pragma warning(pop)            // 恢复保存的警告设置  

#pragma comment 目标文件注释和编译选项传递^

#pragma comment 的做用是在编译或连接过程当中，向 COFF 二进制目标文件或 PE 可执行文件 (.obj/.lib/.exe/.dll) 中插入字符串注释。目的：

(1). 将版本、版权等信息插入到 COFF/PE 文件中，以便发布
(2). 插入的字符串会做为后续编译阶段（如连接）的选项，以便支持如 auto-link 等在源码中设置编译、连接选项

例子：用 #pragma comment(lib) 实现库的 auto-link^

以例 17 DllProj 工程为基础，DllProj 定义有 DLLPROJ_EXPORTS 宏，DllProj.h 以下：

源码打印？

  1. // DllProj.h  

  2.   

  3. #ifndef _DLLPROJ_H_  

  4. #define _DLLPROJ_H_  

  5.   

  6. #ifdef DLLPROJ_EXPORTS  

  7. #define DLLPROJ_API __declspec(dllexport)  

  8. #else  

  9. #pragma comment(lib, "DllProj.lib")     // 指示在导入符号时连接 DllProj.lib  

  10. #define DLLPROJ_API __declspec(dllimport)  

  11. #endif  

  12.   

  13. // 省略代码  

  14.   

  15. #endif  // _DLLPROJ_H_  

在使用工程中 #include 该文件，并设置库搜索路径 /LIBPATH，没必要指定连接导入库 DllProj.lib

#pragma comment(linker) 传递连接选项^

#pragma comment(linker, "link_option")

link_option 只能为如下连接选项：

/DEFAULTLIB
/EXPORT
/INCLUDE
/MANIFESTDEPENDENCY
/MERGE
/SECTION

#pragma comment(linker, "/SECTION") 设置区段属性^

设置区段属性的方法有：

(1). 使用模块定义文件 .def 的 SECTIONS 定义，见 MSDN: SECTIONS (C/C++)

(2). 使用 /SECTION 连接选项，见 MSDN: /SECTION (Specify Section Attributes)

(3). 使用 #pragma section 指令建立区段

对于上面的方法 (2)，可用 #pragma comment(linker) 指定连接选项

例子：#pragma comment(linker, "/SECTION") 设置可读写、共享区段

源码打印？

  1. #pragma comment(linker, "/SECTION:.mydata,RWS")  

  2. #pragma data_seg(".mydata")  

  3.   

  4. // .mydata 区段中的变量定义  

  5.   

  6. #pragma data_seg()  

#pragma 区段操做^

区段属性和标准区段名参考 /SECTION 连接选项。查看区段偏移地址 (RVA)、起始地址和属性，用 dumpbin 工具：

dumpbin /SECTION:secname xxx.exe|xxx.dll

自定义区段名不能和标准区段名冲突。自定义区段名长度限制为 8 个字符，超过 8 个会截断

#pragma section 在目标文件中建立区段^

#pragma section 在.obj 中建立区段，并设置属性 read, write, execute, shared, nopage, nocache, discard, remove

#pragma section 新建的区段不包括任何内容，需向新建的区段放置数据或代码：

(1). 对于数据区段（全局变量）

(a). __declspec(allocate("secname")) 修饰
(b). #pragma bss_seg/const_seg/data_seg 指令

(2). 对于代码区段（函数）

(a). #pragma alloc_text 指令
(b). #pragma code_seg 指令

例子：#pragma section 建立可读写、共享区段

源码打印？

  1. #pragma section(".mydata", read, write, shared)     // 在 .obj 中新建可读写、共享区段 .mydata  

  2. // #pragma comment(linker, "/SECTION:.mydata,RWS")  // 做用与上相似：在连接时调整区段属性  

  3. #pragma data_seg(".mydata")                         // 将如下初始化数据放置到 .mydata  

  4.   

  5. // .mydata 区段中的变量定义  

  6.   

  7. #pragma data_seg()                                  // 恢复默认的初始化数据区段 .data  

  8.   

  9. __declspec(allocate(".mydata"))                     // 用  __declspec(allocate) 放置数据到区段  

  10. int g_Var = 0;  

#pragma alloc_text 将 C 连接约定的函数放置到区段^

#pragma alloc_text 只能应用于 C 连接约定的函数，即对于 C++ 编译方式，需用 extern "C" 声明函数。因此 #pragma alloc_text 不支持重载函数和类成员函数

#pragma alloc_text 在函数声明与函数定义体之间使用

例子：在可执行、非分页区段中，用 #pragma alloc_text 放置 C 连接约定函数

源码打印？

  1. extern "C" void TestFunc_1();                           // 必需在 .mycode 以前有函数声明  

  2. extern "C" void TestFunc_2();                           // 而且是 C 连接约定的  

  3.   

  4. #pragma section(".mycode", read, execute, nopage)       // 创建可执行、非分页区段  

  5. // #pragma comment(linker, "/SECTION:.mycode,RE!P")     // 做用与上相似：在连接时调整区段属性  

  6. #pragma alloc_text(".mycode", TestFunc_1, TestFunc_2)   // 将指定函数放到 .mycode 中  

  7.   

  8. void TestFunc_1()  

  9. {  

  10.     // TestFunc_1 函数体  

  11. }  

  12.   

  13. void TestFunc_2()  

  14. {  

  15.     // TestFunc_2 函数体  

  16. }  

#pragma code_seg 将函数放置到代码区段^

#pragma code_seg/bss_seg/const_seg/data_seg 会新建区段，以前没必要有 #pragma section；若是以前有 #pragma section，会使用 #pragma section 设置的区段属性

若是省略参数，会放置到标准区段：

#pragma code_seg(): .text
#pragma data_seg(): .data
#pragma bss_seg(): .bss
#pragma const_seg(): .rdata

例子：在可执行、非分页区段中，用 #pragma code_seg 放置函数

源码打印？

  1. #pragma section(".mycode", read, execute, nopage)       // 创建可执行、非分页区段  

  2. // #pragma comment(linker, "/SECTION:.mycode,RE!P")     // 做用与上相似：在连接时调整区段属性  

  3.   

  4. #pragma code_seg(".mycode")                             // 将如下函数放到 .mycode 区段中  

  5. void TestFunc_1()  

  6. {  

  7.     // TestFunc_1 函数体  

  8. }  

  9.   

  10. void TestFunc_2()  

  11. {  

  12.     // TestFunc_2 函数体  

  13. }  

  14. #pragma code_seg()                                      // 恢复默认的标准代码区段 .text  

#pragma data_seg/bss_seg/const_seg 将数据放置到区段^

数据性质和区段有对应关系，若是放置区段和数据性质冲突，则不会实际放到该区段中：

(1). .data 标准区段，放置初始化非 0 全局数据。用 #pragma data_seg 放置初始化数据，必需显示初始化其中变量（能够初始化为 0），不然不会放入 #pragma data_seg 指定的区段

(2). .bss 标准区段，放置未初始化、默认或显式初始化为 0 的全局数据。注意连接时 .bss 会向 .data 中合并，因此在 .exe/.dll 中看不到 .bss 区段，可查看 .obj 中的 .bss 区段。用 #pragma bss_seg 放置未初始化数据，必需不初始化其中变量（也不能初始化为 0），不然不会放入 #pragma bss_seg 指定的区段

(3). .rdata 标准区段，放置只读的全局常量数据。const 数字类型会编码到代码中（指令当即数），因此不放到 .rdata 中。用 #pragma const_seg 放置只读常量数据

例子：自定义区段和数据性质冲突

如下错误编译器不会报错，但实际没有放置到指望的区段中

源码打印？

  1. int g_Var1 = 1;     // 放置到 .data 中  

  2.   

  3. int g_Var2 = 0;     // 放置到 .obj 的 .bss 中，连接时合并到 .data  

  4. int g_Var3;         // 同上  

  5.   

  6. const int g_Var4 = 1;           // 编码到代码中，没有放置到 .rdata 中  

  7. const char g_szVar5[]= "foo";   // 放置到 .rdata 中  

  8.   

  9. #pragma const_seg(".myrdata")  

  10. const char g_szVar6[]= "foo";   // 放置到 .myrdata 中  

  11. #pragma const_seg()  

  12.   

  13. #pragma bss_seg(".mybss")  

  14. int g_Var7 = 1;     // 错误：放置到 .data 中  

  15. int g_Var8 = 0;     // 错误：放置到 .obj 的 .bss 中，连接时合并到 .data  

  16. int g_Var9;         // 正确放置到 .mybss 中  

  17. #pragma bss_seg()  

  18.   

  19. #pragma data_seg(".mydata")  

  20. int g_Var10 = 0;    // 正确放置到 .mydata 中  

  21. int g_Var11;        // 错误：放置到 .obj 的 .bss 中，连接时合并到 .data  

  22. #pragma data_seg()  

#pragma pack 设置成员字节对齐^

设置 struct, union, class 成员字节对齐的方法：

(1). 编译选项 /Zp，x86 缺省为 /Zp8，即以 8 byte 对齐，参考 MSDN: /Zp (Struct Member Alignment)

(2). 使用 __declspec(align(#)) 修饰，参考 MSDN: align (C++)

(3). 使用 #pragma pack

#pragma pack(): 不带参数的 #pragma pack() 表示恢复到编译选项 /Zp 设置的字节对齐

#pragma pack(show): 产生一条 C4810 编译警告，报告当前的字节对齐：

Test.cpp(140) : warning C4810: value of pragma pack(show) == 8

例子：使用 #pragma pack 设置成员字节对齐

源码打印？

  1. // x86 32bit  

  2.   

  3. #pragma pack(4)             // 用一对 #pragma pack(4) | #pragma pack()  

  4. // #pragma pack(push, 4)    // 用一对 #pragma pack(push, 4) | #pragma pack(pop)  

  5. struct TestStruct  

  6. {  

  7.     double  a;              // sizeof(double) = 8  

  8.     int     b;              // sizeof(int) = 4  

  9. };                          // sizeof(TestStruct) = 12  

  10.   

  11. // #pragma pack(4) 会一直做用，直到改变 pack   

  12.   

  13. #pragma pack()              // 恢复编译选项 /Zp 设置的字节对齐  

  14. // #pragma pack(pop)        // 恢复 #pragma pack(push, 4) 以前的字节对齐  

#pragma inline 函数设置^

inline 函数修饰，参考 MSDN: inline, __inline, __forceinline

inline 函数编译优化选项，参考 MSDN: /Ob (Inline Function Expansion)

#pragma auto_inline 禁用和启用 auto-inline^

例子：

使用 /O2 编译优化选项，含 /Ob2：启动 auto-inline

源码打印？

  1. #pragma auto_inline(off)  

  2. int simple_func(int a)      // 不会 inline 化  

  3.   

  4. inline                      // #pragma auto_inline(off) 不会做用于显式指定的 inline 函数  

  5. int simple_func2(int a)     // 会 inline 化  

#pragma inline_depth 设置函数调用的 inline 化深度^

#pragma inline_depth(n) 做用于 inline、__inline 和 /Ob2 选项下的 auto-inline 化函数，不做用于 __forceinline 函数。须要 /Ob1 或 /Ob2 编译选项

n: 0 ~ 255，255 表示无限制调用深度 inline 化，0 表示禁止 inline 化，省略参数 #pragma inline_depth() 时 n = 254

递归函数 inline 化的最大调用深度为 16 次调用

#pragma inline_recursion 禁用和启用递归函数的 inline 化^

做用于 inline、__inline 和 /Ob2 选项下的 auto-inline 化函数。须要 /Ob1 或 /Ob2 编译选项

默认为 #pragma inline_recursion(off)，这时一个可 inline 化的递归调用函数只 inline 展开一次。若是 #pragma inline_recursion(on)，则 inline 展开深度由 #pragma inline_depth 限制，并不超过 16 次

#pragma 优化指令^

编译优化选项 /O，参考 MSDN: /O Options (Optimize Code)

#pragma optimize 禁用或启动特定优化^

#pragma optimize("gp(s|t)y", on|off)

优化参数和编译优化选项之间的对应关系：

g: /Og
p: /fp:precise 浮点数一致性
s: /Os 生成最小代码
t: /Ot 生成最快代码
y: /Oy

源码打印？

  1. #pragma optimize("pt", on)  // 对下面的代码使用 fp:precise, /Ot 优化  

  2.   

  3. // 函数定义  

  4.   

  5. #pragma optimize("", off)   // 关闭上次 #pragma optimize 指定的优化  

  6. #pragma optimize("", on)    // 恢复到编译器 /O 选项指定的优化  

#pragma intrinsic 使用 intrinsic 函数^

使用 intrinsic 函数编译选项 /Oi，参考 MSDN: /Oi (Generate Intrinsic Functions)

#pragma intrinsic，参考 MSDN: intrinsic

源码打印？

  1. #include <string.h>  

  2.   

  3. // 使用 /Oi 编译选项  

  4.   

  5. #pragma intrinsic(memcpy)  

#pragma function 使用普通函数^

和 #pragma intrinsic 对应，改变 /Oi 选项或以前的 #pragma intrinsic 设置，使用指定函数名的普通函数版本

#pragma deprecated 声明废弃函数^

#pragma deprecated 用来声明废弃的函数、类型、宏，编译器产生 C4995 警告

__declspec(deprecated) 修饰也可用来声明废弃的函数、类型，编译器产生 C4996 警告

例子：

源码打印？

  1. // 使用 #pragma deprecated  

  2. // BEGIN  

  3. //  

  4. #pragma deprecated(OldClass)  

  5. class OldClass1;  

  6.   

  7. #pragma deprecated(test_func1)  

  8. void old_func1();  

  9. //  

  10. // END  

  11.   

  12. // 使用 __declspec(deprecated)  

  13. // BEGIN  

  14. #define DEPRECATED_WILL_RMOVED  "** will be removed in next version **"  

  15.   

  16. // deprecated() 中的字符串不是必需的，若是有，会在警告时输出  

  17. __declspec(deprecated(DEPRECATED_WILL_RMOVED)) void old_func2();  

  18.   

  19. // 注意 __declspec(deprecated) 修饰 class 时的位置  

  20. class __declspec(deprecated) OldClass2;  

  21. //  

  22. // END  

  23.   

  24. void test()  

  25. {  

  26.     old_func1();    // 产生 C4995 警告  

  27.     OldClass1 obj;  // 产生 C4995 警告  

  28.   

  29.     old_func2();    // 产生 C4996 警告，并输出 "** will be removed in next version **"  

  30.     OldClass2();    // 产生 C4996 警告  

  31. }  

#pragma omp 使用 OpenMP 指令^

指令形式：

#pragma omp omp_directive

用于多线程、并发编程的 OpenMP 指令，子指令 omp_directive 参考 MSDN: OpenMP Directives

#pragma region/endregion 折叠代码块^

标记一整块代码，在 VC 编辑器可折叠成一行 (+) 和展开，见 VC 的 Edit->Outlining 菜单

VC Outlining 经常使用快捷键：

Ctrl + M, Ctrl + L: 折叠或展开全部的代码块
Ctrl + M, Ctrl + M: 折叠或展开光标所在的代码块

源码打印？

  1. #pragma region FuncTestCode             // 折叠成一行后，(+) 后显示的名字  

  2.   

  3. // 这里是一整块代码  

  4.   

  5. #pragma endregion Test Code of Func()   // 折叠后在名字后显示的注释  

#pragma setlocale 设置源代码中字符串字面量的编码^

#pragma setlocale("locale")

#pragma setlocale() 使用的 locale 参数和 CRT 函数 setlocale() 的相同，参考 MSDN: Language Strings，如 简体中文 "chs" (GBK)，繁体中文 "cht" (BIG5)，日文 "jpn" (JIS)。注意：GBK 包括简体中文、繁体中文、日文，因此繁体中文的源文件不必定是 BIG5，也多是 GBK，要看实际的编码

例子：

默认源代码的设置为 #pragma setlocale("")，"" 表示 Windows 用户默认 ANSI 代码页，在控制面板中区域和语言选项中设置，默认简体中文系统为 GBK，繁体中文系统为 BIG5 等。因此在简体系统下编写简体字面量代码，或在繁体系统下编写繁体字面量代码等，无需设置源文件的 #pragma setlocale

在简体中文 Windows 下源文件使用 BIG5 编码源文件，代码中有 L"xxx" 的宽字符字面量，且 "xxx" 在 BIG5 - ASCII 的字符集范围，则应当使用 #pragma setlocale("cht")

#pragma include_alias 定义头文件别名^

源码打印？

  1. #pragma include_alias(<stdio.h>, <newstdio.h>)  

  2. #pragma include_alias("api.h", "test\api.h")  

  3.   

  4. #include <stdio.h>  

  5. #include "api.h"  

预处理相关编译选项^

/D 定义宏^

/D: 定义宏，做用相似 #define，但会去掉选项中的引号
/U: 取消指定的预约义宏，相似 #undef，如 /U _DEBUG
/u: 取消全部的预约义宏。/U 和 /u 都不能取消在源码中用 #define 定义的宏

定义数字^

  • /DTESTMACRO: 等价 #define TESTMACRO 1，整数

  • /DTESTMACRO=1: 同上

  • /DTESTMACRO="1": 同上

  • /DTESTMACRO=3.14: 等价 #define TESTMACRO 3.14，浮点数

  • /DTESTMACRO="3.14": 同上

定义字符串^

  • /DTESTMACRO="abcdef": 等价 #define TESTMACRO abcdef，非字符串字面量（没有引号）

  • /DTESTMACRO=\"abcdef\": 等价 #define TESTMACRO "abcdef"，字符串字面量

  • /DTESTMACRO="\"abcdef\"": 同上

空定义^

  • /DTESTMACRO=: 等价 #define TESTMACRO

  • /DTESTMACRO="": 同上

  • /DTESTMACRO=\"\": 等价 #define TESTMACRO ""，非空定义，而是空字符串

CL 环境变量使用 /D^

SET CL=/DTESTMACRO#1: 用 # 代替 =，等价 /DTESTMACRO=1，即 #define TESTMACRO 1

/E, /EP, /P 预处理选项^

/E: 预处理源文件，结果输出到标准输出，去掉注释，在 #inlcude 展开和条件编译周围产生 #line 行号指示
/EP: 和 /E 类似，结果输出到标准输出，但不产生 #line
/P: 和 /E 类似，产生 #line，结果输出到文件 (test.cpp => test.i)，至关于 cl /E test.cpp > test.i
/P /EP 联用: 结果输出到文件 test.i，且不产生 #line。/E、/EP、/P 不能和预编译头 PCH 联用
/C: 预处理时保留注释，和 /E、/P、/EP 联用

例子：预处理展开源文件^

源文件 test.cpp：

源码打印？

  1. #include <stdio.h>  

  2.   

  3. int main()  

  4. {  

  5. #ifdef _DEBUG  

  6.     printf("Debug config\n");  

  7. #else  

  8.     printf("Release config\n");  

  9. #endif  

  10.   

  11. // MARK: TESTMACRO value  

  12.     printf("TESTMACRO: %d\n", TESTMACRO);  

  13.     return 0;  

  14. }  

预处理编译命令：

cl /P /C /DTESTMACRO test.cpp

预处理输出到 test.i：

源码打印？

  1. #line 1 "test.cpp"  

  2. #line 1 "d:\\Visual Studio 8\\VC\\INCLUDE\\stdio.h"  

  3.   

  4. // #line 中 stdio.h 的路径由实际 VC 安装路径而定  

  5. // 这里省略 stdio.h 展开后的大量代码  

  6.   

  7. #line 706 "d:\\Visual Studio 8\\VC\\INCLUDE\\stdio.h"  

  8.   

  9. #line 2 "test.cpp"  

  10.   

  11. int main()  

  12. {  

  13.   

  14.   

  15.   

  16.     printf("Release config\n");  

  17. #line 10 "test.cpp"  

  18.   

  19. // MARK: TESTMACRO value  

  20.     printf("TESTMACRO: %d\n", 1);  

  21.     return 0;  

  22. }  

例子：过滤查看预处理展开结果^

用这种方法能够查看编译过程当中，实际的宏展开、预处理结果

以上面的 test.cpp 为例，预处理编译命令和 grep 过滤：

cl /EP /C /DTESTMACRO test.cpp 2>NUL | egrep -A 5 -B 5 "MARK: TESTMACRO"

2>NUL: 用于屏蔽输出 VC 编译器 banner 和提示、错误信息，用 /nologo 选项也能够
egrep -A 5 -B 5: 表示输出匹配正则表达式先后 5 行

输出结果以下：

    printf("Release config\n");

// MARK: TESTMACRO value
    printf("TESTMACRO: %d\n", 1);
    return 0;
}

/showIncludes 输出头文件列表^

输出源文件的 #include 的头文件列表到 stderr，包括嵌套 #include

例子：查看 #include 头文件列表^

以上面 test.cpp 为例，编译命令：

cl /nologo /showIncludes /EP test.cpp >NUL

输出头文件列表，由实际 VC 安装路径而定。嵌套 #include 用空格缩进表示，如 stdio.h include=> crtdefs.h：

test.cpp
Note: including file: d:\Visual Studio 8\VC\INCLUDE\stdio.h
Note: including file:  d:\Visual Studio 8\VC\INCLUDE\crtdefs.h
Note: including file:   d:\Visual Studio 8\VC\INCLUDE\sal.h
Note: including file:   d:\Visual Studio 8\VC\INCLUDE\vadefs.h
Note: including file:  d:\Visual Studio 8\VC\INCLUDE\swprintf.inl
相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程