************************************* 错误和警告消息文件 ************************************* 该文件包含 Sun ANSI C++ 编译器 (ccfe) 错误和警告消息。它不包含 CC 驱动程序的其它组件（如优化器、代码发生器或链接器）发出的消息。 消息的格式为： o 消息 o 说明 o 生成消息的代码示例 o 消息标识（标记） 并非所有的消息都包含说明或代码示例。 编译器消息有下面两种类型： o 警告消息，可以提供有用的信息，而无需中断编译。其中，单词“警告”显示在文件名和行号之后。通过这些警告消息，可以诊断编程错误或 C++ 语法或语义的合法性，从而使编译器可以生成有效的对象代码。 o 错误消息，可以导致编译器命令失败。其中，单词“错误”是前缀。如果编译器已经诊断出严重的问题，将会产生错误。其中，该问题会使编译器无法理解程序或继续生成正确的对象代码。但是，该编译器将会尝试检查程序的其余部分，以便发现其它错误。如果编译器诊断出错误，则不会链接到您的程序上。 通常，后面跟着一些消息的词汇“内部错误，不应发生”无法诊断编程错误，但能诊断编译器问题。在编译器的内部一致性检查中，其中一项检查已经失败。由发出的消息诊断的问题是很重要的；您可以帮助 Sun Microsystems, Inc.了解问题，方法如下：1. 失败时，使用相同的选项和 -P 选项重新运行 CC 命令。此后，将输出放在当面目录中后缀为 .i 的文件中。借助该文件，可以了解编译器问题。2. 致电授权的服务提供商。通过联系 Sun Microsystems, Inc. 零售商，可以找到授权的服务提供商。 *************************************

## 内部错误，不应发生

如果发生内部编译器错误，将会生成该消息。请注意有关错误的情况，并与 Sun 取得联系（联系信息）。

消息标识：noerror

## 检测到整数溢出

编译器已尝试在编译时计算浮点加法的结果，并确定该结果溢出。低位 32 位结果将被保留，而编译器将执行此诊断。

消息标识：addfovfl

## 检测到整数溢出

编译器已尝试在编译时计算加法的结果，并确定该结果溢出。低位 32 位结果将被保留，而编译器将执行此诊断。

消息标识：addovfl

## 使用后重新定义

类已经使用外部作用域名称，所以无法重新定义名称。 生成错误消息的代码示例：

    typedef int Integer;

    class A {
    Integer i;
    float Integer; //错误：在 A 中使用后重新定义整数
    };

消息标识：alreadyusedc

## 使用后重新定义模板

模板已经在本地使用，所以无法重新定义。 生成警告消息的代码示例：

    template < class T >
    class A {};

    class B {
    	A<int> a1;
    	float A; // 警告
    };

    template < class T >
    class C {
    	A<float> a2;
    	long A;
    };
    C<int> ac; // 警告

消息标识：alreadyusedt

## 名称不明确

名称同时存在于下面两个基类中：%3 和 %4。请使用作用域运算符指定所需的一个基类。 生成错误消息的代码示例：

    struct A {
    int i;
    };

    struct A2 {
    int i;
    };

    struct B:A, A2 {
    B() { i = 7; }
    	// 错误：B 中的名称 i 不明确：A::i 和 A2::i
    };

消息标识：ambigfield

## 基类不明确

基类包含在某个类的两个或多个基类中。因此，必须指定所需的一个基类。 生成错误消息的代码示例：

    struct B { int i; };

    struct B1:B {
    int j;
    };

    struct B2:B {
    int j;
    };

    struct A:B1, B2 {
    A() {
    i = 7; // 错误：B::i 不明确
    B1::i = 7; // ok
    B2::i = 7; // ok
      }
    };

消息标识：ambigbfield

## 基类不明确

基类不明确：它包含在一个或多个基类中。 生成错误消息的代码示例：

    struct A {
    int i;
    };

    struct B:A {
    int j;
    };

    struct C:A, B {
    int k;
    void foo() {
    	A::i = 10; // 错误：C 中的基类 A 不明确。
      };
    };

消息标识：ambigbspec

## 名称不明确

在两个或多个基类中可以找到相同的名称。指定所需的一个名称。 生成错误消息的代码示例：

    struct B1 {
    void foo(){}
    };

    struct B2 {
    void foo(){}
    };

    struct A:B1, B2 {
    int i;
    };

    void bar()
    {
    A a;
    a.foo(); // 错误
    a.B1::foo(); // ok
    a.B2::foo(); // ok
    }

消息标识：ambigname

## 匿名联合不能有函数成员

匿名联合不能有函数成员。 生成错误消息的代码示例：

    static union {
    void foo(){} // 错误
    };

消息标识：anonnofunc

## 匿名联合不能有专用的或受保护的成员

匿名联合不能有专用的或受保护的成员。 生成错误消息的代码示例：

    static union {
    long j;

    private:
    	int i; // 错误
    };

消息标识：anonnoprivate

## 全局匿名联合必须是静态的

全局匿名联合必须是静态的 生成错误消息的代码示例：

    union { // 错误
    long i;
    int j;
    	float k;
    };

消息标识：anonnotstatic

## 联合成员不能有用户定义的赋值运算符

对联合成员而言，拥有用户定义的赋值运算符是非法的 生成错误消息的代码示例：

    class A {
    public:
    int i;
    A &operator =(A &la);
    };

    union B {
    A a;
    int i;
    };

消息标识：asgnotall

## 拥有一个引用成员，无法赋值

类拥有引用成员。无法为这种类的实例赋值。 生成错误消息的代码示例：

    class A {
    public:
    int &i;
    int j;
    A() :i(j), j(5) {}
    };

    void foo()
    {
    A a1;
    A a2;
    a1 = a2; // 错误：无法为实例 a1 的引用成员 i 赋值
    }

消息标识：asgwref

## 拥有常量成员，无法赋值

成员被声明为常量，所以无法赋值。 生成错误消息的代码示例：

    class A {
    public:
    const int i;
    A():i(5) {}
    };

    void foo()
    {
    A a1;
    A a2;
    a1 = a2; // 错误：无法为实例 a1 的常量成员 i 赋值
    }

消息标识：asgwconst

## 使用模板，无需声明

首先应该声明模板。 生成警告消息的代码示例：

    template class B<int>; // 警告：未声明 B

消息标识：assumetemp

## 无法更改访问

无法通过这种方法对成员的访问进行更改。 生成错误消息的代码示例：

    class A {
    protected:
    int i;
    };

    class B :public A {
    public:
    A::i;  // 错误：无法更改访问
    };

消息标识：badaccadj

## 无法更改访问，因为

因为存在其它类成员，所以无法更改访问。 生成错误消息的代码示例：

    class A {
    public:
    int i;
    };

    class B :public A {
    protected:
    int i;
    public:
    A::i;  // 错误：由于 B::i 而无法更改对 A::i 的访问
    };

消息标识：badadjname

## 该操作是非法的

未定义该对象的一元运算符。要解决这个问题，可以为传入的类型定义重载一元运算符。 生成错误消息的代码示例：

    class A {
    	int i;
    public:
    	//运算符 ++(); // 前缀运算符 ++
    };

    void foo()
    {
    	A a;
    	a++; // 错误：要更正的重载运算符 ++
    }

消息标识：badtunaryop

## 该操作是非法的

未定义该对象的二进制运算。要解决这个问题，可以重载二进制运算符，使其包含传入的参数。 生成错误消息的代码示例：

    class A {
    int i;
    };

    void foo()
    {
    A a, b;
    int i = a + b; // 错误
    int j = a%b;	// 错误
    }

    void bar() {
    int i = 9;
    float j = -9.3;
    i % j; // 错误
    }

消息标识：badbinaryop

## 类型的形式参数需要一个左值

传递到包含引用的函数中的值不是左值。 生成错误消息的代码示例：

    int foo( int &i)
    {
    i = foo(1); // 错误：“1”不是左值。
    return 2;
    }

消息标识：badarglval

## 调用时所用的类型形式参数需要一个左值

传递到包含指针或地址的函数中的值不是左值。 生成错误消息的代码示例：

    int foo( int &i)
    {
    i = foo(1); // 错误：“1”不是左值。
    return 2;
    }

消息标识：badarglval2

## 正在传递类型的形式参数

无法将传递到函数中的参数赋值给该函数的某个参数。 生成错误消息的代码示例：

    void foo(int *cp);

    int main() {
    const char *cp = "abcd";
    foo(cp); // 错误：正在向 int* 传递常量 char *cp
    return 0;
    }

消息标识：badargtype

## 正在传递调用时使用的类型形式参数

无法将调用函数时使用的形式参数赋值给该函数的某个参数。 生成错误消息的代码示例：

    void foo(int *cp);

    int main() {
    const char *cp = "Hello";
    foo(cp); // 错误：正在向 int* 传递常量 char *cp
    return 0;
    }

消息标识：badargtype2

## 正在传递类型的形式参数

调用函数时使用的形式参数类型与该函数的参数不匹配。 生成错误消息的代码示例：

    class A {
    public:
    int i;
    A() { i = 1; };
    };

    void foo(A *Ap);

    int main() {
    const A *Ap = new A();
    foo(Ap); // 错误：正在将常量 A* 传递参数类型 A*
    return 0;
    }

消息标识：badargtypew

## 字符串文字在形式参数中转换为 char*

调用函数时使用的形式参数类型与该函数的参数不匹配。 生成警告消息的代码示例：

    void foobar(char *c);

    void foo()
    {
    	const char *c = "abcde";
    	foobar(c); // 警告，正在将常量 char* 传递给调用 foobar 时使用的 char*
    }

消息标识：badargtypelw

## 正在传递调用时使用的类型形式参数

调用函数时使用的形式参数类型与该函数的参数不匹配。 生成警告消息的代码示例：

    class A {
    public:
    int i;
    A() { i = 1; };
    };

    void foo(A *Ap);

    int main() {
    const A *Ap = new A();
    foo(Ap); // 警告：正在将常量 A* 传递参数类型 A*
    return 0;
    }

消息标识：badargtype2w

## 字符串文字在调用时使用的形式参数中转换为 char*

调用函数时使用的形式参数类型与该函数的参数不匹配。

消息标识：badargtypel2w

## 数组初始化表达式中出现非法括号

数组初始化程序应该加波形括号。 生成警告消息的代码示例：

    static char a [5] = ("qwer");

消息标识：badarrinit

## 某个条件无法具有类型

遇到语法错误：条件类型不正确。 生成错误消息的代码示例：

    void foo() {
    for ( ;int i[1] = (1); );    // 错误：条件无法具有类型 int[1]
    };

消息标识：badcondtype

## 类型的形式参数有一个无法访问的复制构造函数

类型有一个无法访问的构造函数。 生成错误消息的代码示例：

    class A {
    A(A& a) { };  // 用户定义的专用复制构造函数
    public:
    A() {};
    };

    A the_a;

    void foo(A a) { };

    void bar() { foo(the_a); }; // 错误：调用 foo(A) 时使用的类型 A 的形式参数 a
    // 有一个无法访问复制构造函数

消息标识：badcopyacc

## 调用时使用的类型形式参数有一个无法访问的复制构造函数

调用函数时使用的形式参数的对象类型没有可以访问的复制构造函数。无法将形式参数复制到新的对象。 生成错误消息的代码示例：

    class A {
    	A(A &a); // 用户定义的专用复制构造函数
    public:
    	A();
    	void foo(A a);
    } a1, a2;

    int main() {
    a2.foo(a1); // 错误：A(A&) 是专用的。
    };

消息标识：badcopyacc2

## 数组必须至少有一个元素

数组声明的大小不能为零或负数。 生成错误消息的代码示例：

    int ia[-5];
    int ib[0];

消息标识：badarraysize

## 该操作是非法的

对象类型不是数组类型，所以不能使用数组运算符。 生成错误消息的代码示例：

    class A {
    public:
    //A operator[] (int);
    } a1, a2, a3[4];

    int main() {
    a1[7] = a2; // 错误：a1 不是数组
    a3[4] = a2; // ok
    };

消息标识：badarraytype

## 无法赋值

将对象赋值给不兼容的类型。 生成错误消息的代码示例：

    class A {
    int i;
    };

    void foo()
    {
    A a;
    int j;
    j = a; // 错误：无法将 A 赋值给 int
    }

消息标识：badassignment

## 没有 operator=，无法赋值

应该提供显式赋值运算符。 生成错误消息的代码示例：

    class A { };

    class B {
    public:
    int operator = (int ) { return 0; }
    // 应该定义下列运算符，以便
    // 去除错误消息：
    // int 运算符 = (const A&);
    };

    int main() {
    A a;
    B b;

    b = a;
    }

消息标识：badasscasg

## 基类必须预先定义为类或结构

指定的基类不是预先定义的类或结构。 生成错误消息的代码示例：

    class B;

    class A:B {}; // 错误：未定义基类“B”。

消息标识：badbaseclass

## 位字段必须为整型类型

位字段属于非整型类型是错误的。 生成错误消息的代码示例：

    static union {
    float c:3; //错误
    };

消息标识：badbftype

## 该中断语句不在循环语句或开关语句中

`break` 语句可能不在 `loop` 或 `switch` 语句之外。 生成错误消息的代码示例：

    int main()
    {
    	int i = 5;

    	break ;

    return 0;
    }

消息标识：badbreak

## 开关选择表达式必须为整型类型

只有整型类型才能在 switch 选择表达式中使用。 生成错误消息的代码示例：

    void foo()
    {
    	float i = 9;
    	switch(i) {	// 错误：i 不属于整型类型
    		case 1:
    		case 9:
    			break;
    	};
    return;
    }

消息标识：badcasetype

## 无法转换

尝试的转换操作是非法的。使用构造函数或转换函数进行转换。 生成错误消息的代码示例：

    class A {
    int i;
    };

    union B {
    int j;
    double k;
    };

    class C {
    public:
    int c;
    operator A();
    	operator int();
    };

    void foo() {
    B b;
    A a;
    C c;
    b = (B)a; // 错误：无法从 A 转换到 B
    c = (C)a; // 错误：无法从 A 转换到 C。
    	a = A(c); // ok
    	int i = c; // ok
    }

消息标识：badcast

## 在预处理程序指令中出现非法字符

预处理程序指令已经使用非法的字符。

消息标识：badchar

## 发现异常

已经检测到语法错误。 生成错误消息的代码示例：

    void foo()
    {
    goto b:// 错误：“b:”应该是“b;”
    b:
    	return;
    }

    class B {
    public:
    int j;
    A anA;

    class A {
    public:
    int i;
        };
    };

    int main()
    {
    B aB;
    aB.anA:i = 1;  // 错误：“:”应该是“.”
    return 0;
    }

消息标识：badcolon

## 位置错误，只能在类型限定符之前或之后

作用域运算符不能在类型限定符之前或之后。 生成错误消息的代码示例：

    class B {
    public:
    static int i;
    static int j;
    };

    ::int i;      //  错误
    B::j = 9; // ok

消息标识：badcolon2

## 两边必须有标记

## 运算符的两边必须有标记。 生成错误消息的代码示例：

    #define foo(a)	abc ##       // 错误

消息标识：badconcat

## 只有构造函数才能有构造函数初始化程序

只有构造函数才能有构造函数初始化程序。 生成错误消息的代码示例：

    class B {
    int i;
    B():i(5) {}  // ok
    void foo() :i(6) {} // 错误
    };

消息标识：badconinit

## 不允许使用 const_cast 进行转换

const_cast 转换是非法的。类型不兼容。 生成错误消息的代码示例：

    void foo()
    {
    int j = 5;
    const int i = j;
    int x = const_cast<int>(i); // 错误：i 不是左值。从常量 int 转换为 int。
    int y = const_cast<float>(j); // 错误：从 int 到浮点型的 const_cast 转换是非法的

    const int z = const_cast<int>(j); // ok：从 int 到 int 的 const_cast 转换
    }

消息标识：badconstcast

## 不是一个有效的常量

语法错误。常量无效。 生成错误消息的代码示例：

    int i = 2ooo; // 错误
    int k = 0x9; //ok

消息标识：badconsterr

## 无法声明函数

导致错误的原因可能包括：非成员函数已声明为 const 或 volatile，或将静态成员函数声明为 const 或 volatile。更多// 生成错误消息的代码示例：

    class A {
    static void foo() volatile {}; // 错误
    };
    void foo() const {}; // 错误

消息标识：badconstfunc

## 构造函数不可以有返回类型说明

构造函数不能包含返回类型说明，其中包括 void。 生成错误消息的代码示例：

    class A {
    	int A(); // 错误
    };

消息标识：badcontype

## 没有循环语句以继续执行

`continue` 只能在循环语句中使用。循环示例包括 `while`、`for` 和 `do-while`。 生成错误消息的代码示例：

    void foo()
    {
    int i = 5;
    if ( i > 4 ) {
    	   i = 4;
    	   continue; // 错误：循环语句中没有 continue
          }
    }

消息标识：badcontin

## 转换函数不可以有返回类型说明

转换函数不能包含返回类型说明。运算符类型足以说明返回的值。 生成错误消息的代码示例：

    class A {
    	int j;
    	float f;
    	int operator int() { return j; };		// 错误：可能未指定返回类型。
    	operator float() { return f; };		// ok
    };

消息标识：badconvtype

## 从不隐式地使用由用户所定义的到"void"的转换

从不隐式地使用由用户定义的到类型 void 的转换。到类型 void 的转换是非法的。 生成警告消息的代码示例：

    class A {
    public:
    	operator void();		// 警告
    };

消息标识：wbadconvret

## 声明被错误终止

遇到语法错误：声明被错误终止。 生成错误消息的代码示例：

    class A {
    void f() ; { }   // 错误：声明被错误终止
    };

消息标识：baddeclerr

## 必须有一个标识符来声明

分析声明时应该有一个标识符。声明 typedef 时，可能会遇到词法错误。 生成错误消息的代码示例：

    typedef *int my_type; // 错误：stray star

消息标识：baddecl

## 每一个剩余参数都必须具有一个缺省值

声明参数列表中的缺省值时，第一个缺省参数之后的其余所有参数也必须有缺省值。 生成错误消息的代码示例：

    template <class T=long,
    	  class K> // 错误：无缺省值
    class A {};

    void foo( int a,
    		float b,
    		long c = 6,
    		double e; // 错误
    		int f = 2; )
    {}

消息标识：baddefault

## 无效的模板参数缺省值

模板参数缺省值必须是定义或声明的类型。 生成错误消息的代码示例：

    template <class T, class K>
    class A;

    template <class T, class K = Eye>
    class A {
    int i;
    };

消息标识：baddefaultpar

## 不能通过在相同作用域内的两个不同声明来给模板参数赋予缺省参数值

在相同的作用域中，相同模板声明使用不同缺省参数会产生错误。 生成错误消息的代码示例：

    template <class T = int>
    class A;

    template <class T = long> // 错误
    class A {
    int i;
    };

消息标识：sametmpldef

## 不能将缺省参数添加到相同作用域的模板函数的后来声明中

在相同作用域中，如果在模板函数的后来声明中添加缺省参数，则会产生错误。 生成错误消息的代码示例：

    template < class T >
    T foo(T);

    template < class T >
    T foo(T = (T)9)  // 错误
    { return T; }

消息标识：badtmplfundef

## 析构函数名必须与类名匹配

析构函数名必须与类名相同。

消息标识：baddestrname

## 析构函数不可以有返回类型说明

析构函数不能包含返回类型，其中包括 void。 生成错误消息的代码示例：

    class A {
    A();
    int ~A();
    };

消息标识：baddestrtype

## 未预料的 else 子句 - 前面没有 if

`else` 子句的前面必须有 `if` 语句。 生成错误消息的代码示例：

    void foo() {
    int i = 0;
    else	// 错误：前面没有 if
    	      i++;
    }

消息标识：badelseerr

## 枚举器值溢出

枚举常量值溢出最大整数值。最大整数值与计算机有关。 生成错误消息的代码示例：

    #include <limits.h>

    enum e { e1=ULONG_MAX, e2 }; /* overflow for e2 */

消息标识：badenumrange

## 表达式结构错误

表达式中出现语法错误或错误。 生成错误消息的代码示例：

    int* foo() { return int[1]; }

消息标识：badexprerr

## 未知语言，必须为 C 或 C++

使用 `extern` 指定的语言必须是“C”或“`C++`”。 生成错误消息的代码示例：

    extern "c" int i;  // 错误：“c”应该是“C”

消息标识：badextern

## 前面已用不同语言声明

前面已经使用不同语言声明函数。只能使用一种语言版本。 生成错误消息的代码示例：

    void foo();

    extern "C" void foo() {} // 错误：foo() 以前是作为 C++ 进行声明的

消息标识：badextlnk

## 前面已用不同语言声明

前面已经使用不同语言声明变量。 生成错误消息的代码示例：

    extern "C" int i;
    extern "C++" int i;

消息标识：badextlnkw

## 成员不允许有存储类 %1

成员不允许使用存储类。 生成错误消息的代码示例：

    class A {
    	register int j; // 错误：此处不允许有存储类寄存器
    	extern int k;   // 错误
    	auto   int l;   // 错误
    };

消息标识：badfieldstore

## 包含文件名结构错误

包含文件名的结构错误。 生成错误消息的代码示例：

    #include 'includefile,h'
    #inlcude stdio.h

消息标识：badfilename

## 函数在使用前应该具有原型。

函数在使用前应该具有原型。如果对编译器进行设置，使其在 C 模式下编译，则会显示该消息。 生成警告消息的代码示例：

    int main() {
    return foo(); // 警告：函数应该具有原型（仅限 C 模式）
    }

消息标识：badfunc

## 函数必须有原型

在程序中使用函数之前，该函数必须具有原型或函数定义。 生成错误消息的代码示例：

    int main()
    {
    goo(); // 错误
    return 0;
    }

    void goo() {};

消息标识：badfunccp

## 函数必须是静态或外部的

函数存储类型必须是静态或外部函数。这些类型不能是 mutable、register 或 auto。 生成错误消息的代码示例：

    static f1(); // ok
    extern f2(); // ok

    // 错误如下：
    mutable f1(); // “mutable”不允许在类之外
    register f2();
    auto f3();

消息标识：badfuncstore

## 函数无法返回数组或函数

遇到语法错误。最有可能的是，函数声明中指定的返回类型错误。 生成错误消息的代码示例：

    int a[] = {1, 2, 3, 6, 4, 5};
    typedef void bar();

    class A {
    bar goo(); // 错误
    int foo()[] { return a; } // 错误
    };

消息标识：badfunctype

## Goto 跳过了变量（或异常）初始化

变量已在 goto 跳过的块中声明。 生成警告消息的代码示例：

    int main()
    {
    int a = 2;

    goto next;
    int b = 3; // 已跳过初始化 b
    next:
    a++;
    return 0;
    }

消息标识：badgoto

## 无法打开包含文件

无法访问或找到包含文件。因此，无法将其打开。检查该包含文件名的拼写。

消息标识：badinclfile

## 外部变量无法在局部作用域内初始化

外部变量无法在局部作用域内初始化。 生成错误消息的代码示例：

    extern int out = 2; // ok

    void foo()
    {
    out = 3; // ok
    extern int in = 9; // 错误
    extern int in2;
    in2 = 10; // ok
    };

消息标识：badinit

## 无法用来初始化类

类不是聚集对象。只有不包含构造函数、专用或受保护的成员、基类和虚拟函数的类，才能使用加括号的初始化。 生成错误消息的代码示例：

    class A {
    int i;
    int j;
    };
    A a = {1, 2}; // 错误：i 和 j 是专用的。

消息标识：badinitcl

## 无法用来初始化

