Fatal Error C999：UNKNOWN MESSAGE Please choose the Technical Support command on the Visual C++ Help menu, or open the Technical Support help file for more information。
                  This error usually means that you have mixed files from different versions of the compiler, or your compiler installation is corrupted. Use the Programs and Features applet in the Control Panel to repair or reinstall the product.
                   未知的消息请选择Visual C ++帮助菜单上的技术支持命令，或者打开技术支持帮助文件以获取更多信息。
                   这个错误通常意味着你有来自不同版本编译器的混合文件，或者你的编译器安装被破坏了。 使用控制面板中的程序和功能小程序修复或重新安装产品。
Fatal Error C1001：INTERNAL COMPILER ERROR(compiler file file, line number)。
                   The compiler cannot generate correct code for a construct, probably due to the combination of an expression and an optimization option. Try removing one or more optimization options and recompiling the function containing the line indicated in the error message.
                   You can probably fix the problem by removing one or more optimization options. To determine which option is at fault, remove options one at a time and recompile until the error message goes away. The options most commonly responsible are /Og, /Oi, and /Oa. Once you determine which option is responsible, you can disable it using the optimize pragma around the function where the error occurs and continue to use the option for the rest of the module.
                   The Microsoft Knowledge Base has more information about C1001; see http://support.
                   Try rewriting the line where the error is reported, or several lines of code surrounding that line.
                   内部编译器错误（编译器文件文件，行号）。
                   编译器无法为构造生成正确的代码，可能是由于表达式和优化选项的组合。 尝试删除一个或多个优化选项并重新编译包含错误消息中指示的行的函数。
                   您可以通过删除一个或多个优化选项来解决该问题。 要确定哪个选项出错，请一次删除一个选项并重新编译，直到错误消息消失。 最常见的选项是/ Og，/ Oi和/ Oa。 一旦确定了哪个选项是负责的，您可以在发生错误的函数周围使用optimize pragma来禁用它，并继续为模块的其余部分使用该选项。
                   Microsoft知识库包含有关C1001的更多信息; 请参阅http://support.。
                   尝试重写报告错误的行或围绕该行的几行代码。
Fatal Error C1002：compiler is out of heap space in pass 2。
                   The compiler ran out of dynamic memory space during its second pass, probably due to a program with too many symbols or complex expressions
                   To fix by using the following possible solutions。
                   1.Divide the source file into several smaller files.
                   2.Break expressions into smaller subexpressions.
                   3.Remove other programs or drivers that consume memory.
                   编译器在第2遍中没有堆空间。
                   编译器在第二遍时耗尽了动态内存空间，可能是由于程序中符号太多或表达式复杂。
                   使用以下可能的解决方案进行修复。
                   1：将源文件分成几个较小的文件。
                   2：将表达式分解成更小的子表达式。
                   3：删除其他消耗内存的程序或驱动程序。

Fatal Error C1003：error count exceeds number; stopping compilation
                   Errors in the program are too numerous to allow recovery. The compiler must terminate.
                   错误计数超过数量; 停止编译。
                   程序中的错误太多，无法恢复。 编译器必须终止。
Fatal Error C1004：unexpected end of file found。
                   The compiler reached the end of a source file without resolving a construct. The code may be missing one of the following elements:
                   A closing brace。
                   A closing parenthesis。
                   A closing comment marker (*/)
                   A semicolon。
                   To resolve this error, check for the following:
                   The default disk drive has insufficient space for temporary files, which require about twice as much space as the source file.
                   An #if directive that evaluates to false lacks a closing #endif directive.
                   A source file does not end with a carriage return and line feed.
                   发现意外的文件结尾。
                   编译器在不解析构造的情况下到达源文件的末尾。 该代码可能缺少以下元素之一：
                    一个右大括号。
                   右括号。
                   结束评论标记（* /）
                   分号。
                   要解决此错误，请检查以下内容：
                   默认磁盘驱动器没有足够的空间存放临时文件，这需要大约两倍于源文件的空间。
                   #if指令的计算结果为false缺少关闭#endif指令。
                   源文件不会以回车和换行符结束。
 Fatal Error C1005：string too big for buffer。
                   A string in a compiler intermediate file overflowed a buffer.
                   You could get this error when the parameter that you pass to either the /Fd or /Yl compiler options is greater than 256 bytes.
                   字符串对于缓冲区太大。
                   编译器中间文件中的字符串溢出缓冲区。
                   当传递给/ Fd或/ Yl编译器选项的参数大于256字节时，可能会出现此错误。

