该文件包含 Sun ANSI C++ 编译器 (ccfe) 错误和警告消息。它不包含 CC 驱动程序的其他组件（如优化器、代码生成器或链接器）发出的消息。
消息的格式为：
o 消息 o 说明 o 生成该消息的代码示例 o 消息 ID（标记）
并非所有的消息都包含说明或代码示例。
编译器消息有下面两种类型：
o 警告消息，可以提供有用的信息，而无需中断编译。其中，“警告”一词显示在文件名和行号之后。通过这些警告消息，可以诊断编程错误或 C++ 语法或语义的合法性，从而使编译器可以生成有效的对象代码。
o 错误消息，可以导致编译器命令失败。其中，“错误”一词是前缀。如果编译器诊断出严重的问题，并且该问题会使编译器无法理解程序或继续生成正确的对象代码，则将产生错误。但是，编译器将会尝试检查程序的其余部分，以便发现其他错误。如果编译器诊断出错误，则不会链接到您的程序上。
通常，短语“内部错误，不应发生”后面跟着一些消息，它无法诊断编程错误，但能诊断编译器问题。在编译器的内部一致性检查中，其中一项检查失败。由发出的消息诊断的问题是很重要的；您可以帮助 Sun Microsystems, Inc. 了解问题，方法如下：1. 失败时，使用相同的选项和 -P 选项重新运行 CC 命令。此后，将输出放在当面目录中后缀为 .i 的文件中。借助该文件，可以了解编译器问题。2. 致电授权的服务提供商。通过联系 Sun Microsystems, Inc. 零售商，可以找到授权的服务提供商。
*************************************
如果发生内部编译器错误，将会生成该消息。请注意有关错误的情况，并与 Sun 取得联系（联系信息）。
消息 ID：noerror
编译器尝试在编译时计算浮点加法的结果时，确定该结果溢出。低位 32 位结果将被保留，而编译器将执行此诊断。
消息 ID：addfovfl
编译器尝试在编译时计算加法的结果时，确定该结果溢出。低位 32 位结果将被保留，而编译器将执行此诊断。
消息 ID：addovfl
类已经使用外部作用域名称，所以无法重新定义名称。
生成错误消息的代码示例：
typedef int Integer;
class A {
Integer i;
float Integer; // 错误：在 A 中使用后重新定义整数
};
消息 ID：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; // 警告
消息 ID：alreadyusedt
名称同时存在于下面两个基类中：%3 和 %4。请使用作用域运算符指定所需的一个基类。
生成错误消息的代码示例：
struct A {
int i;
};
struct A2 {
int i;
};
struct B: A, A2 {
B() { i = 7; }
// 错误：B 中的名称 i 不明确：A::i 和 A2::i
};
消息 ID：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; // 正确
B2::i = 7; // 正确
}
};
消息 ID：ambigbfield
基类不明确：它包含在一个或多个基类中。
生成错误消息的代码示例：
struct A {
int i;
};
struct B: A {
int j;
};
struct C: A, B {
int k;
void foo() {
A::i = 10; // 错误：C 中的基类 A 不明确。
};
};
消息 ID：ambigbspec
在两个或多个基类中可以找到相同的名称。指定所需的一个名称。
生成错误消息的代码示例：
struct B1 {
void foo(){}
};
struct B2 {
void foo(){}
};
struct A: B1, B2 {
int i;
};
void bar()
{
A a;
a.foo(); // 错误
a.B1::foo(); // 正确
a.B2::foo(); // 正确
}
消息 ID：ambigname
匿名联合不能有函数成员。
生成错误消息的代码示例：
static union {
void foo(){} // 错误
};
消息 ID：anonnofunc
匿名联合不能有专用的或受保护的成员。
生成错误消息的代码示例：
static union {
long j;
private:
int i; // 错误
};
消息 ID：anonnoprivate
全局匿名联合必须是静态的。
生成错误消息的代码示例：
union { // 错误
long i;
int j;
float k;
};
消息 ID：anonnotstatic
对联合成员而言，拥有用户定义的赋值运算符是非法的。
生成错误消息的代码示例：
class A {
public:
int i;
A &operator =(A &la);
};
union B {
A a;
int i;
};
消息 ID：asgnotall
类拥有引用成员。无法为这种类的实例赋值。
生成错误消息的代码示例：
class A {
public:
int &i;
int j;
A(): i(j), j(5) {}
};
void foo()
{
A a1;
A a2;
a1 = a2; // 错误：无法为实例 a1 的引用成员 i 赋值
}
消息 ID：asgwref
成员被声明为常量，所以无法赋值。
生成错误消息的代码示例：
class A {
public:
const int i;
A(): i(5) {}
};
void foo()
{
A a1;
A a2;
a1 = a2; // 错误：无法为实例 a1 的常量成员 i 赋值
}
消息 ID：asgwconst
首先应该声明模板。
生成警告消息的代码示例：
template class B<int>; // 警告：未声明 B
消息 ID：assumetemp
无法通过这种方法对成员的访问进行更改。
生成错误消息的代码示例：
class A {
protected:
int i;
};
class B : public A {
public:
A::i; // 错误：无法更改访问
};
消息 ID：badaccadj
因为存在其他类成员，所以无法更改访问。
生成错误消息的代码示例：
class A {
public:
int i;
};
class B : public A {
protected:
int i;
public:
A::i; // 错误：由于 B::i 而无法更改对 A::i 的访问
};
消息 ID：badadjname
未定义该对象的一元运算符。要解决这个问题，可以为传入的类型定义重载一元运算符。
生成错误消息的代码示例：
class A {
int i;
public:
//运算符 ++(); // 前缀运算符 ++
};
void foo()
{
A a;
a++; // 错误：重载运算符 ++ 以进行更正
}
消息 ID：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; // 错误
}
消息 ID：badbinaryop
传递到包含引用的函数中的值不是左值。
生成错误消息的代码示例：
int foo( int &i)
{
i = foo(1); // 错误："1" 不是左值。
return 2;
}
消息 ID：badarglval
传递到包含指针或地址的函数中的值不是左值。
生成错误消息的代码示例：
int foo( int &i)
{
i = foo(1); // 错误："1" 不是左值。
return 2;
}
消息 ID：badarglval2
无法将传递到函数中的参数赋值给该函数的某个参数。
生成错误消息的代码示例：
void foo(int *cp);
int main() {
const char *cp = "abcd";
foo(cp); // 错误：正在向 int* 传递常量 char *cp
return 0;
}
消息 ID：badargtype
无法将调用函数时使用的形式参数赋值给该函数的某个参数。
生成错误消息的代码示例：
void foo(int *cp);
int main() {
const char *cp = "Hello";
foo(cp); // 错误：正在向 int* 传递常量 char *cp
return 0;
}
消息 ID：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;
}
消息 ID：badargtypew
调用函数时使用的形式参数类型与该函数的参数不匹配。
生成警告消息的代码示例：
void foobar(char *c);
void foo()
{
const char *c = "abcde";
foobar(c); // 警告，正在将常量 char* 传递给调用 foobar 时使用的 char*
}
消息 ID：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;
}
消息 ID：badargtype2w
调用函数时使用的形式参数类型与该函数的参数不匹配。
消息 ID：badargtypel2w
数组初始化程序应该加花括号。
生成警告消息的代码示例：
static char a [5] = ("qwer");
消息 ID：badarrinit
遇到语法错误：条件类型不正确。
生成错误消息的代码示例：
void foo() {
for ( ;int i[1] = (1); ); // 错误：条件无法具有类型 int[1]
};
消息 ID：badcondtype
类型有一个无法访问的构造函数。
生成错误消息的代码示例：
class A {
A(A& a) { }; // 用户定义的专用复制构造函数
public:
A() {};
};
A the_a;
void foo(A a) { };
void bar() { foo(the_a); }; // 错误：调用 foo(A) 时使用的类型 A 的形式参数 a
// 有一个无法访问的复制构造函数
消息 ID：badcopyacc
调用函数时使用的形式参数的对象类型没有可以访问的复制构造函数。无法将形式参数复制到新的对象。
生成错误消息的代码示例：
class A {
A(A &a); // 用户定义的专用复制构造函数
public:
A();
void foo(A a);
} a1, a2;
int main() {
a2.foo(a1); // 错误：A(A&) 是专用的。
};
消息 ID：badcopyacc2
类型有一个无法访问的构造函数。
生成错误消息的代码示例：
class A {
A(A& a) { }; // 用户定义的专用复制构造函数
public:
A() {};
};
A the_a;
void foo(A a) { };
void bar() { foo(the_a); }; // 错误：调用 foo(A) 时使用的类型 A 的形式参数 a
// 有一个无法访问的复制构造函数
消息 ID：badcopyaccw
调用函数时使用的形式参数的对象类型没有可以访问的复制构造函数。无法将形式参数复制到新的对象。
生成错误消息的代码示例：
class A {
A(A &a); // 用户定义的专用复制构造函数
public:
A();
void foo(A a);
} a1, a2;
int main() {
a2.foo(a1); // 错误：A(A&) 是专用的。
};
消息 ID：badcopyacc2w
对象类型不是数组类型，所以不能使用数组运算符。
生成错误消息的代码示例：
class A {
public:
//A operator[] (int);
} a1, a2, a3[4];
int main() {
a1[7] = a2; // 错误：a1 不是数组
a3[4] = a2; // 正确
};
消息 ID：badarraytype
将对象赋值给不兼容的类型。
生成错误消息的代码示例：
class A {
int i;
};
void foo()
{
A a;
int j;
j = a; // 错误：无法将 A 赋值给 int
}
消息 ID：badassignment
应该提供显式赋值运算符。
生成错误消息的代码示例：
class A { };
class B {
public:
int operator = (int ) { return 0; }
// 应该定义下列运算符，以便
// 去除错误消息：
// int 运算符 = (const A&);
};
int main () {
A a;
B b;
b = a;
}
消息 ID：badasscasg
指定的基类不是预先定义的类或结构。
生成错误消息的代码示例：
class B;
class A: B {}; // 错误：未定义基类 "B"。
消息 ID：badbaseclass
位字段属于非整型是错误的。
生成错误消息的代码示例：
static union {
float c:3; //错误
};
消息 ID：badbftype
break 语句可能不在 loop 或 switch 语句之外。
生成错误消息的代码示例：
int main()
{
int i = 5;
break;
return 0;
}
消息 ID：badbreak
只有整型才能在 switch 选择表达式中使用。
生成错误消息的代码示例：
void foo()
{
float i = 9;
switch(i) { // 错误：i 不是整型
case 1:
case 9:
break;
};
return;
}
消息 ID：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); // 正确
int i = c; // 正确
}
消息 ID：badcast
预处理程序指令使用了非法的字符。
消息 ID：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;
}
消息 ID：badcolon
作用域运算符应该位于类型限定符之间。
生成错误消息的代码示例：
class B {
public:
static int i;
static int j;
};
::int i; // 错误
B::j = 9; // 正确
消息 ID：badcolon2
## 运算符的两边必须有标记。
生成错误消息的代码示例：
#define foo(a) abc ## // 错误
消息 ID：badconcat
只有构造函数才能有构造函数初始化程序。
生成错误消息的代码示例：
class B {
int i;
B(): i(5) {} // 正确
void foo() : i(6) {} // 错误
};
消息 ID：badconinit
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); // 正确：从 int 到 int 的 const_cast 转换
}
消息 ID：badconstcast
语法错误。常量无效。
生成错误消息的代码示例：
int i = 2ooo; // 错误 int k = 0x9; //正确
消息 ID：badconsterr
导致错误的原因可能包括：非成员函数已声明为 const 或 volatile，或将静态成员函数声明为 const 或 volatile。
生成错误消息的代码示例：
class A {
static void foo() volatile {}; // 错误
};
void foo() const {}; // 错误
消息 ID：badconstfunc
构造函数不能包含返回类型说明，其中包括 void。
生成错误消息的代码示例：
class A {
int A(); // 错误
};
消息 ID：badcontype
continue 只能在循环语句中使用。循环示例包括 while、for 和 do-while。
生成错误消息的代码示例：
void foo()
{
int i = 5;
if ( i > 4 ) {
i = 4;
continue; // 错误：循环中没有 continue
}
}
消息 ID：badcontin
转换函数不能包含返回类型说明。运算符类型足以说明返回的值。
生成错误消息的代码示例：
class A {
int j;
float f;
int operator int() { return j; }; // 错误：可能未指定返回类型。
operator float() { return f; }; // 正确
};
消息 ID：badconvtype
从不隐式地使用由用户定义的到类型 void 的转换。到类型 void 的转换是非法的。
生成警告消息的代码示例：
class A {
public:
operator void(); // 警告
};
消息 ID：wbadconvret
遇到语法错误：声明被错误终止。
生成错误消息的代码示例：
class A {
void f() ; { } // 错误：声明被错误终止
};
消息 ID：baddeclerr
分析声明时应该有一个标识符。声明 typedef 时，可能会遇到词法错误。
生成错误消息的代码示例：
typedef *int my_type; // 错误：stray star
消息 ID：baddecl
声明参数列表中的缺省值时，第一个缺省参数之后的其余所有参数也必须有缺省值。
生成错误消息的代码示例：
template <class T=long,
class K> // 错误：无缺省值
class A {};
void foo( int a,
float b,
long c = 6,
double e; // 错误
int f = 2; )
{}
消息 ID：baddefault
模板参数缺省值必须是定义或声明的类型。
生成错误消息的代码示例：
template <class T, class K>
class A;
template <class T, class K = Eye>
class A {
int i;
};
消息 ID：baddefaultpar
在相同的作用域中，相同模板声明使用不同缺省参数会产生错误。
生成错误消息的代码示例：
template <class T = int>
class A;
template <class T = long> // 错误
class A {
int i;
};
消息 ID：sametmpldef
在相同作用域中，如果在模板函数的后来声明中添加缺省参数，则会产生错误。
生成错误消息的代码示例：
template <class T>
T foo(T);
template <class T>
T foo(T = (T)9) // 错误
{ return T; }
消息 ID：badtmplfundef
析构函数名必须与类名相同。
消息 ID：baddestrname
析构函数不能包含返回类型，其中包括 void。
生成错误消息的代码示例：
class A {
A();
int ~A();
};
消息 ID：baddestrtype
else 子句的前面必须有 if 语句。
生成错误消息的代码示例：
void foo() {
int i = 0;
else // 错误：前面没有 if
i++;
}
消息 ID：badelseerr
枚举常量值溢出最大整数值。最大整数值与计算机有关。
生成错误消息的代码示例：
#include <limits.h>
enum e { e1=ULONG_MAX, e2 }; /* overflow for e2 */
消息 ID：badenumrange
表达式中出现语法错误或错误。
生成错误消息的代码示例：
int* foo() { return int[1]; }
消息 ID：badexprerr
使用 extern 指定的语言必须是 "C" 或 "C++"。
生成错误消息的代码示例：
extern "c" int i; // 错误："c" 应该是 "C"
消息 ID：badextern
前面已经使用不同语言声明函数。只能使用一种语言版本。
生成错误消息的代码示例：
void foo();
extern "C" void foo() {} // 错误：foo() 以前声明为 C++
消息 ID：badextlnk
前面已经使用不同语言声明变量。
生成错误消息的代码示例：
extern "C" int i; extern "C++" int i;
消息 ID：badextlnkw
成员不允许使用存储类。
生成错误消息的代码示例：
class A {
register int j; // 错误：此处不允许使用存储类寄存器
extern int k; // 错误
auto int l; // 错误
};
消息 ID：badfieldstore
include 文件名的格式不正确。
生成错误消息的代码示例：
#include 'includefile,h' #inlcude stdio.h
消息 ID：badfilename
函数在使用前应该具有原型。如果对编译器进行设置，使其在 C 模式下编译，将会显示该消息。
生成警告消息的代码示例：
int main () {
return foo(); // 警告：函数应该具有原型（仅限 C 模式）
}
消息 ID：badfunc
在程序中使用函数之前，该函数必须具有原型或函数定义。
生成错误消息的代码示例：
int main()
{
goo(); // 错误
return 0;
}
void goo() {};
消息 ID：badfunccp
函数存储类型必须是静态或外部函数。这些类型不能是 mutable、register 或 auto。
生成错误消息的代码示例：
static f1(); // 正确 extern f2(); // 正确 // 错误如下： mutable f1(); // "mutable" 不允许在类之外 register f2(); auto f3();
消息 ID：badfuncstore
遇到语法错误。最有可能的是，函数声明中指定的返回类型错误。
生成错误消息的代码示例：
int a[] = {1, 2, 3, 6, 4, 5};
typedef void bar();
class A {
bar goo(); // 错误
int foo()[] { return a; } // 错误
};
消息 ID：badfunctype
变量已在 goto 跳过的块中声明。
生成警告消息的代码示例：
int main()
{
int a = 2;
goto next;
int b = 3; // 已跳过初始化 b
next:
a++;
return 0;
}
消息 ID：badgoto
无法访问或找到 include 文件。因此，无法将其打开。请检查该 include 文件名的拼写。
消息 ID：badinclfile
外部变量无法在局部作用域内初始化。
生成错误消息的代码示例：
extern int out = 2; // 正确
void foo()
{
out = 3; // 正确
extern int in = 9; // 错误
extern int in2;
in2 = 10; // 正确
};
消息 ID：badinit
类不是聚集对象。只有不包含构造函数、专用或受保护的成员、基类和虚拟函数的类，才能使用带括号的初始化。
生成错误消息的代码示例：
class A {
int i;
int j;
};
A a = {1, 2}; // 错误：i 和 j 是专用的。
消息 ID：badinitcl
无法对该对象使用带括号的初始化。
生成错误消息的代码示例：
namespace N {
int i;
int j;
}
N n = { 1, 2 };
消息 ID：badinitbrace
必须使用左值对引用进行赋值。
生成错误消息的代码示例：
int &i = 3; // 错误
const int i = 0;
int &ri = i; // 错误：常量 int i 不是左值
int j = 0;
int &rj = j; // 正确
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; // 正确，"jr" 是对 int 的引用。 }
消息 ID：badinitlval
初始化变量时使用的类型是非法的。如果执行这种赋值操作，可以使用构造函数、转换运算符或赋值运算符的重载。
生成错误消息的代码示例：
class A {
int j;
public:
operator int() {return j; } // A 的转换运算符
};
void foo() {
A a;
int i = a; // 正确。提供 A 到 int 的转换格式
a = new A(); // 错误：使用 A* 初始化 A
};
void bar() {
int i = 9;
char *a = &i; // 错误：无法使用 int* 初始化 char*
}
消息 ID：badinittype
无法初始化构造函数参数列表中的数组成员。
生成错误消息的代码示例：
class A {
int i[3];
int j;
A(): i(1,2,3),
j(3) {};
};
消息 ID：badarrayinit
该计算机上的整数太大，无法表示。
生成错误消息的代码示例：
int i = 999999999999999999999999999999999;
消息 ID：badinteger
Line 指令要求使用无符号的十进制整数。
生成错误消息的代码示例：
#0x12 // 错误 #line 0xff "file.cc" // 错误 #line 12345 "file.cc" // 正确
消息 ID：badlinedir
line 指令只能指定 1 到 32767 之间的整数。
生成错误消息的代码示例：
#line 1234567 "file.cc"
消息 ID：badlinenum
以前已经使用不同的链接声明标识符，所以不能对其进行更改。
生成错误消息的代码示例：
extern char * static_and_extern(); static char * static_and_extern(); // 错误：已将其声明为 extern 而非 static
消息 ID：badlinkage
根据相关的标准，main() 必须有一个 int 返回类型。
生成错误消息的代码示例：
void main() {}
消息 ID：badmain
根据相关的标准，获取 main() 函数的地址是非法的。
生成错误消息的代码示例：
int main()
{
int *a = main;
return 0;
}
消息 ID：badmainaddr
不允许递归调用 main。
生成错误消息的代码示例：
int main()
{
main();
return 0;
}
消息 ID：badmaincall
无法重载 main()。
生成错误消息的代码示例：
int main( int j) // 错误：无法重载 main ()
{
return 0;
}
int main()
{
return 0;
}
消息 ID：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(); // 正确，使用基类构造函数初始化
i = 7;
j = 9;
}
};
消息 ID：badmembinit
定义类主体之前，无法通过指向成员函数的指针调用成员函数。
生成错误消息的代码示例：
class A;
void (A::* f_ptr) ();
int main () {
A *a;
(a->*f_ptr)();
}
消息 ID：badmfcall
成员函数可以有存储类 mutable、auto、register 和 extern。
生成错误消息的代码示例：
class A {
mutable void f1(); // 错误
auto void f2(); // 错误
extern void f3(); // 错误
static void f4(); // 正确
register void f5(); // 错误
};;
消息 ID：badmfstore
八进制常量只能包含 0 到 7 之间的数字。
生成错误消息的代码示例：
int i = 08; // 错误：对八进制数字而言，8 是非法数字
消息 ID：badoctal
重载函数的集合中只能有一个是外部 "C"。
生成错误消息的代码示例：
extern "C" int foo (char); extern "C" int foo (double); // 错误：已使用另外一个外部 "C" 函数重载 // 外部 "C" 函数
消息 ID：badollnk
声明重载运算符时使用的参数太多。无法对运算符使用的参数数目进行更改。
生成错误消息的代码示例：
class B {
int j;
B operator +(B, B); // 错误：应该是 "B operator +(B)"
};
消息 ID：badopcount
new 和 delete 运算符的返回类型不正确。
生成错误消息的代码示例：
#include <stddef.h>
class A {
A* operator new[] (size_t); // 错误：返回类型应该是 void*
A operator delete[] (void*); // 错误：返回类型应该是 void
};
消息 ID：badoprtype
构造函数或运算符中的参数非法。
生成错误消息的代码示例：
class A {
void operator delete[] (long* ); // 错误：long* 应该是 void*
A(A); // 错误：复制构造函数中的参数必须是对类类型的引用
};
消息 ID：badoptypes
(Kernigan and Ritchie) 参数已被声明，但未在参数列表中定义
生成错误消息的代码示例：
void foo (a,b)
int a;
char b;
long d; // 错误：参数列表中未定义 d
{}
消息 ID：badparamerr
重载后缀二进制运算符必须使用 int 参数。
生成错误消息的代码示例：
class B {
B operator++(); // 前缀 ++b
B operator++(float); // 后缀 b++，
//错误：应该是 B operator++(int)
};
消息 ID：badpostfix1
后缀运算符的第二个参数必须使用 int 值。
生成错误消息的代码示例：
template<class T> T operator ++(T &t, float); // 错误：将 float 更改为 int。
消息 ID：badpostfix2
无法识别预处理程序指令。检查拼写。
生成错误消息的代码示例：
#bad_directive
消息 ID：badppdir
预处理程序指令中应该包含常量表达式，但未找到。
生成错误消息的代码示例：
#if 0xkl0 // 错误：常量表达式的格式不正确。 #fi
消息 ID：badppexpr
像 int、float 和 char 这些简单类型没有析构函数。
生成错误消息的代码示例：
int main() {
int *i = new int(0);
i->int::~int(); // 错误：改用 "delete i"
}
消息 ID：badpseudodestr
只有虚拟函数，才能声明为纯函数。
生成错误消息的代码示例：
class A {
A() = 0; // 错误：A::A() 不是虚拟的，但已声明为纯函数
virtual void foo() = 0; // 正确
};
消息 ID：badpuref
纯函数要求函数声明为虚拟函数，且设置等于 0。其他任何语法将会产生错误。
生成错误消息的代码示例：
class A {
A() = 0; // 错误：A::A() 不是虚拟的
virtual void foo() = 1; // 错误："1" 应该是 "0"
void foo() = 99; // 错误：A::foo() 不是虚拟的
virtual void foobar() = 0; // 正确
};
消息 ID：badpuresyn
"?:" 的第二个和第三个操作数不兼容，所以无法进行转换。
void foo()
{
int *x;
int y;
int i = (1 == 4 ) ? x : y; // 错误
}
消息 ID：badquesttypes
浮点常量无效。该常量太大，将会溢出，或者其数字之后的字符（F、f、L 或 l）无效。
生成错误消息的代码示例：
float i = 123.34f; // 正确 float j = 987.2g; // 错误
消息 ID：badreal
不允许 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; // 正确，指针类型
b = (B*)a1; // 正确
a1 = (A*)b; // 正确
}
消息 ID：badreintcast
函数返回的类型与函数声明指定的一个类型不同。
生成错误消息的代码示例：
class A{
A foo() {
char a = 'c';
return a;
}
};
消息 ID：badreturn
遇到意外的 ")"。
生成该消息的代码示例：
int main(){
int i;
); // 错误：右括号不匹配
消息 ID：badrparerr
只有从一种类型隐式转换成另外一种类型时，static cast 才是合法的。
生成错误消息的代码示例：
struct A {
operator int();
} a;
struct B {} b;
void foo()
{
int i = 3;
double d = 3.14159;
i = d; // 正确
i = static_cast<int> (d); // 正确
static_cast<A> (i); // 错误
static_cast<B> (a); // 错误
int(a); // 正确，提供从类型 A 到 int 的转换
static_cast<int> (a); // 正确
};
消息 ID：badstaticcast
不能将成员函数声明为静态函数。
生成错误消息的代码示例：
#include <iostream.h>
class A {
static A foo(); // 正确
// 错误如下：
static A();
static A( int i, int j );
static ~A();
static A operator+(A a);
static istream& operator>>(A& a);
};
消息 ID：badstatmf
函数不能既声明为虚拟函数又声明为静态函数。
生成错误消息的代码示例：
class A {
static virtual void foo();
};
class C {
virtual void foo();
};
class D: C {
static void foo(); // 错误
};
消息 ID：badstatvirtf
未定义字符串中使用的字符转义符序列。
生成错误消息的代码示例：
void foo()
{
char *a = "Hello World!\i"; // 错误：未定义 "\i"
}
消息 ID：badstring
字符型的值太大，无法适合字符类型。
生成错误消息的代码示例：
char c = '\xabc'; int i = '\xabcdefg';
消息 ID：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; // 错误：非静态成员的地址
消息 ID：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; // 确定
A<j> a4; // 确定
};
消息 ID：badtmplrefarg
模板参数类型必须是整数类型。
消息 ID：badtemppar
一元运算符的操作数必须是左值。
生成错误消息的代码示例：
void foo() {
const int x = 7;
x++; // 错误
int j = --9; // 错误
}
消息 ID：badunaryop
只有非静态成员函数，才能使用 this。
生成错误消息的代码示例：
class A {
int j;
public:
static void foo() { this.j = 20*j; } // 错误
void foobar() {this.j = 21*j; }; // 正确
};
消息 ID：badthis
此处不允许有类型说明符。
消息 ID：badtypeerr
派生类具有虚拟函数，该函数包含基类中的函数指定的不同返回类型。
生成错误消息的代码示例：
class Base {
virtual void foo();
};
class A: Base {
int foo(); // 错误：应该返回 void
};
消息 ID：badvirttype
为位字段指定的位数太多。最有可能的是，位字段的类型太小，无法具有指定数目的位数。
生成错误消息的代码示例：
struct tag {
char a: 32; // 警告：char 太小，无法具有 32 位
} t;
消息 ID：bfbigger
声明的位字段太大。位字段的大小与计算机有关。
生成错误消息的代码示例：
static union {
int a:33; // 错误：位字段可能不长于 32 位（在此计算机上）
};
消息 ID：bftoobig
不能使用少于一位的大小定义位字段。
生成错误消息的代码示例：
class A {
int a:0; // 错误：位字段必须至少包含一位
};
消息 ID：bftoosmall
最有可能的是，尝试将成员函数的指针赋值给函数的指针。
生成错误消息的代码示例：
class A {
public:
A () { }
int goo ();
};
int main () {
A a;
int (*foo) ();
// 应该使用下列声明：
// int (A::* foo) ();
foo = a.goo;
}
消息 ID：boundfuncaddr
获取构造函数的地址是非法的。
生成错误消息的代码示例：
struct A {
A();
};
void foo()
{
const int &i = A::A; // 错误：无法获取构造函数的地址
}
消息 ID：cantaddrcon
获取析构函数的地址是非法的。
生成错误消息的代码示例：
struct A {
~A();
};
void foo()
{
const int & i = A::~A; // 错误：无法获取析构函数的地址
}
消息 ID：cantaddrdest
正在尝试重新赋值已经声明为常量但无法进行修改的左操作数。
生成错误消息的代码示例：
const int i = 7;
int j = 9;
void foo () {
i = j; // 错误：无法赋值左操作数
}
消息 ID：cantassign
无法修改操作数。无法赋值常量值、数组名称和函数。
生成错误消息的代码示例：
int i = 7;
int *const pi = &i;
int j[5];
j = 9;
void foo() {}
void goo() {
foo = 5; // 错误：无法赋值操作数 "*foo"。
pi = &i; // 错误：无法赋值操作数 "pi"。
}
消息 ID：cantassignop2
无法链接宽字符类型的字符串和字符类型的字符串。
生成错误消息的代码示例：
char str [] = "abcdefhg" L"hijklmnop";
消息 ID：cantcatstring
如果检测到的错误太多，则编译器会发送该错误，以便继续调试程序。
消息 ID：cantgoon
未找到指定的重载运算符。如果尚未定义运算符的类型，也会生成该错误。
生成错误消息的代码示例：
#include <stddef.h>
class A {
void* operator anew[] (size_t); // 错误：操作数 "anew" 不存在
void operator delete[] (void*);
};
为未定义类型声明的运算符示例：
class B {
operator C(); // 错误：尚未定义类型 C
};
class C {};
消息 ID：cantoverop
对于每种定义，重载函数的地址不同。获取地址不明确，因此会产生错误。
生成错误消息的代码示例：
int foo() {return 1; }
int foo(int i) { return 0; }
int main()
{
const int & i = foo; // 错误
const int & j = foo; // 错误
return 0;
}
消息 ID：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); // 错误
消息 ID：xcastawayconst
当前未执行该错误。如果从不完整且不为 void 的结构强制转换，则会发出该错误。
消息 ID：castfrominc
当前未执行该错误。如果强制转换到不完整且不是 void 的结构，则会发出该错误。
消息 ID：casttoinc
异常处理程序可能没有缺省参数。
生成错误消息的代码示例：
int main ()
{
int i = 3;
try
{
if (i < 100) throw 100;
}
catch (int j = 1000) // 错误
{
i += j;
};
}
消息 ID：catchdef
如果派生类的处理程序位于基类处理程序之后，则将会生成该警告。第二种情况永远无法捕获异常。第一种情况将会捕获基类实例和派生类实例的异常。
生成错误消息的代码示例：
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;
};
}
消息 ID：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) // 正确
{
i = j = i + j;
}
catch (int y ) // 错误：重复的异常处理程序，类型相同
{
j = 2;
};
}
消息 ID：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;
}
消息 ID：catchmularg
处理程序必须有一个异常。
生成错误消息的代码示例：
int main() {
int i = 3;
try
{
if ( i != 3 )
throw 3;
}
catch ( ) // 错误：处理程序没有异常
{
i = 3;
}
return 0;
}
消息 ID：catchnoarg
try 必须至少有一个异常处理程序。
生成错误消息的代码示例：
int main ()
{
int a = 107;
try
{
if (a > 2000) throw 2000;
if (a < 100) throw 100;
throw a / 3;
}
// 错误：缺少 catch 语句
}
消息 ID：catchnosym
指定缺省参数值之后，无法对其进行重新定义。
生成错误消息的代码示例：
void foo( int i, int j = 7 ); // j 的缺省值是 7
int main()
{
return 0;
}
void foo( int i, int j = 9 ) {}
// 错误：已经定义 j，其缺省值为 7
消息 ID：changedef
字符常量的长度超过了 char 的最大存储空间。只能使用正则字符常量的前四个字符和宽字符常量的第一个字符。长度超过一个字符的字符常量无法进行移植。
生成警告消息的代码示例：
char c = '9999'; // 正确 char ch = '12345'; // 错误
消息 ID：chartoolong
无法将以前作为类或结构类型定义的对象重新定义为联合。
生成错误消息的代码示例：
class A {
int i;
};
union A { // 错误
int i;
long j;
};
消息 ID：cltounion
无法将作为联合类型定义的对象重新定义为类或结构类型。
生成错误消息的代码示例：
union A {
int i;
long j;
};
class A {
int i;
};
消息 ID：clfromunion
（C 模式）在 C 模式下，声明不能与语句混合使用。
生成错误消息的错误示例：
void foo () {
int a = 0;
a++;
int c; // 错误：不允许在此处进行声明
}
消息 ID：declplaceerr
各类的向量只能使用缺省的构造函数。
生成错误消息的代码示例：
class A {
A() {};
};
typedef A B[5];
void foo() { B b(1, 2, 3, 4, 5); }; // 错误
消息 ID：defaultonly
在条件表达式中定义类型是非法的。
生成错误消息的代码示例：
int main () {
for (int i = 0; struct t {}; j++) // 错误：不能在此处定义 'struct t'
;
}
消息 ID：defincond
类的析构函数是专用且受到保护的函数，所以在此处无法对其进行访问。
生成错误消息的代码示例：
class A {
private:
~A();
public:
char *ch;
A();
};
void foo() throw(A) {
throw A(); // 错误：无法访问析构函数
}
int main () {
foo();
}
消息 ID：destnotacc
同一函数被声明返回两个不同的类型。
生成错误消息的代码示例：
void foo(); int foo(); // 错误：foo() 以前返回 void。
消息 ID：difreturns
编译器确定浮点除法表达式的求值将会溢出。
消息 ID：divfovfl
编译器确定整数值正在除以零，所以将会溢出。
生成错误消息的代码示例：
int i = 1/0;
消息 ID：divovfl
尝试除以零，然后将结果交由运行时处理。
生成警告消息的代码示例：
int i = 9; int j = i/0;
消息 ID：divovflnv
当前的 switch 语句包含两个 default 语句。
生成该消息的代码示例：
f(void){
long i = 5;
switch(i) {
case 1:
case 2:
break;
default:
default: // 错误：default 语句太多
}
}
消息 ID：doubdefault
使用两个连续的下条时，将会发出警告。名称可能与编译器生成的代码的内部名称冲突。
消息 ID：doubunder
基类的访问只能指定一次。
生成错误消息的代码示例：
class B {};
class D: public private protected B {}; // 错误
class G: public public {}; // 错误
消息 ID：dupaccess
一个基类只能被包含一次。
生成错误消息的代码示例：
struct A2 {
int i;
};
struct A {
int i;
};
struct A2 {
int i;
};
struct B: A, A2, A { // 错误：基类 A 被包含了两次
B() { A::i = 7; };
};
消息 ID：dupbaseclass
当前 switch 语句包含两个具有相同常量值的 case 语句。
生成错误消息的代码示例：
f(void){
long i = 5;
switch(i) {
case 4:
case 4:
break;
}
}
消息 ID：dupcaselabel
之前已经在构造函数初始化程序列表中初始化成员。
生成错误消息的代码示例：
class A {
int i;
A(): i(0),
i(0) { // 错误：重复初始化成员 i
}
};
消息 ID：dupinit
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); // 正确
消息 ID：dynbadtype
dynamic_cast 操作数必须使用指向多态类型的指针或引用。类型必须至少有一个虚拟函数。
生成错误消息的代码示例：
class B {};
class D: public B {};
B * pb = new D;
D *pd = dynamic_cast<D*>(pb); // 错误：类 B 没有虚拟函数
消息 ID：dynnotpolym
预期的结果是引用，而操作数不是引用、指针或结构类型。
生成错误消息的代码示例：
class B { virtual void foo(); };
class D: public B {};
B *pb = new D;
int &c = int j;
D *pd1 = dynamic_cast<D&>(pb); // 错误：操作数 pb 是一个指针
D *pd2 = dynamic_cast<D&>(c); // 错误：c 不是结构类型
消息 ID：dynnotref
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); // 正确
消息 ID：dynnotptr
dynamic_cast 的目标结果不是指向类的指针或引用。
生成错误消息的代码示例：
class B { virtual void foo(); };
class D: public B {
};
B *pb = new D;
D *pd1 = dynamic_cast<int*>(pb); // 错误：dynamic_cast 应该指定类型 "D*"
消息 ID：dynnotclass
操作数未指向类类型。
生成错误消息的代码示例：
class B { virtual void foo(); };
class D: public B {};
int *c = int j;
D *pd = dynamic_cast<D*>(c); // 错误：c 指向 int
消息 ID：dynbadopnd
使用相同名称声明的对象不止一个。
生成错误消息的代码示例：
int i; float i; // 错误 typedef int I //. . . int I; // 错误
消息 ID：multdecl
已经初始化基类。
生成错误消息的代码示例：
class B {
int i;
B() { i = 0; };
};
class A: B {
int i;
A(): B(),
B() { // 错误：已重新初始化基类。
}
};
消息 ID：dupbaseinit
生成错误消息的代码示例：
int const int i = 9; const float const j = 3;
消息 ID：duptypeerr
函数只能定义一次。
生成错误消息的代码示例：
void foo() { int i; }
int main()
{
/* code */
}
void foo() { int i; } // 错误，foo() 定义了两次
消息 ID：dupfuncdef
基类的虚拟声明太多。基类只需一个虚拟声明。
生成错误消息的代码示例：
class B {};
class D: virtual public virtual B {}; // 错误：虚拟声明太多。
消息 ID：dupvirtspec
"catch(...)" 必须是异常处理程序块的最后一个处理程序。
生成错误消息的代码示例：
int main ()
{
int i = 3;
try
{
if (i < 100) throw 100;
}
catch (...){} // 错误：将该 catch 移至最后一个 catch 语句
catch (int j)
{
i += j;
};
}
消息 ID：eliplaceerr
使用了未包含字符的字符常量。
生成该消息的代码示例：
f(void) {
char c = ''; // 建议：char c = ' ';
}
消息 ID：emptychar
代码包含名称空间作用域内（包括全局和文件作用域）的空声明。最有可能的原因是有多余的分号。
生成该消息的代码示例：
namespace {
; // 错误
};
class A {
;
}
消息 ID：emptydecl
文件为空。如果文件未作为 C++ 文件进行编译，且编译器未处于兼容模式，将会产生该错误。
消息 ID：emptyfile
在结束注释之前，遇到文件结束标记。
生成错误消息的代码示例：
/* message text . . . <EOF> // 错误
消息 ID：eofincomment
跳转文本时，编译器遇到文件结束标记。检查 #if .. . #endif 的匹配性。
生成错误消息的代码示例：
#if false // . . . #if 与 #endif 不匹配 // <EOF>
消息 ID：eofskipping
表达式超过了该编译器所允许的最多操作数和运算符数。尝试将表达式分成更小的中间表达式。
消息 ID：exprtoomuch
参数列表不应该以结尾逗号结尾。
生成警告消息的代码示例：
void foo( int i, int j) {}
int main()
{
foo(1,2,); // 错误
return 0;
}
消息 ID：extracomma
只能在构造函数中初始化成员。
生成错误消息的代码示例：
struct A {
int i = 9; // 错误
int j = 4; // 错误
};
class B {
int k;
B() { k = 7; } // 正确
};
消息 ID：fieldinit
派生类中的函数将函数隐藏在基类中。
生成警告消息的代码示例：
class A {
public:
int foo(int);
};
class B: A {
public:
virtual int foo(char *i);
};
消息 ID：hidef
在作用域中找不到普通的 delete 运算符。最有可能的是，delete 运算符在类作用域中被非法覆盖。
生成错误消息的代码示例：
#include <new>
template<class t_arg> class A {
public:
void operator delete(void*, const std::nothrow_t&) throw(); // 错误：delete(void*) 被隐藏，
// need to provide operator delete
// with one parameter as well
};
int main () {
A<int> * a = new A<int>;
}
消息 ID：hideferr
派生类中的函数将其对应的函数隐藏在基类中。如果在派生类中重新声明虚拟函数，且其原型与基类中指定的原型不匹配，通常会产生该错误。
生成错误消息的代码示例：
class B {
public:
virtual int foo(int); // 被 B::foo() 隐藏
};
class D: B {
public:
virtual int foo(char *i); // B::foo() 隐藏虚拟的 A::foo(int)
};
消息 ID：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)
};
消息 ID：hidevfinvb
在当前的上下文中，无法将名称用作缺省参数。
生成错误消息的代码示例：
void foo () {
int a;
class A {
public:
void goo (int b = a) {} // 错误：此处无法使用 a
};
}
消息 ID：identundef
无法在指定的上下文中使用名称。
生成错误消息的代码示例：
void foo () {
int a;
class A {
public:
void goo () {
int k = a; // 错误：此处无法使用 a
}
};
}
消息 ID：identunnestf
只有非静态成员函数才能使用该名称。成员变量不是静态的。每种类型的实例会有自身的副本。
生成错误消息的代码示例：
struct A {
int i;
};
struct B: A {
public:
int i;
static int j;
void foo() { B::i = 2; } // 正确
static foobar() { i = 2; } // 错误："foobar()" 是静态的，但 "i" 不是静态的
};
void foobar() {
A a;
A::i = 7; // 错误：A::i 不是静态的
B::j = 3; // 正确
a.i = 7; // 正确
}
消息 ID：identunstat
在强制转换表达式中定义类型是非法的。
生成错误消息的代码示例：
int i;
float j = ( class A{} ) (i);
消息 ID：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
消息 ID：inaccessible
类型的定义不正确，或尚未分配存储。
生成错误消息的代码示例：
class C;
void f ()
{
new C; // 错误：类型 C 不完整
}
消息 ID：incomplete
尚未定义 delete 中使用的类型。
生成错误消息的代码示例：
class A;
int main () {
A * a_ptr = 0;
delete[] a_ptr; // 警告：在 delete 中使用的类型 A 不完整
}
消息 ID：incompletew
不同类型变量的名称与包含外部链接的变量名称相同。
生成错误消息的代码示例：
extern int i; float i; // 错误
消息 ID：incomtype
（Kernigan 和 Ritchie）：不允许在 Kernigan 和 Ritchie 模式下重载函数。
生成错误消息的代码示例：
int foo (char); int foo (float); // 错误：不允许在 KnR 模式下重载
消息 ID：incomtypef
联合不能拥有需要初始化或析构的成员。
生成错误消息的代码示例：
class A {
public:
A();
};
union {
A a; // 错误：联合成员无法要求初始化或析构
} un;
消息 ID：initnotall
函数无法定义为内联，因为该函数已被调用，且其声明不包含内联关键字。
生成错误消息的代码示例：
class A {
public:
void foo ();
};
int main () {
A a;
a.foo();
}
inline
void A::foo () {}
消息 ID：xinlafteruse
对编译器而言，函数太大，无法生成内联。
消息 ID：inllargeuse
对编译器而言，函数太大，无法自动生成。但是，仍可以手动内联函数。
消息 ID：inllargeint
已使用标签，但未对其进行定义。
生成错误消息的代码示例：
int main()
{
//. . .
goto label1; // 错误：从未定义 "label1"
//. . .
return 0;
}
消息 ID：labelundef
不能在局部类中声明静态成员。
生成错误消息的代码示例：
void foo()
{
class A {
static int i;
};
}
消息 ID：lcstatic
必须定义局部类的虚拟成员函数主体。
生成错误消息的代码示例：
int main () {
class inner_class {
public:
virtual int foo (); // 错误
virtual int goo () {} // 正确
};
}
消息 ID：lcfnodef
存储类 auto 和 register 只能在函数参数的块中使用。
生成错误消息的代码示例：
register int a = 3; // 错误
auto float b = 3.14159; // 错误
void foo( auto int i, // 正确
register j ) // 正确
{
register int x = 3; // 正确
auto int y = 4; // 正确
}
消息 ID：locstorespec
尚未在文件级别使用链接说明。
生成错误消息的代码示例：
extern "C" int k; //正确
void foo() {
extern "C" int i; // 错误
extern "C" int j; // 错误
};
消息 ID：loclinkage
不允许在字符串和字符常量中使用行分隔符。
生成错误消息的代码示例：
char c = ' '; // 错误：包含行分隔符。
消息 ID：longstring
如果不介入 #undef，则无法将宏重新定义为不同的值。
生成错误消息的代码示例：
#define count 1 #define count 2 // 错误：尝试不使用 #undef 而重新定义计数。
消息 ID：macroredef
该宏的参数超过了该编译器所允许的最大数。
消息 ID：manymacroparms
具有相同名称的宏参数有两个或多个。参数名称必须唯一。
生成错误消息的代码示例：
#define foo( X, X )
消息 ID：dupmacroparms
调用的重载函数不明确。
生成错误消息的代码示例：
void foo (int i, int j);
void foo (int i = 3, int j = 7);// 正确：foo(int, int) 的重新声明
void foo (); // 正确：foo 的重载声明
int main()
{
foo (1, 2); // 正确：调用 f(int, int)
foo (); // 错误：调用 f(int,int) 还是 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) 还是 foo(b)？
}
int i = b; // 正确：与 B 到 int 的转换匹配
float f1 = b; // 错误：调用 int 还是 double 运算符？
float f2 = double(b); // 正确：指定了转换运算符。
消息 ID：manymatchover
类成员无法在该类之外声明。
生成错误消息的代码示例：
class A {
public:
void foo();
};
void A::foobar(); // 错误：在类之外声明成员是非法的
消息 ID：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; // 警告
};
消息 ID：mixedreturns
尝试计算与零相除的余数。
生成错误消息的代码示例：
int i = 1000000 % 0;
消息 ID：modovfl
尝试计算变量与零相除的余数。转交运行时处理该警告。
生成警告消息的代码示例：
void foo()
{
int i = 9;
i%0; // 警告：计算与零相除的余数
}
消息 ID：modovflnv
编译器确定浮点乘法表达式溢出。转交运行时处理该错误。
消息 ID：mulfovfl
编译器尝试在编译时计算乘法的结果之后，确定该结果溢出。低位 32 位结果将被保留，而编译器将执行此诊断。
生成该消息的代码示例：
int i = 1000000 * 1000000;
消息 ID：mulovfl
不允许有多个限定符。
消息 ID：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(); // 正确
pb->::foo(); // 错误：该基类的指针类型 B 无法
// 访问 A::foo()
return 0;
}
消息 ID：mustbebase
声明的运算符必须是成员函数。必须将下列运算符定义为成员："="、"->"、"{"、"()" 和类型转换。检查运算符定义中是否缺少作用域运算符。
生成错误消息的代码示例：
class B {
int i;
operator =(const B&);
};
B::operator =(const B &b){ return (this->i + b.i); }; // 正确，已定义为成员
// 下列情况将会产生错误：
B operator ->();
B operator {();
B operator ()();
B operator int();
消息 ID：mustbemem
函数无法返回函数的数组。
生成错误消息的代码示例：
void foo[3] (); // 错误
消息 ID：noarroffunc
不允许有引用数组。
触发错误消息的代码示例：
int main() {
int &j; // 正确
int &i[3]; // 错误
}
消息 ID：noarrofref
该类不是派生类，所以无法初始化基类。
生成错误消息的代码示例：
class A {
int i;
A(): (10) {};
};
消息 ID：nobaseclass
语句缺少 "="。
生成错误消息的代码示例：
void foo()
{
if ( const int i 2 ) // 错误：i 之后缺少 "="
;
}
消息 ID：nobecomeserr
获取位字段的地址是非法的。
生成错误消息的代码示例：
struct A {
int i:3;
int j:4;
int k:5;
int foo() { return &i; } // 错误：
};
消息 ID：nobitaddr
引用位字段是非法的。
生成错误消息的代码示例：
struct A {
int i:3;
int j:4;
int k:5;
int &foo() { int &ri = i; return ri;} // 错误
};
消息 ID：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; // 正确
a.foobar(); // 错误：foobar 不是 A 的成员
a.foo(); // 错误：foo 是友元，但不是 A 的成员
}
消息 ID：nofieldfnd
出现语法错误。
生成错误消息的代码示例：
void foo()
{
int i = 0;
switch (i) {
case 3:
case 4; // 错误：应该是 ":"，而不是 ";"
i++;
break;
};
};
消息 ID：nocolonerr
"?" 之后应该有 ":"。
生成错误消息的代码示例：
int main()
{
int i= -7;
i = ( i < 0 ) ?-i i; // 错误："?" 之后应该有 ":"
}
消息 ID：nocolonop
代码中出现语法错误。
可以生成错误消息的代码示例：
int foo( int i; int j) // 错误：";" 应该是 ","
{
return i*j;
}
struct A {
int k;
} a, aa:
// 错误：应该是 ","，其后跟声明；或者 ":" 应该是 ";"
消息 ID：nocommaerr
使用编译器参数 -noex 时忽略 throw。
消息 ID：noexthrow
使用编译器参数 -noex 时忽略 try 和 catch 异常结构。
消息 ID：noextry
标识符列表以 ")" 终止之前，该列表遇到行尾。应该在一行中定义宏。是否缺少 "\"？
生成错误消息的代码示例：
#define foo( A, // 缺少 "\" B )
消息 ID：noidentlist
应该初始化常量成员对象。
消息 ID：noconstinit
使用运算符 new[] 分配数组时，无法提供初始化程序。
生成错误消息的代码示例：
class A {
public:
A (int k=0) {}
};
int main () {
A * ptr = new A[2](3); // 错误：无需提供 \'3\' 作为初始化程序
}
消息 ID：noconstrparm
类定义必须以分号或后面跟分号的声明结尾。
生成错误消息的代码示例：
struct A {
int i;
} a, :
消息 ID：nodeclerr
该声明没有指定存储类或类型。
生成错误消息的代码示例：
class A {
i; // 错误：无存储类或类型
};
消息 ID：nodeclspec
不允许在重载运算符或函数指针中使用缺省参数值。
生成警告消息的代码示例：
class T {
int i;
public:
T(int j);
};
T operator+ (T t, T t2= T(0) ); // 错误：重载运算符中不能使用缺省参数值。
void (*fptr)(int k = 3); // 错误：函数指针中不能使用缺省参数值
消息 ID：nodefall
不能在运算符 new 中定义任何类型。
生成警告消息的代码示例：
int main () {
void * t = (void *) new (struct t {}); // 错误：遇到运算符 new 中
// 的结构声明。
}
消息 ID：nodefinnew
函数不能在函数的参数中定义类型。
生成错误消息的代码示例：
class A {
A();
friend void foo( class B{} b;);
};
消息 ID：nodefinproto
无法在返回类型说明中使用类型定义。
生成错误的代码示例：
struct t{} foo () { // 错误：不能在此处定义 'struct t'
}
消息 ID：nodefinret
无法在 "sizeof" 表达式中定义新类型。
生成错误消息的代码示例：
int foo () {
return sizeof (struct t {}); // 错误：在 sizeof 表达式中找到结构声明
}
消息 ID：nodefinsizeof
无法在 "typeid" 表达式中定义新类型。
生成错误消息的代码示例：
#include <typeinfo>
int main () {
typeid (struct t {}); // 错误：在 typeid 表达式中找到结构声明
}
消息 ID：nodefintypeid
在 "delete []" 运算符中使用计数是过时的。删除该计数。
生成警告消息的代码示例：
void foo()
{
int *i = new int[10];
delete [10] i; // 错误：在 "delete []" 中使用计数
}
消息 ID：nodelno
语法错误。该标记之前缺少直接声明符。
生成错误消息的代码示例：
int () {}; // 错误：缺少函数名称
struct A {
static int i;
static int j;
};
void foo()
{
A::i = 7; //正确
A:: ; // 错误：缺少变量
int []; // 错误 缺少数组名称
}
消息 ID：nodirdecl
RTTI 已遭禁用，所以 dynamic casting 会被 static casting 所取代。
消息 ID：nodyncast
关键字 enum 之后遇到语法错误。
生成错误消息的代码示例：
class A {
enum A = { x, y, z }
};
消息 ID：noenumerr
应为表达式，但是未找到。
生成错误消息的代码示例：
int j =;
int k = {};
int l[] = {};
if ( );
消息 ID：noexprerr
试图引用类、结构或联合的不存在成员。
生成错误消息的代码示例：
struct {
// 应该定义下列字段：
// int a;
} t;
int main () {
return t.a;
}
消息 ID：nofieldident
友元声明未指定类或函数。
生成错误消息的代码示例：
class A {
int i;
friend;
};
消息 ID：nofriendfield
计时错误。类友元需要显式“类”。
生成警告消息的代码示例：
class A {
int i;
friend B; // 警告：应该是 "friend class B"
};
class B {
int j;
};
消息 ID：nofriendw
不能在 Kernigan 和 Ritchie 兼容模式下将函数声明为结构成员。
生成错误消息的代码示例：
struct {
int foo () { return 0; } // 错误
} t;
int main () {
return t.foo();
}
消息 ID：nofunchere
模板和强制转换参数列表必须具有与 ">" 匹配的 "<"。
生成错误消息的代码示例：
class B { virtual void foo(); };
class A: public B {};
int main()
{
B * pb = new A;
A *pa1 = dynamic_cast<A*(pb); // "A*" 后面应该紧跟 ">"
}
消息 ID：nogtrerr
应该是标识符。
生成错误消息的代码示例：
void foo()
{
int float j; // 错误：int 之后应该是标识符
int; // 错误
goto; // 错误
}
消息 ID：noidenterr
（Kernigan 和 Ritchie，Ansi 模式）：应该是标识符。
生成错误消息的代码示例：
void foo()
{
int; // 错误
}
消息 ID：noidentwarn
不属于外部符号的常量值必须进行初始化。
生成错误消息的代码示例：
const int *pj = new int(0); //正确 int a = 10; const int i; // 错误 const int &j; // 错误 const int &k = a; // 正确 }
消息 ID：noiniterr
（Kernigan、Ritchie）：应该初始化不属于外部符号的常量值。
生成错误消息的代码示例：
int main () {
static const int a; // 警告：应该初始化 a
}
消息 ID：noinitwarn
必须使用初始值、构造函数或初始化程序对使用 new() 运算符创建的常量对象进行初始化。
生成错误消息的代码示例：
const int *ip = new const int; // 错误 const int *jp = new const int(0); // 正确
消息 ID：noinitanac
尚未定义内联函数的主体。
生成该消息的代码示例：
inline void foo(); // 错误：尚未定义函数主体以内联 foo()
int main()
{
foo();
return 0;
}
消息 ID：noinlbody
必须在使用引用成员之前对其进行初始化。
生成错误消息的代码示例：
class A {
public:
int &i;
};
void foo() {
A a;
a.i = 7; // 错误：尚未初始化 "a.i"。
int j;
a.i = j;
a.i = 7; // 正确
}
消息 ID：noirefmem
标签之后需要语句（即使为空）。
生成该消息的代码示例：
main() {
int i = 10;
switch (i) {
case 1:
default:
i++;
break;
case 2: // 错误：标签在 "case 2" 之后没有语句
}
}
消息 ID：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 }; // 正确
}
class A {
int i;
public:
A(): i(10); // 错误：应该定义构造函数
A(): i(10) {}; // 正确
};
消息 ID：nolcurlerr
不能在函数的作用域之外使用作为对局部变量或临时变量的引用返回的值。
生成错误消息的代码示例：
int &foo(int i)
{
return i; // 错误
}
int &foobar(int &i)
{
return i; // 正确
}
消息 ID：nolocalname
无法返回对位字段的引用。
生成错误消息的代码示例：
struct A {
int i:3;
int j:4;
int k:5;
int &foo() { return i; } // 错误：无法返回对位字段的引用
};
消息 ID：noretbitref
无法在局部作用域内定义名称空间。
生成错误消息的代码示例：
namespace names { //正确
int j;
int k;
};
void foo() {
namespace ns { // 错误：名称空间位于局部作用域内
int i;
};
ns n;
n::i++;
}
消息 ID：nolocalns
(ccfe)：-nocx 选项禁止同时使用 long long 和 long long 常量。
生成错误消息的代码示例：
long foo () { return 0ll; } // 错误 使用了 -nocx 选项
消息 ID：nollconst
(ccfe)：-nocx 选项禁止同时使用 long long 和 long long 常量。
生成错误消息的代码示例：
long long cll = 0; // 错误 使用了 -nocx 选项
消息 ID：nolonglong
不允许使用 long long 类型的位字段。
生成错误消息的代码示例：
class a {
long long a:7; // 错误：不允许使用 long long 位字段
int b:4;
};
消息 ID：nollbitfield
表达式中应该有 "("，但未找到。
生成错误消息的代码示例：
int i;
for i = 0; i < 7; ++i ) {} // 错误：应该是 "("，而不是 "i"
if i < 7); // 错误
消息 ID：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{};
消息 ID：nolsserr
基类没有匹配的构造函数，所以无法初始化该类。
生成错误消息的代码示例：
class B {
public:
int i;
//B();
B(int x) { i = x; }
};
class A: B {
A() { // 错误：找不到基类的缺省构造函数 B::B()
}
};
消息 ID：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);
}
};
消息 ID：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); // 错误：将三个参数传递给构造函数，无匹配项
}
消息 ID：nomatchover
每个左圆括号必须有一个匹配的右圆括号。
生成错误消息的代码示例：
int foo( // 错误：没有匹配的 ")"
{
int i = 3;
reutrn 0;
}
消息 ID：nomatchrpar
无法使用 new 运算符分配引用和函数类型。
生成错误消息的代码示例：
int main () {
new (int&); // 错误：尝试使用 new 分配引用
}
消息 ID：nonewtype
基类没有定义缺省构造函数。如果基类已定义构造函数，则编译器不会生成缺省构造函数。
struct A { A(int); };
struct C: A {};
C c; // 错误
C c1(); // 正确，缺省构造函数已由编译器生成
消息 ID：nonulconbase
结构类型的成员没有缺省构造函数，或缺省构造函数无法由编译器生成，因为包含的类型至少有一个指定的构造函数。
生成错误消息的代码示例：
struct B {
int i;
B(int x);
};
struct A {
B b_in_A; // A 没有缺省构造函数。
};
A a; // 在此处标记错误
消息 ID：nonulcon
尚未生成或定义缺省构造函数。无法初始化向量。
生成错误消息的代码示例：
class A {
public:
int i;
//A();
A(int);
};
A *a = new A[8]; // 错误
消息 ID：nonulvec
const 对象调用了尚未声明为 const 的成员函数。
生成错误消息的代码示例：
class A {
public:
A();
int foo(int i) {return i;}
};
void bar() {
const int i = 7;
A const a;
a.foo(i);
}
消息 ID：nonconmf
const 对象调用了尚未声明为 const 的成员函数。
消息 ID：nonconmfp
函数返回引用值，但返回的值不是左值。
生成错误消息的代码示例：
int &foo()
{
return 0;
}
消息 ID：nonvarref
无法将非左值强制转换为指定类型。
int main () {
const_cast<int&>(0); // 错误：无法将非左值强制转换为 int&
}
消息 ID：nonlvalcast
函数无法返回值，因为声明的函数返回说明是 void。
生成错误消息的代码示例：
void foo()
{
int i = 3;
return i; // 错误：函数的返回类型是 void，而不是 int
}
消息 ID：nonvoidret
声明为 volatile 的对象只能调用 volatile 函数。
生成错误消息的代码示例：
class A {
public:
void foo();
};
int main()
{
A volatile a;
a.foo(); // 错误：A::foo() 不是 volatile 函数
}
消息 ID：nonvolmf
成员函数必须声明为 volatile，以便由 volatile 指针调用。
生成错误消息的代码示例：
class B {
public:
void bar();
};
void (B::* b_ptr)();
int main()
{
B volatile *b;
(b->*b_ptr)(); // 错误：B::bar() 未声明为 volatile
}
消息 ID：nonvolmfp
类的实例应该使用 "." 或 "->" 调用成员函数。
生成错误消息的代码示例：
class A
{
public:
void foo(){ /* code */ }
};
int main()
{
A::foo();
}
消息 ID：noobjcall
应该是操作数，但是未找到。
生成错误消息的代码示例：
void foo()
{
int i = 2;
int j[5];
i = j[]; // 错误：缺少下标
i = [i]; // 错误：应该是 j[i]
double d = ()i; // 错误："()i" 应该是 "(double)i"
}
消息 ID：nooprnderr
无法从整数类型减去指针类型。
生成错误消息的代码示例：
void foo()
{
int i = 2;
int *j = &i;
i = i - j;
}
消息 ID：noptrsub
访问成员时，需要对象的指针类型。
生成错误消息的代码示例：
class A {
public:
int i;
};
void foo() {
A a;
a->i = 8; // 错误："a" 不是指针类型
};
void bar() {
int j;
j[0] = 7; // 错误："j" 不是指针类型
}
消息 ID：noptrvar
数组子脚本存在语法错误。
生成该消息的代码示例：
int i[7]; i[6} = 10; // 错误：应该是 "]"
消息 ID：norbrackerr
应该包含 "}"，但未遇到。
生成错误消息的代码示例：
int a [2] = { 1, 2 ; // 错误，初始化程序的列表应该以
// "}" 终止
消息 ID：norcurlerr
在找到匹配的 "}" 之前，遇到文件结束标记。
生成错误消息的代码示例：
void foo()
{
/* code */
<EOF> // 错误，应该是 "}"，但是遇到了 EOF
消息 ID：norcurleof
如果设置标记 -feature=no%rtti，将会禁用 Typeid 和动态强制转换。
消息 ID：nortti
引用或指向引用的指针是非法的。
生成错误消息的代码示例：
const int &const &i = 12345678; // 错误 int i; int &ri = i; int &(*pri) = &ri; // 错误
消息 ID：noptrtoref
存在指向 void 类型的引用声明。
生成错误消息的代码示例：
void &foo(); // 错误：将引用的返回值声明为 void 类型
消息 ID：noreftotype
声明对成员类型的引用是非法的，因为这样会使他人对专用或受保护的类成员数据进行访问。
消息 ID：noreftomem
寄存器没有地址。如果程序未作为 C++ 程序进行编译，且尝试获取寄存器的地址，将会触发该错误。
生成错误消息的代码示例：
register int i = 3; int *pi = & i;
消息 ID：noregaddr
存在语法错误。表达式中应该包含 ")" 标记。 可以
生成错误消息的代码示例：
void foo()
{
int i = 3;
switch (i // 错误：缺少 ")"
{
case 2:
i++;
break;
};
}
void foobar( int i; float j ) // 错误："int i" 后面应该跟 ","
{
if ( i = 9) // 错误："=" 应该是 "=="
i++;
消息 ID：norparerr
语句必须以 ";" 结尾。
生成该消息的代码示例：
int main()
{
int i;
int j = 1;
i = j + 3 // 错误
return 0;
}
消息 ID：nosemierr
声明必须以 ";" 结尾。
生成该消息的代码示例：
volatile int foo int goo ()
消息 ID：nosemiheaderr
此处需要语句（即使为空语句）。
生成错误消息的代码示例：
void foo( int i ) {
if ( i < 10 )
++i;
else
// 错误：缺少语句
}
消息 ID：nostaterr
静态位字段是非法的。
生成错误消息的代码示例：
class A {
static int i:4; // 错误
};
消息 ID：nostaticbf
变量不是结构的实例。
生成错误消息的代码示例：
int main ()
{
int j;
j.novar = 7;
return 0;
}
消息 ID：nostructsym
不能在非结构的类型中使用点运算符。
生成错误消息的代码示例：
int main () {
int().a; // 错误：int 不是结构类型
}
消息 ID：nostructype
已经使用该标记。
生成错误消息的代码示例：
typedef int A;
class A {};
消息 ID：nostructerr
静态成员由对象类型的所有实例共享。该成员不是静态的；因此，必须使用该对象的实例指定要使用的一个成员。
生成错误消息的代码示例：
struct A {
int i;
void foo() { A::i = 2; } //正确
};
A::i = 7; // 错误，i 不是静态的
void foo()
{
A aa;
aa.i = 7; // 正确
}
消息 ID：notastatmem
"using" 指令中应该包含基类名称。
生成错误消息的代码示例：
class t {
public:
int a;
};
class A {
using t::a; // 错误：t 不是 A 的基类，无法使用 t::a
};
消息 ID：notbase
语法错误：要求使用整型常量表达式。
生成错误消息的代码示例：
int a;
enum {
mem1 = a, // 错误：此处要求使用整型常量表达式
mem2,
mem3
} e;
消息 ID：notconst
条件标签需要整型常量表达式。
生成错误消息的代码示例：
int main()
{
int i = 0;
switch (i) {
case 4: // 正确
case 3.141592654: // 错误
i++;
break;
};
};
消息 ID：notconstcase
数组子脚本运算符只能使用整型常量。
生成错误消息的代码示例：
int e[7]; e[2.718281828] = 5; // 错误
消息 ID：notconstsub
位字段需要整型常量表达式。
生成错误消息的代码示例：
class A {
int a:2; // 正确
int b:6; // 正确
int d:3.141592654; // 错误
};
消息 ID：notconstbit
由于编译器遇到只允许在 C++ 中使用的代码，因此发出该警告。
消息 ID：notcpp
typedef 名无法用于枚举类型和类类型。
生成错误消息的代码示例：
typedef struct S T;
struct T *p; // 错误
enum x { a, b }
typedef enum x y;
y x; // 正确
enum y x; // 错误
消息 ID：notdclass
函数定义不能是 typedef 声明。
生成错误消息的代码示例：
typedef int(mft)(int i);
mft foo
{ // 错误
return i + 2;
}
消息 ID：notdfunc
应该包含类模板名，但未找到。
生成错误消息的代码示例：
int foo () { return 0; }
template<> int foo(); // 错误：foo 不是模板类名
消息 ID：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;
}
消息 ID：notempparm
获取几个参数时，已声明模板类，但在实例化过程中并未提供这些参数。
生成错误消息的代码示例：
template <class A>
class B {};
template class B<>; // 错误：必须提供模板参数
消息 ID：notemparg
无法调用对象。只能调用函数。
生成错误消息的代码示例：
void foo() {}
int main()
{
int i;
i(); // 错误：只能调用函数
foo(); // 正确
return 0;
}
消息 ID：notfunc
声明中必须包含标记或标识符。
生成错误消息的代码示例：
int; float; enum E;
消息 ID：nothingdecl
根据标准，运算符 new 应该具有异常规范。
生成警告消息的代码示例：
#include <new> // 正确的声明： // void* operator new(size_t) throw(std::bad_alloc); void * operator new (size_t); // 错误
消息 ID：nothrownew
该运算符先前有一个异常规范。调用该运算符时，将不会抛出异常。
生成警告消息的代码示例：
#include <stddef.h> void* operator new[] (size_t); // 警告：原始运算符 new 抛出 "std::bad_alloc"
消息 ID：nothrowneww
（兼容模式）过时的 new 运算符不使用异常规范。 生成错误消息的代码示例如下（仅限兼容模式）：
#include <new.h> void* operator new(size_t) throw(std::bad_alloc); // 错误：对运算符 new 而言， // 禁止在兼容模式下使用 // 异常规范
消息 ID：nothrowold
条件标签只能在 switch 语句中使用。
生成错误消息的代码示例：
int main()
{
int i = 7;
case 7: // 错误：case 语句不在 switch 语句中
i++;
break;
return 0;
}
消息 ID：notinsw
缺省标签只能在 switch 语句中使用。
生成错误消息的代码示例：
int main()
{
int i;
default:
i = 3;
return 0;
}
消息 ID：notinswdef
\".*\" 或 \"->*\" 右侧使用的指针不是成员指针。
struct S {
int i;
};
void foo()
{
int y;
S cs;
int S::* pm = &S::i; // pm 引用的是成员 S::i
cs.*pm = 88; // 确定
cs.*y = 88; // 错误：不是成员指针
// ".*" 或 "->*" 的右侧必须是成员指针
}
消息 ID：notmembptr
只能调用从 .* 或 -> 生成的函数，但无法获取其地址。
生成错误消息的代码示例：
class A {
public:
void foo () {}
};
void (A::* f_ptr) ();
int main () {
A a;
f_ptr = A::foo;
a.*f_ptr; // 错误：只能调用函数。有效代码是
// (a.*f_ptr)();
}
消息 ID：notmembcall
用户尝试为非名称空间创建名称空间别名时，通常会产生该错误。
生成错误消息的代码示例：
struct not_a_namespace {};
int main () {
namespace alias=not_a_namespace; // 错误：尝试为结构创建别名
}
消息 ID：notnamespace
标识符已被使用，所以无法重新定义为名称空间。
生成错误消息的代码示例：
int n;
namespace n { // 错误
int i;
};
消息 ID：notnsname
由于编译器找到代码中未使用的声明对象，因此发出该警告。
生成警告消息的代码示例：
void foo() {
int i; // 未使用 i
}
void foobar( int a, // 未使用 a
int b ) // 未使用 b
{}
消息 ID：notused
如果要执行该操作，则必须包含文件 typeinfo.h，以便使用 type_info 类。否则，如果希望未来的程序可以将 typeinfo 类用于 RTTI 支持，建议选择其他名称。
消息 ID：notypeinfoh
using 声明应该使用属于基类的类名。使用的名称已是名称空间。
生成错误消息的代码示例：
namespace NS {int j; }
//. . .
class A: NS {
using NS::j;
};
消息 ID：nsnotall
using 指令应该使用名称空间的名称。使用的名称已是类类型的名称。
struct A{int j;};
void foo()
{
using A::j; // 错误：名称空间应该位于 foo 中。
}
消息 ID：nsnotcl
由于编译器找到从未使用的标签，因此发出该警告。
生成警告消息的代码示例：
void foo() {
int i = 0;
goto b:
a:
--i;
b:
++i;
};
消息 ID：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; // 错误：逗号后面缺少类型名称
消息 ID：notypenameerr
预定义的宏由编译器使用，所以不能被定义或取消定义。
消息 ID：noundef
联合不能有基本类型。
生成错误消息的代码示例：
class C {
int i;
};
union B: C { // 错误
int j;
};
消息 ID：nounionbase
联合不能有基本类型。
生成错误消息的代码示例：
union C {
int i;
};
union B: C { // 错误
int j;
};
消息 ID：nounionasbase
联合不能有虚拟函数。
生成错误消息的代码示例：
union A {
int i;
void foo() {}; //正确
virtual void foobar() {}; // 错误
};
消息 ID：nounionvirt
类型数据 void 不是值。
生成错误消息的代码示例：
foo()
{
int i = (void)1;
}
消息 ID：novoidval
不能解除对 void 指针的引用。void 没有值。
生成该消息的代码示例：
void *i; int j = *i; // 错误：不能解除对 void* 的引用
消息 ID：novoidderef
在 do-while 循环中，do 块必须以 while 语句结尾。
生成错误消息的代码示例：
void foo()
{
int i = 0;
int j = 7;
do {
i++;
} // 错误：应该是 "while"，而不是 "}"
i = 0;
do {
i++;
} while ( i < j); // 正确
}
消息 ID：nowhileerr
不能在类中使用 using 指令。
生成错误消息的代码示例：
namespace NS { int j; };
class A {
using namespace NS;
};
消息 ID：nsdirinclass
引用初始化表达式的值为零。
生成错误消息的代码示例：
static int zero; int& c = *(int*)0; // 警告：引用被初始化为零
消息 ID：nullref
不使用类名或成员名称的基类初始化当前已经过时。
生成错误消息的代码示例：
struct A {
int i;
A(int);
};
struct B: A {
int j;
B() : (3) { // 错误
j = 7;
};
};
消息 ID：obsinit
函数定义不能声明其他对象。只有类定义才能声明其他对象。同时声明函数和对象时，将不会触发该错误，除非该函数以其他对象的声明结尾。
生成错误消息的代码示例：
int i,
foo() { // 错误：此处无法声明函数。
return 0;
} int j;
消息 ID：onlyonefunc
表达式已经溢出 int 的大小，或数字已被零除。
消息 ID：overflow
该编译器内存不足。释放一些资源，然后重试。
消息 ID：outofmem
使用 "+w2" 标记进行编译时，如果初始化结构成员时不带括号，将会生成警告。
生成错误消息的代码示例：
struct B {
int i;
int j;
} X[] = { 1, 2, 3, 4 };
消息 ID：partinit
#else 指令之前必须有一个与之对应的 #if 指令。
生成错误消息的代码示例：
//#if true #define num 1 #else num 0 // . . .
消息 ID：ppbadelse
预处理程序指令 #endif 必须有一个与之对应的 #if。
消息 ID：ppbadendif
预处理程序命令之后的文本多余。
生成错误消息的代码示例：
#include <file.h>; // 错误：删除多余的 ";"
消息 ID：ppextra
该行中的多余文本已在 ANSI C 忽略。
消息 ID：ppextraw
仅声明了前缀增减运算符。在使用后缀运算符之前，还必须对其进行声明。
生成错误消息的代码示例：
class A {
public:
int i;
A operator ++(); // 声明前缀运算符 ++
};
int main()
{
A a;
a++; // 错误：重载后缀运算符 ++ 以进行更正
}
消息 ID：postincdec
在函数原型中使用结构和枚举类型之前，应该对其进行声明。如果对编译器进行设置，使其在 C 模式下编译，将会显示该消息。
消息 ID：protodec
一个或多个纯虚拟函数的抽象类只能用作基类。无法直接创建抽象类的实例。必须创建派生类的对象。
生成错误消息的代码示例：
class A {
virtual void foo() = 0;
virtual int bar() = 0;
};
A a; // 错误
消息 ID：purealloc
抽象类型不能用作成员。如果该成员是派生类，确保该类已经在基类中定义所有的纯虚拟函数。
生成错误消息的代码示例：
class B {
virtual void foo() = 0;
};
class X { B b; }; // 错误：B 是抽象类型
template <class T>
class Y {};
Y<B> y; // 错误
消息 ID：puremem
参数不能是抽象类型。
消息 ID：pureparm
返回类型说明不能是抽象类。抽象类尚未实现，所以无法使用。如果返回说明是派生类，确保该类已经在基类中定义所有的纯虚拟函数。
生成错误消息的代码示例：
class B {
virtual B foo(B) = 0; // 错误：foo(B) 返回抽象类型
};
class A: B {};
A bar() { // 错误
A *a;
return *a;
}
消息 ID：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 是抽象类
}
消息 ID：pureval
在覆盖基类的纯虚拟函数之前，已经实例化抽象类的派生类变量。
生成错误消息的代码示例：
class B {
virtual void foo() = 0;
};
class A: B {};
A a; // 错误
消息 ID：puref
要指定不同的作用域，就不能使用类型限定符声明成员函数。
class A {
};
class B {
void A::foo(); // 错误：不能使用类型限定符
void B::goo(); // 正确。在类 B 中声明 goo()
};
消息 ID：qualnotok
参数列表中只允许有存储类 register。不允许有 static、extern 和 mutable。
生成错误消息的代码示例：
class A {
void foo( register int a,// 正确
mutable int b, // 错误
extern c, // 错误
static int d, // 错误
auto int e ) // 正确
{}
};
消息 ID：registeronly
匿名联合成员与其包含类的名称不能相同。
生成错误消息的代码示例：
class A {
union {
int i;
long j;
int A; // 错误
};
};
消息 ID：sameanon
枚举器与其包含类的名称不能相同。
生成错误消息的代码示例：
class A {
enum e { A, B, C }; // 错误
};
消息 ID：sameenum
静态成员与其包含类的名称不能相同
生成错误消息的代码示例：
class A {
static int A;
};
消息 ID：samestatic
不能在与类型同名的类中定义该类型。
生成错误消息的代码示例：
class A {
typedef struct { int a; } A; // 错误：类 A 和 typedef A 同名
};
消息 ID：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++) {}
}
消息 ID：scalarexpected
sizeof 不能应用于位字段。
生成错误消息的代码示例：
class A {
public:
A() { size = sizeof(i); }
int i:3;
int size;
};
消息 ID：sizeofbf
sizeof 不能应用于函数。它只能应用于主类型、类对象和表达式。
生成错误消息的代码示例：
int i; int j; int foo(int k); int goo(); k = sizeof (i*j*foo(10)); //正确 k = sizeof (unsigned int); //正确 k = sizeof(foo); // 错误 k = sizeof(goo); // 错误
消息 ID：sizeoffunc
重载函数不能同时具有静态和非静态两种版本。
生成错误消息的代码示例：
class A {
static void foo();
void foo(); // 错误
};
消息 ID：statnonconf
语法错误。此处不允许使用说明符。
生成错误消息的代码示例：
inline class A{}; // 错误
virtual void foo(); // 错误
void foo() {
virtual void f1(); // 错误
friend void f2(); // 错误
explicit void f3(); // 错误
};
void foo() {}
消息 ID：storenotok
说明符不允许在此处使用，所以被编译器忽略。如果尝试对模板执行 typedef 操作，也会发出该消息。
生成警告消息的代码示例：
template <class T> static class A; // 警告：不允许使用 "static"，因而将其忽略
消息 ID：storenotokw
编译器确定浮点数字减法运算溢出，交由运行时处理。
消息 ID：subfovfl
局部变量被忽视，所以无法进行初始化。
生成错误消息的代码示例：
void foo()
{
int i=7;
switch(i) {
case 7:
break;
int j = 2;
default: // 该条件忽视局部变量 j 的初始化
i = 8;
}
}
消息 ID：swuninit
为该模板参数提供的类型无效，或未提供参数。
生成错误消息的代码示例：
template <class T, class K>
class B {
public:
T t;
K k;
};
B<int> b1; // 错误：B<T,K> 需要其他模板参数
B<int, 12345> b2; // 错误：12345 无效
消息 ID：temargnotype
表达式与模板参数的类型不匹配。更多//没有对对象类型引用的非类型模板参数应用转换。
生成错误消息的代码示例：
template <int i> class A {int i;};
;
A<3.141593> a1; // 错误：参数不是 int
A<3> a2; // 正确
template<class T, char* p> class D {
D();
D(const char* q);
};
D<int,"penny"> x1; // 错误：将字符串型作为模板参数
char p[] = "dime";
D<int,p> x2; // 正确
消息 ID：temargnoval
已经将错误类型的实际参数作为模板参数进行传递。通常，这意味着，NULL 指针已经作为指针类型的模板参数加以传递，进而会产生错误，因为不能对模板参数应用 NULL 指针转换。
生成错误消息的代码示例：
template <char * i> class A {};
int main () {
A<0> a;
}
消息 ID：tempargnullptr
只有类模板和类成员函数才能使用缺省模板参数。
生成错误消息的代码示例：
template <class T=int> T foo();
消息 ID：temdefparms
非类型模板参数不允许用于非成员函数。
生成错误消息的代码示例：
template <int x> int foo();
消息 ID：temfuncnontype
模板的参数太多。
消息 ID：temmanyargs
只能将模板用于类和函数。
生成错误消息的代码示例：
template <class T> int i;
消息 ID：tempnotfunc
模板只能在全局级别声明。
生成错误消息的代码示例：
void foo() {
int i;
template <class T> class B { int j; }; // 错误
};
消息 ID：temnotglob
模板的嵌套深度只能有 20 个层级。
消息 ID：temtoodeep
无法限定成员。
消息 ID：tdefqual
异常规范包含两个相同的对象类型。
生成警告消息的代码示例：
void foo() throw(float i, float j);
消息 ID：tltwice
异常规范已经通过声明发生更改。异常规范必须匹配。
生成错误消息的代码示例：
void foo() throw(int i);
// . . .
void foo() throw(float i ) {} // 错误
消息 ID：tnotinnew
以前的异常规范不包含当前参数类型。异常规范必须匹配。
生成错误消息的代码示例：
void foo() throw();
// . . .
void foo() throw(float i ) {} // 错误
消息 ID：tnotinold
调用函数时使用的参数比声明函数时使用的参数少。
生成错误消息的代码示例：
void foo( int i, int j ) {}
int main()
{
foo(1); // 错误：调用 foo() 时所用的参数不足
return 0;
}
消息 ID：toofewargs
调用宏时使用的参数比定义宏时使用的参数少。
生成警告消息的代码示例：
#define mask 0xffff00 #define getField(data, mask) data & mask // 定义宏时使用 2 个参数 int field = getField( 1 ); // 错误：调用宏时使用 1 个参数
消息 ID：toofewmargs
模板使用的参数比提供的参数多。
生成错误消息的代码示例：
template <class A1, class A2> class B {};
int main () {
B<int> b;
}
消息 ID：toofewtargs
调用函数时使用的参数比声明函数时使用的参数多。
生成警告消息的代码示例：
void foo( int i, int j ) {}
int main()
{
foo( 1, 2, 3 )
return 0;
}
消息 ID：toomanyargs
遇到语法错误，传递给强制转换表达式的参数太多。
生成错误消息的代码示例：
class A {
public:
operator long ();
};
int main () {
long t = long(A(), 0); // 错误：强制转换为 long 时使用的参数太多
// 应该是：
// long t = long(A());
}
消息 ID：toomanycargs
调用宏时使用的参数比该宏定义的参数多。
生成错误消息的代码示例：
#define mask 0xff0000 #define getField(data,mask) data & mask // 宏是使用 2 个参数定义的 int field = getField( 1, 2, mask ); // 调用宏时使用 3 个参数
消息 ID：toomanymargs
构造函数的初始化程序只能有一个参数。
生成错误消息的代码示例：
class A {
int i;
A(): i(1,2) {}
};
消息 ID：toomanynargs
模板的参数太多。
生成错误消息的代码示例：
template< class T, class K > // 2 个模板参数
class A {
T t;
K k;
};
A<int, float, long> a; // 错误：3 个模板参数
消息 ID：toomanytargs
无法将类成员的访问级别更改为专用 (private)。只能将访问更改为公共的 (public) 或受保护的 (protected)。
生成错误的代码示例：
class A {
public: int i;
};
class B: A {
private: A::i;
};
消息 ID：topubliconly
值被初始化两次。
生成错误消息的代码示例：
class A {
public:
static const int j = 9;
A() {}
};
const int A::j = 9; // A::j 被初始化两次
消息 ID：twoinits
表达式太复杂。
生成错误消息的代码示例：
void foo(){
int **************************i;
**************************i = 9; // 错误：太复杂，26 个 "*"
}
消息 ID：twtoocomp
使用函数或类之前，尚未定义类型名称。
生成错误消息的代码示例：
template<class T>
class A {
T t;
};
class B{
int i;
};
int main() {
A<float> a; // 正确
B<int> b; // 错误：未定义类型 B 的模板
}
消息 ID：typenotall
使用了尚未赋值的变量。
生成警告消息的代码示例：
void foo()
{
int i;
i++;
}
消息 ID：unassigned
使用了尚未定义的标识符。
生成错误消息的代码示例：
void foo()
{
int i;
j++; // 错误：未定义 j
}
消息 ID：undefidenterr
在将模板用作模板类型参数之前，必须定义该模板。
生成错误消息的代码示例：
template <t_arg<int> > struct tmp {}; // 错误：未定义 t_arg
消息 ID：undeftemperr
未使用比较结果。
生成警告消息的代码示例：
void foo()
{
int i = 9;
i == 9; // 警告：未使用结果
i++;
}
消息 ID：unusedcomp
不允许使用虚拟的构造函数。
生成错误消息的代码示例：
class A {
int a;
virtual A(); // 错误
};
消息 ID：virtconstr
虚拟友元函数需要限定类名。
生成错误消息的代码示例：
void foo() { return; }
void goo() { return; }
class A {
virtual friend void foo(); // 错误
virtual friend void A::goo(); // 正确
};
消息 ID：virtfriend
函数应该返回一个值，但返回的是 void。
生成错误消息的代码示例：
int foo()
{
return; // 错误：应该返回类型 int
}
消息 ID：voidret
只能对变量或左值应用运算符的地址。要获取的地址必须是存在的。
生成错误消息的代码示例：
int *i = &3; // 错误："3" 不是左值。
消息 ID：wantvarname
ANSI C 只支持有符号或无符号的 int 位字段。
消息 ID：wbadbftype
运算符 new 或 delete 应该具有不同的链接。
生成警告消息的代码示例：
#include <new> // 警告：new 不应该是静态的（它已声明为 extern）。 static void* operator new(size_t) throw(std::bad_alloc);
消息 ID：wbadlinkage
声明为空。最有可能的原因是有多余的分号。
生成错误消息的代码示例：
; // 警告：无声明
namespace NS{}; // 警告：名称空间 NS 在结尾处包含多余的分号
}; // 错误：右括号不匹配
消息 ID：wemptydecl
（Kernigan 和 Ritchie）：声明中必须包含标记或标识符。
生成错误消息的代码示例：
struct {}; // 错误
消息 ID：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; // 正确，pa* 强制转换为指向基类的指针
}
消息 ID：wbadasg
字符串型在赋值时转换为 char*。
生成警告消息的代码示例：
void foo () {
char *s;
s = "abcd"; // 警告
}
消息 ID：wbadasgl
使用不同类型初始化类型时会发出警告。
消息 ID：wbadinit
使用了字符串型来初始化不同的兼容类型。
void foo()
{
char * s = "f"; // 警告：使用常量 char* 初始化 E
}
消息 ID：wbadinitl
（Kernigan 和 Ritchie）：将函数声明为返回一个值，但没有返回。
生成错误消息的代码示例：
int foo()
{
return; // 错误：foo() 应该返回一个值
}
消息 ID：wvoidret
函数中的变量会隐藏类成员名称。
生成警告消息的代码示例：
class A {
int i;
void foo() {
int i; // 警告：i 隐藏 A::i
}
};
消息 ID：wvarhidemem
变量会在外部作用域隐藏变量名称。
生成警告消息的代码示例：
void foo() {
int i;
for ( int i = 0; // 警告：i 在外部作用域隐藏变量。
i < 10;
++i ){};
}
消息 ID：wvarhidenmem
只能将没有参数的空函数作为参数传递给 init 或 fini pragma。
生成错误消息的代码示例：
void my_fini (int a) { }
#pragma fini(my_fini)
消息 ID：prbadfunc
一些 pragma 要求至少传递一个参数。
生成错误消息的代码示例：
#pragma fini ()
消息 ID：premptylist
对齐值必须是 2 的非负整数幂，但其最大值必须为 128。
生成错误消息的代码示例：
#pragma align 256 ( an_int, a_ptr, a_struct, a_class )
消息 ID：prbadalign
一些 pragma 要求其参数为函数。
生成错误消息的代码示例：
int my_fini; #pragma fini(my_fini) // 错误：my_fini 不是函数
消息 ID：prnotfunc
如果任何 pragma 参数列表中会显示某个函数，则应该首先声明该函数。
生成错误消息的代码示例：
#pragma fini(my_fini) // 错误：应该首先声明 my_fini
void my_fini (int a) { }
消息 ID：prnotdecl
Pragma 语句不正确。最有可能的是，忽视了必需的 pragma 参数。
生成错误消息的代码示例：
int a, b, c; #pragma align (a, b, c)
消息 ID：prsyntax
#pragma ident 之后缺少字符串型。
消息 ID：prnostr
用作 pragma 参数分隔符的符号错误。
生成错误消息的代码示例：
void my_init1 () { }
void my_init2 () { }
void my_init3 () { }
#pragma init(my_init1,my_init2.my_init3)
消息 ID：prnocomma
Pragma 参数列表应该以 '(' 开头。
生成错误消息的代码示例：
void my_init1 () { }
#pragma init my_init1)
消息 ID：prnolp
参数列表中缺少 ')' 或符号错误。
生成错误消息的代码示例：
void my_init1 () { }
void my_init2 () { }
void my_init3 () { }
#pragma init(my_init1,my_init2.my_init3)
消息 ID：prnorp
编译器使用该消息显示包含错误消息的行号。
消息 ID：linetheword
asm 语句中必须包含字符串型。
生成错误消息的代码示例：
void foo()
{
asm( nop ); // 错误
}
消息 ID：noasmstring
asm 语句不允许在函数之外使用。
生成错误消息的代码示例：
asm(" nop "); // 错误
void foo()
{
asm(" nop "); // 正确
}
消息 ID：asmnotinfunc
指定的标记需要值。
消息 ID：cmd_needvalue
不能同时指定某些 CC 标记（例如，+e0 和 -compat=5）。
消息 ID：cmd_badflag
未传递输入文件时，ccfe 会发出该错误。
消息 ID：noinpfile
缺少或无法访问传递到编译器的文件，所以无法将其打开。
消息 ID：openinpfile
预处理程序无法打开输出文件。请检查文件权限和/或可用磁盘空间。
消息 ID：openoutfile
该警告指示文件没有以新行字符结尾。
消息 ID：nonewline
不能在类之外使用关键字 mutable。mutable 用于对声明为常量的类对象中的字段进行修改。
生成错误消息的代码示例：
void foo()
{
mutable int i = 0; // 错误
}
class A {
mutable int i; // 正确
};
消息 ID：mutclassonly
mutable 只能用于成员数据。
生成错误消息的代码示例：
class A {
public:
mutable int i; //正确
mutable void foo() {} // 错误
A() {}
};
消息 ID：mutnofunc
常量名称也不能声明为 mutable。
生成错误消息的代码示例：
class A {
public:
A(int j) { i = j; };
mutable const int i; // 错误
};
消息 ID：mutnoconst
静态数据成员不能是 mutable。
生成错误消息的代码示例：
class A {
public:
mutable static int i;
};
消息 ID：mutdatamems
必须使用 C++ 语言声明重载运算符。
class A {};
extern "C" A& operator *(A&, A&);
消息 ID：mustbecpp
不能在友元声明中指定类定义。
生成错误消息的代码示例：
class A {
friend class B {}; // 错误：友元声明中包含类定义
};
消息 ID：nofrienddef
类成员访问级别的说明后面没有冒号。Private、protected 和 public 后面必须跟冒号。
生成错误消息的代码示例：
class A {
public // 错误：public 之后没有 ":"
int i;
};
消息 ID：nocolaftacc
在宏参数的结尾处发现文件结束标记。
#define foo( A, B, C ) foo(1, 2, // 错误：缺少参数。 <EOF>
消息 ID：eofinmargs
C++ 不支持使用隐式 int 声明的变量。应该指定该类型。
生成警告消息的代码示例：
i[] = {1, 2, 3};
消息 ID：noimplint
模板声明中应该包含类关键字。如果函数模板声明不正确，似乎是类模板声明，也会产生该错误。
生成错误消息的代码示例：
template <class T> A // 错误：缺少类关键字
{
int i;
int j;
};
template <class T> foo : /* .. . */ ; // 错误
消息 ID：noclasskey
局部定义的类型无法用作模板参数。
生成错误消息的代码示例：
template <class T>
class A{};
void foo()
{
class B {};
enum E {one, two, three};
A<B> a1; // 错误
A<E> a2; // 错误
}
消息 ID：nolocaltarg
模板参数不能是未命名的类型。与此同时，也不能在模板参数中定义类型。
生成错误消息的代码示例：
template <class T>
class A {
T t;
};
A<class{}> a; // 错误：结构没有类型名称。
// 要使用用户定义的类型，请在使用前先定义该类型。
消息 ID：nounnamedtarg
分析构造函数初始化程序列表时，检测到语法错误。
生成错误消息的代码示例：
class A {
int a;
long b;
int c[2];
A() : a(0) : b(0) {} // 错误：初始化程序列表中意外包含 ':'
};
消息 ID：unexpinitl
这是 Java 本地编译器使用的内部消息。
消息 ID：jdeadcode
这是 Java 本地编译器使用的内部消息。
消息 ID：jnoclass
这是 Java 本地编译器使用的内部消息。
消息 ID：jnomember
这是 Java 本地编译器使用的内部消息。
消息 ID：jbadcpool
这是 Java 本地编译器使用的内部消息。
消息 ID：jbadtcode
这是 Java 本地编译器使用的内部消息。
消息 ID：jbadbcode
导出被忽略。尚未执行该导出。
消息 ID：exportnotimpl
在模板声明中，"<" 之前找不到关键字 template。
生成错误消息的代码示例：
export <class T> // 错误
class A{};
消息 ID：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
消息 ID：oldexpspecial
尚未在该编译器中执行显式非类、非函数实例化/特化。
消息 ID：noexpimpl
类重载 "->" 运算符。该运算符返回一个类类型值。
生成错误消息的代码示例：
class A {
public:
int j;
A operator->(); // 返回 A
};
void foo() {
A a;
a->j = 9; // 错误
};
消息 ID：recurarrow
重载运算符 -> 应该返回指向类类型对象的指针。
生成错误消息的代码示例：
class B {
public:
int j;
B operator->(); // 返回 B
B& operator->();
};
void foo() {
B b;
b->j = 7; // 错误：不明确，operator->() 返回 B
};
消息 ID：recurarrow2
重载 "->" 运算符应该返回指向类类型对象的指针。
生成警告消息的代码示例：
class A {
public:
int* operator->(); // 警告 A::operator->() 返回 int*
int k;
};
消息 ID：arrowrtn
尚未定义函数指针和对象指针之间的强制转换结果，但是，如果使用 Solaris，将不会丢失信息。
消息 ID：badcastw
类中的匿名联合不能包含某些说明符，如 extern、static 和 the like。
生成错误消息的代码示例：
class A {
static union { // 错误：匿名联合不能是静态的
int a;
long b;
};
};
消息 ID：badclanon
不允许在类中声明名称空间。
生成错误消息的代码示例：
class A {
namespace ns {} // 错误：在类作用域中声明名称空间
};
消息 ID：noclassns
不能在该作用域内重新声明模板参数。最有可能的是，已经在模板作用域的声明中使用模板参数的名称。
生成错误消息的代码示例：
template <class t_arg> class A {
int t_arg; // 错误：重新声明了模板参数 t_arg
};
int main () {
A<int> a;
}
消息 ID：templparamdecl
禁止在创建的类型说明符中使用模板参数。
生成错误消息的代码示例：
template <class t_arg> class A {
class t_arg {}; // 错误：在创建的类型说明符中使用了模板参数 t_arg
};
int main () {
A<int> a;
}
消息 ID：templtypedecl
遇到语法错误。
生成错误消息的代码示例：
template <class t_arg> class A {};
typedef class A<int> my_type; // 错误：非法语法...
消息 ID：badelabtype
pragma 包的有效值必须为二的幂。
生成错误消息的代码示例：
#pragma pack (3)
消息 ID：prbadpack
无法使用外部 C 链接声明模板。
生成错误消息的代码示例：
extern "C"
template <class t_arg> class A {}; // 错误：模板声明不能包含该链接
消息 ID：temnotexternc
由模板参数限定类型名称时，需要 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;
}
消息 ID：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 实例
}
消息 ID：ambigcast
如果没有特化，则无法将模板声明为友元。
生成错误消息的代码示例：
template <class t_arg> class A {};
class B {
friend class A; // 错误：友元模板声明。应该是：
// friend class A<int>;
};
消息 ID：nofriendtmpl
不能将模板函数声明为友元。
生成错误消息的代码示例：
template<class t_arg> int foo () { return t_arg; }
class A {
friend int foo<int>(); // 错误：模板函数不能是友元
};
消息 ID：nofunctmpl
在全局作用域中未找到声明为友元的函数。
生成错误消息的代码示例：
class A {
friend int ::foo (); // 错误：在全局作用域中未声明 foo
};
消息 ID：noglobaldecl
不能同时指定某些 CC 标记（例如，+e0 和 -compat=5）。
消息 ID：cmd_badflag_wrn
不能同时指定某些 CC 标记（例如，-memtmpl 和 -compat=5）。
消息 ID：cmd_badflag_err
对位字段的引用不是常量。
生成错误消息的代码示例：
struct C {
int x : 2 ;
};
C oc;
int & xref = oc.x; // 错误：xref 是非常量引用
消息 ID：varbitref
无法打开选项 -preinstlib=<file-name> 指定的文件。
消息 ID：openinstlib
无法读取选项 -preinstlib=<file-name> 指定的文件中的符号。
消息 ID：readinstlib
尝试使用函数类型模板参数声明成员函数。
生成错误消息的代码示例：
template <class T> struct X { T t; };
typedef int F();
X < F > m1; // 错误：无法将 't' 声明为 int t()。
消息 ID：badtmplfunctyp
非类型的模板参数和非模板的模板参数不能具有指定的类型。有关详细信息，请参见 ISO C++ Standard 14.3.2。
生成错误消息的代码示例：
template<class T, int I> class X { };
X<int, 2.7> x;
消息 ID：badtmplexparg
由于字符串型 (lex.string) 是包含内部链接的对象，因此它不是可接受的模板参数。有关详细信息，请参见 ISO C++ Standard 14.3.2。
生成错误消息的代码示例：
template<class T, char* p> class X { };
X<int,"String"> x;
消息 ID：tmplexpstrlit
数组元素和名称的地址或非静态类成员的地址不是可接受的模板参数。有关详细信息，请参见 ISO C++ Standard 14.3.2。
生成错误消息的代码示例：
template<int* p> class X { };
int a[10];
X<&a[2]> x;
消息 ID：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
消息 ID：ambigpartial
部分特化之前没有主特化。用户应该始终提供主特化，以便声明或定义部分特化。
生成错误消息的代码示例：
template<class T> class A<T, T*> { };
template<class T1, class T2> class A { };
消息 ID：psnoprimary
特化的模板参数列表不能包含缺省模板参数值。原因是无法使用这些值。
生成错误消息的代码示例：
template<class T1, class T2> class A { };
template<class T = int> class A<T, T*> { };
消息 ID：psdefaults
非类型参数不能用作表达式的一部分。
生成错误消息的代码示例：
template<class T, int p, int c> class X { };
template<class T, int p > class X<T, p, p + 5> { };
消息 ID：psntinexpr
部分特化不应该包含与主特化相同的参数，因为无法使用这种构造。
生成错误消息的代码示例：
template<class T1, class T2> class A { };
template<class T1, class T2 > class A<T1, T2> { };
消息 ID：pssameargs
与专用非类型参数对应的模板参数类型应与特化参数无关。
生成错误消息的代码示例：
template< int X, int (*array_ptr)[X] > class A {};
int array[5];
template< int X > class A<X,&array> {};
消息 ID：psargdeptype
用户提供一个或多个部分特化参数，但在特化本身中不使用这些参数。
生成错误消息的代码示例：
template<class T1, class T2> class A { };
template<class T, class T2> class A<T, T*> { };
消息 ID：psargnotused
用户显式关闭部分特化处理时，将会发出该消息。 生成错误消息的代码示例如下（仅限兼容模式）：
template<class T1, class T2> class A { };
template<class T> class A<T, T*> { };
消息 ID：psnotimp
生成错误消息的代码示例：
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;
}
消息 ID：usingdestr
编译器遇到与其不兼容的 SunWS_cache 目录。早期的编译器遇到较新的编译器生成的模板数据库时，将会产生该错误。
请使用较新的编译器编译源，或者使用 CCadmin -d
消息 ID：tdb_version
在命令行找到多个 -I- 选项。
消息 ID：duplicate_i
生成错误消息的代码示例如下：
template < class T > void copy ( T to ) { }
template int copy ( long ) ; // 错误！
消息 ID：badexplctinst
生成错误消息的代码示例如下：
struct x {
x();
int x;
};
消息 ID：samemem
在声明所有 sizeof 运算符的枚举器之前，不能对枚举类型应用该运算符。
生成错误消息的代码示例如下：
int mymain()
{
enum E { A, B = sizeof A }; // 错误 - 目前无法应用 sizeof A
return 0;
}
消息 ID：badenumsize
在 C++ 中，将指针赋值给完整或不完整的数组类型是错误的，反之亦然。
生成错误消息的代码示例如下：
extern int a_39W73zz[2]; // 大小已知 int (*p2)[] = &a_39W73zz; // 错误 - 类型不匹配，对于 'p2'，大小未知。
消息 ID：badarrptr
如果虚拟函数的返回类型是不包含定义的结构类型，且拒绝代码，则编译器无法处理这种情况。
生成错误消息的代码示例如下：
struct Fum; // 类型不完整
struct B {
Fum virtual f();
};
struct D : virtual B {
D();
};
D::D() { }
消息 ID：incompletert
无法通过这种方法更改对成员的访问。这在兼容模式下是警告消息，而在标准模式下是错误消息。
生成错误消息的代码示例：
class C {
private:
class inner;
public:
class inner { }; // 使用其他访问重新声明
};
消息 ID：badaccadjw
调用的重载函数不明确。
生成错误消息的代码示例：
void foo (int i, int j);
void foo (int i = 3, int j = 7);// 正确：foo(int, int) 的重新声明
void foo (); // 正确：foo 的重载声明
int main()
{
foo (1, 2); // 正确：调用 f(int, int)
foo (); // 错误：调用 f(int,int) 还是 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) 还是 foo(b)？
}
int i = b; // 正确：与 B 到 int 的转换匹配
float f1 = b; // 错误：调用 int 还是 double 运算符？
float f2 = double(b); // 正确：指定了转换运算符。
消息 ID：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
消息 ID：inaccessible_w
在字段声明的结尾处检测到多余的分号。
生成警告消息的代码示例：
struct S {
int ii;;
void f();;
};
消息 ID：fieldsemicolonw
无法获取编译器生成的临时函数的地址。
生成警告消息的代码示例：
struct C { C(int); };
void add( C *c );
void foo() { add( &C(6) ); }
消息 ID：addressoftemp
生成警告消息的代码示例：
struct A {
friend static void foo(A arg);
};
消息 ID：storeclassfriend
生成警告消息的代码示例：
class C {
C::C();
enum E { a, b } e;
};
C::C() {
switch(e) {
case E::a: // <-- 此处出错
break;
}
}
消息 ID：enumasscope
无法执行语句。
生成错误消息的代码示例：
int foo(int x) {
if ( x > 0 )
return 1;
else
return 2;
return 3; // 警告：无法执行语句
}
消息 ID：wunreachable
非空函数的最后一条语句应该返回一个值。
生成错误消息的代码示例：
int foo(int x) {
if ( x > 0 )
bar(); // 警告：最后一条语句应该返回一个值
else
return 2;
}
消息 ID：wnoretvalue
if 语句的 else 分支语句应该返回一个值。
生成错误消息的代码示例：
int foo(int x) {
if ( x > 0 ) // 警告：else 分支语句应该返回一个值
return 2;
}
消息 ID：wnoelseretvalue
类中的匿名结构不能包含某些说明符，如 extern、static 和 the like。
生成错误消息的代码示例：
class A {
static struct { // 错误：匿名结构不能是静态的
int a;
long b;
};
};
消息 ID：badclanonstruct
匿名结构成员与其包含类的名称不能相同。
生成错误消息的代码示例：
class A {
struct {
int i;
long j;
int A; // 错误
};
};
消息 ID：sameanonstruct
匿名结构无法具有专用的或受保护的成员。
生成错误消息的代码示例：
static struct {
long j;
private:
int i; // 错误
};
消息 ID：anonstructnoprivate
匿名结构不能包含函数成员。
生成错误消息的代码示例：
static struct {
void foo(){} // 错误
};
消息 ID：anonstructnofunc
生成警告消息的代码示例：
union U {
struct {
int a;
long b;
};
};
消息 ID：anonstruct
生成警告消息的代码示例：
enum A;
消息 ID：forwardenum
如果名称空间作用域或块作用域内的函数声明与 using 指令引入的函数具有相同的名称和参数类型，则表明程序的格式不正确。
生成错误消息的代码示例：
namespace B {
void f(int);
}
namespace N {
using B::f; // 将 B::f(int) 引入 N
void f(int); // 错误：N::f(int) 与 B::f(int) 冲突
}
消息 ID：ambigdecl
如果联合包含引用类型的成员，则表明程序的格式不正确。
生成错误消息的代码示例：
union x {
int &i;
};
消息 ID：nounionref
生成警告消息的代码示例：
unsigned long l;
void foo()
{
l >> 32; // 应该收到一条警告消息
}
消息 ID：largeshift
无法获取编译器生成的临时函数的地址。
消息 ID：compataddressoftemp
生成警告消息的代码示例：
enum E { e1 = 5 };
struct S { E e; } s = { 5 }; // 警告
消息 ID：wintenuminit
函数只能抛出它所覆盖的函数允许的异常。
生成错误消息的代码示例：
struct A
{
virtual void foo() throw(A);
};
struct B : A
{
virtual void foo();
};
消息 ID：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>;
}
消息 ID：whideferr
生成错误消息的代码示例：
class A {
public:
int a;
void foo () const { a++; }
}
消息 ID：constaccess
最有可能的是，显式实例化声明中缺少关键字 'class'。
生成错误消息的代码示例：
templateclass X { }; template X ; // 应该是：template class X ;
消息 ID：explclassinst
不应使用临时函数来初始化非常量引用。
生成警告消息的代码示例：
struct C { C(int); };
void add( C& c );
void foo() { add( C(6) ); }
消息 ID：reftotemp
模板表达式不能是非常量值。
生成错误消息的代码示例：
templatevoid f(); int main() { const int& ri = 12; f (); // 错误 }
消息 ID：tmplexpnotconst
函数只能抛出它覆盖的函数允许的异常。生成警告的代码示例：
struct A
{
virtual void foo() throw(A);
};
struct B : A
{
virtual void foo();
};
消息 ID：wlessrestrictedthrow
返回指向局部自动变量的指针。
生成该警告消息的代码示例：
int* f() {
int k=5;
return &k;
}
消息 ID：autoaddrreturn
指针指向未知大小参数的数组。
生成错误消息的代码示例：
typedef int UNKA[]; void f(UNKA *p);
消息 ID：ptrarray0
引用未知大小参数的数组。
生成错误消息的代码示例：
typedef int UNKA[]; void f(UNKA &p);
消息 ID：refarray0
实际参数由模板参数决定。
生成错误消息的代码示例：
void foo(...); templateT count(T t); void bar() { foo(count); }
消息 ID：dummyactualarg
应该是标识符。如果构造出错，则会出现该错误，但编译器可以有效地予以恢复。
生成错误消息的代码示例：
enum A {a, };
消息 ID：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 的外部名称相同
消息 ID：sameextname
在兼容模式下对整个程序优化（-xcrossfile 或 -xipo）进行编译时，不允许在内部作用域内使用嵌套的静态变量。
示例如下：
int f(int i)
{
if (i != 0) {
static int sv = 2;
return sv + i;
}
return 0;
}
sv 将会触发该错误。
消息 ID：nocrossstatic
静态数据成员定义使用派生类。
生成警告的代码示例：
struct BASE { static int static_data; };
struct DERIVED : public BASE { };
int DERIVED::static_data;
消息 ID：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 作为类型进行查找。
消息 ID：skipfield
typedef 声明中不允许包含异常规范。
例如：
typedef void (*pf) () throw();
消息 ID：badexceptionspec
函数指针只能抛出其赋值函数指针所抛出的异常。生成警告的代码示例：
void (*pf1)();
void (*pf2)() throw(int);
void f() {
pf2 = pf1;
}
消息 ID：fptrthrow
生成该消息的代码示例：
int NE_C2_3()
{
int a = 1;
#pragma omp parallel if ( a > 1 ) if ( a < 5 )
{
}
return 0;
}
消息 ID：omp_extraclause
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;
}
消息 ID：omp_structblkviolation
OpenMP for 的索引变量必须包含带符号的整数类型。
生成该消息的代码示例：
int NE_C2_4_1_3()
{
unsigned int i;
#pragma omp for
for (i = 0 ; i < 10 ; i++ )
{
}
return 0;
}
消息 ID：omp_forbadindxtype
"section" OpenMP pragma 必须直接显示在 "sections" 块中。
生成该消息的代码示例：
int NE_C2_4_2_1()
{
#pragma omp sections
{
;
}
#pragma omp section
{
}
return 0;
}
消息 ID：omp_sectionoutsidesections
生成该消息的代码示例：
int NE_C2_6_5_1()
{
int i = 5;
int & n = i;
#pragma omp parallel
{
#pragma omp flush (n)
}
return 0;
}
消息 ID：omp_varhasreftype
OpenMP 指令 ordered 不能位于未指定 ordered 子句的 for 指令的动态范围内。
生成该消息的代码示例：
int NE_C2_6_6_1()
{
int i;
#pragma omp for
for (i=0; i<10 ; i++)
{
#pragma omp ordered
{
}
}
return 0;
}
消息 ID：omp_nonorderedfor
threadprivate 指令必须显示在文件作用域或名称空间作用域之内，并且还必须位于任何定义或声明之外。
生成该消息的代码示例：
int a=0;
class A
{
#pragma omp threadprivate ( a )
};
int NE_C2_7_1_1b()
{
return a;
}
消息 ID：omp_nonfilethreadprivate
Threadprivate 指令必须按照词法位于其列表中所有变量引用之前。
生成该消息的代码示例：
int a = 1;
void foo()
{
a--;
}
#pragma omp threadprivate ( a )
int NE_C2_7_1_1c()
{
return a;
}
消息 ID：omp_threadprivateprecederef
threadprivate 变量不能具有引用类型。
生成该消息的代码示例：
int a;
int & b = a;
#pragma omp threadprivate (b)
int NE_C2_7_1_6a()
{
return 0;
}
消息 ID：omp_varinprivateref
生成该消息的代码示例：
class A;
int foo(A & a)
{
#pragma omp parallel private (a)
{
}
return 0;
}
int NE_C2_7_2_1_3()
{
return 0;
}
消息 ID：omp_varinprivateincomplete
除 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;
}
消息 ID：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;
}
消息 ID：omp_varmustnotbeconstqual
生成该消息的代码示例：
int NE_C2_7_2_5_2()
{
int a;
#pragma omp parallel default (none)
{
a=1;
}
return 0;
}
消息 ID：omp_defaultviolated
对于 reduction 运算符，在 reduction 子句中指定的变量类型必须是有效的，除非从不允许使用指针类型。
生成该消息的代码示例：
class A
{
};
int NE_C2_7_2_6_1a()
{
A a;
#pragma omp parallel reduction(+:a)
{
}
return 0;
}
消息 ID：omp_reductionbadtype
在 reduction 子句中指定的变量不能具有常量限定类型。
生成该消息的代码示例：
int NE_C2_7_2_6_2()
{
const int a = 0;
#pragma omp parallel reduction (+: a)
{
}
return 0;
}
消息 ID：omp_constreduction
不能在多个子句中指定变量，除非该变量可以同时在 firstprivate 和 lastprivate 子句中指定。
生成该消息的代码示例：
int NE_C2_7_2_6_4()
{
int a = 0;
#pragma omp parallel shared (a) reduction (+: a)
{
}
return 0;
}
消息 ID：omp_dupclause
在 copyin 子句中指定的变量必须是 threadprivate 变量。
生成该消息的代码示例：
int x;
int NE_C2_7_2_7_2()
{
#pragma omp parallel copyin (x)
{
}
return 0;
}
消息 ID：omp_copyinnotthreadprivate
不允许具有相同名称的 critical 指令相互嵌套。
生成该消息的代码示例：
int NE_C2_9_3_1()
{
#pragma omp critical
{
#pragma omp critical
{
}
}
return 0;
}
消息 ID：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;
}
消息 ID：omp_badnestingregion
绑定到相同 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;
}
消息 ID：omp_badnestingparallel
包含 flush 指令的最小语句必须是块（或复合语句）。
生成该消息的代码示例：
int NE_C2_6_5_2()
{
int i = 5;
#pragma omp parallel
{
if ( i > 0 )
#pragma omp barrier
}
return 0;
}
消息 ID：xomp_mustbeblock
在指定 schedule(runtime) 时，不能指定 chunk_size。
生成该消息的代码示例：
int NE_C2_4_1_9()
{
int i;
#pragma omp for schedule(runtime, 2)
for (i=1;i<10;i++)
{
}
return 0;
}
消息 ID：omp_chunksizemustnotbespecified
生成该消息的代码示例：
int main(void)
{
#pragma omp for default(none)
for (int i = 0 ; i < 10 ; i++ )
{
}
return 0;
}
消息 ID：omp_badclause
跳过当前 pragma 的其余部分，转到新行上。这样做可以将与 OpenMP 有关的错误恢复和特定于 C++ 的错误恢复分开。
生成该消息的代码示例：
int main(void)
{
#pragma omp for default(none)
for (int i = 0 ; i < 10 ; i++ )
{
}
return 0;
}
消息 ID：omp_skip
Line 指令必须指定正整数。
生成错误消息的代码示例：
#line 0 "file.cc"
消息 ID：poslinenum
在封装共享作业或并行指令的 private (firstprivate/lastprivate) 子句中，不能指定在并行区域内为 private (firstprivate/lastprivate) 的变量。因此，在共享作业或并行指令中指定为 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;
}
消息 ID：omp_varalreadyprivate
生成该消息的代码示例：
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;
}
消息 ID：omp_badnesting
在 reduction 子句中指定的变量必须在封装上下文中进行共享。
生成该消息的代码示例：
int main()
{
int i;
#pragma omp parallel private(i)
#pragma omp sections reduction(+:i)
{
i++;
}
return 0;
}
消息 ID：omp_reductionnotshared
在 OpenMP pragma 中发现通用语法错误时，将会显示该消息。
生成该消息的代码示例：
int main()
{
#pragma omp parallel private
{
}
return 0;
}
消息 ID：omp_badlyformedomppragma
OpenMP for 的控制表达式必须采用规范的形式，如下所示：<index> <logical-op> <integer_expr>
生成该消息的代码示例：
int main()
{
int i,j=0;
#pragma omp parallel for
for (i=0; j<10; i++) {
}
return 0;
}
消息 ID：omp_forbadcontrol
对于 default 子句，只有 none 或 shared 才是有效值。
生成该消息的代码示例：
int main()
{
int i;
#pragma omp parallel default(private)
{
i++;
}
return 0;
}
消息 ID：omp_baddefault
schedule 子句的种类必须属于 static、dynamic、guided 或 runtime 之一。
生成该消息的代码示例：
int main()
{
int i;
#pragma omp parallel for schedule(normal,1)
for (i=0;i<10;i++) {
}
return 0;
}
消息 ID：omp_badschedulekind
生成该消息的代码示例：
int main()
{
#pragma omp unknown
return 0;
}
消息 ID：omp_badomppragma
OpenMP 并行和共享作业构造之后必须跟结构化块。结构化块是包含一个 entry 和一个 exit 的语句。不允许使用导致跳转到块或跳转出块的语句。结构化块不能包含用于控制从块流出的 return、goto、break 或 continue 语句。
生成该消息的代码示例：
int foo() {
#pragma omp parallel
{
return 1;
}
}
消息 ID：omp_strblkviolation
OpenMP for 的迭代表达式必须具有规范的形式。
生成该消息的代码示例：
int main() {
int i;
#pragma omp parallel for
for (i=0; i<10; foo(&i)) {
}
return 0;
}
消息 ID：omp_forbaditer
OpenMP for 的初始化表达式必须采用规范的形式，如下所示： 生成该消息的代码示例：
消息 ID：omp_forbadinit
int main() {
int i=0;
#pragma omp parallel for
for (; i<10; i++) {
}
return 0;
}
OpenMP for pragma 后面必须跟 for 语句。
生成该消息的代码示例：
int main() {
int i=0;
#pragma omp parallel for
{
while( 0 ){
i++;
}
return 0;
}
消息 ID：omp_forbadfollow
\"%1\" 的声明在语法上不明确，但是标准将其解释为函数声明。无论如何，程序员一般都会声明对象。为了避免混淆，请使用语法上明确的方式重新编写声明。
生成警告消息的代码示例：
struct T { };
T t( T() ); // t 一个是函数
建议采用语法上明确的解决方法：
T t( (T()) ); // t 是一个对象（类型不能有多余的 parens） T t = T(); // t 是一个对象（赋值样式的初始化） T t( T(*)() ); // t 是一个函数（显式函数指针）
消息 ID：ambigfuncdecl
chunksize 必须是整型循环固定非零正值。
生成错误消息的代码示例：
#pragma omp for schedule (static, 0)
消息 ID：badchunksize
并行区域内的循环索引必须是该区域的专用变量。
生成该消息的代码示例：
int main() {
int i=0;
#pragma omp parallel for shared(i)
for(i=0; i<4; i++){
}
return 0;
}
消息 ID：omp_sharedforindex
该文件中使用的类包含没有非静态数据成员的虚拟基类。在某些情况下，这会导致虚拟函数调用错误的函数。
消息 ID：warn_empty_virt_base
引用返回值应该是左值。标准允许函数返回一个对要编写的左值的引用。但是，如果实际使用该值，则结果是不可预测的。
消息 ID：nonvarrefww
如果尝试从尚未覆盖纯虚拟函数的对象中调用该函数，将总是失败。基类的纯虚拟函数将不会通过虚拟调用机制进行调用。您必须显式限定该调用，并且还必须在单独的函数定义中提供该函数的主体。示例：
struct T {
virtual int f() = 0;
T() { f(); } // 警告，调用纯虚拟函数
~T() { T::f(); } // 正确，跳过虚拟调用机制
void g() { f(); } // 正确 如果从纯虚拟函数的派生类
};
int T::f() { return 0; } // 对象定义进行调用
消息 ID：pure_virtual_w
不允许具有相同名称的 critical 指令相互嵌套。生成消息的代码示例：
void main(void) {
#pragma omp critical(foo)
#pragma omp critical(foo)
;
}
消息 ID：omp_badcriticalnesting
必须使用 C++ 函数执行声明为本地方法的 Java 方法。如果之前未将方法声明为 .class 文件中的本地方法，则提供该方法的 C++ 版本会产生错误。
消息 ID：notjavanative
未定义将非 POD 对象作为变量参数传递的结果。
POD（Plain Old Data，平面旧数据）对象是一个不包含下列内容的对象：用户声明的构造函数、用户定义的析构函数、用户定义的复制赋值运算符、基类、虚拟函数、专用或受保护的非静态数据成员以及指针到成员类型的非静态数据成员、非 POD 结构、非 POD 联合或引用。
void foo(int, ...);
struct T {
T();
~T();
};
extern T t;
int main()
{
foo(1, t); // 警告
}
消息 ID：nonpodvarargw
友元声明未指定类或函数。
生成错误消息的代码示例：
namespace N {
template struct B { };
}
struct A {
friend struct N::B; //此处出错，B 是模板，而不是结构
};
消息 ID：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);
}
消息 ID：nontmplfriend
调用 #pragma dumpmacros 时使用的有效参数如下：defs、undefs、loc、conds、sys
生成错误消息的代码示例：
#pragma dumpmacros(definitions)
消息 ID：prbadarg
模板嵌套深度引用了函数模板的特化，只有非模板函数才可用。
生成错误消息的代码示例：
templatestruct A { void f(int); }; template<> template<> void A ::f(int) {} // spec 多余
消息 ID：mismatchtmpdepth
移植为 64 位时，赋值、初始化或强制转换可能会截断数据。
生成错误消息的代码示例：
long l; (int)l;
消息 ID：truncwarn1
如果移植为 64 位，则在赋值为无符号的 long 之前，可以扩展数据的符号。
生成错误消息的代码示例：
int i; unsigned long ul = i;
消息 ID：signextwarn
移植为 64 位时，long 或无符号 long 位字段声明可能会更改位字段包装。
生成错误消息的代码示例：
struct S {
unsigned long b1:20;
long b2:20;
};
消息 ID：bitfield64
正在定义关键字。 生成警告的代码示例：
#define bool unsigned int
消息 ID：nokeyworddefine
第二个操作数和第三个操作数可以相互转换。
struct S {
S (int);
operator int () const;
};
int main (int i)
{
S s0(0);
i ? s0 : 1; // 类型转换不明确
}
消息 ID：questambigerr
在 threadprivate 指令中指定的块作用域变量必须是静态的。
生成该消息的代码示例：
int main() {
#pragma omp parallel
{
int i;
#pragma omp threadprivate(i)
i = 50;
}
}
消息 ID：omp_threadprivatenotstatic
静态块作用域变量的 threadprivate 指令必须出现在变量的作用域内，而不能出现在嵌套的作用域内。
生成该消息的代码示例：
int main() {
static int i;
#pragma omp parallel
{
#pragma omp threadprivate(i)
i = 50;
}
}
消息 ID：omp_threadprivateinnested
在 OpenMP 并行区域的 if 子句中指定的表达式必须具有标量类型。
生成该消息的代码示例：
int main() {
struct { float val; } good = {3.62};
#pragma omp parallel if(good)
good.val = 4.12;
}
消息 ID：omp_badiftype
在 OpenMP 并行区域的 num_threads 子句中指定的表达式必须具有整数类型。
生成该消息的代码示例：
int main() {
int i = 0;
#pragma omp parallel num_threads(3.62)
i++;
}
消息 ID：omp_badnumthreadstype
在模板参数声明中不能指定类定义。
生成错误消息的代码示例：
templateclass S{};
消息 ID：noclassdef
copyprivate 子句不能与 nowait 子句一起使用。
生成该消息的代码示例：
int main() {
int i = 42;
#pragma omp single nowait copyprivate(i)
{
i++;
}
}
消息 ID：omp_badusecopyprivate
如果在并行区域的动态范围内遇到使用 copyprivate 子句的单个指令，则在 copyprivate 子句中指定的所有变量必须是封装上下文中的专用变量。
生成该消息的代码示例：
int main() {
int i = 1;
#pragma omp parallel
{
i = 42;
#pragma omp single copyprivate(i)
{
i++;
}
}
}
消息 ID：omp_notprivateincontext
必须使用声明符和初始化程序声明常量变量。
生成该消息的代码示例：
const enum E1 {a, b}; // 错误
const enum E2 {c, d} x = c; // 正确
消息 ID：badconstdecl
volatile 变量必须使用声明符进行声明。
生成该消息的代码示例：
volatile enum E1 {a, b}; // 错误
volatile enum E2 {c, d} x; // 正确
消息 ID：badvoldecl
存储类说明符必须具有 init 声明符列表。
生成该消息的代码示例：
register enum E4 { a4, b4 }; // 错误
register enum E5 { a5, b5 } e; // 正确
消息 ID：badstgdecl
这种类型的声明中需要 init 声明符列表。
生成该消息的代码示例：
typedef struct T { int i; };
typedef enum F { f1, f2 };
消息 ID：declreq
生成错误消息的代码示例：
struct A {
friend static void foo(A arg);
};
消息 ID：storefrienderr
生成警告消息的代码示例：
#includeint main() { enum Shape { shape1=2, shape2}; enum Point { point1=4, point2}; Shape cylinder = shape1; Point uper = point2; if ( cylinder == uper ) // 警告 cout << "Comparing different enum types" << endl; }
消息 ID：diffenumtype
消息 ID：demxarchv8plus
生成该消息的代码示例：struct S { int f1(int = f2()); int f2(int = f1()); };
消息 ID：recurseindefault
不能将虚拟函数声明为友元函数。
生成错误消息的代码示例：
void foo() { return; }
void goo() { return; }
class A {
virtual friend void foo(); // 错误
virtual friend void A::goo(); // 错误
};
消息 ID：virtfriendfunction
仅使用函数名称声明了友元函数。
生成错误消息的代码示例：
namespace N {
void foo(char);
void foo();
};
class A {
friend N::foo;
};
消息 ID：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 行：警告
}
消息 ID：negbitfield
生成警告消息的代码示例：
namespace N {
template struct ap {
ap(X* p = 0);
};
};
using namespace N;
class A { };
A* a;
ap ap(a) ;
消息 ID：baddeclare
生成警告消息的代码示例：
class A {
};
main()
{
A a(10);
#pragma omp parallel private(a)
{
;
}
}
消息 ID：nodefctor
生成警告的代码示例：
templateclass A { ... }; class A ; // 警告：已忽略 template<> class A ; // 声明显式特化 template class A ; // 显式实例化指令
消息 ID：oldspecialdecl
生成警告的代码示例：
__thread void func();
struct type {
__thread void func();
};
消息 ID：nothreadfuncs
生成警告的代码示例：
int changed; __thread int changed;
消息 ID：threaddeclfirst
__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();
消息 ID：threaddyninit
生成警告的代码示例：
void func() {
__thread int a;
}
消息 ID：noautothread
生成警告的代码示例：
templatestruct traits { typedef T ty; }; template struct tn { typedef typename traits ::ty tn_ty; }; template <> struct tn { typedef typename traits ::ty tn_ty; };
消息 ID：explctspectypename
生成警告的代码示例：
class A {
private:
int a;
} ;
struct B: A {
private:
A::a; // 标准模式警告
} ;
消息 ID：inaccessible_anach
不能在绑定到并行构造的共享作业指令的 reduction 子句中指定并行区域中的专用变量。
生成该消息的代码示例：
int main() {
int i;
#pragma omp parallel private(i)
#pragma omp sections reduction(+:i)
{
i++;
}
}
消息 ID：omp_cant_be_in_private
不能在绑定到并行构造的共享作业指令的 reduction 子句中指定并行指令 reduction 子句中出现的变量。
生成该消息的代码示例：
int main() {
int i;
#pragma omp parallel reduction(+:i)
#pragma omp sections reduction(+:i)
{
i++;
}
}
消息 ID：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;
}
消息 ID：omp_varmustnotbeconst_qual
如果段包含多个语句，则这些语句必须位于 {} 中。
生成该消息的代码示例：
#pragma omp sections
{
// 可选 #pragma omp section
x = 5;
y = 10;
}
消息 ID：omp_badsectionstructure
友元函数名称尚未在最近的名称空间中声明模板，或者在当前类中包含该模板。
生成错误消息的代码示例：
#includenamespace 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<> 在名称空间 M 中未声明 } ; };
消息 ID：wnotempdecl
内联函数没有外部链接。
生成该消息的代码示例：
int f();
inline int f() { return 0; }
消息 ID：wbadlinkage_w
生成警告的代码示例：
static __symbolic int variable;
static __hidden int function() {
__global int stackvar;
}
消息 ID：ldscopeonlyextern
链接器作用域对后续声明的限制性更大。链接器作用域 __hidden 比 __symbolic 限制性大，__symbolic 比 __global 限制性大，__global 比未指定的链接器作用域限制性大。生成警告的代码示例：
__hidden int function(); __symbolic int function();
消息 ID：ldscoperestrict
生成警告的代码示例：
__symbolic int function() { }
__hidden int function();
消息 ID：ldscopechanged
生成警告的代码示例：
char c[100000]; short i = sizeof(c);
消息 ID：truncwarn2
具有引用成员的类必须具有用户定义的构造函数。
生成错误消息的代码示例：
struct S {
int x&;
};
消息 ID：refmemnoconstr
正在使用的 pch 文件没有正确的魔数。
消息 ID：pchbadmagicnumber
正在使用的 pch 文件在前页中的格式字符串不正确。
消息 ID：pchbadformatstr
pch collect 和 use 模式编译器版本字符串不兼容。
消息 ID：pchbadreleasestr
pch 文件应该包含 defines。
消息 ID：pchexpdefines
pch 文件应该包含 undefs。
消息 ID：pchexpundefs
pch collect 和 use 模式中的 defines 列表不同。
消息 ID：pchbaddefines
pch collect 和 use 模式中的 undefs 列表不同。
消息 ID：pchbadundefs
pch collect 和 use 模式中的可用前缀不是相同的 PRE>。
消息 ID：pchbadviableprefix
模板嵌套深度无效。
生成错误消息的代码示例：
template <class X> template <class Y>
void foo(); // 错误：模板嵌套深度无效
struct S {
template <class X> template <class Y>
void foo(); // 错误：模板嵌套深度无效
}
消息 ID：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;
}
消息 ID：omp_shared_control_var
并行区域中不允许有静态非 POD 声明。
生成错误消息的代码示例：
class A {public: int i; A(){i = 10;};};
#pragma omp parallel
{
static A a;
;
}
消息 ID：omp_staticclassdecl
生成警告的代码示例：
unsigned short bar[] = U"é";
消息 ID：ustronlyascii
生成警告的代码示例：
unsigned short bar[] = U"\351";
消息 ID：ustrnoescape
可能缺少 #pragma hdrstop 或 -xpchstop point，或者其位置错误。
消息 ID：pchbadstoppoint
可用前缀中只能使用注释和某些预处理程序指令。
消息 ID：pchbadviablepref
打开的文件太多，可能是一个包含自身的文件。
消息 ID：toomanyopenfiles
尝试强制转换为 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); // 错误
消息 ID：castawayconst
threadprivate 指令必须显示在定义或声明之外。
生成该消息的代码示例：
class A
{
int a;
#pragma omp threadprivate ( a )
};
消息 ID：omp_badthreadprivate
主模板声明中不允许使用显式模板参数列表。
生成该消息的代码示例：
templatevoid bar (); template void bar ();
消息 ID：wexpltemplid
原子 pragma 后面必须跟一个表达式语句。
生成该消息的代码示例：
#pragma omp atomic
{ // 不允许有 '{'
i++;
}
消息 ID：omp_badatomicfollow
函数在其声明为内联之前已经使用。这意味着， 所有的预先调用将会作为 extern 进行处理。后续调用 将被内联。
生成错误消息的代码示例：
class A {
public:
void foo ();
};
int main () {
A a;
a.foo();
}
inline
void A::foo () {}
消息 ID：inlafteruse
有符号类型和无符号类型之间的比较。
生成该消息的代码示例：
int foo(unsigned ui, int i) {
if ( ui < i )
return 0;
else
return 1;
}
消息 ID：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;
}
}
}
消息 ID：omp_badordered
在最深层的封装非类作用域中找不到声明为局部类友元的函数或类。 生成警告的代码示例：
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(); // 正确
friend class A; // 警告
friend class B; // 正确
};
}
消息 ID：badlocalfrienddecl
某些 OpenMP 指令的显示位置受到限制。
生成该消息的代码示例：
void foo() {
int i = 0;
label:
#pragma omp barrier
i++;
goto label;
}
消息 ID：omp_mustbeblock
不能对 barrier 和 flush standalone 指令进行标记。
生成该消息的代码示例：
main() {
int i = 0;
#pragma omp parallel
{
label:
#pragma omp flush
i++;
goto label;
}
}
消息 ID：omp_no_label
pch 文件应该包含 srcdir。
消息 ID：pchexpsrcdir
pch collect 和 use 模式中的源目录不同。
消息 ID：pchbadsrcdir
pch 文件应该包含 cwd。
消息 ID：pchexpcwd
pch collect 和 use 模式中的当前目录不同。
消息 ID：pchbadcwd
pch 文件应该包含选项。
消息 ID：pchexpoptions
pch collect 和 use 模式中的选项不同。
消息 ID：pchbadoptions
由于抛出异常的线程必须捕获 try， 因此不允许在 try 块中使用 OpenMP 构造。
生成该消息的代码示例：
try {
#pragma omp parallel
{
throw a();
}
}
catch(...) {
printf("in catcher\n");
} }
消息 ID：omp_in_guarded
标准要求 omp 段构造之后必须跟 { section-sequence }。
生成该消息的代码示例：
#pragma omp parallel sections i = i + 5;
消息 ID：omp_nosectionscope
有关合法原子表达式的规则，请参见 OpenMP API。
生成该消息的代码示例：
#pragma omp atomic i = i + 5;
消息 ID：omp_badatomicexpr
标准禁止修改循环中 OpenMP for 索引 变量的值。
生成该消息的代码示例：
#pragma omp parallel for
for (i = 0; i < 10; i++) {
i = i + 5;
}
消息 ID：omp_forindexmod
模板的友元声明必须具有相同的参数数目。
生成错误消息的代码示例：