无法对该对象使用加括号的初始化。 生成错误消息的代码示例：

    namespace N {
    int i;
    int j;
    }

    N n = { 1, 2 };

消息标识：badinitbrace

## 初始化时需要左值

必须使用左值对引用进行赋值。 生成错误消息的代码示例：

    int &i = 3; // 错误
    const int i = 0;
    int &ri = i; // 错误：常量 int i 不是左值

    int j = 0;
    int &rj = j; // ok

    short sv = 9;
    int &ir = sv; // 错误：将 short 赋值给 int 引用“ir”时，
    // 要求“ir”引用实际的 int。

下面是纠正以前是计时错误的错误示例。

    void foo() {
    	short sv = 9;
    	int &ir = sv; // 错误：将 short 赋值给 int 引用“ir”时，
    	      // 要求“ir”引用实际的 int。

使用下列代码，可以纠正上述错误：

    	int *j;
    	*j = (int)sv;
    	int &jr = *j; // ok，“jr”是对 int 的引用。
    }

消息标识：badinitlval

## 无法用来初始化

初始化变量时使用的类型是非法的。如果执行这种赋值操作，可以使用构造函数、转换运算符或赋值运算符的重载。 生成错误消息的代码示例：

    class A {
    int j;
    public:
    operator int() {return j; } // A 的转换运算符
    };

    void foo() {
    A a;
    int i = a; // ok。提供 A 到 int 的转换格式
    a = new A(); // 错误：使用 A* 初始化 A
    };

    void bar() {
    int i = 9;
    char *a = &i; // 错误：无法使用 int* 初始化 char*
    }

消息标识：badinittype

## 无法初始化构造函数参数列表中的数组成员

无法初始化构造函数参数列表中的数组成员。 生成错误消息的代码示例：

    class A {
    int i[3];
    int j;
    A():i(1,2,3),
    j(3) {};
    };

消息标识：badarrayinit

## 整数太大而无法表示

该计算机上的整数太大，无法表示。 生成错误消息的代码示例：

    int i = 999999999999999999999999999999999;

消息标识：badinteger

## line 指令要求无符号十进制整数和字符串

Line 指令要求使用无符号的十进制整数。 生成错误消息的代码示例：

    #0x12 // 错误
    #line 0xff "file.cc" // 错误
    #line 12345 "file.cc" // ok

消息标识：badlinedir

## line 指令只能指定 1 到 32767 之间的数值

line 指令只能指定 1 到 32767 之间的整数。 生成错误消息的代码示例：

    #line 1234567 "file.cc"

消息标识：badlinenum

## 以前已声明

以前已经使用不同的链接声明标识符，所以不能对其进行更改。 生成错误消息的代码示例：

    extern char * static_and_extern();
    static char * static_and_extern(); // 错误：已将其声明为外部而非静态的标识符

消息标识：badlinkage

## main() 必须有一个整型的返回类型

根据相关的标准，`main()` 必须有一个 `int` 返回类型。 生成错误消息的代码示例：

    void main() {}

消息标识：badmain

## 无法获取 main() 的地址

根据相关的标准，获取 `main()` 函数的地址是非法的。 生成错误消息的代码示例：

    int main()
    {
    int *a = main;
    return 0;
    }

消息标识：badmainaddr

## 无法递归调用 main()

不允许递归调用 main。 生成错误消息的代码示例：

    int main()
    {
    	main();
    	return 0;
    }

消息标识：badmaincall

## 无法重载 main()

无法重载 main()。 生成错误消息的代码示例：

    int main( int j) // 错误：无法重载 main ()
    {
    	return 0;
    }

    int main()
    {
    	return 0;
    }

消息标识：badmainol

## 无法在构造函数中初始化

派生类的构造函数初始化程序无法对基类的成员直接进行初始化。 生成错误消息的代码示例：

    class B {
    	public:
    		int i;
    		int j;
    		B() { i = 0; j = 0; }
    };

    class A:B {
    	int k;
    	A():i(7), j(5) {
    	// i(7) 出错，无法在构造函数中初始化 j(5)
    		B(); // ok，使用基类构造函数初始化
    		i = 7;
    		j = 9;
    	}
    };

消息标识：badmembinit

## 在定义类之前无法通过指向成员函数的指针进行调用

定义类主体之前，无法通过指向成员函数的指针调用成员函数。 生成错误消息的代码示例：

    class A;

    void (A::* f_ptr) ();

    int main() {
    A* a;
    (a->*f_ptr)();
    }

消息标识：badmfcall

## 成员函数不能有存储类

成员函数可以有存储类 `mutable`、`auto`、`register` 和 `extern`。 生成错误消息的代码示例：

    class A {
    mutable void f1();  // 错误
    auto void f2();     // 错误
    extern void f3();   // 错误
    static void f4();   // ok
    register void f5(); // 错误
    };;

消息标识：badmfstore

## 八进制常量包含非法数字

八进制常量只能包含 0 到 7 之间的数字。 生成错误消息的代码示例：

    int i = 08; // 错误：对八进制数字而言，8 是非法数字

消息标识：badoctal

## 重载函数的集合中只能有一个是外部 C

重载函数的集合中只能有一个是外部`“C”` 生成错误消息的代码示例：

    extern "C" int foo (char);
    extern "C" int foo (double); // 错误：已使用另外一个外部“C”函数重载
    //        外部“C”函数

消息标识：badollnk

## 参数数目非法

声明重载运算符时使用的参数太多。无法对运算符使用的参数数目进行更改。 生成错误消息的代码示例：

    class B {
    int j;
    B operator +(B, B); // 错误：应该是“B 运算符 +(B)”
    };

消息标识：badopcount

## 不能有返回类型

new 和 delete 运算符的返回类型不正确。 生成错误消息的代码示例：

    #include <stddef.h>
    class A {
    A* operator new[] (size_t);  // 错误：返回类型应该是 void*
    A operator delete[] (void*);  // 错误：返回类型应该是 void
    };

消息标识：badoprtype

## 参数类型非法

构造函数或运算符中的参数非法。 生成错误消息的代码示例：

    class A {
    	 void operator delete[] (long* );  // 错误：long* 应该是 void*

    	A(A); // 错误：复制构造函数中的参数必须是对类类型的引用
    };

消息标识：badoptypes

## 错误的参数元素

(Kernigan and Ritchie) 参数已被声明，但未在参数列表中定义 生成错误消息的代码示例：

    void foo (a,b)
    int a;
    char b;
    long d;     // 错误：参数列表中未定义 d
    {}

消息标识：badparamerr

## 参数必须是 int 类型

重载后缀二进制运算符必须使用 int 参数。 生成错误消息的代码示例：

    class B {
    B operator++(); // 前缀 ++b
    B operator++(float); // 后缀 b++，
    // 错误：应该是 B 运算符 ++ (int)
    };

消息标识：badpostfix1

## 第二个参数必须是 int 类型

后缀运算符的第二个参数必须使用 int 值。 生成错误消息的代码示例：

    template<class T>
    T operator ++(T &t, float); // 错误：将浮点型更改为 int。

消息标识：badpostfix2

## 未知的预处理程序指令

无法识别预处理程序指令。检查拼写。 生成错误消息的代码示例：

    #bad_directive

消息标识：badppdir

## 常量表达式结构错误

预处理程序指令中应该包含常量表达式，但未找到。 生成错误消息的代码示例：

    #if 0xkl0   // 错误：常量表达式结构错误。
    #fi

消息标识：badppexpr

## 简单类型没有析构函数

象 `int`、`float` 和 `char` 这些简单类型没有析构函数。 生成错误消息的代码示例：

    int main() {
    int *i = new int(0);
    i->int::~int(); // 错误：替用“delete i”
    }

消息标识：badpseudodestr

## 非虚拟函数声明为纯函数

只有虚拟函数，才能声明为纯函数。 生成错误消息的代码示例：

    class A {
    	A() = 0; // 错误：A::A() 不是虚拟的，但已声明为纯函数
    	virtual void foo() = 0; // ok
    };

消息标识：badpuref

## 纯函数定义语法错误

纯函数要求函数声明为虚拟函数，且设置等于 0。其它任何语法将会产生错误。 生成错误消息的代码示例：

    class A {
    	A() = 0; // 错误：A::A() 不是虚拟函数
    	virtual void foo() = 1; // 错误：“1”应该是“0”
    	void foo() = 99; // 错误：A::foo() 不是虚拟函数

    	virtual void foobar() = 0; // ok
    };

消息标识：badpuresyn

## 类型不同

“?:”的第二个和第三个操作数不兼容，所以无法进行转换。

    void foo()
    {
    int *x;
    int y;
    int i = (1 == 4 ) ? x :y; // 错误
    }

消息标识：badquesttypes

## 浮点常量无效

浮点常量无效。该常量太大，将会溢出，或者其数字之后的字符（F、f、L 或 l）无效。 生成错误消息的代码示例：

    float i = 123.34f; // ok
    float j = 987.2g; // 错误

消息标识：badreal

## 不允许使用 reinterpret_cast 进行转换

不允许 `reinterpret_cast`。 生成错误消息的代码示例：

    struct B { int j; };
    struct A:B { int i; };

    void foo() {
    	B *b = new A;
    	A *a1 = new A;
    	int *i = (int*)a1;

    	int j = reinterpret_cast<int> (*a1); // 错误：无法将 a1 转换为 int
    	a1 = (A*)i;  // ok，指针类型
    	b = (B*)a1; // ok
    	a1 = (A*)b; // ok
    }

消息标识：badreintcast

## 无法从应该返回的函数中返回

函数返回的类型与函数声明指定的一个类型不同。 生成错误消息的代码示例：

    class A{
    	A foo() {
    		char a = 'c';
    		return a;
    	}
    };

消息标识：badreturn

## 对括号匹配性进行意外检查

遇到意外的“)”。 生成消息的代码示例：

    int main() {
    int i;
    ); // 错误：右括号不匹配

消息标识：badrparerr

## 不允许使用 static_cast 进行转换

只有从一种类型隐式转换成另外一种类型时，static cast 才是合法的。 生成错误消息的代码示例：

    struct A {
    operator int();
    } a;

    struct B {} b;

    void foo()
    {
    int i = 3;
    double d = 3.14159;

    i = d; // ok
    i = static_cast<int> (d); // ok

    static_cast<A> (i); // 错误
    static_cast<B> (a); // 错误

    int(a); // ok，提供从类型 A 到 int 的转换
    static_cast<int> (a); // ok
    };

消息标识：badstaticcast

## 函数不能为静态的

不能将成员函数声明为静态函数。 生成错误消息的代码示例：

    #include <iostream.h>
    class A {
    static A foo();  // ok

    // 错误如下：
    static A();
    static A( int i, int j );
    static ~A();
    static A operator+(A a);
    static istream& operator>>(A& a);
    };

消息标识：badstatmf

## 函数不能既是虚拟函数又是静态函数

函数不能既声明为虚拟函数又声明为静态函数。 生成错误消息的代码示例：

    class A {
    static virtual void foo();
    };

    class C {
    virtual void foo();
    };

    class D:C {
    static void foo(); // 错误
    };

消息标识：badstatvirtf

## 字符换码序列未定义

未定义字符串中使用的字符换码序列。 生成错误消息的代码示例：

    void foo()
    {
    char *a = "Hello World!\i"; // 错误：未定义“\i”
    }

消息标识：badstring

## 值太大而无法适合字符

字符文字值太大，无法适合字符类型。 生成错误消息的代码示例：

    char c = '\xabc';
    int i = '\xabcdefg';

消息标识：badstringcon

## 非法的模板参数值

数组元素和名称的地址或非静态类成员的地址是非法的模板参数。模板参数必须是整型常量，或指向外部变量的指针或引用。 生成错误消息的代码示例：

    template<int* p> class X { };

    int a[10];
    struct S { int m; static int s; } s;

    X<&a[2]> x3;                    //  错误：数组元素的地址
    X<&s.m> x4;                     //  错误：非静态成员的地址

消息标识：badtemparg

## 用于模板引用参数的参数必须是外部命名的对象

模板引用参数所用的参数必须是外部命名的对象。临时变量或未命名的左值是非法的。 生成错误消息的代码示例：

    template <int &i>
    struct A {
    int &j;
    A();
    };

    int j = 9;

    void foo( int i ) {
    A<i> a1; // 错误：i 是临时变量

    extern int x[3];
    A< x[1] > a2; // 错误：数组元素的地址是非法的
    		// （对模板参数而言）。

    extern int x;
    A<x> a3; // ok
    A<j> a4; // ok
    };

消息标识：badtmplrefarg

## 模板参数无法具有类型

模板参数类型必须是整数类型。

消息标识：badtemppar

## 运算符的操作数必须为左值

一元运算符的操作数必须是左值。 生成错误消息的代码示例：

    void foo() {
    const int x = 7;
    x++; // 错误

    int j = --9; // 错误
    }

消息标识：badunaryop

## 仅在非静态成员函数内可以使用 this

只有非静态成员函数，才能使用 `this`。 生成错误消息的代码示例：

    class A {
    int j;
    public:
    	static void foo()  { this.j = 20*j; } // 错误
    	void foobar() {this.j = 21*j; }; // ok
    };

消息标识：badthis

## 此处的类型说明符不合法

此处不允许有类型说明符。

消息标识：badtypeerr

## 返回时返回虚拟函数

派生类具有虚拟函数，该函数包含基类中的函数指定的不同返回类型。 生成错误消息的代码示例：

    class Base {
    virtual void foo();
    };

    class A:Base {
    int foo(); // 错误：应该返回 void
    };

消息标识：badvirttype

## 位字段包含位数

为位字段指定的位数太多。最有可能的是，位字段的类型太小，无法具有指定数目的位数。 生成错误消息的代码示例：

    struct tag {
    char a:32;     // 警告：char 太小，无法具有 32 位
    } t;

消息标识：bfbigger

## 位字段可能不长于指定位数

声明的位字段太大。位字段的大小与计算机有关。 生成错误消息的代码示例：

    static union {
    int a:33; // 错误：位字段可能少于 32 位（与本计算机有关）
    };

消息标识：bftoobig

## 位字段必须至少包含一个位

不能使用少于一个位的大小定义位字段。 生成错误消息的代码示例：

    class A {
    	int a:0; // 错误：位字段必须至少包含一个位
    };

消息标识：bftoosmall

## 获取边界函数的地址

最有可能的是，尝试将成员函数的指针赋值给函数的指针。 生成错误消息的代码示例：

    class A {
    public:
    A() {}

    int goo();
    };

    int main() {
    A a;
    int (*foo) ();
    // 应该使用下列声明：
    // int (A::* foo) ();

    foo = a.goo;
    }

消息标识：boundfuncaddr

## 无法获取构造函数的地址

获取构造函数的地址是非法的。 生成错误消息的代码示例：

    struct A {
    A();
    };

    void foo()
    {
    	const int &i = A::A; // 错误：无法获取构造函数的地址
    }

消息标识：cantaddrcon

## 无法获取析构函数的地址

获取析构函数的地址是非法的。 生成错误消息的代码示例：

    struct A {
    ~A();
    };

    void foo()
    {
    	const int & i = A::~A; // 错误：无法获取析构函数的地址
    }

消息标识：cantaddrdest

## 无法赋值左操作数

正在尝试重新赋值已经声明为常量但无法进行修改的左操作数。 生成错误消息的代码示例：

    const int i = 7;
    int j = 9;

    void foo () {
    i = j; // 错误：无法赋值左操作数
    }

消息标识：cantassign

## 无法赋值操作数

无法修改操作数。无法赋值常量值、数组名称和函数。 生成错误消息的代码示例：

    int i = 7;
    int *const pi = &i;

    int j[5];
    j = 9;

    void foo() {}

    void goo () {
    foo = 5; // 错误：无法赋值操作数“*foo”。
    pi = &i; // 错误：无法赋值操作数“pi”。
    }

消息标识：cantassignop2

## 无法链接不同字符类型的字符串

无法链接宽字符类型的字符串和字符类型的字符串。 生成错误消息的代码示例：

    char str [] = "abcdefhg" L"hijklmnop";

消息标识：cantcatstring

## 由于先前的错误，无法继续处理

如果检测到的错误太多，则编译器会发送该错误，以便继续调试程序。

消息标识：cantgoon

## 应该有可以重载的运算符

未找到指定的重载运算符。如果尚未定义运算符的类型，也会生成该错误。 生成错误消息的代码示例：

    #include <stddef.h>

    class A {
    	void* operator anew[] (size_t); // 错误：运算符“anew”不存在
    	void operator delete[] (void*);
    };

为未定义类型声明的运算符示例：

    class B {
    operator C(); // 错误：尚未定义类型 C
    };

    class C {};

消息标识：cantoverop

## 试图获取重载函数的地址

对于每种定义，重载函数的地址不同。获取地址不明确，因此会产生错误。 生成错误消息的代码示例：

    int foo () { return 1; }
    int foo(int i) { return 0; }

    int main()
    {
    const int & i = foo; // 错误
    const int & j = foo; // 错误
    return 0;
    }

消息标识：cantuseover

## 无法转换常量

已尝试转换常量。 生成错误消息的代码示例：

    class B { virtual void foo(); };

    class A:public B {};

    const B * pb = new A;
    A *pa1 = dynamic_cast<A*>(pb); // 错误：dynamic_cast 将常量 pb 转换为非常量指针。

    int j = 4;
    const int *c = &j;
    int *i = reinterpret_cast<int*>(c); // 错误

消息标识：xcastawayconst

## 类型不完整，且可能尚未定义转换源

当前未执行该错误。如果从不完整且不为 void 的结构转换，则会发出该错误。

消息标识：castfrominc

## 类型不完整，且可能尚未定义转换目标

当前未执行该错误。如果转换到不完整且不是 void 的结构，则会发出该错误。

消息标识：casttoinc

## 无法为异常处理程序提供缺省参数

异常处理程序可能没有缺省参数。 生成错误消息的代码示例：

    int main()
    {
    int i = 3;

    try
       {
    if (i < 100)  throw 100;
       }
    catch (int j = 1000)  // 错误
       {
    i += j;
       };
    }

消息标识：catchdef

## 派生类的处理程序放在基类处理程序之后

如果派生类的处理程序位于基类处理程序之后，case 语句将会生成该警告。第二个 case 决会不捕获异常。第一个 case 将会捕获基类实例和派生类实例的异常。 生成错误消息的代码示例：

    class A {
    public:
    int i;
    A() { i = 1; }

    };

    class B:A {
    public:
    int j;
    B() { j = 2; }
    };

    int main()
    {
    A a;
    B b;

    try
       {
    if ( b.j != 3)
    	  throw a;
    if ( a.i != 2)
    	  throw b;
       }
    catch (A anA)  // 捕获 A 和 B 异常
       {
    a.i = anA.i + 1;
       }
    catch (B anB) { // 警告：从未连接处理程序
    b.j = anB.j + 1;
       };

    }

消息标识：catchderive

## 重复的异常处理程序

`try` 之后的异常处理程序不止一个。 生成警告消息的代码示例：

    int main()
    {
    int i = 3, j = 4;

    try
       {
    if ( i == 3 || j == 4 )
    	  throw 5;
       }
    catch (int x)
       {
    i = x + 1;
       }
    catch (double z) // ok
       {
    i = j = i + j;
       }
    catch (int y )  // 错误：重复的异常处理程序，类型相同
       {
    j = 2;
       };

    }

消息标识：catchdup

## 一个处理程序的多个异常

一个处理程序只能有一个异常。 生成错误消息的代码示例：

    int main() {
    int i = 3;
    double j = 4;

    try
      {
    if ( i != 3 )
    throw 3;
    if ( j != (double)4 )
    throw (double)4;
      }
    catch ( int x, double y ) // 错误：一个处理程序的多个异常
      {
    i = 3;
    j = 4;
      }
    return 0;
    }

消息标识：catchmularg

## 处理程序没有异常

处理程序必须有一个异常。 生成错误消息的代码示例：

    int main() {
    int i = 3;

    try
      {
    if ( i != 3 )
    throw 3;
      }
    catch (  ) // 错误：处理程序没有异常
      {
    i = 3;
      }
    return 0;
    }

消息标识：catchnoarg

## try 块必须至少有一个处理程序

`try` 必须至少有一个异常处理程序。 生成错误消息的代码示例：

    int main()
    {
    int a = 107;

    try
       {
    if (a > 2000) throw 2000;
    if (a < 100)  throw 100;
    throw a / 3;
       }
    // 错误：未捕获
    }

消息标识：catchnosym

## 无法更改以前指定的缺省参数值

指定缺省参数值之后，无法对其进行重新定义。 生成错误消息的代码示例：

    void foo( int i, int j = 7 ); // j 的缺省值是 7

    int main()
    {
    return 0;
    }

    void foo( int i, int j = 9 ) {}
    // 错误：j 已经定义，其缺省值为 7

消息标识：changedef

## 字符常量中的字符过多

字符常量的长度超过了 `char` 的最大存储空间。只能使用正则字符常量的前四个字符和宽字符常量的第一个字符。长度超过一个字符的字符常量无法进行移植。 生成警告消息的代码示例：

    char c = '9999'; // ok
    char ch = '12345'; // 错误

消息标识：chartoolong

## 无法将类或结构更改为联合

无法将以前作为类或结构类型定义的对象重新定义为联合。 生成错误消息的代码示例：

    class A {
    int i;
    };

    union A { // 错误
    int i;
    long j;
    };

消息标识：cltounion

## 无法将联合更改为类或结构

无法将作为联合类型定义的对象重新定义为类或结构类型。 生成错误消息的代码示例：

    union A {
    int i;
    long j;
    };

    class A {
    int i;
    };

消息标识：clfromunion

## 不允许在这里声明

（C 模式）在 C 模式下，声明不能与语句混合使用。 生成错误消息的错误示例：

    void foo () {
    int a = 0;

    a++;

    int c;      // 错误：不允许在这里声明
    }

消息标识：declplaceerr

## 各类的向量必须使用缺省的初始化程序

各类的向量只能使用缺省的构造函数。 生成错误消息的代码示例：

    class A {
    A() {};
    };

    typedef A B[5];

    void foo() { B b(1, 2, 3, 4, 5); }; // 错误

消息标识：defaultonly

## 无法在条件表达式中定义类型

在条件表达式中定义类型是非法的。 生成错误消息的代码示例：

    int main() {
    for (int i = 0; struct t {}; j++)   // 错误：无法在此处定义‘struct t’
            ;
    }

消息标识：defincond

## 无法访问析构函数

类的析构函数是专用且受到保护的函数，所以在此处无法对其进行访问。 生成错误消息的代码示例：

    class A {
    private:
    ~A();
    public:
    char *ch;
    A();
    };
    void foo() throw(A) {
    throw A();  // 错误：无法访问析构函数
    }

    int main() {
    foo();
    }

消息标识：destnotacc

## 以前已声明返回

已经对相同的函数做以声明，使其返回两个不同的类型。 生成错误消息的代码示例：

    void foo();
    int foo(); // 错误：foo() 以前返回 void。

消息标识：difreturns

## 浮点除法运算溢出，转交运行时处理

编译器已经确定，浮点除法表达式的求值将会溢出。

消息标识：divfovfl

## 试图除以零

编译器已经确定，整数值正在除以零，所以将会溢出。 生成错误消息的代码示例：

    int i = 1/0;

消息标识：divovfl

## 试图除以零，转交运行时处理

尝试除以零，然后将结果交由运行时处理。 生成警告消息的代码示例：

    int i = 9;
    int j = i/0;

消息标识：divovflnv

## switch 中出现两个 default

当前的 `switch` 语句包含两个 default 语句。 生成消息的代码示例：

    f(void) {
    long i = 5;
    	switch(i) {
    	case 1:
    	case 2:
    		    break;
    	default:
    	default:// 错误：default 语句太多
    	}
    }

