************************************* 错误和警告消息文件 ************************************* 该文件包含 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
调用函数时使用的形式参数类型与该函数的参数不匹配。 生成警告消息的代码示例:
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
调用函数时使用的形式参数类型与该函数的参数不匹配。
消息标识: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
应该提供显式赋值运算符。 生成错误消息的代码示例:
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 转换是非法的。类型不兼容。 生成错误消息的代码示例:
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 的转换是非法的。 生成警告消息的代码示例:
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 语句。 生成错误消息的代码示例:
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
使用 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
成员不允许使用存储类。 生成错误消息的代码示例:
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 跳过的块中声明。 生成警告消息的代码示例:
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 指令要求使用无符号的十进制整数。 生成错误消息的代码示例:
#0x12 // 错误 #line 0xff "file.cc" // 错误 #line 12345 "file.cc" // ok
消息标识:badlinedir
line 指令只能指定 1 到 32767 之间的整数。 生成错误消息的代码示例:
#line 1234567 "file.cc"
消息标识:badlinenum
以前已经使用不同的链接声明标识符,所以不能对其进行更改。 生成错误消息的代码示例:
extern char * static_and_extern(); static char * static_and_extern(); // 错误:已将其声明为外部而非静态的标识符
消息标识:badlinkage
根据相关的标准,main() 必须有一个 int 返回类型。 生成错误消息的代码示例:
void main() {}
消息标识:badmain
根据相关的标准,获取 main() 函数的地址是非法的。 生成错误消息的代码示例:
int main() { int *a = main; return 0; }
消息标识:badmainaddr
不允许递归调用 main。 生成错误消息的代码示例:
int main() { main(); return 0; }
消息标识:badmaincall
无法重载 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” 生成错误消息的代码示例:
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 参数。 生成错误消息的代码示例:
class B { B operator++(); // 前缀 ++b B operator++(float); // 后缀 b++, // 错误:应该是 B 运算符 ++ (int) };
消息标识:badpostfix1
后缀运算符的第二个参数必须使用 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。 生成错误消息的代码示例:
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 才是合法的。 生成错误消息的代码示例:
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。 生成错误消息的代码示例:
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 必须至少有一个异常处理程序。 生成错误消息的代码示例:
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 语句。 生成消息的代码示例:
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 语句。 生成错误消息的代码示例:
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 的结果必须是指针或引用类型。 生成错误消息的代码示例:
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 操作数必须使用指向多态类型的指针或引用。类型必须至少有一个虚拟函数。 生成错误消息的代码示例:
class B {}; class D:public B {}; B *pb = new D; D *pd = dynamic_cast<D*>(pb); // 错误:类 B 没有虚拟函数
消息标识:dynnotpolym
预期的结果是引用,而操作数不是引用、指针或结构类型。 生成错误消息的代码示例:
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 的操作数应该是指针类型。 生成错误消息的代码示例:
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 的目标结果不是指向类的指针或引用。 生成错误消息的代码示例:
class B { virtual void foo(); }; class D:public B { }; B *pb = new D; D *pd1 = dynamic_cast<int*>(pb); // 错误:dynamic_cast 应该指定类型“D*”
消息标识:dynnotclass
操作数未指向类类型。 生成错误消息的代码示例:
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(...)”必须是异常处理程序块的最后一个处理程序。 生成错误消息的代码示例:
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 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
在转换表达式中定义类型是非法的。 生成错误消息的代码示例:
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 中的类型。 生成错误消息的代码示例:
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,则无法将宏重新定义为不同的值。 生成错误消息的代码示例:
#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。
消息标识:noexthrow
已经使用编译器参数 -noex 忽略 try 和 catch 异常结构。
消息标识:noextry
标识符列表以“)”终止之前,该列表遇到行尾。应该在一行中定义宏。是否缺少“\”? 生成错误消息的代码示例:
#define foo( A, // 缺少“\” B )
消息标识:noidentlist
常量成员应该初始化。
消息标识:noconstinit
使用运算符 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 中定义任何类型。 生成警告消息的代码示例:
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”表达式中定义新类型。 生成错误消息的代码示例:
int foo() { return sizeof (struct t {}); // 错误:在 sizeof 表达式中找到结构声明 }
消息标识:nodefinsizeof
无法在“typeid”表达式中定义新类型。 生成错误消息的代码示例:
#include <typeinfo> int main() { typeid (struct t {}); // 错误:在 typeid 表达式中找到结构声明 }
消息标识:nodefintypeid
在“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 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
(ccfe):-nocx 选项禁止使用 long long 和 long long 常量。 生成错误消息的代码示例:
long foo () { return 0ll; } // 错误 使用 -nocx 选项
消息标识:nollconst
(ccfe):-nocx 选项禁止使用 long long 和 long long 常量。 生成错误消息的代码示例:
long long cll = 0; // 错误 使用 -nocx 选项
消息标识:nolonglong
不允许使用 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 运算符分配引用和函数类型。 生成错误消息的代码示例:
int main() { new (int&); // 错误:尝试使用 new 分配引用 }
消息标识:nonewtype
基类没有定义缺省的构造函数。如果基类已定义构造函数,则编译器不会生成缺省的构造函数。
struct A { A(int); }; struct C:A {}; C c; // 错误 C c1(); // ok,缺省构造函数已由编译器生成
消息标识:nonulconbase
结构类型的成员没有缺省的构造函数,或缺省构造函数无法由编译器生成,因为包含的类型至少有一个指定的构造函数。 生成错误消息的代码示例:
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 的成员函数。 生成错误消息的代码示例:
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 的成员函数。
消息标识: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 函数。 生成错误消息的代码示例:
class A { public: void foo (); }; int main() { A volatile a; a.foo(); // 错误:A::foo() 不是 volatile 函数 }
消息标识:nonvolmf
成员函数必须声明为 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
找到匹配的“}”之前,已遇到文件尾。 生成错误消息的代码示例:
void foo() { /* code */ <EOF> // 错误,应该是“}”,但是遇到了 EOF
消息标识:norcurleof
如果设置标记 -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++ 中使用的代码,且已经发出该警告。
消息标识:notcpp
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 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 语句中使用。 生成错误消息的代码示例:
int main() { int i = 7; case 7: // 错误:case 语句不在 switch 语句中 i++; break; return 0; }
消息标识:notinsw
缺省标签只能在 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
如果要执行该操作,则必须包含文件 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
预定义的宏由编译器使用,所以不能被定义或取消定义。
消息标识: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 不是值。 生成错误消息的代码示例:
foo() { int i = (void)1; }
消息标识:novoidval
无法非关联化 void 指针。void 没有值。 生成消息的代码示例:
void *i; int j = *i; // 错误:无法非关联化 void*
消息标识:novoidderef
在 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 指令。 生成错误消息的代码示例:
namespace NS { int j; }; class A { using namespace NS; };
消息标识:nsdirinclass
引用初始化表达式的值为零。 生成错误消息的代码示例:
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
#else 指令之前必须有一个与之对应的 #if 指令。 生成错误消息的代码示例:
//#if true #define num 1 #else num 0 // . . .
消息标识:ppbadelse
预处理程序指令 #endif 必须有一个与之对应的 #if。
消息标识:ppbadendif
预处理程序命令之后的文本多余。 生成错误消息的代码示例:
#include <file.h>; // 错误:删除多余的“;”
消息标识:ppextra
该行中的多余文本已在 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 不能应用于位字段。 生成错误消息的代码示例:
class A { public: A() { size = sizeof(i); } int i:3; int size; };
消息标识:sizeofbf
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
无法将类成员的访问级别更改为专用 (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 只支持带符号或无符号的 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*。 生成警告消息的代码示例:
void foo() { char *s; s = "abcd"; // 警告 }
消息标识:wbadasgl
使用不同类型初始化类型时会发出警告。
消息标识:wbadinit
已经使用字符串文字初始化不同的兼容类型。
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
只能将没有参数的空函数作为参数传递给 init 或 fini pragma。 生成错误消息的代码示例:
void my_fini (int a) { } #pragma fini(my_fini)
消息标识:prbadfunc
一些 pragma 要求至少传递一个参数。 生成错误消息的代码示例:
#pragma fini ()
消息标识:premptylist
对齐值必须是幂为 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 fini(my_fini) // 错误:应该首先声明 my_fini void my_fini (int a) { }
消息标识:prnotdecl
Pragma 语句不正确。最有可能的是,忽视了必需的 pragma 参数。 生成错误消息的代码示例:
int a, b, c; #pragma align (a, b, c)
消息标识:prsyntax
#pragma ident 之后缺少字符串文字。
消息标识:prnostr
用作 pragma 参数的分隔符的符号错误。 生成错误消息的代码示例:
void my_init1 () { } void my_init2 () { } void my_init3 () { } #pragma init(my_init1,my_init2.my_init3)
消息标识:prnocomma
Pragma 参数列表应该以‘(’开头。 生成错误消息的代码示例:
void my_init1 () { } #pragma init my_init1)
消息标识:prnolp
参数列表中缺少‘)’或符号错误。 生成错误消息的代码示例:
void my_init1 () { } void my_init2 () { } void my_init3 () { } #pragma init(my_init1,my_init2.my_init3)
消息标识:prnorp
编译器使用该消息显示包含错误消息的行号。
消息标识:linetheword
asm 语句中必须包含字符串文字。 生成错误消息的代码示例:
void foo() { asm( nop ); // 错误 }
消息标识:noasmstring
asm 语句不允许在函数之外使用。 生成错误消息的代码示例:
asm(" nop "); // 错误 void foo() { asm(" nop "); // ok }
消息标识:asmnotinfunc
指定的标记需要值。
消息标识:cmd_needvalue
不能同时指定某些 CC 标记(例如,+e0 和 -compat=5)。
消息标识:cmd_badflag
未传递输入文件时,ccfe 会发出该错误。
消息标识:noinpfile
缺少或无法访问传递到编译器的文件,所以无法将其打开。
消息标识:openinpfile
预处理程序无法打开输出文件。请检查文件权限和/或可用的磁盘空间。
消息标识:openoutfile
该警告指出,文件没有以新行的字符结尾。
消息标识:nonewline
不能在类之外使用关键字 mutable。使用 mutable,可以对声明为 const 的类对象中的字段进行修改。 生成错误消息的代码示例:
void foo() { mutable int i = 0; // 错误 } class A { mutable int i; //ok };
消息标识:mutclassonly
mutable 只能供成员数据使用。 生成错误消息的代码示例:
class A { public: mutable int i; //ok mutable void foo() {} // 错误 A() {} };
消息标识:mutnofunc
const 名称也不能声明为 mutable。 生成错误消息的代码示例:
class A { public: A(int j) { i = j; }; mutable const int i; // 错误 };
消息标识:mutnoconst
静态数据成员不能是 mutable。 生成错误消息的代码示例:
class A { public: mutable static int i; };
消息标识:mutdatamems
必须使用 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 声明的变量。应该指定该类型。 生成警告消息的代码示例:
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 pack (3)
消息标识:prbadpack
无法使用外部的 C 链接声明模板。 生成错误消息的代码示例:
extern "C" template <class t_arg> class A {}; // 错误:模板声明不能包含该链接
消息标识: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; }
消息标识: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
不能将模板函数作为友元进行声明。 生成错误消息的代码示例:
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
生成错误消息的代码示例:
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
编译器遇到与该编译器不兼容的 SunWS_cache 目录。早期的编译器遇到更新的编译器生成的模板数据库时,将会产生该错误。
使用更新的编译器编译源,或者使用 CCadmin -d
消息标识:tdb_version
在命令行找到的 -I- 选项不止一个。
消息标识:duplicate_i
生成错误消息的代码示例如下:
template < class T > void copy ( T to ) { } template int copy ( long ) ; // 错误!
消息标识:badexplctinst
生成错误消息的代码示例如下:
struct x { x(); int x; };
消息标识:samemem
声明所有 sizeof 运算符的枚举器之前,不能对枚举类型应用该运算符。 生成错误消息的代码示例如下:
int mymain() { enum E { A, B = sizeof A }; // 错误 - 还无法应用 sizeof A return 0; }
消息标识:badenumsize
在 C++ 中,将指针赋值给完整或不完整的数组类型是错误的,反之亦然。 生成错误消息的代码示例如下:
extern int a_39W73zz[2]; // 大小既知 int (*p2)[] = &a_39W73zz; // 错误 - 类型不匹配,对于 `p2`,大小未知。
消息标识:badarrptr
如果虚拟函数的返回类型是没有定义的结构类型,且拒绝代码,则编译器无法处理这种情况。 生成错误消息的代码示例如下:
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
生成警告消息的代码示例:
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
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 指令引入函数的的名称和参数类型相同,则说明程序的结构错误。 生成错误消息的代码示例:
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
函数只能抛出它覆盖的函数允许的异常。生成错误消息的代码示例:
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
最有可能的是,显式实例化声明中缺少关键字‘class’。 生成错误消息的代码示例:
templateclass X { }; template X ; // 应该是:模板类 X ;
消息标识:explclassinst
不应使用临时来初始化非常量引用。 生成警告消息的代码示例:
struct C { C(int); }; void add( C& c ); void foo() { add( C(6) ); }
消息标识:reftotemp
模板表达式不能是非常量值。 生成错误消息的代码示例:
templatevoid f(); int main() { const int& ri = 12; f (); // 错误 }
消息标识:tmplexpnotconst
函数只能抛出它覆盖的函数允许的异常。生成警告的代码示例:
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(...); templateT 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 void (*pf) () throw();
消息标识:badexceptionspec
函数指针只能抛出它赋值的函数指针抛出的异常。生成警告的代码示例:
void (*pf1)(); void (*pf2)() throw(int); void f() { pf2 = pf1; }
消息标识:fptrthrow
生成消息的代码示例:int NE_C2_3() { int a = 1;
#pragma omp parallel if ( a > 1 ) if ( a < 5 ) { } return 0; }
消息标识: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; }
消息标识:omp_structblkviolation
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”OpenMP pragma 必须直接显示在“sections”块中。 生成消息的代码示例:
int NE_C2_4_2_1() { #pragma omp sections { ; } #pragma omp section { } return 0; }
消息标识:omp_sectionoutsidesections
生成消息的代码示例:
int NE_C2_6_5_1() { int i = 5; int & n = i; #pragma omp parallel { #pragma omp flush (n) } return 0; }
消息标识:omp_varhasreftype
排序的 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 指令必须显示在文件作用域或名称空间作用域内,还必须显示在任何定义或声明之外。 生成消息的代码示例:
int a=0; class A { #pragma omp threadprivate ( a ) }; int NE_C2_7_1_1b() { return a; }
消息标识:omp_nonfilethreadprivate
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
除 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
生成消息的代码示例:
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 变量。 生成消息的代码示例:
int x; int NE_C2_7_2_7_2() { #pragma omp parallel copyin (x) { } return 0; }
消息标识:omp_copyinnotthreadprivate
不允许具有相同名称的 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 指令不允许相互嵌套。 生成消息的代码示例:
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 指令的最小语句必须是块(或复合语句)。 生成消息的代码示例:
int NE_C2_6_5_2() { int i = 5; #pragma omp parallel { if ( i > 0 ) #pragma omp barrier } return 0; }
消息标识:xomp_mustbeblock
当指定进度表(运行时)时,不能指定 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 的其它部分,转到新行上。这样做可以将与 OpenMP 有关的错误恢复和特定于 C++ 的错误恢复分开。 生成消息的代码示例:
int main(void) { #pragma omp for default(none) for ( int i = 0; i < 10; i++ ) { } return 0; }
消息标识:omp_skip
Line 必须指定正整数。 生成错误消息的代码示例:
#line 0 "file.cc"
消息标识:poslinenum
不能在封装共享作业或并行指令的 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
生成消息的代码示例:
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 中发现通用语法错误时显示此消息。 生成消息的代码示例:
int main() { #pragma omp parallel private { } return 0; }
消息标识:omp_badlyformedomppragma
OpenMP for 的控制表达式必须采用规范的形式,如下: 消息标识:omp_forbadcontrol
int main()
{
int i,j=0;
#pragma omp parallel for
for (i=0; j<10; i++) {
}
return 0;
}
对于 default 子句,只有 none 或 shared 才是有效值。 生成消息的代码示例:
int main() { int i; #pragma omp parallel default(private) { i++; } return 0; }
消息标识: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; }
消息标识:omp_badschedulekind
生成消息的代码示例:
int main() { #pragma omp unknown return 0; }
消息标识:omp_badomppragma
OpenMP 并行和共享作业构造之后必须跟结构化的块。结构化块是拥有一个 entry 和一个 exit 的语句。不允许使用造成跳转到块或跳转出块的语句。结构化块不能包含造成控制从块流出的 return、goto、break 或 continue 语句。 生成消息的代码示例:
int foo() { #pragma omp parallel { return 1; } }
消息标识:omp_strblkviolation
OpenMP for 的迭代表达式的形式必须规范。 生成消息的代码示例:
int main() { int i; #pragma omp parallel for for (i=0; i<10; foo(&i)) { } return 0; }
消息标识:omp_forbaditer
OpenMP for 的 Init 表达式必须采用规范的形式,如下: 消息标识:omp_forbadinit
int main() {
int i=0;
#pragma omp parallel for
for (; i<10; i++) {
}
return 0;
}
pragma OpenMP 的后面必须跟 for 语句。 生成消息的代码示例:
int main() { int i=0; #pragma omp parallel for { while( 0 ){ i++; } return 0; }
消息标识:omp_forbadfollow
\"%1\" 的声明在语法上不明确,但是标准将其解释为函数声明。无论如何,程序员一般都会声明对象。为了避免混淆,请使用语法上明确的方式重新编写声明。 生成警告消息的代码示例:
struct T { }; T t( T() ); // t 是函数建议采用语法上明确的解决方法:
T t( (T()) ); // t 是对象(类型不能有多余的 parens) T t = T(); // t 是对象(赋值样式的初始化) T t( T(*)() ); // t 是函数(显式函数指针)
消息标识:ambigfuncdecl
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
不允许具有相同名称的 critical 指令相互嵌套生成消息的代码示例:
void main(void) { #pragma omp critical(foo) #pragma omp critical(foo) ; }
消息标识:omp_badcriticalnesting
必须使用 c++ 函数执行声明为本地方法的 Java 方法。如果方法之前没有作为 .class 文件中的本地方法进行声明,则提供该方法的 C++ 版本会产生错误。
消息标识:notjavanative
未定义将非 POD 对象作为变量参数传递的结果。
POD(平面旧数据)对象是一个不包含下列内容的对象:用户声明的构造函数、用户定义的析构函数、用户定义的复制运算符、虚拟函数、专用或受保护的非静态数据成员和指针到成员类型的非静态数据成员、非 POD 结构、非 POD 联合或引用。
void foo(int, ...); struct T { T(); ~T(); }; extern T t; int main() { foo(1, t); // 警告 }
消息标识:nonpodvarargw
友元声明未指定类或函数。 生成错误消息的代码示例:
namespace N { templatestruct 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_identifierbi; foo(100); }
消息标识:nontmplfriend
调用 #pragma dumpmacros 时使用的有效参数如下:defs、undefs、loc、conds 和 sys 生成错误消息的代码示例:
#pragma dumpmacros(definitions)
消息标识:prbadarg
模板嵌套深度引用了函数模板的专门化,只有非模板函数才可用。 生成错误消息的代码示例:
templatestruct A { void f(int); }; template<> template<> void A ::f(int) {} // spec 多余
消息标识:mismatchtmpdepth
移植为 64 位时,赋值、初始化或转换可能会截断数据。 生成错误消息的代码示例:
long l; (int)l;
消息标识:truncwarn1
如果移植为 64 位,则赋值为无符号的 long 之前,可以扩展数据的符号。 生成错误消息的代码示例:
int i; unsigned long ul = i;
消息标识:signextwarn
移植为 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 指令中指定的块作用域变量必须是静态的。 生成消息的代码示例:
int main() { #pragma omp parallel { int i; #pragma omp threadprivate(i) i = 50; } }
消息标识:omp_threadprivatenotstatic
静态块作用域变量的 threadprivate 指令必须出现在变量的作用域内,而不能出现在嵌套的作用域内。 生成消息的代码示例:
int main() { static int i; #pragma omp parallel { #pragma omp threadprivate(i) i = 50; } }
消息标识:omp_threadprivateinnested
在 OpenMP 并行区域的 if 子句中指定的表达式必须具有标量类型。 生成消息的代码示例:
int main() { struct { float val; } good = {3.62}; #pragma omp parallel if(good) good.val = 4.12; }
消息标识:omp_badiftype
在 OpenMP 并行区域的 num_threads 子句中指定的表达式必须具有整数类型。 生成消息的代码示例:
int main() { int i = 0; #pragma omp parallel num_threads(3.62) i++; }
消息标识:omp_badnumthreadstype
在模板参数声明中不能指定类定义。 生成错误消息的代码示例:
templateclass S{};
消息标识:noclassdef
copyprivate 子句不能与 nowait 子句一起使用。 生成消息的代码示例:
int main() { int i = 42; #pragma omp single nowait copyprivate(i) { i++; } }
消息标识:omp_badusecopyprivate
如果在并行区域的动态范围内遇到使用 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 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
生成警告消息的代码示例:
#includeint main() { enum Shape { shape1=2, shape2}; enum Point { point1=4, point2}; Shape cylinder = shape1; Point uper = point2; if ( cylinder == uper ) // 警告 cout << “比较不同的枚举类型” << endl; }
消息标识:diffenumtype
消息标识:demxarchv8plus
生成消息的代码示例 struct S { int f1(int = f2()); int f2(int = f1()); };
消息标识:recurseindefault
不能将虚拟函数声明为友元函数。 生成错误消息的代码示例:
void foo() { return; } void goo() { return; } class A { virtual friend void foo(); // 错误 virtual friend void A::goo(); // 错误 };
消息标识:virtfriendfunction
仅使用函数名称声明了友元函数。 生成错误消息的代码示例:
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 { templatestruct ap { ap(X* p = 0); }; }; using namespace N; class A {}; A* a; ap ap(a) ;
消息标识:baddeclare
生成警告消息的代码示例:
class A { }; main() { A a(10); #pragma omp parallel private(a) { ; } }
消息标识:nodefctor
生成警告的代码示例:
templateclass A { ... }; class A ; // 警告:已忽略 template<> class A ; // 声明显式专门化 template class A ; // 显式实例化指令
消息标识:oldspecialdecl
生成警告的代码示例:
__thread void func(); struct type { __thread void func(); };
消息标识:nothreadfuncs
生成警告的代码示例:
int changed; __thread int changed;
消息标识: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();
消息标识:threaddyninit
生成警告的代码示例:
void func() { __thread int a; }
消息标识:noautothread
生成警告的代码示例:
templatestruct 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
如果段包含的语句不止一个,则这些语句必须位于 {} 生成消息的代码示例:
#pragma omp sections { // optional #pragma omp section x = 5; y = 10; }
消息标识: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<> 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
生成警告的代码示例:
char c[100000]; short i = sizeof(c);
消息标识:truncwarn2
具有引用成员的类必须具有用户定义的构造函数 生成错误消息的代码示例:
struct S { int x&; };消息标识:refmemnoconstr
正在使用的 pch 文件没有正确的魔数
消息标识:pchbadmagicnumber
正在使用的 pch 文件在前页中的格式字符串不正确
消息标识:pchbadformatstr
pch collect 和 use 模式编译器版本字符串不兼容
消息标识:pchbadreleasestr
pch 文件应该包含 defines
消息标识:pchexpdefines
pch 文件应该包含 undefs
消息标识:pchexpundefs
pch collect 和 use 模式中的 defines 列表不同
消息标识:pchbaddefines
pch collect 和 use 模式中的 undefs 列表不同
消息标识:pchbadundefs
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 声明 生成错误消息的代码示例:
class A {public:int i; A(){i = 10;};}; #pragma omp parallel { static A a; ; }
消息标识:omp_staticclassdecl
生成警告的代码示例:
unsigned short bar[] = U"é";
消息标识:ustronlyascii
生成警告的代码示例:
unsigned short bar[] = U"\351";
消息标识:ustrnoescape
可能缺少或位置错误 #pragma hdrstop or -xpchstop point
消息标识:pchbadstoppoint
可用前缀中只能使用注释和某些预处理程序指令
消息标识:pchbadviablepref
打开的文件太多,可能是一个包含自身的文件
消息标识: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); // 错误
消息标识:castawayconst
threadprivate 指令必须显示在定义或声明之外。 生成消息的代码示例:
class A { int a; #pragma omp threadprivate ( a ) };
消息标识:omp_badthreadprivate
在主模板声明中不允许使用显式模板参数列表 生成消息的代码示例:
templatevoid bar (); template void bar ();
消息标识:wexpltemplid
原子 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
尚未在最深层的封装非类作用域中找到声明为友元或局部类的函数或类。 生成警告的代码示例:
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
消息标识:pchexpsrcdir
pch collect 和 use 模式中的源目录不同
消息标识:pchbadsrcdir
pch 文件应该包含 cwd
消息标识:pchexpcwd
pch collect 和 use 模式中的当前目录不同
消息标识:pchbadcwd
pch 文件应该包含选项
消息标识:pchexpoptions
pch collect 和 use 模式中的选项不同
消息标识:pchbadoptions
因为抛出异常的线程必须捕获 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 索引 变量的值 生成此消息的代码示例:
#pragma omp parallel for for (i = 0; i < 10; i++) { i = i + 5; }
消息标识:omp_forindexmod
模板的友元声明必须具有相同的参数数目 生成错误消息的代码示例:
templateclass 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 语法无效 生成错误消息的代码示例:
extern __declspec dllimport) int bar;
消息标识:declspecsyntax
不应该是 __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 some_unknown // ragma 未知 int main() { #pragma opm for // pragma 拼写错误 for ( int i = 0; i < 10; i++ ) { } return 0; }
消息标识:unknownpragma
无法专门化内部模板,同时也无法专门化外部模板 生成错误消息的代码示例:
templatestruct S { template struct I; template void foo(); }; template template<> struct S ::I ; // 错误 template template<> void S ::foo (); // 错误
消息标识:nestexplspec
只能在名称空间作用域内声明显式专门化 生成错误消息的代码示例:
struct S { templatestruct I; template void foo(); template<> struct I ; // 错误 template<> void foo (); // 错误 };
消息标识:badexplspec
必须在相同的名称空间中将模板的显式专门化声明为模板 生成错误消息的代码示例:
namespace N { templatestruct S {}; template void foo(); } template<> struct N::S ; // 警告 template<> void N::foo (); // 警告
消息标识:badexplspecdecl
可以在包含声明的名称空间或使用声明封装的名称空间内定义显式专门化 生成错误消息的代码示例:
namespace N { templatestruct S {}; template void foo(); template<> struct S ; template<> void foo (); } namespace M { template<> struct N::S {}; // 警告 template<> void N::foo () {} // 警告 }
消息标识:badexplspecdef