Fatal Error C1007：unrecognized flag string in option。
                   The command-line option contains an invalid string. Check the CL command line and environment variable for errors.
                   选项中无法识别的标志字符串。
                   命令行选项包含无效的字符串。 检查CL命令行和环境变量是否有错误。

Fatal Error C1008：no input file specified。
                   The compiler was not given a C or C++ source file to compile. Check the CL command line and environment variable for filename specifications.
                   没有指定输入文件。
                   编译器没有被赋予C或C ++源文件进行编译。 检查CL命令行和环境变量的文件名规范。

Fatal Error C1009：compiler limit : macros nested too deeply。
                   The compiler tried to expand too many macros at the same time. The compiler has a limit of 256 levels of nested macros. Split nested macros into simpler macros.
                   编译器限制：宏嵌套过深。
                   编译器试图同时扩展太多的宏。 编译器具有256个嵌套宏级别的限制。 将嵌套宏分解为更简单的宏。

Fatal Error C1010：unexpected end of file while looking for precompiled header. Did you forget to add '#include name' to your source?
                  
                  An include file specified with /Yu is not listed in the source file. This option is enabled by default in most Visual C++ Project types and "stdafx.h" is the default include file specified by this option.
                 In the Visual Studio environment, use one of the following methods to resolve this error:
                 If you do not use precompiled headers in your project, set the Create/Use Precompiled Header property of source files to Not Using Precompiled Headers. To set this compiler option, follow these steps:
                 1：In the Solution Explorer pane of the project, right-click the project name, and then click Properties.
                 2：In the left pane, click the C/C++ folder.
                 3：Click the Precompiled Headers node.
                 4：In the right pane, click Create/Use Precompiled Header, and then click Not Using Precompiled Headers.
                 Make sure you have not inadvertently deleted, renamed or removed header file (by default, stdafx.h) from the current project. This file also needs to be included before any other code in your source files using #include "stdafx.h". (This header file is specified as Create/Use PCH Through File project property)。
                在查找预编译头文件时意外的文件结尾。 你忘了添加'＃包括名称'到你的源？
                / Yu中指定的包含文件未在源文件中列出。 大多数Visual C ++ Project类型默认启用此选项，“stdafx.h”是此选项指定的默认包含文件。  
                在Visual Studio环境中，使用以下方法之一来解决此错误：
                如果您在项目中不使用预编译头文件，请将源文件的创建/使用预编译头文件属性设置为不使用预编译头文件。 要设置此编译器选项，请按照下列步骤操作：
                1：在项目的解决方案资源管理器窗格中，右键单击项目名称，然后单击属性。
                2：在左侧窗格中，单击C / C ++文件夹。
                3：单击预编译头节点。
                4：在右窗格中，单击创建/使用预编译的标题，然后单击不使用预编译的标题。
                确保您没有在当前项目中无意中删除，重命名或删除头文件（默认为stdafx.h）。 这个文件还需要包含在使用#include“stdafx.h”的源文件中的任何其他代码之前。 （该头文件被指定为创建/使用PCH通过文件项目属性）。

Fatal Error C1012：unmatched parenthesis : missing character。
                   The parentheses in a preprocessor directive do not match.
                   无与伦比的括号：缺少字符。
                   预处理器指令中的括号不匹配。