消息标识：doubdefault

## 有两个连续的下条

使用两个连续的下条时，将会发出警告。名称可能与编译器生成的代码的内部名称冲突。

消息标识：doubunder

## 该基类已经指定了访问

基类的访问只能指定一次。 生成错误消息的代码示例：

    class B {};

    class D:public private protected B {}; // 错误
    class G:public public {}; // 错误

消息标识：dupaccess

## 该基类被多次包含

基类只能被包含一次。 生成错误消息的代码示例：

    struct A2 {
    int i;
    };
    struct A {
    int i;
    };

    struct A2 {
    int i;
    };

    struct B:A, A2, A { // 错误：基类 A 被包含了两次
    B() { A::i = 7; };
    };

消息标识：dupbaseclass

## switch 语句包含两个 case 语句

当前具有相同常量值的 `switch` 语句包含两个 case 语句。 生成错误消息的代码示例：

    f(void) {
    long i = 5;
    	switch(i) {
    	case 4:
    	case 4:
    		    break;
    	}
    }

消息标识：dupcaselabel

## 之前初始化成员

之前已经在构造函数初始化程序列表中初始化成员。 生成错误消息的代码示例：

    class A {
    int i;
    A():i(0),
    i(0) { // 错误：重复初始化成员 i
      }
    };

消息标识：dupinit

## dynamic_cast 的结果不是指针或引用类型

dynamic_cast 的结果必须是指针或引用类型。 生成错误消息的代码示例：

    class B {
    virtual foo();
    };

    class D:public B {
    int i;
    };

    B *pb = new D;

    D *pd1 = dynamic_cast<D>(pb); // 错误，转换不会生成指针或引用
    D *pd2 = dynamic_cast<D*>(pb); // ok

消息标识：dynbadtype

## dynamic_cast 操作数必须是指向多态类型的指针或引用

dynamic_cast 操作数必须使用指向多态类型的指针或引用。类型必须至少有一个虚拟函数。 生成错误消息的代码示例：

    class B {};

    class D:public B {};

    B *pb = new D;
    D *pd = dynamic_cast<D*>(pb);  // 错误：类 B 没有虚拟函数

消息标识：dynnotpolym

## dynamic_cast 操作数不是引用类型

预期的结果是引用，而操作数不是引用、指针或结构类型。 生成错误消息的代码示例：

    class B { virtual void foo(); };

    class D:public B {};

    B *pb = new D;
    int &c = int j;

    D *pd1 = dynamic_cast<D&>(pb); // 错误：The operand pb is a pointer
    D *pd2 = dynamic_cast<D&>(c);  // 错误：c 不是结构类型

消息标识：dynnotref

## dynamic_cast 操作数不是指针类型

dynamic_cast 的操作数应该是指针类型。 生成错误消息的代码示例：

    class B { virtual foo(); };

    class D:public B { int i; };

    B *pb = new D;
    D d;

    D *pd1 = dynamic_cast<D*>(d); // 错误：d 应该为指针类型
    D *pd2 = dynamic_cast<D*>(pb); // ok

消息标识：dynnotptr

## dynamic_cast 的结果不是指向类的指针或引用

dynamic_cast 的目标结果不是指向类的指针或引用。 生成错误消息的代码示例：

    class B { virtual void foo(); };

    class D:public B {
    };

    B *pb = new D;
    D *pd1 = dynamic_cast<int*>(pb); // 错误：dynamic_cast 应该指定类型“D*”

消息标识：dynnotclass

## dynamic_cast 的操作数不是指向类的指针或引用

操作数未指向类类型。 生成错误消息的代码示例：

    class B { virtual void foo(); };

    class D:public B {};

    int *c = int j;
    D *pd = dynamic_cast<D*>(c);  // 错误：c 指向 int

消息标识：dynbadopnd

## 多项声明

使用相同名称声明的对象不止一个。 生成错误消息的代码示例：

    int i;
    float i; // 错误

    typedef int I
    //. . .
    int I; // 错误

消息标识：multdecl

## 之前已初始化基类

已经初始化基类。 生成错误消息的代码示例：

    class B {
    int i;
    B() { i = 0; };
    };

    class A:B {
    int i;
    A():B(),
    B() { // 错误：重新初始化基类。
      }
    };

消息标识：dupbaseinit

## 已经包含在该声明中

生成错误消息的代码示例：

    int const int i = 9;
    const float const j = 3;

消息标识：duptypeerr

## 已定义主体

函数只能定义一次。 生成错误消息的代码示例：

    void foo() { int i; }

    int main()
    {
    	/* code */
    }

    void foo() { int i; } // 错误，foo() 定义了两次

消息标识：dupfuncdef

## 该基类已经声明为虚拟

基类的虚拟声明太多。基类只需一个虚拟声明。 生成错误消息的代码示例：

    class B {};
    class D:virtual public virtual B {}; // 错误：虚拟声明太多。

消息标识：dupvirtspec

## catch(...) 必须是最后一个处理程序

“catch(...)”必须是异常处理程序块的最后一个处理程序。 生成错误消息的代码示例：

    int main()
    {
    int i = 3;

    try
       {
    if (i < 100)  throw 100;
       }
    catch (...){} // 错误：将该 catch 移至最后一个 catch 语句
    catch (int j)
       {
    i += j;
       };
    }

消息标识：eliplaceerr

## 空的字符常量

已经使用未包含字符的字符常量。 生成消息的代码示例：

    f(void) {

    char c = '';    // 建议：char c = ' ';
    }

消息标识：emptychar

## 空的声明（可能有多余的分号）

代码包含名称空间作用域内（包括全局和文件作用域）的空声明。最有可能的原因是有多余的分号。 生成消息的代码示例：

    namespace {
    ;  // 错误
    };

    class A {
    ;
    }

消息标识：emptydecl

## 文件必须至少包含一个外部声明

文件为空。如果文件未作为 `C++` 文件进行编译，且编译器未处于兼容模式，将会产生该错误。

消息标识：emptyfile

## 在注释中遇到文件尾

在结束注释之前，遇到文件尾。 生成错误消息的代码示例：

    /*
    	message text . . .
    <EOF> // 错误

消息标识：eofincomment

## 跳转文本时文件结束 -- 检查 #if ..#endif 的匹配性

跳转文本时，编译器遇到文件尾。检查 #if。. . #endif 的匹配性。 生成错误消息的代码示例：

    #if false

    // . . . #if unmatched with #endif
    // <EOF>

消息标识：eofskipping

## 表达式过于复杂

表达式已经超过了该编译器所允许的最多操作数和运算符数。尝试将表达式分成更小的中间表达式。

消息标识：exprtoomuch

## 结尾逗号出现在参数列表中

参数列表不应该以结尾逗号结尾。 生成警告消息的代码示例：

    void foo( int i, int j ) {}

    int main()
    {
    	foo(1,2,); // 错误
    return 0;
    }

消息标识：extracomma

## 除了在构造函数中，成员无法被初始化

只能在构造函数中初始化成员。 生成错误消息的代码示例：

    struct A {
    	int i = 9; // 错误
    	int j = 4; // 错误
    };

    class B {
    	int k;
    	B() { k = 7; } // ok
    };

消息标识：fieldinit

## 隐藏函数

派生类中的函数将函数隐藏在基类中。 生成警告消息的代码示例：

    class A {
    public:
    int foo(int);
    };

    class B:A {
    public:
    virtual int foo(char *i);
    };

消息标识：hidef

## 隐藏

在作用域中找不到普通的 delete 运算符。最有可能的是，delete 运算符在类作用域中被非法覆盖。 生成错误消息的代码示例：

    #include <new>

    template<class t_arg> class A {
    public:
    void  operator delete(void*, const std::nothrow_t&) throw(); // 错误：delete(void*) 被隐藏，
    // 还需要为 delete 运算符
    // 提供一个参数
    };

    int main() {
    A<int> * a = new A<int>;
    }

消息标识：hideferr

## 隐藏虚拟函数

派生类中的函数将其对应的函数隐藏在基类中。如果在派生类中重新声明虚拟函数，且其原型与基类中指定的原型不匹配，通常会产生该错误。 生成错误消息的代码示例：

    class B {
    public:
    virtual int foo(int); // 被 B::foo() 隐藏
    };

    class D:B {
    public:
    virtual int foo(char *i); // B::foo() 隐藏虚拟的 A::foo(int)
    };

消息标识：hidevf

## 在虚拟基类中隐藏虚拟函数

警告。函数正在其虚拟基类中隐藏函数。 生成警告消息的代码示例：

    class B {
    void i;
    public:
    virtual int foo(int); // 被 B::foo() 隐藏
    };

    class D:virtual B {
    public:
    virtual int foo(char *i); // 警告：B::foo() 隐藏虚拟的 A::foo(int)
    };

消息标识：hidevfinvb

## 名称在缺省参数中无法使用

在当前的上下文中，无法将名称用作缺省参数。 生成错误消息的代码示例：

    void foo () {
    int a;

    class A {
    public:
    void goo (int b = a) {} // 错误：此处无法使用 a
        };
    }

消息标识：identundef

## 无法使用名称

无法在指定的上下文中使用名称。 生成错误消息的代码示例：

    void foo () {
    int a;

    class A {
    public:
    void goo () {
    int k = a; // 错误：此处无法使用 a
                }
        };
    }

消息标识：identunnestf

## 除了在非静态成员函数中，该名称不能使用

只有非静态成员函数才能使用该名称。成员变量不是静态的。每种类型的实例会有自身的副本。 生成错误消息的代码示例：

    struct A {
    	int i;
    };

    struct B:A {
    public:
    	int i;
    	static int j;

    	void foo() { B::i = 2; }	// ok
    	static foobar() { i = 2; }	// 错误：“foobar()”是静态的，但“i”是不是静态的
    };

    void foobar() {
    	A a;

    	A::i = 7; // 错误：A::i 不是静态的

    	B::j = 3; // ok
    	a.i = 7; // ok
    }

消息标识：identunstat

## 在转换中定义 %1 是非法的

在转换表达式中定义类型是非法的。 生成错误消息的代码示例：

    int i;
    float j = ( class A{} ) (i);

消息标识：illegalcast

## 无法访问

尝试直接访问类中的专用成员。 生成错误消息的代码示例：

    class A {
    int i; // 专用数据成员
    };

    void foo() {
    A a;
    a.i = 9; // 错误：错误：无法通过 foo() 访问 i
    }

    class T {
    	T(const T&); // 专用复制构造函数
    };

    void foo( T t ) {}		// 错误：无法传递 T，复制构造函数是专用函数
    T f2() { T t; return t; }	// 错误：无法返回 T

消息标识：inaccessible

## 类型不完整

类型的定义不正确，或尚未分配存储。 生成错误消息的代码示例：

    void i;  // 错误：类型“void”不完整
    void *i; // ok，*i 是指针类型 void

    class A;
    A a; // 错误

    class B {
    friend void A::f(); // 错误：f 是不完整类型成员
    };

    int xp[];   // 错误：类型“int[]”不完整。
    struct x y; // 错误：类型“x”不完整。
    int main()
    {
    xp [1] = 1;
    return 0;
    }

消息标识：incomplete

## 在 delete 中使用的类型不完整

尚未定义 delete 中的类型。 生成错误消息的代码示例：

    class A;

    int main() {
    A * a_ptr = 0;
    delete[] a_ptr; // 警告：在 delete 中使用的类型 A 不完整
    }

消息标识：incompletew

## 前面已声明类型的对象

不同类型变量的名称与包含外部链接的变量名称相同。 生成错误消息的代码示例：

    extern int i;
    float i; // 错误

消息标识：incomtype

## 以前已声明

(Kernigan and Ritchie):不允许在 Kernigan oí Ritchie 模式下重载函数。 生成错误消息的代码示例：

    int foo (char);
    int foo (float); // 错误：不允许在 KnR 模式下重载

消息标识：incomtypef

## 联合成员无法要求初始化或析构

联合不能拥有需要初始化或析构的成员。 生成错误消息的代码示例：

    class A {
    public:
    A();
    };

    union {
    A   a;  // 错误：联合成员无法要求初始化或析构
    } un;

消息标识：initnotall

## 已被调用并且无法定义为内联

函数无法定义为内联，因为该函数已被调用，且其声明不包含内联关键字。 生成错误消息的代码示例：

    class A {
    public:
    void foo ();
    };

    int main() {
    A a;
    a.foo();
    }

    inline
    void A::foo () {}

消息标识：xinlafteruse

## 太大并且将无法扩展为内联

对编译器而言，函数太大，无法生成内联。

消息标识：inllargeuse

## 太大而不能生成内联，请考虑自己写入

对编译器而言，函数太大，无法自动生成。但是，仍可以手动内联函数。

消息标识：inllargeint

## 该标签从未定义

已使用标签，但未对其进行定义。 生成错误消息的代码示例：

    int main()
    {
    	//. . .
    goto label1; // 错误：从未定义“标签”
    	//. . .

    return 0;
    }

消息标识：labelundef

## 局部类不能包含静态成员

不能在局部类中声明静态成员。 生成错误消息的代码示例：

    void foo()
    {
    class A {
    static int i;
            };

    }

消息标识：lcstatic

## 局部类中的成员函数必须在类中定义

必须定义局部类的虚拟成员函数主体。 生成错误消息的代码示例：

    int main() {
    class inner_class {
    public:
    virtual int foo ();     // 错误
    virtual int goo () {}   // ok
        };
    }

消息标识：lcfnodef

## 只能用于块或函数参数

存储类 `auto` 和 `register` 只能在函数参数的块中使用。 生成错误消息的代码示例：

    register int a = 3;		// 错误
    auto float b = 3.14159;	// 错误

    void foo( auto int i,		// ok
    		register j )	// ok
    {
    	register int x = 3;	// ok
    	auto int y = 4;		// ok
    }

消息标识：locstorespec

## 链接说明仅允许出现在文件级别

尚未在文件级别使用链接说明。 生成错误消息的代码示例：

    extern "C" int k; //ok

    void foo() {
    extern "C" int i; // 错误
    extern "C" int j; // 错误
    };

消息标识：loclinkage

## 字符串/字符常量不可以包含行分隔符

不允许在字符串和字符常量中使用行分隔符。 生成错误消息的代码示例：

    char c = '
    '; // 错误：有行分隔符。

消息标识：longstring

## 尝试不使用 #undef 而重新定义

如果不介入 `#undef`，则无法将宏重新定义为不同的值。 生成错误消息的代码示例：

    #define count 1
    #define count 2 // 错误：尝试不使用 #undef 而重新定义计数

消息标识：macroredef

## 该宏的参数过多

该宏的参数超过了该编译器所允许的最大数。

消息标识：manymacroparms

## 宏参数重复

具有相同名称的宏参数有两个或多个。参数名称必须唯一。 生成错误消息的代码示例：

    #define foo( X, X )

消息标识：dupmacroparms

## 重载不明确

调用的重载函数不明确。 生成错误消息的代码示例：

    void foo (int i, int j);
    void foo (int i = 3, int j = 7);//  ok：redeclaration of  foo(int,   int)
    void foo ();                      //  ok：foo 的重载声明

    int main()
    {
    	foo (1, 2);                   //  ok：call  f(int, int)
    foo ();                       //  错误：call f(int,int)  or  f()?
    }

使用构造函数和转换运算符时，也会产生二义性问题：

    struct A { A(int); };
    struct B {
    	B(int);
    	operator int();
    	operator double();
    } b;

    A foo( A a );
    B foo( B b );

    int main()
    {
    foo(1); //错误：foo(A) or foo(b)?
    }

    int i = b; // ok：与 B 到 int 的转换匹配
    float f1 = b; // 错误：调用 int 还是双精度运算符？
    float f2 = double(b); // ok：指定转换运算符。

消息标识：manymatchover

## 类成员无法在该类之外声明

类成员无法在该类之外声明。 生成错误消息的代码示例：

    class A {
    public:
    	void foo ();
    };

    void A::foobar(); // 错误：在类之外声明成员是非法的

消息标识：membnotall

## 有带值返回和无值返回

函数经声明后，可以返回一个值，但该函数包含带值返回和无值返回。 生成警告消息的代码示例：

    int foo() {
    int i = 9;
    if ( i == 1 ) return; // 错误：foo() 应该返回一个值
    else if ( i == 2 ) return 8; // 警告：来自 foo() 的带值返回和无值返回
    else if ( i == 3 ) return 1; // 警告
    else if ( i == 9 ) return; // 错误
    else
    return 1; // 警告
    };

消息标识：mixedreturns

## 试图计算与零相除的余数

试图计算与零相除的余数。 生成错误消息的代码示例：

    int i = 1000000 % 0;

消息标识：modovfl

## 试图计算与零相除的余数，转交运行时处理

试图计算变量与零相除的余数。转交运行时处理该警告。 生成警告消息的代码示例：

    void foo()
    {
    	int i = 9;
    	i%0;   // 警告：计算与零相除的余数
    }

消息标识：modovflnv

## 浮点乘法运算存在溢出，转交运行时处理

编译器已确定浮点乘法表达式溢出。转交运行时处理该错误。

消息标识：mulfovfl

## 检测到整数溢出

编译器尝试在编译时计算乘法的结果之后，已确定该结果溢出。低位 32 位结果将被保留，而编译器将执行此诊断。 生成消息的代码示例：

    int i = 1000000 * 1000000;

消息标识：mulovfl

## 该名称有多个限定符，只允许有一个

不允许有多个限定符。

消息标识：multqualerror

## 类不是直接基类

该类不是直接基类。基类不能直接使用该类的成员。 生成错误消息的代码示例：

    struct B {
    int j;
    void foo() { /* B::foo() */ };
    };

    struct A:B { // B 是 A 的基类
    int i;
    void foo() { /* A::foo() */ };
    };

    A *pa;
    B *pb;
    A a;
    B b;

    int main() {
    pa = &a;
    pb = &b;

    pa->B::foo(); // ok
    pb->::foo(); // 错误：该基类的指针类型 B 无法
    // 访问 A::foo()
    return 0;
    }

消息标识：mustbebase

## 声明的运算符必须是成员函数

声明的运算符必须是成员函数。必须将下列运算符定义为成员：“=”、“->”、“{”、“()”和类型转换。检查运算符定义中是否缺少作用域运算符。 生成错误消息的代码示例：

    class B {
    int i;
    operator =(const B&);
    };
    B::operator =(const B &b){ return (this->i + b.i); }; // ok，已定义为成员

    // 下列情况将会产生错误：
    B operator ->();
    B operator {();
    B operator ()();
    B operator int();

消息标识：mustbemem

## 无法具有函数数组

函数无法返回函数的数组。 生成错误消息的代码示例：

    void foo[3] (); // 错误

消息标识：noarroffunc

## 无法具有引用数组

不允许有引用的数组。 触发错误消息的代码示例：

    int main() {
    	int &j;    // ok
    int &i[3]; // 错误
    }

消息标识：noarrofref

## 没有基类要初始化

该类不是派生类，所以无法初始化基类。 生成错误消息的代码示例：

    class A {
    int i;
    A(): (10) {};
    };

消息标识：nobaseclass

## 应替换为

语句缺少“=”。 生成错误消息的代码示例：

    void foo()
    {
    if ( const int i 2 ) // 错误：i 之后缺少“=”
        ;
    }

消息标识：nobecomeserr

## 无法获取位字段的地址

获取位字段的地址是非法的。 生成错误消息的代码示例：

    struct A {
    int i:3;
    int j:4;
    int k:5;

    int foo() { return &i; } // 错误：
    };

消息标识：nobitaddr

## 无法引用位字段

引用位字段是非法的。 生成错误消息的代码示例：

    struct A {
    int i:3;
    int j:4;
    int k:5;

    int &foo() { int &ri = i; return ri;}  // 错误
    };

消息标识：nobitref

## 不是成员

已尝试访问不是成员的对象或函数。 生成错误消息的代码示例：

    void foo() {}
    void foobar() {}

    class A {
    public:
    int i;
    int j;

    friend void foo();
    };

    void A::goo() {}; // 错误：goo 不是 A 的成员

    int main()
    {
    A a;
    a.i = 0; // ok
    a.foobar(); // 错误：foobar 不是 A 的成员
    a.foo(); // 错误：foo 是友元，但不是 A 的成员
    }

消息标识：nofieldfnd

## 应替换为

出现语法错误。 生成错误消息的代码示例：

    void foo()
    {
    	int i = 0;
    	switch(i) {
    		case 3:
    		case 4; // 错误 应该是“:”，而不是“;”
    			i++;
    			break;
    	};
    };

消息标识：nocolonerr

## 该对象后面没有

“:”的之前应该有“?”。 生成错误消息的代码示例：

    int main()
    {
    int i = -7;
    i = ( i < 0 ) ?-i  i; // 错误：":" 之前应该有“?”
    }

消息标识：nocolonop

## 应该替用逗号

代码中出现语法错误。 可以生成错误消息的代码示例：

    int foo( int i; int j) // 错误：“;”应该是“,”
    {
    return i*j;
    }

    struct A {
    int k;
    } a, aa:
    // 错误：后面跟声明的“,”应该是 OR“:”应该是“;”

消息标识：nocommaerr

## 在用 -noex 编译时忽略 throw 表达式

已经使用编译器参数 `-noex` 忽略 throw。

消息标识：noexthrow

## 在用 -noex 编译时忽略 try 和 catch

已经使用编译器参数 `-noex` 忽略 try 和 catch 异常结构。

消息标识：noextry

## 需要标识符列表而不是

标识符列表以“)”终止之前，该列表遇到行尾。应该在一行中定义宏。是否缺少“\”？ 生成错误消息的代码示例：

    #define foo( A,  // 缺少“\”
    	     B )

消息标识：noidentlist

## 常量成员没有初始化

`常量`成员应该初始化。

消息标识：noconstinit

## 不允许初始化程序用于数组的 new

使用运算符 new[] 分配数组时，无法提供初始化程序。 生成错误消息的代码示例：

    class A {
    public:
    A (int k=0) {}
    };

    int main() {
    A * ptr = new A[2](3); // 错误：无需提供 \'3\' 作为初始化程序
    }

消息标识：noconstrparm

## 需要声明而不是

类定义必须以后面跟分号的分号或声明结尾。 生成错误消息的代码示例：

    struct A {
    	int i;
    } a, :

消息标识：nodeclerr

## 该声明没有存储类或类型

该声明没有指定存储类或类型。 生成错误消息的代码示例：

    class A {
    	i;	// 错误：无存储类或类型
    };

消息标识：nodeclspec

## 不允许使用缺省参数

不允许在重载运算符或指向函数的指针中使用缺省的参数值。 生成警告消息的代码示例：

    class T {
    int i;
    public:
    T(int j);

    };

    T operator+ (T t, T t2= T(0) ); // 错误：重载运算符中不能有缺省参数值。
    void (*fptr)(int k = 3); // 错误：指向函数的指针中不能有缺省参数值。

消息标识：nodefall

## 不允许在运算符 new 中定义

不能在运算符 new 中定义任何类型。 生成警告消息的代码示例：

    int main() {
    void * t = (void *) new (struct t {}); // 错误：遇到运算符 new 中
    // 的结构声明。
    }

消息标识：nodefinnew

## 不允许在参数类型中定义

函数不能在函数的参数中定义类型。 生成错误消息的代码示例：

    class A {
    A();
    friend void foo( class B{} b;);
    };

消息标识：nodefinproto

## 返回类型中不允许类型定义

无法在返回类型定义中使用类型定义。 生成错误的代码示例：

    struct t{} foo () {     // 错误：无法在此处定义‘struct t’
    }

消息标识：nodefinret

## sizeof 表达式中不允许类型定义

无法在“sizeof”表达式中定义新类型。 生成错误消息的代码示例：

    int foo() {
    return sizeof (struct t {}); // 错误：在 sizeof 表达式中找到结构声明
    }

消息标识：nodefinsizeof

## typeid 表达式中不允许类型定义

无法在“typeid”表达式中定义新类型。 生成错误消息的代码示例：

    #include <typeinfo>

    int main() {
    typeid (struct t {}); // 错误：在 typeid 表达式中找到结构声明
    }

消息标识：nodefintypeid

## 在 delete 中使用计数

在“delete []”运算符中使用计数是过时的。删除该计数。 生成警告消息的代码示例：

    void foo()
    {
    int *i = new int[10];
    delete [10] i;  // 错误：在"delete []"中使用计数
    }

消息标识：nodelno

## 之前没有直接声明符

语法错误。该标记之前缺少直接声明符。 生成错误消息的代码示例：

    int () {}; // 错误：缺少函数名称

    struct A {
    	static int i;
    	static int j;
    };

    void foo()
    {
    	A::i = 7; //ok
    	A::;  // 错误：缺少变量

    	int []; // 错误 缺少数组名称
    }

消息标识：nodirdecl

## RTTI 已禁用，dynamic_cast 被 static_cast 取代

RTTI 已遭禁用，所以 dynamic casting 会被 static casting 所取代。

消息标识：nodyncast

## 不是枚举标记

关键字 `enum` 之后遇到语法错误。 生成错误消息的代码示例：

    class A {
    enum A = { x, y, z }
    };

消息标识：noenumerr

## 应为表达式

应为表达式，但是未找到。 生成错误消息的代码示例：

    int j =;
    int k = {};
    int l[] = {};
    if ( );

消息标识：noexprerr

## 不是成员

试图引用类、结构或联合的不存在成员。 生成错误消息的代码示例：

    struct {
    // 应该定义下列字段：
    // int a;
    } t;

    int main() {
    return t.a;
    }

消息标识：nofieldident

## 友元声明必须指定类或函数

友元声明未指定类或函数。 生成错误消息的代码示例：

    class A {
    int i;
    friend;
    };

消息标识：nofriendfield

## 类友元要求显式类

计时错误。类友元需要显式“类”。 生成警告消息的代码示例：

    class A {
    int i;
    friend B; // 警告：应该是“友元类 B”
    };

    class B {
    int j;
    };

消息标识：nofriendw

## 函数不可以是结构或联合的一部分

不能在 Kernigan 和 Ritchie 兼容模式下将函数声明为结构成员。 生成错误消息的代码示例：

    struct {
    int foo () { return 0; } // 错误
    } t;

    int main() {
    return t.foo();
    }

消息标识：nofunchere

## 模板和转换参数列表必须具有

模板和转换参数列表必须具有与“>”匹配的“<”。 生成错误消息的代码示例：

    class B { virtual void foo(); };
    class A:public B {};

    int main()
    {
    B * pb = new A;
    A *pa1 = dynamic_cast<A*(pb); // “A*”后面应该直接跟“>”
    }

消息标识：nogtrerr

## 应为标识符，而不是

应该是标识符。 生成错误消息的代码示例：

    void foo()
    {
    	int float j; // 错误：int 之后应该是标识符
    	int; // 错误
    	goto; // 错误
    }

消息标识：noidenterr

## 需要标识符而不是（警告）

（Kernigan 和 Ritchie, Ansi 模式）：应该是标识符。 生成错误消息的代码示例：

    void foo()
    {
    	int; // 错误
    }

消息标识：noidentwarn

## 必须进行初始化

不属于外部符号的`常量`值必须进行初始化。 生成错误消息的代码示例：

    const int *pj = new int(0); //ok
    int a = 10;
    const int i;  // 错误
    const int &j; // 错误
    const int &k = a; // ok
    }

消息标识：noiniterr

## 应该进行初始化

（Kernigan 和 Ritchie）：不属于外部符号的`常量`值应该进行初始化。 生成错误消息的代码示例：

    int main() {
    static const int a; // 警告：a 应该进行初始化
    }

消息标识：noinitwarn

## 类型的对象必须初始化

必须使用初始值、构造函数或初始化程序对使用 new() 运算符创建的常量对象进行初始化。 生成错误消息的代码示例：

    const int *ip = new const int; // 错误
    const int *jp = new const int(0); // ok

消息标识：noinitanac

## 函数尚未定义主体

尚未定义内联函数的主体。 生成消息的代码示例：

    inline void foo(); // 错误：未定义函数主体，使其内联 foo()

    int main()
    {
    	foo();
    	return 0;
    }

消息标识：noinlbody

## 引用成员没有初始化

必须在使用引用成员之前对其进行初始化。 生成错误消息的代码示例：

    class A {
    public:
    	int &i;
    };
    void foo() {
    	A a;
    	a.i = 7; // 错误：尚未初始化“a.i”

    	int j;
    	a.i = j;
    	a.i = 7; // ok
    }

消息标识：noirefmem

## 标签之后需要语句（即使为空）

标签之后需要语句（即使为空）。 生成消息的代码示例：

    main() {
    int i = 10;
    switch(i) {
    case 1:
    default:
    i++;
    break;
    case 2:// 错误：标签在“case 2”之后没有语句
      }
    }

消息标识：nolabstaterr

## 应替换为左大括号

语法错误。 可以生成错误消息的代码示例：

    void foo()
    {
    	int i[] { 1, 2, 3, 4, 5 }
    }

    int main()
    int i;	// 错误：应该是“{”，而不是“int”
    {
    return 0;
    }

    int foo()
    {
    	int m[] = 5; // 错误：应该是“{”，而不是“5”
    	int n[] = { 2, 3, 5 }; // ok
    }

    class A {
    	int i;
    public:
    	A():i(10); // 错误：应该定义构造函数
    	A():i(10) {}; // ok
    };

消息标识：nolcurlerr

## 返回指向局部变量或临时的引用

不能在函数的作用域之外使用正在作为指向局部变量或临时变量的引用返回的值。 生成错误消息的代码示例：

    int &foo(int i)
    {
    return i; // 错误
    }

    int &foobar(int &i)
    {
    return i; // ok
    }

消息标识：nolocalname

## 无法返回指向位字段的引用

无法返回指向位字段的引用。 生成错误消息的代码示例：

    struct A {
    int i:3;
    int j:4;
    int k:5;

    int &foo() { return i; } // 错误：无法返回指向位字段的引用
    };

消息标识：noretbitref

## 无法在局部作用域内声明名称空间

无法在局部作用域内定义`名称空间`。 生成错误消息的代码示例：

    namespace names { //ok
    	int j;
    	int k;
    };

    void foo() {
    namespace ns { // 错误：局部作用域包含名称空间
    int i;
        };
    ns n;
    n::i++;
    }

消息标识：nolocalns

## long long 常量不允许与 -nocx 选项一起使用

(ccfe)：-nocx 选项禁止使用 long long 和 long long 常量。 生成错误消息的代码示例：

    long foo () { return 0ll; } // 错误 使用 -nocx 选项

消息标识：nollconst

## long long 不允许与 -nocx 选项一起使用

(ccfe)：-nocx 选项禁止使用 long long 和 long long 常量。 生成错误消息的代码示例：

    long long cll = 0;  // 错误 使用 -nocx 选项

消息标识：nolonglong

## long long 位字段是不允许的

不允许使用 `long long` 类型的位字段。 生成错误消息的代码示例：

    class a {
    	long long a:7; // 错误：long long 位字段是不允许的
    	int b:4;
    };

消息标识：nollbitfield

## 应该是左圆括号，而不是

表达式中应该有“(”，但未找到。 生成错误消息的代码示例：

    int i;

    for i = 0; i < 7; ++i ) {} // 错误：应该是“(”，而不是“i”

    if i < 7); // 错误

消息标识：nolparerr

## 应该是左方括号，而不是

cast 表达式或模板中缺少“<”时，可能会产生该错误。 生成错误消息的代码示例：

    class B { virtual void foo(); };
    class A:public B {};

    B *b = new A;
    A *a = dynamic_cast A*>(b);

    template class T>
    class D{};

消息标识：nolsserr

## 无法找到以初始化基类

基类没有匹配的构造函数，所以无法初始化该类。 生成错误消息的代码示例：

    class B {
    public:
    	int i;
    	 //B();
    	B(int x) { i = x; }
    };

    class A:B {
    	A() { // 错误：未找到基类的缺省构造函数 B::B()
    	}
    };

消息标识：nomatchbase

## 无法找到以初始化

对于调用，该类中的对象不包含匹配的构造函数。 生成错误消息的代码示例：

    class B {
    public:
    	int i;
    	 //B();
    	B(int x); // 已提供构造函数，编译器将不会生成缺省构造函数
    };

    class A {
    	B b_in_A; // 未初始化
    	int i;
    	A(int x) { // 错误：未找到初始化成员 b_in_A 时所用的缺省构造函数 B::B()
    	i = x;
    	B(1);
    	}
    };

消息标识：nomatchmem

## 无法找到匹配项

无法在重载函数和/或模板中找到调用时所用的函数的匹配项。 生成错误消息的代码示例：

    struct S { int &r; };
    int main() {
    struct S *x = new S(0); // 错误：未找到构造函数 S::S(int)
    };

    class A {
    public:
    int i;
    A();
    A(int a, int b);
    };

    void foo() {
    A a(1,2,3); // 错误：将三个参数传递给构造函数，不匹配
    }

消息标识：nomatchover

## 没有匹配的右括号