Fatal Error C1013：compiler limit : too many open parentheses。
                   An expression contains too many levels of parentheses in a single expression. Simplify the expression or break it into multiple statements.
                   Prior to Visual C++ 6.0 Service Pack 3, the limit on nested parenthesis in a single expression was 59. Currently, the limit on nested parenthesis is 256.
                   编译器限制：打开的括号过多。
                   表达式在单个表达式中包含太多括号。 简化表达式或将其分解为多个语句。
                   在Visual C ++ 6.0 Service Pack 3之前，单个表达式中嵌套括号的限制为59.目前，嵌套括号的限制为256。

Fatal Error C1014：too many include files : depth = level
                   The nesting of #include directives is too deep. Nested directives can include open files. The source file containing the directive counts as one file.
                   包含文件过多：深度=级别
                   #include指令的嵌套太深了。 嵌套指令可以包含打开的文件。 包含该指令的源文件计为一个文件。
                  
Fatal Error C1016：ifdef expected an identifier#ifndef expected an identifier
                   The conditional compilation directive (#ifdef or #ifndef) has no identifier to evaluate. To resolve the error, specify an identifier.
                   ifdef预期标识符＃ifndef预计标识符
                   条件编译指令（#ifdef或#ifndef）没有要评估的标识符。 要解决该错误，请指定一个标识符。
 
Fatal Error C1017：invalid integer constant expression
                   The expression in an #if directive did not exist or did not evaluate to a constant.
                   Constants defined using #define must have values that evaluate to an integer constant if they are used in an #if, #elif, or #else directive.
                   The following sample generates C1017:
                   // C1017.cpp  
                     #define CONSTANT_NAME "YES"  
                     #if CONSTANT_NAME   // C1017  
                     #endif  
                    Possible resolution:
                    // C1017b.cpp  
                    // compile with: /c  
                     #define CONSTANT_NAME 1  
                     #if CONSTANT_NAME  
                     #endif
                   Because CONSTANT_NAME evaluates to a string and not an integer, the #if directive generates fatal error C1017.
                   In other cases, the preprocessor evaluates an undefined constant as zero. This can cause unintended results, as shown in the following sample. YES is undefined, so it evaluates to zero. The expression #if CONSTANT_NAME evaluates to false and the code to be used on YES is removed by the preprocessor. NO is also undefined (zero), so #elif CONSTANT_NAME==NO evaluates to true (0 == 0), causing the preprocessor to leave the code in the #elif portion of the statement — exactly the opposite of the intended behavior.
                   // C1017c.cpp  
                   // compile with: /c  
                   #define CONSTANT_NAME YES  
                   #if CONSTANT_NAME  
                  // Code to use on YES...  
                   #elif CONSTANT_NAME==NO  
                  // Code to use on NO...  
                  #endif  
                   To see exactly how the compiler handles preprocessor directives, use /P, /E, or /EP.
                   无效整数常量表达式
                   #if指令中的表达式不存在或未计算为常量。
                   如果在#if，#elif或#else指令中使用，则使用#define定义的常量必须具有计算为整数常量的值。
                   以下示例生成C1017：
                    // C1017.cpp  
                     #define CONSTANT_NAME "YES"  
                     #if CONSTANT_NAME   // C1017  
                     #endif
                    可能的决议：
                     // C1017b.cpp  
                     // compile with: /c  
                     #define CONSTANT_NAME 1  
                     #if CONSTANT_NAME  
                     #endif
                     由于CONSTANT_NAME计算结果为字符串而不是整数，因此#if指令会生成致命错误C1017。
                     在其他情况下，预处理器将未定义的常量评估为零。 这可能会导致意想不到的结果，如下面的示例所示。 YES是未定义的，所以它的计算结果为零。 表达式#if CONSTANT_NAME的计算结果为false，预处理器将删除YES上使用的代码。 NO也是未定义的（零），因此#elif CONSTANT_NAME == NO的计算结果为true（0 == 0），导致预处理器将代码留在语句的#elif部分 - 与预期行为完全相反。
                     // C1017c.cpp  
                     // compile with: /c  
                     #define CONSTANT_NAME YES  
                     #if CONSTANT_NAME  
                     // Code to use on YES...  
                     #elif CONSTANT_NAME==NO  
                    // Code to use on NO...  
                     #endif  
                     要准确查看编译器如何处理预处理器指令，请使用/ P，/ E或/ EP。

Fatal Error C1018: unexpected #elif
                   The #elif directive appears outside an #if, #ifdef, or #ifndef construct. Use #elif only within one of these constructs.
                   The following sample generates C1018:
                    // C1018.cpp  
                     #elif      // C1018  
                     #endif  
  
                     int main() {}  
                    Possible resolution:
                   // C1018b.cpp  
                    #if 1  
                    #elif  
                    #endif  
  
                   int main() {}  
                    意外#elif
                    #elif指令出现在#if，#ifdef或#ifndef结构之外。 仅在这些构造之一中使用#elif。
                    以下示例生成C1018：
                    // C1018.cpp  
                     #elif      // C1018  
                     #endif  
  
                     int main() {}
                     可能的决议：
                     // C1018b.cpp  
                    #if 1  
                    #elif  
                    #endif  
  
                   int main() {}
Fatal Error C1019:unexpected #else
                  The #else directive appears outside an #if, #ifdef, or #ifndef construct. Use #else only within one of these constructs.
                  The following sample generates C1019:
                  // C1019.cpp  
                   #else   // C1019  
                   #endif  
  
                   int main() {}
                   Possible resolution:
                  // C1019b.cpp  
                  #if 1  
                  #else  
                  #endif  
  
                  int main() {}  
                  意外#else
                  #else指令出现在#if，#ifdef或#ifndef结构之外。 仅在这些结构中使用#else。
                  以下示例生成C1019：
                  // C1019.cpp  
                   #else   // C1019  
                   #endif  
  
                   int main() {}
                   可能的决议：         
                   // C1019b.cpp  
                  #if 1  
                  #else  
                  #endif  
  
                  int main() {}

Fatal Error C1020:unexpected #endif
                  The #endif directive has no matching #if, #ifdef, or #ifndef directive. Be sure each #endif has a matching directive.
                  The following sample generates C1020:
                  // C1020.cpp  
                   #endif     // C1020  
                  Possible resolution:
                  // C1020b.cpp  
                  // compile with: /c  
                   #if 1  
                   #endif
                   意外#endif
                   #endif指令没有匹配的#if，#ifdef或#ifndef指令。 确保每个#endif都有一个匹配的指令。
                   以下示例生成C1020：
                   // C1020.cpp  
                   #endif     // C1020  
                  可能的决议：
                  // C1020b.cpp  
                  // compile with: /c  
                   #if 1  
                   #endif

Fatal Error C1021：invalid preprocessor command 'string'
                   string is not a valid preprocessor directive. To resolve the error, use a valid preprocessor name for string.
                   The following sample generates C1021:
                    // C1021.cpp  
                    #BadPreProcName    // C1021 delete line
                    无效的预处理器命令“字符串”
                    字符串不是有效的预处理器指令。 要解决该错误，请为字符串使用有效的预处理器名称。
                    以下示例生成C1021：
                    // C1021.cpp  
                    #BadPreProcName    // C1021 delete line
Fatal Error C1022:  expected #endif
                    An #if, #ifdef, or #ifndef directive has no matching #endif directive. Be sure each #if, #ifdef, or #ifndef has a matching #endif.
                    The following sample generates C1022:
                    // C1022.cpp  
                     #define true 1  
                     #if (true)  
                     #else   
                     #else    // C1022  
                     Possible resolution:
                    // C1022b.cpp  
                    // compile with: /c  
                    #define true 1  
                    #if (true)  
                    #else   
                    #endif  
                    预计#endif
                    #if，#ifdef或#ifndef指令没有匹配的#endif指令。 确保每个#if，#ifdef或#ifndef都有匹配的#endif。
                    以下示例生成C1022：   
                     / C1022.cpp  
                     #define true 1  
                     #if (true)  
                     #else   
                     #else    // C1022  
                     可能的决议：
                    // C1022b.cpp  
                    // compile with: /c  
                    #define true 1  
                    #if (true)  
                    #else   
                    #endif  
Fatal Error C1023: file' : unexpected error with pch, try rebuilding the pch
                   C1023 could be caused by one of several problems, the solution to which is a rebuild of the precompiled header file.
                   C1023 may be caused if you attempt to use a precompiled header file on a machine other than the one on which it was built.
                   文件'：与pch出现意外错误，请尝试重新生成pch
                   C1023可能是由几个问题之一引起的，解决方法是重新编译预编译头文件。
                   如果您尝试在非构建它的机器上使用预编译头文件，可能会导致C1023。
Fatal Error C1026: parser stack overflow, program too complex
                   The space required to parse the program caused a compiler stack overflow.
                   Decrease the complexity of expressions by:
                   Decreasing nesting in for and switch statements. Put more deeply nested statements in separate functions.
                   Breaking up long expressions that involve comma operators or function calls.
                   解析器堆栈溢出，程序太复杂
                   解析程序所需的空间导致编译器堆栈溢出。
                   通过以下方式降低表达的复杂度:
                   减少for和switch语句中的嵌套。 将更深入的嵌套语句放在单独的函数中。
                   分解涉及逗号运算符或函数调用的长表达式。
Fatal Error C1033: cannot open program database pdb
                   This error can be caused by disk error.
                   In Visual C++ .NET 2002, the user locale must be set correctly when the file name (or directory path to the file name) contains MBCS characters. Setting the system locale is not sufficient; the user locale must be set to process MBCS characters.
                   For more information, see http://support.
                   无法打开程序数据库pdb
                   此错误可能是由磁盘错误引起的。
                   在Visual C ++ .NET 2002中，当文件名（或文件名的目录路径）包含MBCS字符时，必须正确设置用户区域设置。 设置系统区域是不够的; 用户区域设置必须设置为处理MBCS字符。
                   有关更多信息，请参阅http://support.。
Fatal Error C1035: expression too complex; simplify expression
                   The compiler could not generate code for a complex expression. Split the expression into simpler expressions and recompile.
                   表情太复杂; 简化表达
                   编译器无法为复杂表达式生成代码。 将表达式拆分为更简单的表达式并重新编译。
Fatal Error C1037: cannot open object file filename
                   The object file specified by /Fo cannot be opened.
                   To fix by checking the following possible causes
                   Invalid filename.
                   Insufficient memory to open the file.
                   Another process is using the file.
                   A read-only file has the same name.
                   In Visual C++ .NET (version 1300 of the compiler), there is a bug that requires the user locale to be set correctly when the file name (or directory path to the file name) contains MBCS characters. Setting the system locale is not sufficient; the user locale must be set to process MBCS characters.
                   无法打开目标文件的文件名
                   他/ object指定的目标文件无法打开。
                   通过检查以下可能的原因来解决问题
                   无效的文件名。
                   内存不足以打开文件。
                   另一个过程是使用该文件。
                   只读文件具有相同的名称。
                   在Visual C ++ .NET（版本1300的编译器）中，存在一个错误，当文件名（或文件名的目录路径）包含MBCS字符时，需要正确设置用户区域设置。 设置系统区域是不够的; 用户区域设置必须设置为处理MBCS字符。
Fatal Error C1038: compiler limit : function : control flow state too complex; simplify function
                   The function has more control-flow states than the compiler can handle. Simplify control flow or split the function into smaller functions.
                   编译器限制：功能：控制流程状态太复杂; 简化功能
                   该函数具有比编译器可处理更多的控制流状态。 简化控制流程或将功能分解为更小的功能。

Fatal Error C1045: compiler limit : linkage specifications nested too deeply
                   Nested externals exceed the compiler limit. Nested externals are allowed with the external linkage type, such as extern "C++". Reduce the number of nested externals to resolve the error.
                   编译器限制：链接规范嵌套过深
                   嵌套外部超出编译器限制。 外部连接类型允许嵌套外部连接，如extern“C ++”。 减少嵌套的外部数量来解决错误。
Fatal Error C1046: compiler limit : structure nested too deeply
                   The structure, union, or class exceeded the nesting limit, which is 15 levels. Rewrite the definition to reduce the nesting level. Split the structure, union, or class into two or more parts by using typedef to define one or more of the nested structures.
                   编译器限制：结构嵌套太深
                   结构，工会或班级超过了15层的嵌套限制。 重写定义以降低嵌套级别。 通过使用typedef来定义一个或多个嵌套结构，将结构，联合或类拆分为两个或更多个部分。
Fatal Error C1047:The object or library file 'file' was created with an older compiler than other objects; rebuild old objects and libraries
                  C1047 is caused when object files or libraries built with /LTCG are linked together, but where those object files or libraries are built with different versions of the Visual C++ toolset.
                  This can happen if you begin using a new version of the compiler but do not do a clean rebuild of existing object files or libraries.
                  To resolve C1047, rebuild all object files or libraries.
                  对象或库文件'文件'是使用比其他对象更旧的编译器创建的; 重建旧的对象和库
                  当使用/ LTCG构建的对象文件或库链接在一起时，会导致C1047，但这些对象文件或库是使用不同版本的Visual C ++工具集构建的。
                  如果您开始使用新版本的编译器，但不执行现有对象文件或库的干净重建，则可能会发生这种情况。
                  要解析C1047，请重建所有对象文件或库。
Fatal Error C1051: program database file, 'pdbfile', has an obsolete format, delete it and recompile
                   The compiler cannot update the program database file, which has an older version number. Delete the file and recompile your program with /Zi or /ZI. For more information, see /Z7, /Zi, /ZI (Debug Information Format)
                   程序数据库文件'pdbfile'具有过时的格式，请将其删除并重新编译  
                   编译器无法更新具有较旧版本号的程序数据库文件。 删除文件并用/ Zi或/ ZI重新编译程序。 有关更多信息，请参阅/ Z7，/ Zi，/ ZI（调试信息格式）
Fatal Error C1053: identifier>' : function too large
                   The function is too large to compile.
                   To fix by using the following possible solutions
                   Try compiling without optimizations.
                   Divide the function into smaller functions.
                   Reduce calls to inline functions.
                   标识符>'：功能太大
                   该函数太大而无法编译。
                   使用以下可能的解决方案进行修复
                   尝试编译没有优化。
                   将函数分成更小的函数。
                   减少对内联函数的调用。
Fatal Error C1054: compiler limit : initializers nested too deeply
                   The code exceeds the nesting limit on initializers (10-15 levels, depending on the combination of types being initialized).
                   To fix by using the following possible solutions
                   Simplify the data types being initialized to reduce nesting.
                   Initialize variables in separate statements after the declaration.
                   编译器限制：初始化器嵌套得太深
                   代码超出初始化程序的嵌套限制（10-15级，取决于初始化类型的组合）。
                   使用以下可能的解决方案进行修复
                   简化正在初始化的数据类型以减少嵌套。
                   声明后，在单独的语句中初始化变量。
Fatal Error C1055: compiler limit : out of keys
                   The source file contains too many symbols. The compiler ran out of hash keys for the symbol table.
                   To fix by using the following possible solutions
                   Split the source file into smaller files.
                   Eliminate unnecessary header files.
                   Reuse temporary and global variables instead of creating new ones.
                   编译器限制：超出密钥
                   源文件包含太多符号。 编译器耗尽了符号表的散列键。
                   使用以下可能的解决方案进行修复
                   将源文件拆分为更小的文件。
                   消除不必要的头文件。
                   重用临时变量和全局变量，而不是创建新变量。

Fatal Error C1057: unexpected end of file in macro expansion
                   The compiler reached the end of the source file while gathering macro-invocation arguments, probably due to a missing right parenthesis in the macro invocation.
                   宏扩展中文件的意外结束
                   编译器在收集宏调用参数时到达源文件的末尾，可能是由于宏调用中缺少右括号。

Fatal Error C1060: compiler is out of heap space
                   The operating system or run-time library cannot fill a request for memory.
                   To fix this error try the following possible solutions
                   1.If the compiler also issues errors C1076 and C3859, use the /Zm compiler option to lower the memory allocation limit. More heap space is available to your application if you lower the remaining memory allocation.
                     If the /Zm option is already set, try removing it. Heap space might be exhausted because the memory allocation limit specified in the option is too high. The compiler uses a default limit if you remove the /Zm option.
                   2.If you are compiling on a 64-bit platform, use the 64-bit compiler toolset. For information, see How to: Enable a 64-Bit Visual C++ Toolset on the Command Line.
                   3.On 32-bit Windows, try using the /3GB boot.ini switch.
                   4.Increase the size of the Windows swap-file.
                   5.Close other running programs.
                   6.Eliminate unnecessary include files.
                   7.Eliminate unnecessary global variables, for example, by allocating memory dynamically instead of declaring a large array.
                   8.Eliminate unused declarations.
                   9.Split the current file into smaller files.
                   编译器不在堆空间中
                   操作系统或运行时库无法填充内存请求。
                   要解决此错误，请尝试以下可能的解决方案
                   1. 如果编译器也发出错误C1076和C3859，请使用/ Zm编译器选项来降低内存分配限制。 如果降低剩余的内存分配，则可以为应用程序提供更多的堆空间。
                      如果/ Zm选项已设置，请尝试删除它。 堆空间可能已耗尽，因为该选项中指定的内存分配限制过高。 如果删除/ Zm选项，编译器将使用默认限制。
                   2. 如果您在64位平台上编译，请使用64位编译器工具集。 有关信息，请参阅如何：在命令行上启用64位Visual C ++工具集。
                   3. 在32位Windows上，尝试使用/ 3GB boot.ini开关。
                   4. 增加Windows交换文件的大小。
                   5. 关闭其他运行的程序。
                   6. 消除不必要的包含文件。
                   7. 消除不必要的全局变量，例如，通过动态分配内存而不是声明大数组。
                   8. 消除未使用的声明。   
                   9. 将当前文件拆分成更小的文件。

Fatal Error C1061: compiler limit : blocks nested too deeply
                   Nesting of code blocks exceeds the limit of 128 nesting levels. This is a hard limit in the compiler for both C and C++, in both the 32-bit and 64-bit tool set. The count of nesting levels can be increased by anything that creates a scope or block. For example, namespaces, using directives, preprocessor expansions, template expansion, exception handling, loop constructs, and else-if clauses can all increase the nesting level seen by the compiler.
                   To fix this error you must refactor your code. In any case, deeply nested code is difficult to understand and reason about. Refactoring your code to have fewer nesting levels may improve code quality and simplify maintenance. Break deeply nested code into functions that are called from the original context. Limit the number of loops or chained else-if clauses within a block.
                   编译器限制：嵌套过深
                   代码块的嵌套超过了128个嵌套级别的限制。 在32位和64位工具集中，这对于C和C ++的编译器都是一个硬性限制。 嵌套级别的数量可以通过创建范围或块的任何内容来增加。 例如，命名空间，使用指令，预处理器扩展，模板扩展，异常处理，循环结构和else-if子句都可以增加编译器看到的嵌套级别。
                   要解决这个错误，你必须重构你的代码。 无论如何，深层嵌套的代码很难理解和推理。 重构代码以减少嵌套级别可以提高代码质量并简化维护。 将深层嵌套代码打破从原始上下文中调用的函数。 限制一个块内的循环数或链接else子句。

Fatal Error C1064: compiler limit : token overflowed internal buffer
                   An identifier exceeds the length of the internal buffer used for identifiers. Shorten the name.
                   编译器限制：令牌溢出内部缓冲区
                   标识符超过用于标识符的内部缓冲区的长度。 缩短名称。
Fatal Error C1065: compiler limit : out of tags
                   The source file contains more than 65,523 classes, structs, unions, namespaces, or enums.
                   Split the file into smaller files.
                   编译器限制：超出标签
                   源文件包含超过65,523个类，结构体，联合体，命名空间或枚举。
                   将文件分割成更小的文件。