每个左括号必须有一个匹配的右括号。 生成错误消息的代码示例：

    int foo(   // 错误：没有匹配的“)”
    {
    int i = 3;
    reutrn 0;
    }

消息标识：nomatchrpar

## 无法使用 new 分配

无法使用 `new` 运算符分配引用和函数类型。 生成错误消息的代码示例：

    int main() {
    new (int&); // 错误：尝试使用 new 分配引用
    }

消息标识：nonewtype

## 无法找到以初始化基类

基类没有定义缺省的构造函数。如果基类已定义构造函数，则编译器不会生成缺省的构造函数。

    struct A { A(int); };
    struct C:A {};

    C c;    // 错误
    C c1(); // ok，缺省构造函数已由编译器生成

消息标识：nonulconbase

## 无法初始化 field2

结构类型的成员没有缺省的构造函数，或缺省构造函数无法由编译器生成，因为包含的类型至少有一个指定的构造函数。 生成错误消息的代码示例：

    struct B {
    int i;
    B(int x);
    };

    struct A {
    	B b_in_A; // A 没有缺省的构造函数。
    };

    A a; // 在此处标记错误

消息标识：nonulcon

## 无法找到以初始化向量

尚未生成或定义缺省的构造函数。无法初始化向量。 生成错误消息的代码示例：

    class A {
    public:
    int i;
    //A();
    A(int);
    };

    A *a = new A[8]; // 错误

消息标识：nonulvec

## const 对象调用非 const 函数

const 对象已经调用尚未声明为 const 的成员函数。 生成错误消息的代码示例：

    class A {
    public:
    A();
    int foo(int i)  {return i;}
    };

    void bar() {
    const int i = 7;
    A const a;
    a.foo(i);
    }

消息标识：nonconmf

## 指向非 const 成员函数的指针和 const 对象一起使用

const 对象已经调用尚未声明为 const 的成员函数。

消息标识：nonconmfp

## 引用返回值必须为左值

函数返回引用值，但返回的值不是左值。 生成错误消息的代码示例：

    int &foo()
    {
    	return 0;
    }

消息标识：nonvarref

## 将非左值转换为

无法将非左值转换为指定类型。

    int main() {
    const_cast<int&>(0);    // 错误：无法将非左值转换为 int&
    }

消息标识：nonlvalcast

## 函数无法返回值

函数无法返回值，因为声明的函数返回说明是 void。 生成错误消息的代码示例：

    void foo()
    {
    	int i = 3;
    	return i;   // 错误：函数的返回类型是 void，而不是 int
    }

消息标识：nonvoidret

## 为 volatile 对象调用非 volatile 函数

声明为 volatile 的对象只能调用 volatile 函数。 生成错误消息的代码示例：

    class A {
    public:
    void foo ();
    };

    int main()
    {
    A volatile a;
    a.foo(); // 错误：A::foo() 不是 volatile 函数
    }

消息标识：nonvolmf

## 指向非 volatile 成员函数的指针与 volatile 对象一起使用

成员函数必须声明为 volatile 指针要调用的 volatile。 生成错误消息的代码示例：

    class B {
    public:
    void bar();
    };

    void (B::* b_ptr)();

    int main()
    {
    B volatile *b;
    (b->*b_ptr)(); // 错误：B::bar() 未声明为 volatile
    }

消息标识：nonvolmfp

## 使用点或箭头调用

类的实例应该使用“.”或“->”调用成员函数。 生成错误消息的代码示例：

    class A
    {
    public:
    	void foo(){ /* code */ }
    };

    int main()
    {
    	A::foo();
    }

消息标识：noobjcall

## 应该为操作数，而不是

应为操作数，但是未找到。 生成错误消息的代码示例：

    void foo()
    {
    int i = 2;
    int j[5];
    i = j[]; // 错误：缺少子脚本
    i = [i]; // 错误：应该是 j[i]
    double d = ()i; // 错误：“()i”应该是“(double)i”
    }

消息标识：nooprnderr

## 无法从整数类型减去指针类型

无法从整数类型减去指针类型。 生成错误消息的代码示例：

    void foo()
    {
    int i = 2;
    int *j = &i;

    i = i - j;
    }

消息标识：noptrsub

## 需要指针类型，而不是

访问成员时，需要对象的指针类型。 生成错误消息的代码示例：

    class A {
    public:
    	int i;
    };

    void foo() {
    	A a;
    	a->i = 8; // 错误：“a”不是指针类型
    };

    void bar() {
    	int j;
    	j[0] = 7; // 错误：“j”不是指针类型
    }

消息标识：noptrvar

## 应该是右圆括号，而不是

数组子脚本存在语法错误。 生成消息的代码示例：

    int i[7];

    i[6} = 10; // 错误：应该是“]”

消息标识：norbrackerr

## 应该是右大括号，而不是

应该有“}”，但未遇到。 生成错误消息的代码示例：

    int a [2] = { 1, 2 ; // 错误，初始化程序的列表应该以
    // “}”终止

消息标识：norcurlerr

## 应该是右大括号，而不是 EOF

找到匹配的“}”之前，已遇到文件尾。 生成错误消息的代码示例：

    void foo()
    {
    	/* code */

    <EOF> // 错误，应该是“}”，但是遇到了 EOF

消息标识：norcurleof

## 当没有 RTTI 支持进行编译时忽略 typeid 或 dynamic_cast

如果设置标记 -feature=no%rtti，将会禁用 Typeid 动态转换。

消息标识：nortti

## 无法定义引用或指向引用的指针

引用或指向引用的指针是非法的。 生成错误消息的代码示例：

    const int &const &i = 12345678; // 错误

    int i;
    int &ri = i;
    int &(*pri) = &ri; // 错误

消息标识：noptrtoref

## 无法声明指向对象的引用

存在指向 void 类型的引用声明。 生成错误消息的代码示例：

    void &foo(); // 错误：将引用的返回类型声明为 void 类型

消息标识：noreftotype

## 无法声明指向成员类型的引用

声明指向成员类型的引用是非法的，因为这样会使他人对专用或受到保护的类成员数据进行访问。

消息标识：noreftomem

## 无法获取寄存器地址

寄存器没有地址。如果程序未作为 `C++` 程序进行编译，且尝试获取寄存器的地址，将会触发该错误。 生成错误消息的代码示例：

    register int i = 3;
    int *pi = & i;

消息标识：noregaddr

## 应该是右圆括号，而不是

存在语法错误。表达式中应该包含“)”标记。 可以生成错误消息的代码示例：

    void foo()
    {
    int i = 3;
    switch (i	// 错误：缺少“)”
      {
    	 case 2:
    		i++;
    		break;
      };
    }

    void foobar( int i; float j ) // 错误：“int i”之后应该跟“,”
    {
    	if ( i = 9)  // 错误：“=”应该是“==”
    		i++;

消息标识：norparerr

## 使用分号终止语句

语句必须以“;”结尾 生成消息的代码示例：

    int main()
    {
    	int i;
    	int j = 1;
    	i = j + 3  // 错误

    return 0;
    }

消息标识：nosemierr

## 使用分号终止声明

声明必须以“;”结尾 生成消息的代码示例：

    volatile int foo
    int goo ()

消息标识：nosemiheaderr

## 这里需要语句（即使为空）

这里需要语句（即使为空语句）。 生成错误消息的代码示例：

    void foo( int i ) {
    	if ( i < 10 )
    		++i;
    	else
    		// 错误：缺少语句
    }

消息标识：nostaterr

## 位字段不能是静态的

静态位字段是非法的。 生成错误消息的代码示例：

    class A {
    static int i:4; // 错误
    };

消息标识：nostaticbf

## 变量不是结构

变量不是结构的实例。 生成错误消息的代码示例：

    int main()
    {
    	int j;
    	j.novar = 7;
    return 0;
    }

消息标识：nostructsym

## 不能在非结构的类型中使用点运算符

不能在非结构的类型中使用点运算符。 生成错误消息的代码示例：

    int main() {
    int().a;    // 错误：int 不是结构类型
    }

消息标识：nostructype

## 已经使用该标记

已经使用该标记。 生成错误消息的代码示例：

    typedef int A;

    class A {};

消息标识：nostructerr

## 不是静态数据成员

静态成员由对象类型的所有实例共享。该成员不是静态的；因此，必须使用该对象的实例指定要使用的一个成员。 生成错误消息的代码示例：

    struct A {
    int i;
    void foo() { A::i = 2; } //ok
    };

    A::i = 7; // 错误，i 不是静态的

    void foo()
    {
    	A aa;
    	aa.i = 7; // ok
    }

消息标识：notastatmem

## 不是基类

`“using”`指令中应该有基类名称。 生成错误消息的代码示例：

    class t {
    public:
    int a;
    };

    class A {
    using t::a; // 错误：t 不是 A 的基类，无法使用 t::a
    };

消息标识：notbase

## 这里需要整型常量表达式

语法错误：需要整型常量表达式。 生成错误消息的代码示例：

    int a;

    enum {
    mem1 = a,   // 错误：这里需要整型常量表达式
    mem2,
    mem3
    } e;

消息标识：notconst

## 条件标签需要整型常量表达式

条件标签需要整型常量表达式。 生成错误消息的代码示例：

    int main()
    {
    int i = 0;

    switch(i) {
    case 4:	// ok
    case 3.141592654:	// 错误
    i++;
    break;
      };
    };

消息标识：notconstcase

## 在数组下标操作符中需要整型常量表达式

数组子脚本运算符只能使用整型常量。 生成错误消息的代码示例：

    int e[7];
    e[2.718281828] = 5; // 错误

消息标识：notconstsub

## 位字段需要整型常量表达式

位字段需要整型常量表达式 生成错误消息的代码示例：

    class A {
    int a:2; // ok
    int b:6; // ok
    int d:3.141592654; // 错误
    };

消息标识：notconstbit

## 该构造仅允许用于 C++

编译器已经遇到只允许在 `C++` 中使用的代码，且已经发出该警告。

消息标识：notcpp

## typedef 名无法用于复杂类型说明符

typedef 名无法用于枚举类型和类类型。 生成错误消息的代码示例：

    typedef struct S T;
    struct T *p; // 错误

    enum x { a, b }
    typedef enum x y;
    y x;      // ok
    enum y x; // 错误

消息标识：notdclass

## 函数定义不能是 typedef 声明

函数定义不能是 typedef 声明。 生成错误消息的代码示例：

    typedef int(mft)(int i);
    mft foo
    {	// 错误
    return i + 2;
    }

消息标识：notdfunc

## 应该有类模板名，而不是

应该有类模板名，但未找到。 生成错误消息的代码示例：

    int foo () { return 0; }

    template<> int foo(); // 错误：foo 不是模板类名

消息标识：notempname

## 没有参数提供给模板

要指定为其生成模板的对象类型，模板化类中必须具有参数。 生成错误消息的代码示例：

    template<class T>
    class A {
    int i;
    T *data;
    public:
    A(int length=10) :data(new T[length]) {}
    };

    int main() {
    A   a;  // 错误：模板需要参数
    return 0;
    }

消息标识：notempparm

## 没有实例化提供给模板的参数

获取几个参数时，已声明模板类，但在实例化过程中并未提供这些参数。 生成错误消息的代码示例：

    template <class A>
    class B {};

    template class B<>; // 错误：必须提供模板参数

消息标识：notemparg

## 只有函数可调用

无法调用对象。只能调用函数。 生成错误消息的代码示例：

    void foo() {}

    int main()
    {
    	int i;
    	i(); // 错误：只能调用函数
    	foo(); // ok
    return 0;
    }

消息标识：notfunc

## 声明没有指定标记或标识符

声明中必须有标记或标识符。 生成错误消息的代码示例：

    int;
    float;
    enum E;

消息标识：nothingdecl

## 对象的先前声明有一个异常规范

根据标准，运算符 new 应该具有异常规范。 生成警告消息的代码示例：

    #include <new>

    // 正确的声明：
    // void* operator new(size_t) throw(std::bad_alloc);

    void * operator new (size_t); // 错误

消息标识：nothrownew

## 对象的先前声明有一个异常规范（警告）

该运算符以前有一个异常规范。调用该运算符时，将不会抛出异常。 生成警告消息的代码示例：

    #include <stddef.h>
    void* operator new[] (size_t); // 警告：原始运算符 new 抛出“std::bad_alloc”

消息标识：nothrowneww

## 对象的先前声明没有一个异常规范

（兼容模式）过时的 new 运算符不会使用异常规范。 生成错误消息的代码示例如下（仅限兼容模式）：

    #include <new.h>

    void* operator new(size_t) throw(std::bad_alloc); // 错误：对运算符 new 而言，
    // 禁止在兼容模式下使用
    // 异常规范

消息标识：nothrowold

## 该条件标签不在 switch 语句中

条件标签只能在 switch 语句中使用。 生成错误消息的代码示例：

    int main()
    {
    	int i = 7;

    	case 7:		// 错误：case 语句不在 switch 语句中
    		i++;
    		break;

    return 0;
    }

消息标识：notinsw

## 该缺省标签不在 switch 语句中

缺省标签只能在 switch 语句中使用。 生成错误消息的代码示例：

    int main()
    {
    	int i;

    	default:
    		i = 3;
    return 0;
    }

消息标识：notinswdef

## 右边必须是成员指针

\".*\" 或 \"->*\" 右边使用的指针不是成员指针。

    struct S {
    	  int i;
    };

    void foo()
    {
    	int y;
    	S cs;
    	int S::* pm = &S::i;	// pm 引用的是成员 S::i
    	cs.*pm = 88;	        // Ok
    	cs.*y = 88;		// 错误：不是成员指针
    					“.*”或“->*”的右边必须是成员指针

    }

消息标识：notmembptr

## 只能调用生成的函数

只能调用从 `.*` 或 `->` 生成的函数，但无法获取其地址。 生成错误消息的代码示例：

    class A {
    public:
    void foo() {}
    };

    void (A::* f_ptr) ();

    int main() {
    A a;
    f_ptr = A::foo;
    a.*f_ptr;       // 错误：只能调用函数。无效代码是
    //        (a.*f_ptr)();
    }

消息标识：notmembcall

## 不是名称空间或类名

用户尝试为非名称空间创建名称空间别名时，通常会产生该错误。 生成错误消息的代码示例：

    struct not_a_namespace {};

    int main() {
    namespace alias=not_a_namespace; // 错误：尝试为结构创建别名
    }

消息标识：notnamespace

## 以前已定义，但不是名称空间

标识符已被使用，所以无法重新定义为名称空间。 生成错误消息的代码示例：

    int n;

    namespace n {  // 错误
    int i;
    };

消息标识：notnsname

## 已定义但未使用

编译器已经找到代码中未使用的声明对象，且已经发出该警告。 生成警告消息的代码示例：

    void foo() {
    int i; // 未使用 i
    }
    void foobar( int a,	// 未使用 a
    	     int b )	// 未使用 b
    {}

消息标识：notused

## 未定义 type_info

如果要执行该操作，则必须包含文件 `typeinfo.h`，以便使用 `type_info` 类。否则，如果希望未来的程序可以将 `typeinfo` 类用于 RTTI 支持，建议选择其它名称。

消息标识：notypeinfoh

## 必须为类名，而不是名称空间的名称

using 声明应该使用是基类的类名。使用的名称已是名称空间。 生成错误消息的代码示例：

    namespace NS {int j; }
    //. . .

    class A:NS {
    	using NS::j;
    };

消息标识：nsnotall

## 必须为名称空间的名称，而不是类名

using 指令应该使用名称空间的名称。使用的名称已是类类型的名称。

    struct A{int j;};
    void foo()
    {
    	using A::j; // 错误：foo 中应该有名称空间。
    }

消息标识：nsnotcl

## 未使用标签

编译器已经找到从未使用的标签，且已经发出该警告。 生成警告消息的代码示例：

    void foo() {
    int i = 0;
    goto b:
    a:
    --i;
    b:
    ++i;
    };

消息标识：labelnotused

## 应该是类型名，而不是

应该是类型名，但未找到。导致该错误产生的情况有很多。 生成错误消息的代码示例：

    class A:// 错误：缺少基类名
    {};

    struct B {
    int i;
    	j; // 错误：应该是类型名，而不是“j”
    };

    struct D :B, { // 错误：“,”之后应该是其它基类名
    int j;
    D() :{ j = 10; };
    // 错误：应该是类型名，而不是“{”，缺少初始化程序
    };

    template <class T, class K>
    class A {};

    A<int, > a; // 错误：逗号后面缺少类型名

消息标识：notypenameerr

## 对于预定义的宏，#define 和 #undef 是不合法的

预定义的宏由编译器使用，所以不能被定义或取消定义。

消息标识：noundef

## 联合不能有基本类型

联合不能有基本类型。 生成错误消息的代码示例：

    class C {
    	int i;
    };

    union B:C { // 错误
    	int j;
    };

消息标识：nounionbase

## 联合不能用作基本类型

联合不能有基本类型。 生成错误消息的代码示例：

    union C {
    	int i;
    };

    union B:C { // 错误
    	int j;
    };

消息标识：nounionasbase

## 联合不能有虚拟函数

联合不能有虚拟函数。 生成错误消息的代码示例：

    union A {
    int i;
    void foo() {};		// ok
    	virtual void foobar() {};	// 错误
    };

消息标识：nounionvirt

## 类型空 (void) 的值是不允许的

类型数据 `void` 不是值。 生成错误消息的代码示例：

    foo()
    {
    int i = (void)1;
    }

消息标识：novoidval

## 无法非关联化 void*

无法非关联化 `void` 指针。void 没有值。 生成消息的代码示例：

    void *i;
    int j = *i; // 错误：无法非关联化 void*

消息标识：novoidderef

## 应该是 while，而不是

在 `do-while` 循环中，`do` 块必须以 `while` 语句结尾。 生成错误消息的代码示例：

    void foo()
    {
    	int i = 0;
    	int j = 7;
    	do {
    	i++;
    	}  // 错误：应该是“while”，而不是“}”

    	i = 0;
    	do {
    	i++;
    	} while ( i < j); // ok
    }

消息标识：nowhileerr

## 在类中不能有 using 指令

不能在类中使用 Using 指令。 生成错误消息的代码示例：

    namespace NS { int j; };

    class A {
    using namespace NS;
    };

消息标识：nsdirinclass

## 初始化为空 (NULL) 值

引用初始化表达式的值为零。 生成错误消息的代码示例：

    static int zero;
    int& c = *(int*)0;  // 警告：引用初始化的值为零

消息标识：nullref

## 没有基类或成员名用于初始化程序

不使用类名或成员名称的基类初始化当前已经过时。 生成错误消息的代码示例：

    struct A {
    int i;
    	A(int);
    };

    struct B:A {
    int j;
    B() :(3) { // 错误
    	   	j = 7;
    	};
    };

消息标识：obsinit

## 其它对象不能在函数定义中声明

函数定义不能声明其它对象。只有类定义才能声明其它对象。同时声明函数和对象时，将不会触发该错误，除非该函数以其它对象的声明结尾。 生成错误消息的代码示例：

    int	i,
    	foo() { // 错误：此处无法声明函数。
    		return 0;
    	} int j;

消息标识：onlyonefunc

## 整型溢出或除以零

表达式已经溢出 `int` 的大小，或数字已被零除。

消息标识：overflow

## 编译器内存不足

该编译器内存不足。释放一些资源，然后再试。

消息标识：outofmem

## 部分加括号的初始化

使用“+w2”标记进行编译时，如果不使用括号初始化结构成员，将会生成警告。 生成错误消息的代码示例：

    struct B {
    int i;
    int j;
    } X[] = { 1, 2, 3, 4 };

消息标识：partinit

## 先前没有 #if 与该指令相对应

`#else` 指令之前必须有一个与之对应的 `#if` 指令。 生成错误消息的代码示例：

    //#if true
    #define num 1
    #else num 0
    // . . .

消息标识：ppbadelse

## 先前没有 #if 与该 #endif 相对应

预处理程序指令 `#endif` 必须有一个与之对应的 `#if`。

消息标识：ppbadendif

## 该行有多余的文本

预处理程序命令之后的文本多余。 生成错误消息的代码示例：

    #include <file.h>; // 错误：删除多余的“;”

消息标识：ppextra

## ANSI C 不允许该行有多余的文本 - 忽略

该行中的多余文本已在 ANSI C 忽略。

消息标识：ppextraw

## 用作后缀运算符

仅声明了前缀增减运算符。使用之前，还必须声明后缀运算符。 生成错误消息的代码示例：

    class A {
    public:
    	int i;
    A operator ++(); // 声明前缀运算符 ++
    };

    int main()
    {
    	A a;
    	a++; // 错误：重载后缀运算符 ++，以便进行更正
    }

消息标识：postincdec

## 在函数原型中使用之前先声明

应该在函数原型中使用之前声明结构和枚举类型。如果对编译器进行设置，使其在 C 模式下编译，将会显示该消息。

消息标识：protodec

## 无法为抽象类创建变量

一个或多个纯虚拟函数的抽象类只能用作基类。无法直接创建抽象类的实例。必须创建派生类的对象。 生成错误消息的代码示例：

    class A {
    virtual void foo() = 0;
    virtual int bar() = 0;
    };

    A a; // 错误

消息标识：purealloc

## 无法声明抽象类型的成员

抽象类型不能用作成员。如果该成员是派生类，确保该类已经在基类中定义所有的纯虚拟函数。 生成错误消息的代码示例：

    class B {
    virtual void foo() = 0;
    };

    class X { B b; }; // 错误：B 是抽象类型

    template < class T >
    class Y {};
    Y<B> y; // 错误

消息标识：puremem

## 无法获取抽象类的参数

参数不能是抽象类型。

消息标识：pureparm

## 无法返回抽象类的值

返回类型说明不能是抽象类。抽象类尚未实现，所以无法予以使用。如果返回说明是派生类，确保该类已经在基类中定义所有的纯虚拟函数。 生成错误消息的代码示例：

    class B {
    virtual B foo(B) = 0; // 错误：foo(B) 返回抽象类型
    };

    class A:B {};

    A bar() { // 错误
    A* a;
    return *a;
    }

消息标识：purert

## 无法创建抽象类的值

无法从抽象类创建值。 生成错误消息的代码示例：

    class A {
    public:
    virtual int foo () = 0;
    };

    class B :public A {
    public:
    virtual int foo () { return 0; };
    };

    int main() {
    B * b = new B();
    A& a = (A) *b;  // 错误：A 是抽象类
    }

消息标识：pureval

## 尚未被覆盖

覆盖基类的纯虚拟函数之前，已经实例化抽象类的派生类变量。 生成错误消息的代码示例：

    class B {
    virtual void foo() = 0;
    };

    class A:B {};

    A a; // 错误

消息标识：puref

## 不能有类型限定符

要指定不同的作用域，就不能使用类型限定符声明成员。

    class A {
    };

    class B {
    void A::foo(); // 错误：不能使用类型限定符
    void B::goo(); // 确定。goo() 已在类 B 中声明
    };

消息标识：qualnotok

## 在参数列表中只允许存储类为寄存器

参数列表中只允许有存储类 `register`。不允许有 `static`、`extern` 和 `mutable`。 生成错误消息的代码示例：

    class A {
    void foo( register int a,// ok
    	    mutable int b, // 错误
    	    extern c,      // 错误
    	    static int d,  // 错误
    	    auto int e )   // ok
        {}
    };

消息标识：registeronly

## 匿名联合成员与其包含类使用相同的名称

匿名联合成员与其包含类的名称不能相同。 生成错误消息的代码示例：

    class A {
    union {
    int i;
    long j;
    int A;  // 错误
      };
    };

消息标识：sameanon

## 枚举器与其包含类使用相同的名称

枚举器与其包含类的名称不能相同。 生成错误消息的代码示例：

    class A {
    enum e { A, B, C }; // 错误
    };

消息标识：sameenum

## 静态成员与其包含类使用相同的名称

静态成员与其包含类的名称不能相同 生成错误消息的代码示例：

    class A {
    	static int A;
    };

消息标识：samestatic

## 类型与其包含类使用相同的名称

不能在相同名称的类中定义类型。 生成错误消息的代码示例：

    class A {
    typedef struct { int a; } A; // 错误：类 A 和 typedef A 具有相同名称
    };

消息标识：sametype

## 需要一个标量类型的表达式

表达式必须是标量类型。 生成错误消息的代码示例：

    class A {
    public:
    A() { i = 0; }
    int i;
    A foo() { return *this; }
    };

    void foo() {
    A a;
    if( a ){ // 错误：应该是标量类型，而不是类型 A
      }

    for( a.i;
    a;    // 错误
    a.i++) {}
    }

消息标识：scalarexpected

## sizeof 不可以应用于位字段

`sizeof` 不能应用于位字段。 生成错误消息的代码示例：

    class A {
    public:
    A() { size = sizeof(i); }
    int i:3;
    int size;
    };

消息标识：sizeofbf

## sizeof 不可以应用于函数

`sizeof` 不能应用于函数。它只能应用于主类型、类对象和表达式。 生成错误消息的代码示例：

    int i;
    int j;
    int foo(int k);
    int goo();

    k = sizeof (i*j*foo(10));	 // ok
    k = sizeof (unsigned int);	 // ok

    k = sizeof(foo);		 // 错误
    k = sizeof(goo);		 // 错误

消息标识：sizeoffunc

## 不能同时具有静态和非静态版本

重载函数不能同时具有静态和非静态这两种版本。 生成错误消息的代码示例：

    class A {
    static void foo();
    void foo(); // 错误
    };

消息标识：statnonconf

## 此处不允许使用说明符

语法错误。此处不允许使用说明符。 生成错误消息的代码示例：

    inline class A{}; // 错误
    virtual void foo(); // 错误

    void foo() {
    virtual  void f1(); // 错误
    friend void f2(); // 错误
    explicit void f3(); // 错误
    };
    void foo() {}

消息标识：storenotok

## 是不允许的，并且正在被忽略

说明符不允许在此处使用，所以被编译器忽略。如果尝试对模板执行 typedef 操作，也会发出该消息。 生成警告消息的代码示例：

    template <class T> static class A; // 警告：“static”不允许，所以被忽略

消息标识：storenotokw

## 浮点减法运算存在溢出，转交运行时处理

编译器已经确定，浮点数字减法运算溢出，交由运行时处理。

消息标识：subfovfl

## 该条件忽视局部变量的初始化

局部变量被忽视，所以无法进行初始化。 生成错误消息的代码示例：

    void foo()
    {
    int i=7;
    switch(i) {
    case 7:
    break;
    int j = 2;
    default:// 该 case 忽视局部变量 j 的初始化
    i = 8;
            }
    }

消息标识：swuninit

## 模板参数需要类型参数

为该模板参数提供的类型无效，或未提供参数。 生成错误消息的代码示例：

    template <class T, class K>
    class B {
    public:
    T t;
    K k;
    };

    B<int> b1; // 错误：B<T,K> 需要其它模板参数
    B<int, 12345> b2; // 错误：12345 无效

消息标识：temargnotype

## 模板参数需要类型的表达式

表达式与模板参数的类型不匹配。更多//没有对对象类型引用的非类型模板参数应用转换。 生成错误消息的代码示例：

    template <int i> class A {int i;};
    ;

    A<3.141593> a1; // 错误：参数不是 int
    A<3> a2; // ok

    template<class T, char* p> class D {
    	D();
    D(const char* q);
    };

    D<int,"penny"> x1; //  错误：字符串文字作为模板参数

    char p[] = "dime";
    D<int,p> x2;       //  OK

消息标识：temargnoval

## 空指针转换无法应用于模板参数

已经将错误类型的实际参数作为模板参数进行传递。通常，这意味着，NULL 指针已经作为指针类型的模板参数加以传递，进而会产生错误，因为不能对模板参数应用 NULL 指针转换。 生成错误消息的代码示例：

    template <char * i> class A {};

    int main() {
    A<0> a;
    }

消息标识：tempargnullptr

## 函数模板不能有缺省模板参数

类模板和类成员函数只能使用缺省的模板参数。 生成错误消息的代码示例：

    template <class T=int>
    T foo();

消息标识：temdefparms

## 非类型模板参数不允许用于函数模板

非类型模板参数不允许用于非成员函数。 生成错误消息的代码示例：

    template <int x>
    int foo();

消息标识：temfuncnontype

## 模板中参数太多，被忽略

模板的参数太多。

消息标识：temmanyargs

## 模板只能声明类或函数

只能将模板用于类和函数。 生成错误消息的代码示例：

    template < class T >
    int i;

消息标识：tempnotfunc

## 模板只能在全局级别声明

模板只能在全局级别声明。 生成错误消息的代码示例：

    void foo() {
    int i;
    template <class T> class B { int j; }; // 错误
    };

消息标识：temnotglob

## 模板嵌套太深（递归？）

模板的嵌套深度只能有 20 层。

消息标识：temtoodeep

## 不允许使用限定符

无法限定成员。

消息标识：tdefqual

## 异常规范包含两个相同的对象类型

异常规范包含两个相同的对象类型。 生成警告消息的代码示例：

    void foo() throw(float i, float j);

消息标识：tltwice

## 不在当前的异常规范中

异常规范已经通过声明发生更改。异常规范必须匹配。 生成错误消息的代码示例：

    void foo() throw(int i);

    // . . .

    void foo() throw(float i ) {} // 错误

消息标识：tnotinnew

## 不在以前的异常规范中

以前的异常规范不包含当前的参数类型。异常规范必须匹配。 生成错误消息的代码示例：

    void foo() throw();

    // . . .

    void foo() throw(float i ) {} // 错误

消息标识：tnotinold

## 调用的参数太少

调用函数时使用的参数比声明函数时使用的参数少。 生成错误消息的代码示例：

    void foo( int i, int j ) {}

    int main()
    {
    foo(1); //错误：调用 foo() 时所用的参数不足
    return 0;
    }

消息标识：toofewargs

## 宏中的参数太少

调用宏时使用的参数比定义宏时使用的参数少。 生成警告消息的代码示例：

    #define mask             0xffff00
    #define getField(data, mask)  data & mask // 定义宏时使用 2 个参数

    int field = getField( 1 ); // 错误：调用宏时使用 1 个参数

消息标识：toofewmargs

## 模板的参数太少

模板使用的参数比提供的参数多。 生成错误消息的代码示例：

    template <class A1, class A2> class B {};

    int main() {
    B<int> b;
    }

消息标识：toofewtargs

## 调用时使用的参数太多

调用函数时使用的参数比声明函数时使用的参数多。 生成警告消息的代码示例：

    void foo( int i, int j ) {}

    int main()
    {
    	foo( 1, 2, 3 )
    return 0;
    }

消息标识：toomanyargs

## 转换时使用的参数太多

遇到语法错误，传递给转换表达式的参数太多。 生成错误消息的代码示例：

    class A {
    public:
    operator long ();
    };

    int main() {
    long t = long(A(), 0); // 错误：转换为 long 时所用的参数太多
    // 应该是：
    // long t = long(A());
    }

消息标识：toomanycargs

## 宏中的参数太多

调用宏时使用的参数比该宏定义的参数多。 生成错误消息的代码示例：

    #define mask             0xff0000
    #define getField(data,mask)  data & mask   // 使用 2 个参数定义宏

    int field = getField( 1, 2, mask ); // 调用宏时使用 3 个参数

消息标识：toomanymargs

## 初始化程序太多

构造函数的初始化出现只能有一个参数。 生成错误消息的代码示例：

    class A {
    int i;
    A():i(1,2) {}
    };

消息标识：toomanynargs

## 模板参数太多

模板的参数太多。 生成错误消息的代码示例：

    template< class T, class K > // 2 个模板参数
    class A {
    T t;
    K k;
    };

    A<int, float, long> a; // 错误：3 个模板参数

消息标识：toomanytargs

## 只能将访问更改为公共的 (public) 或受保护的 (protected)

无法将类成员的访问级别更改为专用 (private)。只能将访问更改为公共的 (public) 或受保护的 (protected)。 生成错误的代码示例：

    class A {
    public:int i;
    };

    class B :A {
    private:A::i;
    };

消息标识：topubliconly

## 初始化两次

值已初始化两次。 生成错误消息的代码示例：

    class A {
    public:
    static const int j = 9;
    A() {}
    };
    const int A::j = 9; // A::j 已初始化两次

消息标识：twoinits

## 太复杂

表达式太复杂。 生成错误消息的代码示例：

    void foo() {
    int **************************i;
    **************************i = 9; // 错误：太复杂，26 个“*”
    }

消息标识：twtoocomp

## 遇到未预料到的类型名称

使用函数或类之前，尚未定义类型名称。 生成错误消息的代码示例：

    template<class T>
    class A {
    	T t;
    };

    class B{
    	int i;
    };

    int main() {
    	A<float> a; // ok
    	B<int> b; // 错误：未定义类型 B 的模板
    }

消息标识：typenotall

## 变量尚未赋值

已经使用尚未赋值的变量。 生成警告消息的代码示例：

    void foo()
    {
    	int i;
    	i++;
    }

消息标识：unassigned

## 未定义

标识符已经使用，但尚未定义。 生成错误消息的代码示例：

    void foo()
    {
    int i;
    j++; // 错误：未定义 j
    }

消息标识：undefidenterr

## 未定义模板

将其用作模板类型参数之前，必须定义模板 生成错误消息的代码示例：

    template <t_arg<int> > struct tmp {};   // 错误：未定义 t_arg

消息标识：undeftemperr

## 比较结果未使用

比较结果未使用。 生成警告消息的代码示例：

    void foo()
    {
    int i = 9;
    i == 9; // 警告：结果未使用
    	i++;
    }

消息标识：unusedcomp

## 构造函数不能是虚拟的

不允许使用虚拟的构造函数。 生成错误消息的代码示例：

    class A {
    int a;
    virtual A(); // 错误
    };

消息标识：virtconstr

## 虚拟友元函数需要合格的类名

虚拟友元函数需要限定类名。 生成错误消息的代码示例：

    void foo() { return; }
    void goo() { return; }

    class A {
    virtual friend void foo();    // 错误
    	virtual friend void A::goo(); // ok
    };

消息标识：virtfriend

## 应该返回一个值

函数应该返回一个值，但返回的是 void。 生成错误消息的代码示例：

    int foo()
    {
    	return; // 错误：返回类型应该是 int
    }

消息标识：voidret

## & 符号运算符只能应用于变量或其它左值

只能对变量或左值应用运算符的地址。要获取的地址必须存在。 生成错误消息的代码示例：

    int *i = &3; // 错误：“3”不是左值

消息标识：wantvarname

## ANSI C 要求位字段应该为有符号或无符号的整型

ANSI C 只支持带符号或无符号的 int 位字段。

消息标识：wbadbftype

## 以前尚未声明

运算符 new 或 delete 应该具有不同的链接。 生成警告消息的代码示例：

    #include <new>

    // 警告：new 应该是静态的（它已经声明为 extern）。
    static void* operator new(size_t) throw(std::bad_alloc);

消息标识：wbadlinkage

## 空的声明（可能有多余的分号）

声明为空。最有可能的原因是有多余的分号。 生成错误消息的代码示例：

    ; // 警告：无声明

    namespace NS{}; // 警告：名称空间 NS 在结尾处的分号多余

    }; // 错误：右括号不匹配

消息标识：wemptydecl

## 声明没有指定标记或标识符

(Kernigan and Ritchie):声明中必须有标记或标识符。 生成错误消息的代码示例：

    struct {};  // 错误

消息标识：wnothingdecl

## 赋值

将类型赋值给不兼容的类型。类对象类型可能需要构造函数、转换函数或重载赋值运算符。 生成警告消息的代码示例：

    class B{
    	int i;
    };

    class A:B {
    	int j;

    };

    void foo()
    {
    	A a;
    	B b;
    	a = b; // 错误
    	b = (B)a; // 错误：对类型 B 而言，A 中没有构造函数或转换函数。

    	A *pa = &a;
    	B *pb;
    	pb = (B*)pa; // ok，pa* 已转换为指向基类的指针
    }

消息标识：wbadasg

## 字符串文字在赋值中转换为 char*

赋值时，字符串文字已转换为 char*。 生成警告消息的代码示例：

    void foo() {
    char *s;
    s  = "abcd"; // 警告
    }

消息标识：wbadasgl

## 用来初始化

使用不同类型初始化类型时会发出警告。

消息标识：wbadinit

## 用来初始化 L

已经使用字符串文字初始化不同的兼容类型。

    void foo()
    {
    char * s = "f"; // 警告：使用常量 char* 初始化 E
    }

消息标识：wbadinitl

## 应该返回一个值

(Kernigan and Ritchie):声明函数返回一个值，但没有返回。 生成错误消息的代码示例：

    int foo()
    {
    	return; // 错误：foo() 应该返回一个值
    }

消息标识：wvoidret

## 隐藏

函数中的变量会隐藏类成员名称。 生成警告消息的代码示例：

    class A {
    int i;

    void foo() {
    int i; // 警告：i 会隐藏 A::i
            }
    };

消息标识：wvarhidemem

## 在外部作用域隐藏相同名称

变量会在外部作用域隐藏变量名称。 生成警告消息的代码示例：

    void foo() {
    int i;
    for ( int i = 0; // 警告：i 会在外部作用域隐藏变量。
    	i < 10;
    	++i ){};
    }

消息标识：wvarhidenmem

## 在 #pragma init/fini 中，应该为没有参数的空函数

只能将没有参数的空函数作为参数传递给 init 或 fini pragma。 生成错误消息的代码示例：

    void my_fini (int a) { }
    #pragma fini(my_fini)

消息标识：prbadfunc

## #pragma 中的列表为空

一些 pragma 要求至少传递一个参数。 生成错误消息的代码示例：

    #pragma fini ()

消息标识：premptylist

## 对齐无效，有效值是： 1,2,4,8,16,32,64,128

对齐值必须是幂为 2 的非负整数，但其最大值必须为 128。 生成错误消息的代码示例：

    #pragma align 256 ( an_int, a_ptr, a_struct, a_class )

消息标识：prbadalign

## 没有声明为函数

一些 pragma 要求其参数是函数。 生成错误消息的代码示例：

    int my_fini;
    #pragma fini(my_fini)   // 错误：my_fini 不是函数

消息标识：prnotfunc

## 在 #pragma 中引用的对象应该为全局的，并且已预先声明

如果函数在任何 pragma 参数列表中显示，则首先应该声明函数。 生成错误消息的代码示例：

    #pragma fini(my_fini)   // 错误：应该首先声明 my_fini
    void my_fini (int a) { }

消息标识：prnotdecl

## pragma 中语法错误

Pragma 语句不正确。最有可能的是，忽视了必需的 pragma 参数。 生成错误消息的代码示例：

    int a, b, c;
    #pragma align (a, b, c)

消息标识：prsyntax

## 在 #pragma ident 之后需要字符串文字

`#pragma ident` 之后缺少字符串文字。

消息标识：prnostr

## 在 #pragma 列表中缺少","

用作 pragma 参数的分隔符的符号错误。 生成错误消息的代码示例：

    void my_init1 () { }
    void my_init2 () { }
    void my_init3 () { }

    #pragma init(my_init1,my_init2.my_init3)

消息标识：prnocomma

## 在 #pragma 中缺少"("

Pragma 参数列表应该以‘(’开头。 生成错误消息的代码示例：

    void my_init1 () { }

    #pragma init my_init1)

消息标识：prnolp

## 在 #pragma 中缺少")"

参数列表中缺少‘)’或符号错误。 生成错误消息的代码示例：

    void my_init1 () { }
    void my_init2 () { }
    void my_init3 () { }

    #pragma init(my_init1,my_init2.my_init3)

消息标识：prnorp

## 行

编译器使用该消息显示包含错误消息的行号。

消息标识：linetheword

## Asm 语句没有字符串

`asm` 语句中必须包含字符串文字。 生成错误消息的代码示例：

    void foo()
    {
    asm( nop ); // 错误
    }

消息标识：noasmstring

## Asm 语句不允许出现在函数之外

`asm` 语句不允许在函数之外使用。 生成错误消息的代码示例：

    asm(" nop  "); // 错误

    void foo()
    {
    asm(" nop "); // ok
    }

消息标识：asmnotinfunc

## 标记需要值

指定的标记需要值。

消息标识：cmd_needvalue

## 警告：该标记不能与此标记一起使用

不能同时指定某些 CC 标记（例如，+e0 和 -compat=5）。

消息标识：cmd_badflag

## 没有输入文件

未传递输入文件时，ccfe 会发出该错误。

消息标识：noinpfile

## 无法打开输入文件

缺少或无法访问传递到编译器的文件，所以无法将其打开。

消息标识：openinpfile

## 无法打开输出文件

预处理程序无法打开输出文件。请检查文件权限和/或可用的磁盘空间。

消息标识：openoutfile

## 文件的最后一行没有用新行终止

该警告指出，文件没有以新行的字符结尾。

消息标识：nonewline

## "mutable"不允许在类之外

不能在类之外使用关键字 `mutable`。使用 mutable，可以对声明为 `const` 的类对象中的字段进行修改。 生成错误消息的代码示例：

    void foo()
    {
    	mutable int i = 0; // 错误
    }

    class A {
    	mutable int i; //ok
    };

消息标识：mutclassonly

## 函数不能声明为 mutable

`mutable` 只能供成员数据使用。 生成错误消息的代码示例：

    class A {
    public:
    mutable int i; //ok
    mutable void foo() {} // 错误
    A() {}
    };

消息标识：mutnofunc

## 常量名不能声明为 mutable

`const` 名称也不能声明为 mutable。 生成错误消息的代码示例：

    class A {
    public:
    A(int j) { i = j; };
    mutable const int i; // 错误
    };

消息标识：mutnoconst

## 只有非静态数据成员可以是 mutable

静态数据成员不能是 mutable。 生成错误消息的代码示例：

    class A {
    public:
    mutable static int i;
    };

消息标识：mutdatamems

## 必须使用 C++ 声明

必须使用 `C++` 语言声明重载运算符

    class A {};
    extern "C" A& operator *(A&, A&);

消息标识：mustbecpp

## 友元声明中不允许有完整的类定义

不能在友元声明中指定类定义。 生成错误消息的代码示例：

    class A {
    friend class B {}; // 错误：友元声明中有类定义
    };

消息标识：nofrienddef

## 之前未找到冒号

冒号之前没有类成员访问级别的说明。此处，冒号之后必须跟 Private、protected 和 public。 生成错误消息的代码示例：

    class A {
    public	// 错误：“:”之前没有 public
    int i;
    };

消息标识：nocolaftacc

## 在宏参数中遇到文件尾

在宏参数的结尾处发现文件尾。

    #define foo( A, B, C )
    foo(1, 2,     // 错误：缺少参数。
    <EOF>

消息标识：eofinmargs

## C++ 不支持隐式的 int

`C++` 不支持使用隐式 int 声明的变量。应该指定该类型。 生成警告消息的代码示例：

    i[] = {1, 2, 3};

消息标识：noimplint

## 之前应该有类或结构

模板声明中应该有类关键字。如果函数模板声明不正确，似乎是类模板声明，也会产生该错误。 生成错误消息的代码示例：

    template <class T> A // 错误：缺少类关键字
    {
    int i;
    int j;
    };

    template <class T> foo :/* . . . */ ; // 错误

消息标识：noclasskey

## 局部类型无法用作模板参数

局部定义的类型无法用作模板参数。 生成错误消息的代码示例：

    template < class T >
    class A {};

    void foo()
    {
    	class B {};
    	enum E {one, two, three};
    	A<B> a1; // 错误
    	A<E> a2; // 错误
    }

消息标识：nolocaltarg

## 模板参数不能是未命名的类型。

模板参数不能是未命名的类型。与此同时，也不能在模板参数中定义类型。 生成错误消息的代码示例：

    template < class T >
    class A {
    T t;
    };

    A<class{}> a;	// 错误：结构没有类型名称。
    		// 要使用用户定义的类型，请在使用前先定义该类型。

消息标识：nounnamedtarg

## 初始化程序列表中出现意外

分析构造函数的初始化列表时，已经检测到语法错误。 生成错误消息的代码示例：

    class A {
    int a;
    long b;
    int c[2];

    A() :a(0) :b(0) {}    // 错误：初始化列表中出现意外的“:”
    };

消息标识：unexpinitl

## 错误类文件格式，终止的代码

这是 Java 本地编译器使用的内部消息

消息标识：jdeadcode

## 找不到文件

这是 Java 本地编译器使用的内部消息

消息标识：jnoclass

## 找不到定义

这是 Java 本地编译器使用的内部消息

消息标识：jnomember

## 错误类文件格式，常量池入口

这是 Java 本地编译器使用的内部消息

消息标识：jbadcpool

## 错误类文件格式，类型代码

这是 Java 本地编译器使用的内部消息

消息标识：jbadtcode

## 错误类文件格式，非法字节代码

这是 Java 本地编译器使用的内部消息

消息标识：jbadbcode

## 导出忽略 -- 尚未执行

已经忽略`导出`。尚未执行该导出。

消息标识：exportnotimpl

## 模板关键字丢失

在模板声明中，在“<”之前找不到关键字 `template`。 生成错误消息的代码示例：

    export <class T>  // 错误
    class A {};

消息标识：notemplkey

## 旧的显式专门化语法

找到过时的显式专门化语法之后，已经发出该警告。 新的显式专门化语法如下： template-id:template-name < template-argument-listopt > template-name:identifier template-argument-list:template-argument template-argument-list , template-argument template-argument:assignment-expression type-id id-expression

消息标识：oldexpspecial

## 显式的非类、非函数的实例/专门化还未执行

尚未在该编译器中执行显式的非类、非函数实例化/专门化。

消息标识：noexpimpl

## 使用操作符 -> 无限递归

类已经重载“->”运算符。该运算符返回一个类类型的值。 生成错误消息的代码示例：

    class A {
    public:
    int j;
    A operator->(); // 返回 A
    };

    void foo() {
    A a;
    a->j = 9; // 错误
    };

消息标识：recurarrow

## 重载运算符应该返回指针

重载运算符 -> 应该返回执行类类型对象的指针。 生成错误消息的代码示例：

    class B{
    public:
    int j;
    B operator->(); // 返回 B
    B& operator->();
    };

    void foo() {
    B b;
    b->j = 7; // 错误：具有二义性，运算符 ->() 返回 B
    };

消息标识：recurarrow2

## 可疑的返回类型

重载“->”运算符应该返回指向类类型对象的指针。 生成警告消息的代码示例：

    class A {
    public:
    int* operator->(); // 警告 A:: 运算符 ->() 返回 int*
    int k;
    };

消息标识：arrowrtn

## 无法转换

尚未定义函数指针和对象指针之间的转换结果，但是，如果使用 Solaris，将会丢失信息。

消息标识：badcastw

## 类中的匿名联合不能是

类中的匿名联合不能包含一些说明符，如 extern、static 和 the like。 生成错误消息的代码示例：

    class A {
    static union {  // 错误：匿名联合不能是静态的
    int a;
    long b;
        };
    };

消息标识：badclanon

## 名称空间无法在类作用域中声明

不允许在类中声明名称空间 生成错误消息的代码示例：

    class A {
    namespace ns {} // 错误：在类作用域中声明名称空间
    };

消息标识：noclassns

## 不能在该作用域内重新声明模板参数

模板参数在该作用域内不能重新声明。最有可能的是，已经在模板作用域的声明中使用模板参数的名称。 生成错误消息的代码示例：

    template <class t_arg> class A {
    int t_arg;      // 错误：重新声明模板参数 t_arg
    };

    int main() {
    A<int> a;
    }

消息标识：templparamdecl

## 模板参数不能在创建的类型说明符中使用

禁止在创建的类型说明符中使用模板参数。 生成错误消息的代码示例：

    template <class t_arg> class A {
    class t_arg {};     // 错误：在创建的类型说明符中使用模板参数 t_arg
    };

    int main() {
    A<int> a;
    }

消息标识：templtypedecl

## 已创建类型说明符的非法语法

遇到语法错误。 生成错误消息的代码示例：

    template <class t_arg> class A {};

    typedef class A<int> my_type;   // 错误：语法非法 ...

消息标识：badelabtype

## pragma 包的值必须为二的幂

pragma 包的有效值必须为二的幂。 生成错误消息的代码示例：

    #pragma pack (3)

消息标识：prbadpack

## 模板声明无法有外部"C"链接

无法使用外部的 C 链接声明模板。 生成错误消息的代码示例：

    extern "C"
    template <class t_arg> class A {}; // 错误：模板声明不能包含该链接

消息标识：temnotexternc

## 由模板参数限定的类型名要求"typename"

模板参数限定类型名称时，需要 `typename` 关键字 生成错误消息的代码示例：

    class A {
    public:
    typedef int my_type;
    };

    template <class t_arg> class B {
    public:
    typedef t_arg::my_type my_type; // 警告
    };

    int main() {
    B<A>::my_type c;
    }

消息标识：typenameass

## 转换不明确

转换不明确。 生成错误消息的代码示例：

    class A {};

    class B :public A {};
    class C :public A {};

    class D:public B, public C {};

    int main() {
    D *d = new D;
    A *a = (A*) d; // 错误：D 包含两个 A 实例
    }

消息标识：ambigcast

## 不允许模板的友元声明

如果没有专门化，则无法将模板作为友元进行声明。 生成错误消息的代码示例：

    template <class t_arg> class A {};

    class B{
    friend class A; // 错误：友元模板声明。应该是：
    // 友元类 A<int>;
    };

消息标识：nofriendtmpl

## "friend"声明与函数模板不兼容

不能将模板函数作为友元进行声明。 生成错误消息的代码示例：

    template<class t_arg> int foo () { return t_arg; }

    class A {
    friend int foo<int>(); // 错误：模板函数不能是友元
    };

消息标识：nofunctmpl

## 全局作用域没有声明

在全局作用域中尚未找到声明为友元的函数。 生成错误消息的代码示例：

    class A {
    friend int ::foo ();    // 错误：没有在全局作用域中声明 foo
    };

消息标识：noglobaldecl

## 警告：该标记不能与此标记一起使用

不能同时指定某些 CC 标记（例如，+e0 和 -compat=）。

消息标识：cmd_badflag_wrn

## 错误：该标记不能与此标记一起使用

不能同时指定某些 CC 标记（例如，-memtmpl 和 -compat=5）。

消息标识：cmd_badflag_err

## 无法具有指向位字段的非常量引用

指向位字段的引用不是常量 生成错误消息的代码示例：

    struct C {
    int x : 2 ;
    };

    C oc;
    int & xref = oc.x;   // 错误：xref 是非常量引用

消息标识：varbitref

## 无法为读取预先实例化的符号而打开库

无法打开选项 -preinstlib=<file-name> 指定的文件。

消息标识：openinstlib

## 无法从预先实例化的库中读取符号

无法从选项 -preinstlib=<file-name> 指定的文件中读取符号。

消息标识：readinstlib

## 不能使用模板类型参数声明成员函数

已尝试使用函数类型模板参数声明成员函数。 生成错误消息的代码示例：

    template <class T> struct X { T t; };

    typedef int F();
    X < F > m1; // 错误：无法将‘t’声明为 int t()

消息标识：badtmplfunctyp

## 模板非类型参数无法具有类型

非类型的模板参数和非模板的模板参数不能具有指定的类型。有关详细信息，请参见 ISO C++ Standard 14.3.2。 生成错误消息的代码示例：

    template<class T, int I> class X { };

    X<int, 2.7> x;

消息标识：badtmplexparg

## 字符串文字不是可接受的模板参数

字符串文字 (lex.string) 不是可接受的模板参数，因为字符串文字是包含内部链接的对象。有关详细信息，请参见 ISO C++ Standard 14.3.2。 生成错误消息的代码示例：

    template<class T, char* p> class X { };

    X<int,"String"> x;

消息标识：tmplexpstrlit

## 数组元素的地址不是可接受的模板参数

数组元素和名称的地址或非静态类成员的地址不是可接受的模板参数。有关详细信息，请参见 ISO C++ Standard 14.3.2。 生成错误消息的代码示例：

    template<int* p> class X { };

    int a[10];

    X<&a[2]> x;

消息标识：tmplexpaddarr

## 部分专门化不明确

用户指定与多个部分专门化匹配的实际模板参数列表。 生成错误消息的代码示例：

    template<class T1, class T2, int I> class A             { };

    template<class T1, class T2, int I> class A<T1*, T2, I> { }; // #1
    template<class T1, class T2, int I> class A<T1, T2*, I> { }; // #2

    A<int*, int*, 2> a5; // 不明确：与 #1 和 #2 匹配

消息标识：ambigpartial

## 没有部分专门化的主专门化

部分专门化之前，没有主专门化。用户始终应该提供主专门化，以便声明或定义部分专门化。 生成错误消息的代码示例：

    template<class T>            class A<T, T*>   { };

    template<class T1, class T2> class A          { };

消息标识：psnoprimary

## 部分专门化不能有缺省参数

专门化的模板参数列表不能包含缺省的模板参数值。原因是没有使用这些值的方法。 生成错误消息的代码示例：

    template<class T1, class T2> class A          { };
    template<class T = int>                  class A<T, T*>   { };

消息标识：psdefaults

## 非类型参数不能用作表达式的一部分

非类型参数 %1 不能用作表达式的一部分。 生成错误消息的代码示例：

    template<class T, int p, int c> class X { };

    template<class T, int p > class X<T, p, p + 5> { };

消息标识：psntinexpr

## 部分专门化包含相同的参数

部分专门化不应该包含与主专门化相同的参数，因为无法使用这种构造。 生成错误消息的代码示例：

    template<class T1, class T2> class A          { };
    template<class T1, class T2 > class A<T1, T2>   { };

消息标识：pssameargs

## 专用参数的类型由另一个参数决定。

与专用的非类型参数对应的模板参数类型与专门化的参数无关。 生成错误消息的代码示例：

    template< int X, int (*array_ptr)[X] > class A {};

    int array[5];

    template< int X > class A<X,&array> {};

消息标识：psargdeptype

## 参数中未使用部分专门化参数

用户提供一个或多个部分专门化参数，且不会在自身的专门化中使用这些参数。 生成错误消息的代码示例：

    template<class T1, class T2> class A          { };
    template<class T, class T2>  class A<T, T*>      { };

消息标识：psargnotused

## 部分专门化没有执行

用户显式关闭部分专门化时，将会发出该消息。 生成错误消息的代码示例如下（仅限兼容模式）：

    template<class T1, class T2> class A          { };
    template<class T>            class A<T, T*>   { };

消息标识：psnotimp

## 无法在 using 声明中使用特定的标识符

生成错误消息的代码示例：

    class B
    {
    public:
    B() :i(0) { }
    ~B() { }
    int i;
    };

    class D:public B
    {
    public:
    using B::~B; // 错误 - using 无法引用析构函数
    D() :j(0) { }
    int j;
    };

    int main()
    {
    return 0;
    }

消息标识：usingdestr

## tdb_version 模板数据库与该编译器不兼容

编译器遇到与该编译器不兼容的 SunWS_cache 目录。早期的编译器遇到更新的编译器生成的模板数据库时，将会产生该错误。 使用更新的编译器编译源，或者使用 `CCadmin -d -clean` 清除该模板数据库。

消息标识：tdb_version

## 重复的 -I- 选项，忽略

在命令行找到的 -I- 选项不止一个。

消息标识：duplicate_i

## badexplctinst 无法找到模板，与从显式实例化推导出的类型匹配

生成错误消息的代码示例如下：

    template < class T > void copy ( T to ) { }

    template int copy ( long ) ;    // 错误！

消息标识：badexplctinst

## samemem 类成员与其类的名称相同

生成错误消息的代码示例如下：

    struct x {
    x();
    int x;
    };

消息标识：samemem

## badenumsize 获取不完整枚举的成员大小

声明所有 sizeof 运算符的枚举器之前，不能对枚举类型应用该运算符。 生成错误消息的代码示例如下：

    int mymain()
    {
    enum E { A, B = sizeof A }; // 错误 - 还无法应用 sizeof A
    return 0;
    }

消息标识：badenumsize

## 将指针 badarrptr 赋值给不兼容的数组类型

在 `C++` 中，将指针赋值给完整或不完整的数组类型是错误的，反之亦然。 生成错误消息的代码示例如下：

    extern int a_39W73zz[2];   // 大小既知
    int (*p2)[] = &a_39W73zz;  // 错误 - 类型不匹配，对于 `p2`，大小未知。

消息标识：badarrptr

## 具有不完整返回类型 \"%2\" 的函数 \"%1\"，编译程序无法在这种情况下生成虚拟表

如果虚拟函数的返回类型是没有定义的结构类型，且拒绝代码，则编译器无法处理这种情况。 生成错误消息的代码示例如下：

    struct Fum; // 类型不完整
    struct B {
    Fum virtual f();
    };
    struct D :virtual B {
    D();
    };
    D::D() { }

消息标识：incompletert

## 无法更改访问

无法通过这种方法对成员的访问进行更改。这是兼容模式下的警告，是标准模式下的错误。 生成错误消息的代码示例：

    class C {
    private:
    class inner;
    public:
    class inner { }; // 使用其它访问重新声明
    };

消息标识：badaccadjw

## 重载不明确

调用的重载函数不明确。 生成错误消息的代码示例：

    void foo (int i, int j);
    void foo (int i = 3, int j = 7);//  ok：redeclaration of  foo(int,   int)
    void foo ();                      //  ok：foo 的重载声明

    int main()
    {
    	foo (1, 2);                   //  ok：call  f(int, int)
    foo ();                       //  错误：call f(int,int)  or  f()?
    }

使用构造函数和转换运算符时，也会产生二义性问题：

    struct A { A(int); };
    struct B {
    	B(int);
    	operator int();
    	operator double();
    } b;

    A foo( A a );
    B foo( B b );

    int main()
    {
    foo(1); //错误：foo(A) or foo(b)?
    }

    int i = b; // ok：与 B 到 int 的转换匹配
    float f1 = b; // 错误：调用 int 还是双精度运算符？
    float f2 = double(b); // ok：指定转换运算符。

消息标识：manymatchover_w

## 无法访问

尝试直接访问类中的专用成员。 生成错误消息的代码示例：

    class A {
    int i; // 专用数据成员
    };

    void foo() {
    A a;
    a.i = 9; // 错误：错误：无法通过 foo() 调用 i
    }

    class T {
    	T(const T&); // 专用复制构造函数
    };

    void foo( T t ) {}		// 错误：无法传递 T，复制构造函数是专用函数
    T f2() { T t; return t; }	// 错误：无法返回 T

消息标识：inaccessible_w

## 忽略多余的 \";\"

在字段声明的结尾处检测到多余的分号 生成警告消息的代码示例：

    struct S {
    int ii;;
    void f();;
    };

消息标识：fieldsemicolonw

## 无法获取临时的地址

无法获取生成临时函数的编译器地址。 生成警告消息的代码示例：

    struct C { C(int); };
    void add( C *c );
    void foo() { add( &C(6) ); }

消息标识：addressoftemp

## 在友元声明中不允许有存储类

生成警告消息的代码示例：

    struct A {
    friend static void foo(A arg);
    };

消息标识：storeclassfriend

## 枚举名称 %1 作为作用域限定符

生成警告消息的代码示例：

    class C {
    C::C();
    enum E { a, b } e;
    };
    C::C() {
    switch(e) {
    case E::a:// <-- 此处出错
    break;
    	    }
    }

消息标识：enumasscope

## 语句无法执行

从未执行语句。 生成错误消息的代码示例：

    int foo(int x) {
    if ( x > 0 )
    	return 1;
    else
    	return 2;
    return 3;	// 警告：语句无法执行
    }

消息标识：wunreachable

## 最后一条语句应该返回一个值

非空函数的最后一条语句应该返回一个值。 生成错误消息的代码示例：

    int foo(int x) {
    if ( x > 0 )
    	bar();  // 警告：最后一条语句应该返回一个值
    else
    	return 2;
    }

消息标识：wnoretvalue

## else 分支语句应该返回一个值

if 语句的 else 分支语句应该返回一个值。 生成错误消息的代码示例：

    int foo(int x) {
    if ( x > 0 )  // 警告：else 分支语句应该返回一个值
    	return 2;
    }

消息标识：wnoelseretvalue

## 类中的匿名结构不能为

类中的匿名结构不能包含一些说明符，如 extern、static 和 the like。 生成错误消息的代码示例：

    class A {
    static struct {  // 错误：匿名结构不能是静态的
    int a;
    long b;
        };
    };

消息标识：badclanonstruct

## 匿名结构具有相同的名称

匿名结构成员与其包含类的名称不能相同。 生成错误消息的代码示例：

    class A {
    struct {
    int i;
    long j;
    int A;  // 错误
      };
    };

消息标识：sameanonstruct

## 匿名结构无法具有专用的或受保护的成员

匿名结构无法具有专用的或受保护的成员。 生成错误消息的代码示例：

    static struct {
    long j;

    private:
    	int i; // 错误
    };

消息标识：anonstructnoprivate

## 匿名结构不能包含成员函数

匿名结构不能包含函数成员。 生成错误消息的代码示例：

    static struct {
    void foo(){} // 错误
    };

消息标识：anonstructnofunc

## 正在声明匿名结构

生成警告消息的代码示例：

    union U {
    struct {
    int a;
    long b;
        };
    };

消息标识：anonstruct

## 正在声明向前枚举类型

生成警告消息的代码示例：

    enum  A;

消息标识：forwardenum

## 声明与通过 using 声明引入的对象冲突

如果名称空间作用域或块作用域内的函数声明与 `using` 指令引入函数的的名称和参数类型相同，则说明程序的结构错误。 生成错误消息的代码示例：

    namespace B {
    void f(int);
    }

    namespace N {
    using B::f;             //  将 B::f(int) 引入 N
    void f(int);            //  错误：N::f(int) 与 B::f(int) 冲突
    }

消息标识：ambigdecl

## 联合不能包含引用类型的成员

如果联合包含引用类型的成员，则表示程序的结构错误。 生成错误消息的代码示例：

    union x {
    int &i;
    };

消息标识：nounionref

## 移位数太大

生成警告消息的代码示例：

    unsigned long l;
    void foo()
    {
    l >> 32; // 应该获得警告
    }

消息标识：largeshift

## 无法获取临时的地址

无法获取生成临时函数的编译器地址。

消息标识：compataddressoftemp

## 不能使用整数初始化枚举

生成警告消息的代码示例：

    enum E { e1 = 5 };
    struct S { E e; } s = { 5 }; // 警告

消息标识：wintenuminit

## 函数 %1 只能抛弃它所覆盖的函数 %2 所抛弃的异常

函数只能抛出它覆盖的函数允许的异常。生成错误消息的代码示例：

    struct A
    {
    virtual void foo() throw(A);
    };

    struct B:A
    {
    virtual void foo();
    };

消息标识：lessrestrictedthrow

## 隐藏

在作用域中找不到普通的 delete 运算符。最有可能的是，delete 运算符在类作用域中被非法覆盖。 生成错误消息的代码示例：

    #include <new>

    template<class t_arg> class A {
    public:
    	void  operator delete(void*, const std::nothrow_t&) throw();
    };

    int main() {
    A<int> * a = new A<int>;
    }

消息标识：whideferr

## 从常量限定的函数进行不正确的成员访问

生成错误消息的代码示例：

    class A {
    public:
    	int a;
    	void foo () const { a++; }
    }

消息标识：constaccess

## 类 %1 的无效显式实例化声明

最有可能的是，显式实例化声明中缺少关键字‘class’。 生成错误消息的代码示例：

    template  class X
    {
    };

    template X ;  // 应该是：模板类 X ;

消息标识：explclassinst

## 不应使用临时来初始化非常量引用

不应使用临时来初始化非常量引用。 生成警告消息的代码示例：

    struct C { C(int); };
    void add( C& c );
    void foo() { add( C(6) ); }

消息标识：reftotemp

## 表达式必须是常量值

模板表达式不能是非常量值。 生成错误消息的代码示例：

    template  void f();

    int main()
    {
    const int& ri = 12;
    f();	// 错误
    }

消息标识：tmplexpnotconst

## 函数 %1 只能抛弃它所覆盖的函数 %2 所抛弃的异常

函数只能抛出它覆盖的函数允许的异常。生成警告的代码示例：

    struct A
    {
    virtual void foo() throw(A);
    };

    struct B:A
    {
    virtual void foo();
    };

消息标识：wlessrestrictedthrow

## 返回自动变量的地址

返回指向局部自动变量的指针。 生成该警告消息的代码示例：

    int* f() {
    int k=5;
    return &k;
    }

消息标识：autoaddrreturn

## 参数类型与指向未知大小数组的指针有关

指针指向未知大小参数的数组 生成错误消息的代码示例：

    typedef int UNKA[];
    void f(UNKA *p);

消息标识：ptrarray0

## 参数类型与未知大小数组的引用有关

引用指向未知大小参数的数组 生成错误消息的代码示例：

    typedef int UNKA[];
    void f(UNKA &p);

消息标识：refarray0

## 实际参数由模板参数决定，而该模板参数不能在使用点导出

实际参数由模板参数决定 生成错误消息的代码示例：

    void foo(...);
    template T count(T t);
    void bar() {
    foo(count);
    }

消息标识：dummyactualarg

## 应为标识符，而不是

应该是标识符。如果构造出错，则会出现该错误，但编译器可以有效地予以恢复。生成错误消息的代码示例：

    enum A {a, };

消息标识：identexpected

## 具有相同的外部名称

两个函数定义不能具有相同的外部名称 生成错误消息的代码示例：

    #pragma redefine_extname        fstat64 fstat

    extern "C"
    {
    int fstat(int fstat_int)
    {
    return (fstat_int+2);
    }
    int fstat64(long fstat64_long)
    {
    if (fstat64_long == 0)
    return 0;
    return -1;
    }
    }  // 错误，fstat64 与 fstat 的外部名称相同

消息标识：sameextname

## 在兼容性模式下，在整个程序优化中不允许有块局部静态变量

在兼容模式下对整个程序优化 (-xcrossfile or -xipo) 进行编译时，不允许在内部作用域内使用嵌套的静态变量。

示例如下

    int f(int i)
    {
    	if (i != 0) {
    		static int sv = 2;
    		return sv + i;
    	}
    	return 0;
    }

sv 将会触发该错误。

消息标识：nocrossstatic

## 静态数据成员定义使用派生类

静态数据成员定义使用派生类。 生成警告的代码示例：

    struct BASE { static int static_data; };
    struct DERIVED :public BASE { };
    int DERIVED::static_data;

消息标识：staticmemsearch

## 无法在类模板中分析字段声明：跳过字段

由于名称查找问题，可能无法在对模板类进行代表性的实例化时分析字段声明。该模板类呈现为无效。

例如：

    template < class T >
    struct base
    {
    typedef T b_type ;
    } ;

    template < class T >
    struct derived :public base < T* >
    {
    typedef base < T* > Base ;
    const b_type foo ( const T & t ) const { }
    } ;

无法分析成员函数 foo，因为分析派生类的代表性实例化时，无法将 b_type 作为类型进行查找。

消息标识：skipfield

## 在 typedef 中不允许有异常规范

typedef 声明中不允许有异常规范

例如：

    typedef void (*pf) () throw();

消息标识：badexceptionspec

## 函数指针只能抛弃已赋值的函数指针所抛弃的异常

函数指针只能抛出它赋值的函数指针抛出的异常。生成警告的代码示例：

    void (*pf1)();
    void (*pf2)() throw(int);
    void f() {
    pf2 = pf1;
    }

消息标识：fptrthrow

## pragma 中只能显示一个 nowait、if、ordered、default 或 schedule 子句

生成消息的代码示例：int NE_C2_3() { int a = 1;

    #pragma omp parallel if ( a > 1 ) if ( a < 5 )
        {
        }

    return 0;
    }

消息标识：omp_extraclause

## openmp 结构的块中不允许有 return、goto、break 或 continue 语句

OpenMP 并行和共享作业构造之后必须跟结构化的块。结构化块是拥有一个 entry 和一个 exit 的语句。不允许使用造成跳转到块或跳转出块的语句。结构化块不能包含造成控制从块流出的 return、goto、break 或 continue 语句。 生成消息的代码示例：

    int NE_C2_4_1_1()
    {
    int i;
    #pragma omp for
    for (i = 0 ; i < 10 ; i++ )
        {
    	break ;
        }
    return 0;
    }

消息标识：omp_structblkviolation

## omp for 循环的索引变量必须是带符号整数

OpenMP for 的索引变量必须具有带符号的整数类型 生成消息的代码示例：

    int NE_C2_4_1_3()
    {
    unsigned int i;
    #pragma omp for
    for (i = 0 ; i < 10 ; i++ )
        {
        }
    return 0;
    }

消息标识：omp_forbadindxtype

## section 指令不得显示在 sections 指令的词法范围之外

“section”OpenMP pragma 必须直接显示在“sections”块中。 生成消息的代码示例：

    int NE_C2_4_2_1()
    {
    #pragma omp sections
        {
    	;
        }
    #pragma omp section
        {
        }
    return 0;
    }

消息标识：omp_sectionoutsidesections

## 在 flush 指令中指定的变量不得有引用类型

生成消息的代码示例：

    int NE_C2_6_5_1()
    {
    int i = 5;
    int & n = i;
    #pragma omp parallel
        {
    #pragma omp flush (n)
        }
    return 0;
    }

消息标识：omp_varhasreftype

## 在 non-ordered for 的词法范围内使用了 ordered 指令

排序的 OpenMP 指令不能在指令的动态范围内。其中，该指令尚未指定排序子句。 生成消息的代码示例：

    int NE_C2_6_6_1()
    {
    int i;
    #pragma omp for
    for (i=0; i<10; i++)
        {
    #pragma omp ordered
    	{
    	}
        }
    return 0;
    }

消息标识：omp_nonorderedfor

## threadprivate 指令必须显示在文件作用域内

threadprivate 指令必须显示在文件作用域或名称空间作用域内，还必须显示在任何定义或声明之外。 生成消息的代码示例：

    int a=0;

    class A
    {
    #pragma omp threadprivate ( a )
    };

    int NE_C2_7_1_1b()
    {
    return a;
    }

消息标识：omp_nonfilethreadprivate

## threadprivate 指令必须位于所有变量引用之前

Threadprivate 指令必须按照字典方式位于列表中所有变量引用之前。 生成消息的代码示例：

    int a = 1;

    void foo()
    {
    a--;
    }

    #pragma omp threadprivate ( a )

    int NE_C2_7_1_1c()
    {
    return a;
    }

消息标识：omp_threadprivateprecederef

## 变量不能具有引用类型

threadprivate 变量不能具有引用类型。 生成消息的代码示例：

    int a;
    int & b = a;

    #pragma omp threadprivate (b)

    int NE_C2_7_1_6a()
    {
    return 0;
    }

消息标识：omp_varinprivateref

## 变量不能具有不完整的类型

生成消息的代码示例：

    class A;

    int foo(A & a)
    {
    #pragma omp parallel private(a)
        {
        }
    return 0;
    }

    int NE_C2_7_2_1_3()
    {
    return 0;
    }

消息标识：omp_varinprivateincomplete

## 该子句中不允许使用 threadprivate 变量

除 copyin、schedule 或 if 子句之外，threadprivate 变量不能出现在任何子句中。因此，不能在 private、firstprivate、lastprivate、shared 或 reduction 子句中使用这些变量。这些变量不受缺省子句的影响。 生成消息的代码示例：

    int a;

    #pragma omp threadprivate ( a )

    int NE_C2_7_1_4a()
    {
    #pragma omp parallel private(a)
        {
        }
    return 0;
    }

消息标识：omp_threadprivatewrongclause

## 在子句中指定的变量不能有常量限定的类型

除非具有包含 mutable 成员的类类型，否则 private 子句中指定的变量不能具有常量限定的类型。 生成消息的代码示例：

    class A
    {
    public:
    A();
    };

    int NE_C2_7_2_1_2()
    {
    const A a;
    #pragma omp parallel private(a)
        {
        }

    return 0;
    }

消息标识：omp_varmustnotbeconstqual

## 变量必须显式地列在封装 omp progma 的数据属性子句中

生成消息的代码示例：

    int NE_C2_7_2_5_2()
    {
    int a;
    #pragma omp parallel default (none)
        {
    	a=1;
        }
    return 0;
    }

消息标识：omp_defaultviolated

## 约简变量的类型无效

对于 reduction 运算符，在 reduction 子句中指定的变量类型是有效的，除非从不允许使用指针类型。 生成消息的代码示例：

    class A
    {
    };

    int NE_C2_7_2_6_1a()
    {
    A a;
    #pragma omp parallel reduction(+:a)
        {
        }
    return 0;
    }

消息标识：omp_reductionbadtype

## 简约变量不能有常量限定的类型

在 reduction 子句中指定的变量不能有常量限定的类型。 生成消息的代码示例：

    int NE_C2_7_2_6_2()
    {
    const int a = 0;
    #pragma omp parallel reduction (+:a)
        {
        }
    return 0;
    }

消息标识：omp_constreduction

## 不能在多个子句中指定变量

不能在多个子句中指定变量，除非该变量可以同时在 firstprivate 和 lastprivate 子句中指定。 生成消息的代码示例：

    int NE_C2_7_2_6_4()
    {
    int a = 0;
    #pragma omp parallel  shared (a) reduction (+:a)
        {
        }

    return 0;
    }

消息标识：omp_dupclause

## copyin 变量不是 threadprivate 变量

在 copyin 子句中指定的变量必须是 threadprivate 变量。 生成消息的代码示例：

    int x;

    int NE_C2_7_2_7_2()
    {
    #pragma omp parallel copyin (x)
        {
        }
    return 0;
    }

消息标识：omp_copyinnotthreadprivate

## 不允许具有相同名称的 critical 指令相互嵌套

不允许具有相同名称的 critical 指令相互嵌套 生成消息的代码示例：

    int NE_C2_9_3_1()
    {
    #pragma omp critical
        {
    #pragma omp critical
    	{
    	}
        }
    return 0;
    }

消息标识：omp_badnestingcritical

## 在区域的动态范围中，不允许使用指令

不允许在 critical、ordered 和 masterfor 区域的动态范围内使用 for、sections 和 single 指令。 生成消息的代码示例：

    int NE_C2_9_4_4()
    {
    #pragma omp master
        {
    #pragma omp for
    	for ( int i=0 ; i < 10 ; i++ )
    	{
    	}
        }
    return 0;
    }

消息标识：omp_badnestingregion

## 绑定到相同 parallel 的 for、sections 和 single 指令不允许相互嵌套

绑定到相同 parallel 的 for、sections 和 single 指令不允许相互嵌套。 生成消息的代码示例：

    int NE_C2_9_2_1()
    {
    #pragma omp parallel
    { int i;
    #pragma omp for
    	for (i=0 ; i < 10 ; i++)
    	{
    #pragma omp sections
    	    {
    		;
    	    }
    	}
        }

    return 0;
    }

消息标识：omp_badnestingparallel

## 包含 flush 指令的最小语句必须是块

包含 flush 指令的最小语句必须是块（或复合语句）。 生成消息的代码示例：

    int NE_C2_6_5_2()
    {
    int i = 5;
    #pragma omp parallel
        {
    	if ( i > 0 )
    #pragma omp barrier
        }
    return 0;
    }

消息标识：xomp_mustbeblock

## 当指定进度表（运行时）时，不能指定 chunk_size

当指定进度表（运行时）时，不能指定 chunk_size。 生成消息的代码示例：

    int NE_C2_4_1_9()
    {
    int i;
    #pragma omp for schedule(runtime, 2)
    for (i=1;i<10;i++)
        {
        }
    return 0;
    }

消息标识：omp_chunksizemustnotbespecified

## 不允许在指令中使用子句

生成消息的代码示例：

    int main(void)
    {
    #pragma omp for default(none)
    for ( int i = 0; i < 10; i++ )
        {
        }
    return 0;
    }

消息标识：omp_badclause

## 跳过当前 pragma 的其它部分，转到新行上

跳过当前 pragma 的其它部分，转到新行上。这样做可以将与 OpenMP 有关的错误恢复和特定于 C++ 的错误恢复分开。 生成消息的代码示例：

    int main(void)
    {
    #pragma omp for default(none)
    for ( int i = 0; i < 10; i++ )
        {
        }
    return 0;
    }

消息标识：omp_skip

## Line 指令必须是正值

Line 必须指定正整数。 生成错误消息的代码示例：

    #line 0 "file.cc"

消息标识：poslinenum

## 已在封装 openmp pragma 中将变量指定为专用变量

不能在封装共享作业或并行指令的 private (firstprivate/lastprivate) 子句中指定在并行区域内为 private 的变量。因此，在共享作业或并行指令中指定为 private 的变量必须在封装的并行区域中进行共享。 生成消息的代码示例：

    int main()
    {
    int i,j;
    #pragma omp parallel private(j)
        {
    	#pragma omp for lastprivate(j)
    	for (i=0; i<10; i++)
    	    j++;
        }
    return 0;
    }

消息标识：omp_varalreadyprivate

## 不允许嵌套 pragma

生成消息的代码示例：

    int NE_C2_9_2_1()
    {
    #pragma omp parallel
    { int i;
    #pragma omp for
    for (i=0 ; i < 10 ; i++)
          {
    #pragma omp sections
              {
                  ;
              }
          }
        }

    return 0;
    }

消息标识：omp_badnesting

## 简约变量未共享

在 reduction 子句中指定的变量必须在封装的上下文中进行共享。 生成消息的代码示例：

    int main()
    {
    int i;
    #pragma omp parallel private(i)
    	#pragma omp sections reduction(+:i)
    	{
    	   i++;
    	}
    return 0;
    }

消息标识：omp_reductionnotshared

## 结构错误的 OpenMP pragma

在 OpenMP pragma 中发现通用语法错误时显示此消息。 生成消息的代码示例：

    int main()
    {
    #pragma omp parallel private
      {
      }
    return 0;
    }

消息标识：omp_badlyformedomppragma

## omp for 循环的控制表达式形式不规范

OpenMP for 的控制表达式必须采用规范的形式，如下： 生成消息的代码示例：

    int main()
    {
    int i,j=0;
    #pragma omp parallel for
    for (i=0; j<10; i++) {
        }
    return 0;
    }

消息标识：omp_forbadcontrol

## default 子句的值不正确

对于 default 子句，只有 none 或 shared 才是有效值。 生成消息的代码示例：

    int main()
    {
    int i;
    #pragma omp parallel default(private)
      {
    	i++;
      }
    return 0;
    }

消息标识：omp_baddefault

## schedule 子句的种类无效

schedule 子句的种类必须属于 static、dynamic、guided 或 runtime 之一。 生成消息的代码示例：

    int main()
    {
    int i;
    #pragma omp parallel for schedule(normal,1)
    for (i=0;i<10;i++) {
      }
    return 0;
    }

消息标识：omp_badschedulekind

## OpenMP pragma 无效

生成消息的代码示例：

    int main()
    {
    #pragma omp unknown
    return 0;
    }

消息标识：omp_badomppragma

## return、goto、break 或 continue 语句不允许进入或退出 openmp 结构的块

OpenMP 并行和共享作业构造之后必须跟结构化的块。结构化块是拥有一个 entry 和一个 exit 的语句。不允许使用造成跳转到块或跳转出块的语句。结构化块不能包含造成控制从块流出的 return、goto、break 或 continue 语句。 生成消息的代码示例：

    int foo() {
    #pragma omp parallel
        {
    	return 1;
        }
    }

消息标识：omp_strblkviolation

## omp for 循环的迭代表达式形式不规范

OpenMP for 的迭代表达式的形式必须规范。 生成消息的代码示例：

    int main() {
    int i;
    #pragma omp parallel for
    for (i=0; i<10; foo(&i)) {
        }
    return 0;
    }

消息标识：omp_forbaditer

## omp for 循环的初始化表达式形式不规范

OpenMP for 的 Init 表达式必须采用规范的形式，如下： = 或 = 生成消息的代码示例：

    int main() {
    int i=0;
    #pragma omp parallel for
    for (; i<10; i++) {
        }
    return 0;
    }

消息标识：omp_forbadinit

## OpenMP for pragma 的后面必须跟一个 for 语句

pragma OpenMP 的后面必须跟 for 语句。 生成消息的代码示例：

    int main() {
    int i=0;
    #pragma omp parallel for
        {
    while( 0 ){
    	i++;
        }
    return 0;
    }

消息标识：omp_forbadfollow

## \"%1\" 的声明是一个函数而不是对象

\"%1\" 的声明在语法上不明确，但是标准将其解释为函数声明。无论如何，程序员一般都会声明对象。为了避免混淆，请使用语法上明确的方式重新编写声明。 生成警告消息的代码示例：

    struct T { };
    T t( T() ); // t 是函数

建议采用语法上明确的解决方法：

    T t( (T()) ); // t 是对象（类型不能有多余的 parens）
    T t = T(); // t 是对象（赋值样式的初始化）
    T t( T(*)() ); // t 是函数（显式函数指针）

消息标识：ambigfuncdecl

## schedule 子句中存在错误的 chunksize 表达式

chunksize 必须是整型循环固定非零正值。 生成错误消息的代码示例：

    #pragma omp for schedule (static, 0)

消息标识：badchunksize

## 并行区域内的循环索引必须是专用变量

并行区域内的循环索引必须是该区域的专用变量。 生成消息的代码示例：

    int main() {
    int i=0;
    #pragma omp parallel for shared(i)
    for(i=0; i<4; i++){
             }
    return 0;
         }

消息标识：omp_sharedforindex

## 类显示为空的虚拟基类

该文件中使用的类包含没有非静态数据成员的虚拟基类。在某些情况下，这会导致虚拟函数调用错误的函数。

消息标识：warn_empty_virt_base

## 引用返回值应当是左值（如果使用此函数的值，结果不可预测）

引用返回值应该为左值。标准允许函数返回一个指向要编写的左值的引用。但是，如果实际使用该值，则结果是难以预见的。

消息标识：nonvarrefww

## 试图调用纯虚拟函数总是失败

如果尝试从尚未覆盖纯虚拟函数的对象中调用该函数，将总是失败。基类的纯虚拟函数将不会通过虚拟调用机制进行调用。必须显式限定该调用，还必须在单独的函数定义中提供该函数的主体。示例：

    struct T {
    virtual int f() = 0;
    T() { f(); }         // 警告，调用纯虚拟函数
    ~T() { T::f(); }     // ok，跳过虚拟调用机制
    void g() { f(); }    // ok，如果从纯虚拟函数的派生类
    };
    int T::f() { return 0; } // 对象定义进行调用

消息标识：pure_virtual_w

## 不允许 pragma critical 以相同的名称嵌套在 critical 中

不允许具有相同名称的 critical 指令相互嵌套生成消息的代码示例：

    void main(void) {
    #pragma omp critical(foo)
    #pragma omp critical(foo)
            ;
    }

消息标识：omp_badcriticalnesting

## 以前未将方法声明为本地方法

必须使用 c++ 函数执行声明为本地方法的 Java 方法。如果方法之前没有作为 .class 文件中的本地方法进行声明，则提供该方法的 C++ 版本会产生错误。

消息标识：notjavanative

## 将非 POD 对象作为变量参数传递给函数

未定义将非 POD 对象作为变量参数传递的结果。

POD（平面旧数据）对象是一个不包含下列内容的对象：用户声明的构造函数、用户定义的析构函数、用户定义的复制运算符、虚拟函数、专用或受保护的非静态数据成员和指针到成员类型的非静态数据成员、非 POD 结构、非 POD 联合或引用。

    void foo(int, ...);
    struct T {
    T();
    ~T();
    };

    extern T t;

    int main()
    {
    foo(1, t); // 警告
    }

消息标识：nonpodvarargw

## 友元声明必须指定类或函数

友元声明未指定类或函数。 生成错误消息的代码示例：

    namespace N {
    	template  struct B { };
    }
    struct A {
    friend struct N::B; //此处应该是错误，B 是模板，而不是结构
    };

消息标识：wnofriendfield

## 友元声明可能必须添加<> 到语法

友元声明声明了非模板函数。 生成警告的代码示例：

    template < class T > bool foo (T);
    template < class T1 > class BC_base_identifier {
    friend bool foo(T1);
    };
    int main()
    {
    BC_base_identifier bi;
    foo(100);
    }

消息标识：nontmplfriend

## 调用 #pragma dumpmacros 时传递的参数不正确

调用 #pragma dumpmacros 时使用的有效参数如下：defs、undefs、loc、conds 和 sys 生成错误消息的代码示例：

    #pragma dumpmacros(definitions)

消息标识：prbadarg

## 模板嵌套深度没有

模板嵌套深度引用了函数模板的专门化，只有非模板函数才可用。 生成错误消息的代码示例：

    template struct A {
    void f(int);
    };

    template<> template<> void A::f(int) {} // spec 多余

消息标识：mismatchtmpdepth

## 转换 64 位类型值

移植为 64 位时，赋值、初始化或转换可能会截断数据。 生成错误消息的代码示例：

    long l;
    (int)l;

消息标识：truncwarn1

## 扩展符号

如果移植为 64 位，则赋值为无符号的 long 之前，可以扩展数据的符号。 生成错误消息的代码示例：

    int i;
    unsigned long ul = i;

消息标识：signextwarn

## 64 位类型位字段可能会更改

移植为 64 位时，long 或无符号 long 位字段声明可能会更改位字段包装。 生成错误消息的代码示例：

    struct S {
    unsigned long b1:20;
    long b2:20;

    };

消息标识：bitfield64

## 正在定义关键字

正在定义关键字。 生成警告的代码示例：

    #define bool unsigned int

消息标识：nokeyworddefine

## 类型转换不明确

第二个操作数和第三个操作数可以相互转换

    struct S {
    S (int);
    operator int () const;
    };

    int main (int i)
    {
    S s0(0);
    i ? s0 :1; // 类型转换不明确
    }

消息标识：questambigerr

## 在 threadprivate 指令中指定的块作用域变量必须是静态的

在 threadprivate 指令中指定的块作用域变量必须是静态的。 生成消息的代码示例：

    int main() {
    #pragma omp parallel
        {
    int i;
    #pragma omp threadprivate(i)
    i = 50;
        }
    }

消息标识：omp_threadprivatenotstatic

## threadprivate 指令必须出现在变量的作用域中

静态块作用域变量的 threadprivate 指令必须出现在变量的作用域内，而不能出现在嵌套的作用域内。 生成消息的代码示例：

    int main() {
    static int i;
    #pragma omp parallel
        {
    #pragma omp threadprivate(i)
    i = 50;
        }
    }

消息标识：omp_threadprivateinnested

## if 子句表达式没有标量类型

在 OpenMP 并行区域的 if 子句中指定的表达式必须具有标量类型。 生成消息的代码示例：

    int main() {
    struct { float val; } good = {3.62};

    #pragma omp parallel if(good)
    good.val = 4.12;
    }

消息标识：omp_badiftype

## num_threads 子句表达式没有整型

在 OpenMP 并行区域的 num_threads 子句中指定的表达式必须具有整数类型。 生成消息的代码示例：

    int main() {
    int i = 0;

    #pragma omp parallel num_threads(3.62)
    i++;
    }

消息标识：omp_badnumthreadstype

## 模板参数声明中不允许有完整的类定义

在模板参数声明中不能指定类定义。 生成错误消息的代码示例：

    template  class S{};

消息标识：noclassdef

## copyprivate 子句不能与 nowait 子句一起使用

copyprivate 子句不能与 nowait 子句一起使用。 生成消息的代码示例：

    int main() {
    int i = 42;
    #pragma omp single nowait copyprivate(i)
        {
    i++;
        }
    }

消息标识：omp_badusecopyprivate

## 在 copyprivate 子句中指定的变量在封装的上下文中必须为专用变量

如果在并行区域的动态范围内遇到使用 copyprivate 子句的一个指令，则在 copyprivate 子句中指定的所有变量必须是封装的上下文中的专用变量。 生成消息的代码示例：

    int main() {
    int i = 1;
    #pragma omp parallel
        {
    i = 42;
    #pragma omp single copyprivate(i)
          {
    i++;
          }
        }
    }

消息标识：omp_notprivateincontext

## 常量限定符必须有声明符和初始化程序

必须使用声明符和初始化程序声明常量变量 生成消息的代码示例：

    const enum E1 {a, b};		// 错误
    const enum E2 {c, d} x = c;	// ok

消息标识：badconstdecl

## volatile 限定符必须有声明符

volatile 变量必须使用声明符进行声明 生成消息的代码示例：

    volatile enum E1 {a, b};		// 错误
    volatile enum E2 {c, d} x;		// ok

消息标识：badvoldecl

## 存储类说明符必须有声明符

存储类说明符必须有 init 声明符列表 生成消息的代码示例：

    register enum E4 { a4, b4 };	// 错误
    register enum E5 { a5, b5 } e;  // ok

消息标识：badstgdecl

## 声明时需要声明符

这种类型的声明中需要 init 声明符列表 生成消息的代码示例：

    typedef struct T { int i; };
    typedef enum F { f1, f2 };

消息标识：declreq

## 在友元声明中不允许有存储类

生成错误消息的代码示例：

    struct A {
    friend static void foo(A arg);
    };

消息标识：storefrienderr

## 比较不同的枚举类型

生成警告消息的代码示例：

    #include

    int main()
    {
    enum Shape { shape1=2, shape2};
    enum Point { point1=4, point2};

    Shape cylinder = shape1;
    Point uper = point2;
    if ( cylinder == uper ) // 警告
    cout << “比较不同的枚举类型” << endl;
    }

消息标识：diffenumtype

## [提示：使用 -xarch=v8plus 编译的对象必须与 -xarch=v8plus 链接]

消息标识：demxarchv8plus

## 生成缺省参数表达式时无限递归

生成消息的代码示例 struct S { int f1(int = f2()); int f2(int = f1()); };

消息标识：recurseindefault

## 关键字 \"virtual\" 和 \"friend\" 不能出现在同一声明中

不能将虚拟函数声明为友元函数。 生成错误消息的代码示例：

    void foo() { return; }
    void goo() { return; }

    class A {
    virtual friend void foo();    // 错误
    virtual friend void A::goo(); // 错误
    };

消息标识：virtfriendfunction

## 函数 \"%1\" 已使用不完整的函数声明语法声明为 \"friend\"

仅使用函数名称声明了友元函数。 生成错误消息的代码示例：

    namespace N {
    void foo(char);
    void foo ();
    };

    class A {
    friend N::foo;
    };

消息标识：friendfunc

## 将负值赋予隐式无符号位字段

生成警告消息的代码示例：

    struct No_constructor {
    int i : 30;
    };

    class Has_constructor {
    int j : 30;
    public:
    Has_constructor():j(-2){}       // 第 8 行：警告
    };

    int main() {
    struct No_constructor b = {1-2};// 第 12 行：警告
    b.i = -1.8;                     // 第 13 行：警告
    }

消息标识：negbitfield

## 对象或函数的名称不能是模板标识

生成警告消息的代码示例：

    namespace N {
    template struct ap {
    ap(X* p = 0);
        };
    };
    using namespace N;
    class A {};
    A* a;
    ap ap(a) ;

消息标识：baddeclare

## 在 OpenMP private、firstprivate 或 lastprivate 数据子句中使用类对象时，类必须具有缺省的构造函数。

生成警告消息的代码示例：

    class A {

    };
    main()
    {
    A a(10);
    #pragma omp parallel private(a)
        {
            ;
        }
    }

消息标识：nodefctor

## 可能准备声明显式模板专门化或创建显式专门化的不明确语法不会产生影响。其它编译器可能会对代码产生不同的中断。

生成警告的代码示例：

    template  class A { ... };
    class A; // 警告：已忽略
    template<> class A; // 声明显式专门化
    template   class A; // 显式实例化指令

消息标识：oldspecialdecl

## 函数不是数据，所以不能具有 __thread 说明符。

生成警告的代码示例：

    __thread void func();
    struct type {
    __thread void func();
    };

消息标识：nothreadfuncs

## __thread 变量的第一个声明必须这样表达。

生成警告的代码示例：

    int changed;
    __thread int changed;

消息标识：threaddeclfirst

## __thread 变量不支持动态初始化程序。

__thread 变量不支持动态初始化程序。重要的构造函数、析构函数、基类或非常量初始化程序表达式可能会生成动态初始化程序。生成警告的代码示例：

    struct nontrivial_constructor {
    nontrivial_constructor();
    };
    __thread nontrivial_constructor unsupported1;
    struct nontrivial_destructor {
    nontrivial_destructor();
    };
    __thread nontrivial_destructor unsupported2;
    struct nontrivial_base :nontrivial_constructor {
    };
    __thread nontrivial_base unsupported3;
    extern int func();
    __thread int unsupported4 = func();

消息标识：threaddyninit

## 自动变量不能是 __thread 变量。

生成警告的代码示例：

    void func() {
    __thread int a;
    }

消息标识：noautothread

## 不能在模板的显式专门化内部使用类型名称

生成警告的代码示例：

    template struct traits {
    typedef T ty;
    };

    template struct tn {
    typedef typename traits::ty tn_ty;
    };

    template<> struct tn {
    typedef typename traits::ty tn_ty;
    };

消息标识：explctspectypename

## 已尝试访问类中的专用成员。

生成警告的代码示例：

    class A {
    private:
    int a;
    } ;
    struct B:A {
    private:
    A::a;	// 标准模式警告
    } ;

消息标识：inaccessible_anach

## 不能在子句中指定专用变量

不能在绑定到并行构造的共享作业指令的 reduction 子句中指定并且区域中的专用变量。 生成消息的代码示例：

    int main() {
    int i;
    #pragma omp parallel private(i)
    #pragma omp sections reduction(+:i)
        {
    i++;
        }
    }

消息标识：omp_cant_be_in_private

## 不能在子句中指定约简变量

不能在绑定到并行构造的共享作业指令的 reduction 子句中指定并行指令 reduction 子句中出现的变量。 生成消息的代码示例：

    int main() {
    int i;
    #pragma omp parallel reduction(+:i)
    #pragma omp sections reduction(+:i)
        {
    	i++;
        }
    }

消息标识：omp_cant_be_in_reduction

## 在子句中指定的变量不能有常量限定的类型

除非具有包含 mutable 成员的类类型，否则在 private 子句中指定的变量不能具有常量限定的类型。 生成消息的代码示例：

    class A
    {
    public:
    A();
    };

    int NE_C2_7_2_1_2()
    {
    const A a;
    #pragma omp parallel private(a)
        {
        }

    return 0;
    }

消息标识：omp_varmustnotbeconst_qual

## 每个 OpenMP 段必须是一个结构化块

如果段包含的语句不止一个，则这些语句必须位于 {} 生成消息的代码示例：

    #pragma omp sections
    {
    // optional #pragma omp section
    x = 5;
    y = 10;
    }

消息标识：omp_badsectionstructure

## 友元函数模板标识名称应该引用模板声明

友元函数名称尚未在最近的名称空间中声明模板，或者在当前的类中包含该模板。 生成错误消息的代码示例：

    #include
    namespace M {
    template < class T > void i(T);
    class A {
    template < class T > void i(T);
    friend void i< > ( int );       //结构错误 - A::i
      };
    template< typename T >
    class Bar
      {
    std::valarray< T > fVA ;
    friend std::valarray< T > const
    Fu< >( Bar< T > const & ) ;     // Fu<> has no declaration in a namespace M
      } ;
    };

消息标识：wnotempdecl

## 内联函数没有外部链接

内联函数没有外部链接。 生成消息的代码示例：

    int f();
    inline int f() { return 0; }

消息标识：wbadlinkage_w

## 只有外部符号才可能有链接程序作用域。

生成警告的代码示例：

    static __symbolic int variable;
    static __hidden int function() {
    __global int stackvar;
    }

消息标识：ldscopeonlyextern

## 链接程序作用域只能有更多限制

链接程序作用域只能是多个限制或后续声明。链接程序作用域 __hidden 比 __symbolic 严格，而 __symbolic 比 __global 严格，而 __global 比未指定的链接程序作用域严格。生成警告的代码示例：

    __hidden int function();
    __symbolic int function();

消息标识：ldscoperestrict

## 不能在符号定义之后更改链接程序作用域。

生成警告的代码示例：

    __symbolic int function() { }
    __hidden int function();

消息标识：ldscopechanged

## 将 \"%1\" 值转换为 \"%2\" 导致截断

生成警告的代码示例：

    char c[100000];
    short i = sizeof(c);

消息标识：truncwarn2

## 具有引用成员的类必须具有用户定义的构造函数

具有引用成员的类必须具有用户定义的构造函数 生成错误消息的代码示例：

    struct S {
    int x&;
    };

    消息标识：refmemnoconstr

## 正在使用的 pch 文件没有正确的魔数

正在使用的 pch 文件没有正确的魔数

消息标识：pchbadmagicnumber

## 正在使用的 pch 文件在前页中的格式字符串不正确

正在使用的 pch 文件在前页中的格式字符串不正确

消息标识：pchbadformatstr

## pch collect 和 use 模式编译器版本字符串不兼容

pch collect 和 use 模式编译器版本字符串不兼容

消息标识：pchbadreleasestr

## pch 文件应该包含 defines

pch 文件应该包含 defines

消息标识：pchexpdefines

## pch 文件应该包含 undefs

pch 文件应该包含 undefs

消息标识：pchexpundefs

## pch collect 和 use 模式中的 defines 列表不同

pch collect 和 use 模式中的 defines 列表不同

消息标识：pchbaddefines

## pch collect 和 use 模式中的 undefs 列表不同

pch collect 和 use 模式中的 undefs 列表不同

消息标识：pchbadundefs

## pch collect 和 use 模式中的可用前缀不同

pch collect 和 use 模式中的可用前缀不是相同的 PRE>

消息标识：pchbadviableprefix

## 无效的模板嵌套深度

无效的模板嵌套深度 生成错误消息的代码示例：

    template <class X> template <class Y>
    void foo ();	// 错误：无效的模板嵌套深度

    struct S {
    template <class X> template <class Y>
    void foo();	// 错误：无效的模板嵌套深度
    }

消息标识：badnesttmpl

## 共享循环控制变量被声明为专用变量

在并行 for 结构中，循环控制使用的变量已隐式声明为专用变量。 因此，shared() 子句不会对这些变量产生影响。 生成消息的代码示例：

    int main() {
    int i,j;
    #pragma omp parallel for shared(i,j)
    for (i=0; i<10; i++) j = i;
    	;
    return 0;
    }

消息标识：omp_shared_control_var

## 在平行区域中不允许有静态的非 POD 声明

在平行区域中不允许有静态的非 POD 声明 生成错误消息的代码示例：

    class A {public:int i; A(){i = 10;};};
    #pragma omp parallel
    {
    static A a;
        ;
    }

消息标识：omp_staticclassdecl

## U 字符串文字只能包含 ASCII

生成警告的代码示例：

    unsigned short bar[] = U"é";

消息标识：ustronlyascii

## U 字符串文字不能包含数字换码

生成警告的代码示例：

    unsigned short bar[] = U"\351";

消息标识：ustrnoescape

## 可能缺少或位置错误 #pragma hdrstop or -xpchstop point

可能缺少或位置错误 #pragma hdrstop or -xpchstop point

消息标识：pchbadstoppoint

## 可用前缀中只能使用注释和某些预处理程序指令

可用前缀中只能使用注释和某些预处理程序指令

消息标识：pchbadviablepref

## 打开的文件太多

打开的文件太多，可能是一个包含自身的文件

消息标识：toomanyopenfiles

## 无法转换为 const 或 volatile

已尝试转换为 const 或 volatile。 生成错误消息的代码示例：

    class B { virtual void foo(); };

    class A:public B {};

    const B * pb = new A;
    A *pa1 = dynamic_cast<A*>(pb); // 错误：dynamic_cast 将常量 pb 转换为非常量指针。

    extern int *const** p1;
    int **const* p2 = reinterpret_cast<int **const*>(p1); // 错误

    extern volatile int *pi;
    int *pi2 = static_cast<int*>(pi); // 错误

消息标识：castawayconst

## threadprivate 指令不能显示在定义或声明中

threadprivate 指令必须显示在定义或声明之外。 生成消息的代码示例：

    class A
    {
    int a;
    #pragma omp threadprivate ( a )
    };

消息标识：omp_badthreadprivate

## 在主模板声明中不允许使用显式模板参数列表

在主模板声明中不允许使用显式模板参数列表 生成消息的代码示例：

    template  void bar ();
    template  void bar ();

消息标识：wexpltemplid

## 原子 pragma 之后必须跟表达式

原子 pragma 后面必须跟一个表达式语句。 生成消息的代码示例：

    #pragma omp atomic
    {               // 不允许有‘{’
    i++;
    }

消息标识：omp_badatomicfollow

## 声明为内联之前已经调用

函数在其声明为内联之前已经使用。这意味着， 所有的预先调用将会作为 extern 进行处理。后续调用 将会内联。 生成错误消息的代码示例：

    class A {
    public:
    void foo ();
    };

    int main () {
    A a;
    a.foo();
    }

    inline
    void A::foo () {}

消息标识：inlafteruse

## 带符号类型和无符号类型之间的比较

带符号类型和无符号类型之间的比较。 生成消息的代码示例：

    int foo(unsigned ui, int i) {
    if ( ui < i )
    return 0;
    else
    return 1;
    }

消息标识：wunsignedcomp

## 循环迭代执行的排序指令不能超过一个

包含 for 构造的循环迭代执行的 指令不能超过一个。 生成消息的代码示例：

    int main () {
    #pragma omp for ordered
    for (int q = 0; q < 100; q++) {
    #pragma omp ordered
            {
    int a;
            }
    #pragma omp ordered
            {
    int b;
            }
        }
    }

消息标识：omp_badordered

## 局部类的友元 %1 必须在最深层的封装非类作用域中声明。

尚未在最深层的封装非类作用域中找到声明为友元或局部类的函数或类。 生成警告的代码示例：

    void global_f();

    class A {};

    void f() {
    extern void another_f();
    class B {};
    class local_class {
    	friend void f();             // 警告
    	friend void global_f();      // 警告
    	friend void another_f();     // Ok

    	friend class A;              // 警告
    	friend class B;              // Ok
        };
    }

消息标识：badlocalfrienddecl

## 包含该指令的最小语句必须是块

可以显示的某些 OpenMP 指令受到限制 生成此消息的代码示例：

    void foo() {
    int i = 0;
    label:
    #pragma omp barrier
    i++;
    goto label;
    }

消息标识：omp_mustbeblock

## 不能对该指令进行标记

不能对 barrier 和 flush standalone 指令进行标记 生成此消息的代码示例：

    main() {
    int i = 0;
    #pragma omp parallel
      {
    label:
    #pragma omp flush
    i++;
    goto label;
      }
    }

消息标识：omp_no_label

## pch 文件应该包含 srcdir

pch 文件应该包含 srcdir

消息标识：pchexpsrcdir

## pch collect 和 use 模式中的源目录不同

pch collect 和 use 模式中的源目录不同

消息标识：pchbadsrcdir

## pch 文件应该包含 cwd

pch 文件应该包含 cwd

消息标识：pchexpcwd

## pch collect 和 use 模式中的当前目录不同

pch collect 和 use 模式中的当前目录不同

消息标识：pchbadcwd

## pch 文件应该包含选项

pch 文件应该包含选项

消息标识：pchexpoptions

## pch collect 和 use 模式中的选项不同

pch collect 和 use 模式中的选项不同

消息标识：pchbadoptions

## 不能在 try 块中使用 OpenMP 构造

因为抛出异常的线程必须捕获 try， 所以不允许在 try 块中使用 OpenMP 构造 生成此消息的代码示例：

    try {
    #pragma omp parallel
      {
    throw a();
      }
    }
    catch(...) {
    printf("in catcher\n");
    }			    }

消息标识：omp_in_guarded

## 段指令之后必须跟由 {} 绑定的段作用域

标准要求，omp 段构造之后必须跟 { section-sequence } 生成此消息的代码示例：

    #pragma omp parallel sections
    i = i + 5;

消息标识：omp_nosectionscope

## 原子构造的表达式无效

有关管理合法原子表达式的规则，请参见 OpenMP API 生成此消息的代码示例：

    #pragma omp atomic
    i = i + 5;

消息标识：omp_badatomicexpr

## 不能修改 OpenMP for 循环中的索引

标准禁止修改循环中 OpenMP for 索引 变量的值 生成此消息的代码示例：

    #pragma omp parallel for
    for (i = 0; i < 10; i++) {
    i = i + 5;
      }

消息标识：omp_forindexmod

## %1 的模板参数与以前的声明不匹配

模板的友元声明必须具有相同的参数数目 生成错误消息的代码示例：

    template
    class X {
    public:
    X() { }

    private:
    template  friend class X ;              // 错误
    template  friend class X ;  // Ok
    };

    X i;

消息标识：nomatchfrienddecl

## 不能在匿名联合中声明类型

不能在匿名联合中声明类型 生成错误消息的代码示例：

    static union {
    struct S {	// 错误
    int i;
    } s;
    int j;
    };

消息标识：anonnotype

## 局部类中包含友元函数定义

只能在非局部类中定义友元函数 生成错误消息的代码示例：

    void f() {
    class A {
    friend int g() { return 1; }; // 错误
         };
    };

消息标识：locfriendfunc

## __declspec 语法无效

__declspec 语法无效 生成错误消息的代码示例：

    extern __declspec dllimport) int bar;

消息标识：declspecsyntax

## 不应该是 __declspec 属性标识符

不应该是 __declspec 属性标识符 生成错误消息的代码示例：

    extern __declspec(foo) int bar;

消息标识：declspecident

## 标记的语句不是结构化的块

结构化块的定义说明带有标记的语句 不是结构化的块。 生成消息的代码示例：

    #pragma omp sections
    {
    // optional #pragma omp section
    label:goto label;
    }

消息标识：omp_labeledisntstructured

## 声明语句不是结构化的块

结构化块的定义说明声明语句 不是结构化的块。 生成消息的代码示例：

    #pragma omp sections
    {
    // optional #pragma omp section
    int a = 1;
    }

消息标识：omp_declisntstructured

## 无法找到所需的匹配项

无法在重载函数和/或模板中找到调用时所用的函数的匹配项。 生成错误消息的代码示例：

    struct S { int &r; };
    int main () {
    struct S *x = new S(0); // 错误：未找到构造函数 S::S(int)
    };

    class A {
    public:
    int i;
    A();
    A(int a, int b);
    };

    void foo(){
    A a(1,2,3); // 错误：将三个参数传递给构造函数，不匹配
    }

消息标识：nomatchoverin

## pragma 无法识别

编译器找到未知或拼写错误的 pragma 生成警告消息的代码示例：

    #pragma some_unknown // ragma 未知
    int main()
    {
    #pragma opm for // pragma 拼写错误
    	for ( int i = 0; i < 10; i++ )
    	{
    	}
    	return 0;
    }

消息标识：unknownpragma

## 模板声明之后不能跟显式专门化声明

无法专门化内部模板，同时也无法专门化外部模板 生成错误消息的代码示例：

    template  struct S {
    template  struct I;
    template  void foo();
    };

    template  template<> struct S::I; // 错误
    template  template<> void S::foo(); // 错误

消息标识：nestexplspec

## 当前的作用域中不允许有显式专门化

只能在名称空间作用域内声明显式专门化 生成错误消息的代码示例：

    struct S {
    template  struct I;
    template  void foo();

    template<> struct I; // 错误
    template<> void foo(); // 错误
    };

消息标识：badexplspec

## 必须在包含模板的名称空间内声明显式专门化

必须在相同的名称空间中将模板的显式专门化声明为模板 生成错误消息的代码示例：

    namespace N {
    template  struct S {};
    template  void foo();
    }
    template<> struct N::S; // 警告
    template<> void N::foo(); // 警告

消息标识：badexplspecdecl

## 不允许在当前的作用域中定义显式专门化

可以在包含声明的名称空间或使用声明封装的名称空间内定义显式专门化 生成错误消息的代码示例：

    namespace N {
    template  struct S {};
    template  void foo();

    template<> struct S;
    template<> void foo();
    }
    namespace M {
    template<> struct N::S {}; // 警告
    template<> void N::foo() {} // 警告
    }

消息标识：badexplspecdef