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

内部错误,不应发生

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

消息标识:noerror


检测到整数溢出

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

消息标识:addfovfl


检测到整数溢出

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

消息标识:addovfl


使用后重新定义

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

typedef int Integer;

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

消息标识:alreadyusedc


使用后重新定义模板

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

template < class T >
class A {};

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

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

消息标识:alreadyusedt


名称不明确

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

struct A {
int i;
};

struct A2 {
int i;
};

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

消息标识:ambigfield


基类不明确

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

struct B { int i; };

struct B1:B {
int j;
};

struct B2:B {
int j;
};

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

消息标识:ambigbfield


基类不明确

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

struct A {
int i;
};

struct B:A {
int j;
};

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

消息标识:ambigbspec


名称不明确

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

struct B1 {
void foo(){}
};

struct B2 {
void foo(){}
};

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

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

消息标识:ambigname


匿名联合不能有函数成员

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

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

消息标识:anonnofunc


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

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

static union {
long j;
       
private: 
	int i; // 错误
}; 

消息标识:anonnoprivate


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

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

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

消息标识:anonnotstatic


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

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

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

union B {
A a;
int i;
};

消息标识:asgnotall


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

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

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

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

消息标识:asgwref


拥有常量成员,无法赋值

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

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

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

消息标识:asgwconst


使用模板,无需声明

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

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

消息标识:assumetemp


无法更改访问

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

class A {
protected:
int i;
};

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

消息标识:badaccadj


无法更改访问,因为

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

class A {
public:
int i;
};

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

消息标识:badadjname


该操作是非法的

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

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

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

消息标识:badtunaryop


该操作是非法的

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

class A {
int i;
};

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

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

消息标识:badbinaryop


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

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

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

消息标识:badarglval


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

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

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

消息标识:badarglval2


正在传递类型的形式参数

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

void foo(int *cp);

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

消息标识:badargtype


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

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

void foo(int *cp);

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

消息标识:badargtype2


正在传递类型的形式参数

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

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

void foo(A *Ap);

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

消息标识:badargtypew


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

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

void foobar(char *c);

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

消息标识:badargtypelw


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

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

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

void foo(A *Ap);

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

消息标识:badargtype2w


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

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

消息标识:badargtypel2w


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

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

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

消息标识:badarrinit


某个条件无法具有类型

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

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

消息标识:badcondtype


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

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

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

A the_a;

void foo(A a) { };

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

消息标识:badcopyacc


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

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

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

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

消息标识:badcopyacc2


数组必须至少有一个元素

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

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

消息标识:badarraysize


该操作是非法的

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

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


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

消息标识:badarraytype


无法赋值

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

class A {
int i;
};

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

消息标识:badassignment


没有 operator=,无法赋值

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

class A { };

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

int main() {
A a;
B b;      

b = a;
}

消息标识:badasscasg


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

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

class B;

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

消息标识:badbaseclass


位字段必须为整型类型

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

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

消息标识:badbftype


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

break 语句可能不在 loopswitch 语句之外。 生成错误消息的代码示例:

int main()
{
	int i = 5;
	
	break ;

return 0;
}

消息标识:badbreak


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

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

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

消息标识:badcasetype


无法转换

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

class A {
int i;
};

union B {
int j;
double k;
};

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

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

消息标识:badcast


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

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

消息标识:badchar


发现异常

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

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

class B {
public:
int j;
A anA;

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

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

消息标识:badcolon


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

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

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

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

消息标识:badcolon2


两边必须有标记

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

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

消息标识:badconcat


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

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

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

消息标识:badconinit


不允许使用 const_cast 进行转换

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

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

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

消息标识:badconstcast


不是一个有效的常量

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

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

消息标识:badconsterr


无法声明函数

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

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

消息标识:badconstfunc


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

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

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

消息标识:badcontype


没有循环语句以继续执行

continue 只能在循环语句中使用。循环示例包括 whilefordo-while。 生成错误消息的代码示例:

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

消息标识:badcontin


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

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

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

消息标识:badconvtype


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

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

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

消息标识:wbadconvret


声明被错误终止

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

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

消息标识:baddeclerr


必须有一个标识符来声明

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

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

消息标识:baddecl


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

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

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

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

消息标识:baddefault


无效的模板参数缺省值

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

template <class T, class K>
class A;

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

消息标识:baddefaultpar


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

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

template <class T = int>
class A;

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

消息标识:sametmpldef


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

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

template < class T >
T foo(T);

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

消息标识:badtmplfundef


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

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

消息标识:baddestrname


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

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

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

消息标识:baddestrtype


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

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

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

消息标识:badelseerr


枚举器值溢出

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

#include <limits.h>

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

消息标识:badenumrange


表达式结构错误

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

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

消息标识:badexprerr


未知语言,必须为 C 或 C++

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

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

消息标识:badextern


前面已用不同语言声明

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

void foo();

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

消息标识:badextlnk


前面已用不同语言声明

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

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

消息标识:badextlnkw


成员不允许有存储类 %1

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

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

消息标识:badfieldstore


包含文件名结构错误

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

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

消息标识:badfilename


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

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

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

消息标识:badfunc


函数必须有原型

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

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

void goo() {};

消息标识:badfunccp


函数必须是静态或外部的

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

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

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

消息标识:badfuncstore


函数无法返回数组或函数

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

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

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

消息标识:badfunctype


Goto 跳过了变量(或异常)初始化

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

int main()
{
int a = 2;

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

消息标识:badgoto


无法打开包含文件

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

消息标识:badinclfile


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

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

extern int out = 2; // ok

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

消息标识:badinit


无法用来初始化类

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

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

消息标识:badinitcl


无法用来初始化

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

namespace N {
int i;
int j;
}

N n = { 1, 2 };

消息标识:badinitbrace


初始化时需要左值

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

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

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

short sv = 9;
int &ir = sv; // 错误:将 short 赋值给 int 引用“ir”时,
// 要求“ir”引用实际的 int。
下面是纠正以前是计时错误的错误示例。
void foo() {
	short sv = 9;
	int &ir = sv; // 错误:将 short 赋值给 int 引用“ir”时,
	      // 要求“ir”引用实际的 int。
使用下列代码,可以纠正上述错误:
	int *j;
	*j = (int)sv;
	int &jr = *j; // ok,“jr”是对 int 的引用。
}

消息标识:badinitlval


无法用来初始化

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

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

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

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

消息标识:badinittype


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

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

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

消息标识:badarrayinit


整数太大而无法表示

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

int i = 999999999999999999999999999999999;

消息标识:badinteger


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

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

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

消息标识:badlinedir


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

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

#line 1234567 "file.cc"

消息标识:badlinenum


以前已声明

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

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

消息标识:badlinkage


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

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

void main() {}

消息标识:badmain


无法获取 main() 的地址

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

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

消息标识:badmainaddr


无法递归调用 main()

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

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

消息标识:badmaincall


无法重载 main()

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

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

int main()
{
	return 0;
}

消息标识:badmainol


无法在构造函数中初始化

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

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

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

消息标识:badmembinit


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

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

class A;

void (A::* f_ptr) ();

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

消息标识:badmfcall


成员函数不能有存储类

成员函数可以有存储类 mutableautoregisterextern。 生成错误消息的代码示例:

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

消息标识:badmfstore


八进制常量包含非法数字

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

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

消息标识:badoctal


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

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

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

消息标识:badollnk


参数数目非法

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

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

消息标识:badopcount


不能有返回类型

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

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

消息标识:badoprtype


参数类型非法

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

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

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

消息标识:badoptypes


错误的参数元素

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

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

消息标识:badparamerr


参数必须是 int 类型

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

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

消息标识:badpostfix1


第二个参数必须是 int 类型

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

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

消息标识:badpostfix2


未知的预处理程序指令

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

#bad_directive

消息标识:badppdir


常量表达式结构错误

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

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

消息标识:badppexpr


简单类型没有析构函数

intfloatchar 这些简单类型没有析构函数。 生成错误消息的代码示例:

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

消息标识:badpseudodestr


非虚拟函数声明为纯函数

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

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

消息标识:badpuref


纯函数定义语法错误

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

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

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

消息标识:badpuresyn


类型不同

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

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

消息标识:badquesttypes


浮点常量无效

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

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

消息标识:badreal


不允许使用 reinterpret_cast 进行转换

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

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


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

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

消息标识:badreintcast


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

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

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

消息标识:badreturn


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

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

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

消息标识:badrparerr


不允许使用 static_cast 进行转换

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

struct A {
operator int();
} a;

struct B {} b;

void foo() 
{
int i = 3;
double d = 3.14159;
  
i = d; // ok
i = static_cast<int> (d); // ok

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

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

消息标识:badstaticcast


函数不能为静态的

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

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

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

消息标识:badstatmf


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

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

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

class C {
virtual void foo();
};

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

消息标识:badstatvirtf


字符换码序列未定义

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

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

消息标识:badstring


值太大而无法适合字符

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

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

消息标识:badstringcon


非法的模板参数值

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

template<int* p> class X { };

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


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

消息标识:badtemparg


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

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

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

int j = 9;

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

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

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

消息标识:badtmplrefarg


模板参数无法具有类型

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

消息标识:badtemppar


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

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

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

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

消息标识:badunaryop


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

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

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

消息标识:badthis


此处的类型说明符不合法

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

消息标识:badtypeerr


返回时返回虚拟函数

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

class Base {
virtual void foo();
};

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

消息标识:badvirttype


位字段包含位数

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

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

消息标识:bfbigger


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

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

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

消息标识:bftoobig


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

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

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

消息标识:bftoosmall


获取边界函数的地址

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

class A {
public:
A() {}

int goo();
};

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

foo = a.goo;
}

消息标识:boundfuncaddr


无法获取构造函数的地址

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

struct A {
A();
};

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

消息标识:cantaddrcon


无法获取析构函数的地址

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

struct A {
~A();
};

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

消息标识:cantaddrdest


无法赋值左操作数

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

const int i = 7;
int j = 9;

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

消息标识:cantassign


无法赋值操作数

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

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

int j[5];
j = 9;

void foo() {}

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

消息标识:cantassignop2


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

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

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

消息标识:cantcatstring


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

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

消息标识:cantgoon


应该有可以重载的运算符

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

#include <stddef.h>

class A {
	void* operator anew[] (size_t); // 错误:运算符“anew”不存在
	void operator delete[] (void*);
};
为未定义类型声明的运算符示例:
class B {
operator C(); // 错误:尚未定义类型 C
};

class C {};

消息标识:cantoverop


试图获取重载函数的地址

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

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

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

消息标识:cantuseover


无法转换常量

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

class B { virtual void foo(); };

class A:public B {};

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


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

消息标识:xcastawayconst


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

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

消息标识:castfrominc


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

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

消息标识:casttoinc


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

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

int main()
{
int i = 3;

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

消息标识:catchdef


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

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

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

};

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

int main()
{
A a;
B b;

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


}

消息标识:catchderive


重复的异常处理程序

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

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

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

}

消息标识:catchdup


一个处理程序的多个异常

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

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

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

消息标识:catchmularg


处理程序没有异常

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

int main() {
int i = 3;

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

消息标识:catchnoarg


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

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

int main()
{
int a = 107;

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

消息标识:catchnosym


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

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

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

int main()
{
return 0;
}

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

消息标识:changedef


字符常量中的字符过多

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

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

消息标识:chartoolong


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

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

class A {
int i;
};

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

消息标识:cltounion


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

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

union A {
int i;
long j;
};

class A {
int i;
};

消息标识:clfromunion


不允许在这里声明

(C 模式)在 C 模式下,声明不能与语句混合使用。 生成错误消息的错误示例:

void foo () {
int a = 0;

a++;

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

消息标识:declplaceerr


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

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

class A {
A() {};
};

typedef A B[5];

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

消息标识:defaultonly


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

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

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

消息标识:defincond


无法访问析构函数

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

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

int main() {
foo();
}

消息标识:destnotacc


以前已声明返回

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

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

消息标识:difreturns


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

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

消息标识:divfovfl


试图除以零

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

int i = 1/0;

消息标识:divovfl


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

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

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

消息标识:divovflnv


switch 中出现两个 default

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

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

消息标识:doubdefault


有两个连续的下条

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

消息标识:doubunder


该基类已经指定了访问

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

class B {};

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

消息标识:dupaccess


该基类被多次包含

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

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

struct A2 {
int i;
};

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

消息标识:dupbaseclass


switch 语句包含两个 case 语句

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

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

消息标识:dupcaselabel


之前初始化成员

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

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

消息标识:dupinit


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

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

class B {
virtual foo();
};

class D:public B {
int i;
};

B *pb = new D;

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

消息标识:dynbadtype


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

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

class B {};

class D:public B {};

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

消息标识:dynnotpolym


dynamic_cast 操作数不是引用类型

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

class B { virtual void foo(); };

class D:public B {};

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

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

消息标识:dynnotref


dynamic_cast 操作数不是指针类型

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

class B { virtual foo(); };

class D:public B { int i; };

B *pb = new D;
D d;

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

消息标识:dynnotptr


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

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

class B { virtual void foo(); };

class D:public B {
};

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

消息标识:dynnotclass


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

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

class B { virtual void foo(); };

class D:public B {};

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

消息标识:dynbadopnd


多项声明

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

int i;
float i; // 错误

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

消息标识:multdecl


之前已初始化基类

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

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

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

消息标识:dupbaseinit


已经包含在该声明中

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

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

消息标识:duptypeerr


已定义主体

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

void foo() { int i; }

int main()
{
	/* code */
}

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

消息标识:dupfuncdef


该基类已经声明为虚拟

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

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

消息标识:dupvirtspec


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

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

int main()
{
int i = 3;

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

消息标识:eliplaceerr


空的字符常量

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

f(void) {

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

消息标识:emptychar


空的声明(可能有多余的分号)

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

namespace {
;  // 错误
};

class A {
;
}

消息标识:emptydecl


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

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

消息标识:emptyfile


在注释中遇到文件尾

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

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

消息标识:eofincomment


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

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

#if false

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

消息标识:eofskipping


表达式过于复杂

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

消息标识:exprtoomuch


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

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

void foo( int i, int j ) {}

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

消息标识:extracomma


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

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

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

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

消息标识:fieldinit


隐藏函数

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

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

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

消息标识:hidef


隐藏

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

#include <new>

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

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

消息标识:hideferr


隐藏虚拟函数

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

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

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

消息标识:hidevf


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

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

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

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

消息标识:hidevfinvb


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

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

void foo () {
int a;

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

消息标识:identundef


无法使用名称

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

void foo () {
int a;

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

消息标识:identunnestf


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

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

struct A {
	int i;
};

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

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

void foobar() {
	A a;

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

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

消息标识:identunstat


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

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

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

消息标识:illegalcast


无法访问

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

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

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


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

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

消息标识:inaccessible


类型不完整

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

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

class A;
A a; // 错误

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

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

消息标识:incomplete


在 delete 中使用的类型不完整

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

class A;

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

消息标识:incompletew


前面已声明类型的对象

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

extern int i;
float i; // 错误

消息标识:incomtype


以前已声明

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

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

消息标识:incomtypef


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

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

class A {
public:
A();
};

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

消息标识:initnotall


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

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

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

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

inline
void A::foo () {}

消息标识:xinlafteruse


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

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

消息标识:inllargeuse


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

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

消息标识:inllargeint


该标签从未定义

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

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

return 0;
}

消息标识:labelundef


局部类不能包含静态成员

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

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

}

消息标识:lcstatic


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

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

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

消息标识:lcfnodef


只能用于块或函数参数

存储类 autoregister 只能在函数参数的块中使用。 生成错误消息的代码示例:

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

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

消息标识:locstorespec


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

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

extern "C" int k; //ok

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

消息标识:loclinkage


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

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

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

消息标识:longstring


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

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

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

消息标识:macroredef


该宏的参数过多

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

消息标识:manymacroparms


宏参数重复

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

#define foo( X, X )

消息标识:dupmacroparms


重载不明确

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

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

int main()
{
	foo (1, 2);                   //  ok:call  f(int, int)
foo ();                       //  错误:call f(int,int)  or  f()?
}
使用构造函数和转换运算符时,也会产生二义性问题:
struct A { A(int); };
struct B {
	B(int);
	operator int();
	operator double();
} b;

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

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

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

消息标识:manymatchover


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

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

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

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

消息标识:membnotall


有带值返回和无值返回

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

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

消息标识:mixedreturns


试图计算与零相除的余数

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

int i = 1000000 % 0;

消息标识:modovfl


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

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

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

消息标识:modovflnv


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

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

消息标识:mulfovfl


检测到整数溢出

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

int i = 1000000 * 1000000;

消息标识:mulovfl


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

不允许有多个限定符。

消息标识:multqualerror


类不是直接基类

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

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

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

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

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

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

消息标识:mustbebase


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

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

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

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

消息标识:mustbemem


无法具有函数数组

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

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

消息标识:noarroffunc


无法具有引用数组

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

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

消息标识:noarrofref


没有基类要初始化

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

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

消息标识:nobaseclass


应替换为

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

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

消息标识:nobecomeserr


无法获取位字段的地址

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

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

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

消息标识:nobitaddr


无法引用位字段

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

struct A {
int i:3;
int j:4;
int k:5;
  
int &foo() { int &ri = i; return ri;}  // 错误
};

消息标识:nobitref


不是成员

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

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

class A {
public:
int i;
int j;
  
friend void foo();
};

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

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

消息标识:nofieldfnd


应替换为

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

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

消息标识:nocolonerr


该对象后面没有

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

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

消息标识:nocolonop


应该替用逗号

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

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

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

消息标识:nocommaerr


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

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

消息标识:noexthrow


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

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

消息标识:noextry


需要标识符列表而不是

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

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

消息标识:noidentlist


常量成员没有初始化

常量成员应该初始化。

消息标识:noconstinit


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

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

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

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

消息标识:noconstrparm


需要声明而不是

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

struct A {
	int i;
} a, :

消息标识:nodeclerr


该声明没有存储类或类型

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

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

消息标识:nodeclspec


不允许使用缺省参数

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

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

};

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

消息标识:nodefall


不允许在运算符 new 中定义

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

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

消息标识:nodefinnew


不允许在参数类型中定义

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

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

消息标识:nodefinproto


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

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

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

消息标识:nodefinret


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

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

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

消息标识:nodefinsizeof


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

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

#include <typeinfo>

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

消息标识:nodefintypeid


在 delete 中使用计数

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

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

消息标识:nodelno


之前没有直接声明符

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

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

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

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

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

消息标识:nodirdecl


RTTI 已禁用,dynamic_cast 被 static_cast 取代

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

消息标识:nodyncast


不是枚举标记

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

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

消息标识:noenumerr


应为表达式

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

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

消息标识:noexprerr


不是成员

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

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

int main() {
return t.a;
}

消息标识:nofieldident


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

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

class A {
int i;
friend;
};

消息标识:nofriendfield


类友元要求显式类

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

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

class B {
int j;
};

消息标识:nofriendw


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

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

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

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

消息标识:nofunchere


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

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

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

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

消息标识:nogtrerr


应为标识符,而不是

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

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

消息标识:noidenterr


需要标识符而不是(警告)

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

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

消息标识:noidentwarn


必须进行初始化

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

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

消息标识:noiniterr


应该进行初始化

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

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

消息标识:noinitwarn


类型的对象必须初始化

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

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

消息标识:noinitanac


函数尚未定义主体

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

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

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

消息标识:noinlbody


引用成员没有初始化

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

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

消息标识:noirefmem


标签之后需要语句(即使为空)

标签之后需要语句(即使为空)。 生成消息的代码示例:

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

消息标识:nolabstaterr


应替换为左大括号

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

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

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

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

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

消息标识:nolcurlerr


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

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

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

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

消息标识:nolocalname


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

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

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

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

消息标识:noretbitref


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

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

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

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

消息标识:nolocalns


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

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

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

消息标识:nollconst


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

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

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

消息标识:nolonglong


long long 位字段是不允许的

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

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

消息标识:nollbitfield


应该是左圆括号,而不是

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

int i;

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

if i < 7); // 错误

消息标识:nolparerr


应该是左方括号,而不是

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

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

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


template class T>
class D{};

消息标识:nolsserr


无法找到以初始化基类

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

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

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

消息标识:nomatchbase


无法找到以初始化

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

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

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

消息标识:nomatchmem


无法找到匹配项

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

struct S { int &r; };
int main() {
struct S *x = new S(0); // 错误:未找到构造函数 S::S(int)
};
class A {
public:
int i;
A();
A(int a, int b);
};

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

消息标识:nomatchover


没有匹配的右括号

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

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

消息标识:nomatchrpar


无法使用 new 分配

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

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

消息标识:nonewtype


无法找到以初始化基类

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

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

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

消息标识:nonulconbase


无法初始化 field2

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

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

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

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

消息标识:nonulcon


无法找到以初始化向量

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

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

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

消息标识:nonulvec


const 对象调用非 const 函数

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

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

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

消息标识:nonconmf


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

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

消息标识:nonconmfp


引用返回值必须为左值

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

int &foo()
{
	return 0;
}

消息标识:nonvarref


将非左值转换为

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

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

消息标识:nonlvalcast


函数无法返回值

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

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

消息标识:nonvoidret


为 volatile 对象调用非 volatile 函数

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

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

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

消息标识:nonvolmf


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

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

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

void (B::* b_ptr)();

int main()
{
B volatile *b;
(b->*b_ptr)(); // 错误:B::bar() 未声明为 volatile
}

消息标识:nonvolmfp


使用点或箭头调用

类的实例应该使用“.”或“->”调用成员函数。 生成错误消息的代码示例:

class A
{
public:
	void foo(){ /* code */ }
};

int main()
{
	A::foo();
}

消息标识:noobjcall


应该为操作数,而不是

应为操作数,但是未找到。 生成错误消息的代码示例:

void foo() 
{
int i = 2;
int j[5];
i = j[]; // 错误:缺少子脚本
i = [i]; // 错误:应该是 j[i]
double d = ()i; // 错误:“()i”应该是“(double)i”
}

消息标识:nooprnderr


无法从整数类型减去指针类型

无法从整数类型减去指针类型。 生成错误消息的代码示例:

void foo() 
{
int i = 2;
int *j = &i;

i = i - j;
}

消息标识:noptrsub


需要指针类型,而不是

访问成员时,需要对象的指针类型。 生成错误消息的代码示例:

class A {
public:
	int i;
};

void foo() {
	A a;
	a->i = 8; // 错误:“a”不是指针类型
};

void bar() {
	int j;
	j[0] = 7; // 错误:“j”不是指针类型
}

消息标识:noptrvar


应该是右圆括号,而不是

数组子脚本存在语法错误。 生成消息的代码示例:

int i[7];

i[6} = 10; // 错误:应该是“]”

消息标识:norbrackerr


应该是右大括号,而不是

应该有“}”,但未遇到。 生成错误消息的代码示例:

int a [2] = { 1, 2 ; // 错误,初始化程序的列表应该以
// “}”终止

消息标识:norcurlerr


应该是右大括号,而不是 EOF

找到匹配的“}”之前,已遇到文件尾。 生成错误消息的代码示例:

void foo() 
{
	/* code */

<EOF> // 错误,应该是“}”,但是遇到了 EOF

消息标识:norcurleof


当没有 RTTI 支持进行编译时忽略 typeid 或 dynamic_cast

如果设置标记 -feature=no%rtti,将会禁用 Typeid 动态转换。

消息标识:nortti


无法定义引用或指向引用的指针

引用或指向引用的指针是非法的。 生成错误消息的代码示例:

const int &const &i = 12345678; // 错误

int i;
int &ri = i;
int &(*pri) = &ri; // 错误

消息标识:noptrtoref


无法声明指向对象的引用

存在指向 void 类型的引用声明。 生成错误消息的代码示例:

void &foo(); // 错误:将引用的返回类型声明为 void 类型

消息标识:noreftotype


无法声明指向成员类型的引用

声明指向成员类型的引用是非法的,因为这样会使他人对专用或受到保护的类成员数据进行访问。

消息标识:noreftomem


无法获取寄存器地址

寄存器没有地址。如果程序未作为 C++ 程序进行编译,且尝试获取寄存器的地址,将会触发该错误。 生成错误消息的代码示例:

register int i = 3;
int *pi = & i;

消息标识:noregaddr


应该是右圆括号,而不是

存在语法错误。表达式中应该包含“)”标记。 可以生成错误消息的代码示例:

void foo() 
{
int i = 3;
switch (i	// 错误:缺少“)”
  { 
	 case 2:
		i++;
		break;
  };
}

void foobar( int i; float j ) // 错误:“int i”之后应该跟“,”
{
	if ( i = 9)  // 错误:“=”应该是“==”
		i++;

消息标识:norparerr


使用分号终止语句

语句必须以“;”结尾 生成消息的代码示例:

int main()
{
	int i;
	int j = 1;
	i = j + 3  // 错误

return 0;
}

消息标识:nosemierr


使用分号终止声明

声明必须以“;”结尾 生成消息的代码示例:

volatile int foo
int goo ()

消息标识:nosemiheaderr


这里需要语句(即使为空)

这里需要语句(即使为空语句)。 生成错误消息的代码示例:

void foo( int i ) {
	if ( i < 10 )	
		++i;
	else	
		// 错误:缺少语句
}	

消息标识:nostaterr


位字段不能是静态的

静态位字段是非法的。 生成错误消息的代码示例:

class A {
static int i:4; // 错误
};

消息标识:nostaticbf


变量不是结构

变量不是结构的实例。 生成错误消息的代码示例:

int main()
{
	int j;
	j.novar = 7;
return 0;
}

消息标识:nostructsym


不能在非结构的类型中使用点运算符

不能在非结构的类型中使用点运算符。 生成错误消息的代码示例:

int main() {
int().a;    // 错误:int 不是结构类型
}

消息标识:nostructype


已经使用该标记

已经使用该标记。 生成错误消息的代码示例:

typedef int A;

class A {};

消息标识:nostructerr


不是静态数据成员

静态成员由对象类型的所有实例共享。该成员不是静态的;因此,必须使用该对象的实例指定要使用的一个成员。 生成错误消息的代码示例:

struct A {
int i;
void foo() { A::i = 2; } //ok
};

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

void foo() 
{
	A aa;
	aa.i = 7; // ok
}

消息标识:notastatmem


不是基类

“using”指令中应该有基类名称。 生成错误消息的代码示例:

class t { 
public:
int a;
};

class A {
using t::a; // 错误:t 不是 A 的基类,无法使用 t::a
};

消息标识:notbase


这里需要整型常量表达式

语法错误:需要整型常量表达式。 生成错误消息的代码示例:

int a;

enum {
mem1 = a,   // 错误:这里需要整型常量表达式
mem2,
mem3
} e;

消息标识:notconst


条件标签需要整型常量表达式

条件标签需要整型常量表达式。 生成错误消息的代码示例:

int main()
{
int i = 0;

switch(i) {
case 4:	// ok
case 3.141592654:	// 错误
i++;
break;
  };
};

消息标识:notconstcase


在数组下标操作符中需要整型常量表达式

数组子脚本运算符只能使用整型常量。 生成错误消息的代码示例:

int e[7];
e[2.718281828] = 5; // 错误

消息标识:notconstsub


位字段需要整型常量表达式

位字段需要整型常量表达式 生成错误消息的代码示例:

class A {
int a:2; // ok
int b:6; // ok
int d:3.141592654; // 错误
};

消息标识:notconstbit


该构造仅允许用于 C++

编译器已经遇到只允许在 C++ 中使用的代码,且已经发出该警告。

消息标识:notcpp


typedef 名无法用于复杂类型说明符

typedef 名无法用于枚举类型和类类型。 生成错误消息的代码示例:

typedef struct S T;
struct T *p; // 错误

enum x { a, b }
typedef enum x y;
y x;      // ok
enum y x; // 错误

消息标识:notdclass


函数定义不能是 typedef 声明

函数定义不能是 typedef 声明。 生成错误消息的代码示例:

typedef int(mft)(int i);
mft foo 
{	// 错误
return i + 2;
}

消息标识:notdfunc


应该有类模板名,而不是

应该有类模板名,但未找到。 生成错误消息的代码示例:

int foo () { return 0; }

template<> int foo(); // 错误:foo 不是模板类名

消息标识:notempname


没有参数提供给模板

要指定为其生成模板的对象类型,模板化类中必须具有参数。 生成错误消息的代码示例:

template<class T>
class A {
int i;
T *data;
public:
A(int length=10) :data(new T[length]) {}
};

int main() {
A   a;  // 错误:模板需要参数
return 0;
}

消息标识:notempparm


没有实例化提供给模板的参数

获取几个参数时,已声明模板类,但在实例化过程中并未提供这些参数。 生成错误消息的代码示例:

template <class A>
class B {};

template class B<>; // 错误:必须提供模板参数

消息标识:notemparg


只有函数可调用

无法调用对象。只能调用函数。 生成错误消息的代码示例:

void foo() {}

int main()
{
	int i;
	i(); // 错误:只能调用函数
	foo(); // ok
return 0;
}

消息标识:notfunc


声明没有指定标记或标识符

声明中必须有标记或标识符。 生成错误消息的代码示例:

int;
float;
enum E;

消息标识:nothingdecl


对象的先前声明有一个异常规范

根据标准,运算符 new 应该具有异常规范。 生成警告消息的代码示例:

#include <new>

// 正确的声明:
// void* operator new(size_t) throw(std::bad_alloc);

void * operator new (size_t); // 错误

消息标识:nothrownew


对象的先前声明有一个异常规范(警告)

该运算符以前有一个异常规范。调用该运算符时,将不会抛出异常。 生成警告消息的代码示例:

#include <stddef.h>
void* operator new[] (size_t); // 警告:原始运算符 new 抛出“std::bad_alloc”

消息标识:nothrowneww


对象的先前声明没有一个异常规范

(兼容模式)过时的 new 运算符不会使用异常规范。 生成错误消息的代码示例如下(仅限兼容模式):

#include <new.h>

void* operator new(size_t) throw(std::bad_alloc); // 错误:对运算符 new 而言,
// 禁止在兼容模式下使用
// 异常规范

消息标识:nothrowold


该条件标签不在 switch 语句中

条件标签只能在 switch 语句中使用。 生成错误消息的代码示例:

int main()
{
	int i = 7;

	case 7:		// 错误:case 语句不在 switch 语句中
		i++;
		break;

return 0;
}

消息标识:notinsw


该缺省标签不在 switch 语句中

缺省标签只能在 switch 语句中使用。 生成错误消息的代码示例:

int main()
{
	int i;

	default:
		i = 3;
return 0;
}		

消息标识:notinswdef


右边必须是成员指针

\".*\" 或 \"->*\" 右边使用的指针不是成员指针。

struct S {
	  int i;
};
     
void foo() 
{  
	int y;
	S cs;
	int S::* pm = &S::i;	// pm 引用的是成员 S::i
	cs.*pm = 88;	        // Ok
	cs.*y = 88;		// 错误:不是成员指针
					“.*”或“->*”的右边必须是成员指针

}

消息标识:notmembptr


只能调用生成的函数

只能调用从 .*-> 生成的函数,但无法获取其地址。 生成错误消息的代码示例:

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

void (A::* f_ptr) ();

int main() {
A a;
f_ptr = A::foo;
a.*f_ptr;       // 错误:只能调用函数。无效代码是
//        (a.*f_ptr)();
}

消息标识:notmembcall


不是名称空间或类名

用户尝试为非名称空间创建名称空间别名时,通常会产生该错误。 生成错误消息的代码示例:

struct not_a_namespace {};

int main() {
namespace alias=not_a_namespace; // 错误:尝试为结构创建别名
}

消息标识:notnamespace


以前已定义,但不是名称空间

标识符已被使用,所以无法重新定义为名称空间。 生成错误消息的代码示例:

int n;

namespace n {  // 错误
int i;
};

消息标识:notnsname


已定义但未使用

编译器已经找到代码中未使用的声明对象,且已经发出该警告。 生成警告消息的代码示例:

void foo() {
int i; // 未使用 i
}
void foobar( int a,	// 未使用 a
	     int b )	// 未使用 b
{}

消息标识:notused


未定义 type_info

如果要执行该操作,则必须包含文件 typeinfo.h,以便使用 type_info 类。否则,如果希望未来的程序可以将 typeinfo 类用于 RTTI 支持,建议选择其它名称。

消息标识:notypeinfoh


必须为类名,而不是名称空间的名称

using 声明应该使用是基类的类名。使用的名称已是名称空间。 生成错误消息的代码示例:

namespace NS {int j; }
//. . .

class A:NS {
	using NS::j;
};

消息标识:nsnotall


必须为名称空间的名称,而不是类名

using 指令应该使用名称空间的名称。使用的名称已是类类型的名称。

struct A{int j;};
void foo() 
{
	using A::j; // 错误:foo 中应该有名称空间。
}

消息标识:nsnotcl


未使用标签

编译器已经找到从未使用的标签,且已经发出该警告。 生成警告消息的代码示例:

void foo() {
int i = 0;
goto b:
a:
--i;
b:
++i;
};

消息标识:labelnotused


应该是类型名,而不是

应该是类型名,但未找到。导致该错误产生的情况有很多。 生成错误消息的代码示例:

class A:// 错误:缺少基类名
{};

struct B {
int i;
	j; // 错误:应该是类型名,而不是“j”
};


struct D :B, { // 错误:“,”之后应该是其它基类名
int j;
D() :{ j = 10; };
// 错误:应该是类型名,而不是“{”,缺少初始化程序
};


template <class T, class K>
class A {};

A<int, > a; // 错误:逗号后面缺少类型名

消息标识:notypenameerr


对于预定义的宏,#define 和 #undef 是不合法的

预定义的宏由编译器使用,所以不能被定义或取消定义。

消息标识:noundef


联合不能有基本类型

联合不能有基本类型。 生成错误消息的代码示例:

class C {
	int i;
};

union B:C { // 错误
	int j;
};

消息标识:nounionbase


联合不能用作基本类型

联合不能有基本类型。 生成错误消息的代码示例:

union C {
	int i;
};

union B:C { // 错误
	int j;
};

消息标识:nounionasbase


联合不能有虚拟函数

联合不能有虚拟函数。 生成错误消息的代码示例:

union A {
int i;
void foo() {};		// ok
	virtual void foobar() {};	// 错误
};

消息标识:nounionvirt


类型空 (void) 的值是不允许的

类型数据 void 不是值。 生成错误消息的代码示例:

foo()
{
int i = (void)1;
}

消息标识:novoidval


无法非关联化 void*

无法非关联化 void 指针。void 没有值。 生成消息的代码示例:

void *i;
int j = *i; // 错误:无法非关联化 void*

消息标识:novoidderef


应该是 while,而不是

do-while 循环中,do 块必须以 while 语句结尾。 生成错误消息的代码示例:

void foo() 
{
	int i = 0;
	int j = 7;
	do {
	i++;
	}  // 错误:应该是“while”,而不是“}”

	i = 0;
	do {
	i++;
	} while ( i < j); // ok
}

消息标识:nowhileerr


在类中不能有 using 指令

不能在类中使用 Using 指令。 生成错误消息的代码示例:

namespace NS { int j; };

class A {
using namespace NS;
};

消息标识:nsdirinclass


初始化为空 (NULL) 值

引用初始化表达式的值为零。 生成错误消息的代码示例:

static int zero;
int& c = *(int*)0;  // 警告:引用初始化的值为零

消息标识:nullref


没有基类或成员名用于初始化程序

不使用类名或成员名称的基类初始化当前已经过时。 生成错误消息的代码示例:

struct A {
int i;
	A(int);
};

struct B:A {
int j;
B() :(3) { // 错误
	   	j = 7; 
	};
};

消息标识:obsinit


其它对象不能在函数定义中声明

函数定义不能声明其它对象。只有类定义才能声明其它对象。同时声明函数和对象时,将不会触发该错误,除非该函数以其它对象的声明结尾。 生成错误消息的代码示例:

int	i, 
	foo() { // 错误:此处无法声明函数。
		return 0;
	} int j; 

消息标识:onlyonefunc


整型溢出或除以零

表达式已经溢出 int 的大小,或数字已被零除。

消息标识:overflow


编译器内存不足

该编译器内存不足。释放一些资源,然后再试。

消息标识:outofmem


部分加括号的初始化

使用“+w2”标记进行编译时,如果不使用括号初始化结构成员,将会生成警告。 生成错误消息的代码示例:

struct B {
int i;
int j;
} X[] = { 1, 2, 3, 4 };

消息标识:partinit


先前没有 #if 与该指令相对应

#else 指令之前必须有一个与之对应的 #if 指令。 生成错误消息的代码示例:

//#if true
#define num 1
#else num 0
// . . .

消息标识:ppbadelse


先前没有 #if 与该 #endif 相对应

预处理程序指令 #endif 必须有一个与之对应的 #if

消息标识:ppbadendif


该行有多余的文本

预处理程序命令之后的文本多余。 生成错误消息的代码示例:

#include <file.h>; // 错误:删除多余的“;”

消息标识:ppextra


ANSI C 不允许该行有多余的文本 - 忽略

该行中的多余文本已在 ANSI C 忽略。

消息标识:ppextraw


用作后缀运算符

仅声明了前缀增减运算符。使用之前,还必须声明后缀运算符。 生成错误消息的代码示例:

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

int main()
{
	A a;
	a++; // 错误:重载后缀运算符 ++,以便进行更正
}

消息标识:postincdec


在函数原型中使用之前先声明

应该在函数原型中使用之前声明结构和枚举类型。如果对编译器进行设置,使其在 C 模式下编译,将会显示该消息。

消息标识:protodec


无法为抽象类创建变量

一个或多个纯虚拟函数的抽象类只能用作基类。无法直接创建抽象类的实例。必须创建派生类的对象。 生成错误消息的代码示例:

class A {
virtual void foo() = 0;
virtual int bar() = 0;
};

A a; // 错误

消息标识:purealloc


无法声明抽象类型的成员

抽象类型不能用作成员。如果该成员是派生类,确保该类已经在基类中定义所有的纯虚拟函数。 生成错误消息的代码示例:

class B { 
virtual void foo() = 0;
};

class X { B b; }; // 错误:B 是抽象类型

template < class T >
class Y {};
Y<B> y; // 错误

消息标识:puremem


无法获取抽象类的参数

参数不能是抽象类型。

消息标识:pureparm


无法返回抽象类的值

返回类型说明不能是抽象类。抽象类尚未实现,所以无法予以使用。如果返回说明是派生类,确保该类已经在基类中定义所有的纯虚拟函数。 生成错误消息的代码示例:

class B {
virtual B foo(B) = 0; // 错误:foo(B) 返回抽象类型
};

class A:B {};

A bar() { // 错误
A* a;
return *a;
}

消息标识:purert


无法创建抽象类的值

无法从抽象类创建值。 生成错误消息的代码示例:

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

class B :public A {
public:
virtual int foo () { return 0; };
};

int main() {
B * b = new B();
A& a = (A) *b;  // 错误:A 是抽象类
}

消息标识:pureval


尚未被覆盖

覆盖基类的纯虚拟函数之前,已经实例化抽象类的派生类变量。 生成错误消息的代码示例:

class B {
virtual void foo() = 0;
};

class A:B {};

A a; // 错误

消息标识:puref


不能有类型限定符

要指定不同的作用域,就不能使用类型限定符声明成员。

class A {
};

class B {
void A::foo(); // 错误:不能使用类型限定符
void B::goo(); // 确定。goo() 已在类 B 中声明
};

消息标识:qualnotok


在参数列表中只允许存储类为寄存器

参数列表中只允许有存储类 register。不允许有 staticexternmutable。 生成错误消息的代码示例:

class A {
void foo( register int a,// ok
	    mutable int b, // 错误
	    extern c,      // 错误
	    static int d,  // 错误
	    auto int e )   // ok
    {}
};

消息标识:registeronly


匿名联合成员与其包含类使用相同的名称

匿名联合成员与其包含类的名称不能相同。 生成错误消息的代码示例:

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

消息标识:sameanon


枚举器与其包含类使用相同的名称

枚举器与其包含类的名称不能相同。 生成错误消息的代码示例:

class A {
enum e { A, B, C }; // 错误
};

消息标识:sameenum


静态成员与其包含类使用相同的名称

静态成员与其包含类的名称不能相同 生成错误消息的代码示例:

class A {
	static int A;
};

消息标识:samestatic


类型与其包含类使用相同的名称

不能在相同名称的类中定义类型。 生成错误消息的代码示例:

class A {
typedef struct { int a; } A; // 错误:类 A 和 typedef A 具有相同名称
};

消息标识:sametype


需要一个标量类型的表达式

表达式必须是标量类型。 生成错误消息的代码示例:

class A {
public:
A() { i = 0; }
int i;
A foo() { return *this; }
};

void foo() {
A a;
if( a ){ // 错误:应该是标量类型,而不是类型 A
  }

for( a.i;
a;    // 错误
a.i++) {}
}

消息标识:scalarexpected


sizeof 不可以应用于位字段

sizeof 不能应用于位字段。 生成错误消息的代码示例:

class A {
public:
A() { size = sizeof(i); }
int i:3;
int size;
};

消息标识:sizeofbf


sizeof 不可以应用于函数

sizeof 不能应用于函数。它只能应用于主类型、类对象和表达式。 生成错误消息的代码示例:

int i;
int j;
int foo(int k);
int goo();
	
k = sizeof (i*j*foo(10));	 // ok
k = sizeof (unsigned int);	 // ok

k = sizeof(foo);		 // 错误
k = sizeof(goo);		 // 错误

消息标识:sizeoffunc


不能同时具有静态和非静态版本

重载函数不能同时具有静态和非静态这两种版本。 生成错误消息的代码示例:

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

消息标识:statnonconf


此处不允许使用说明符

语法错误。此处不允许使用说明符。 生成错误消息的代码示例:

inline class A{}; // 错误
virtual void foo(); // 错误

void foo() {
virtual  void f1(); // 错误
friend void f2(); // 错误
explicit void f3(); // 错误
};
void foo() {}

消息标识:storenotok


是不允许的,并且正在被忽略

说明符不允许在此处使用,所以被编译器忽略。如果尝试对模板执行 typedef 操作,也会发出该消息。 生成警告消息的代码示例:

template <class T> static class A; // 警告:“static”不允许,所以被忽略

消息标识:storenotokw


浮点减法运算存在溢出,转交运行时处理

编译器已经确定,浮点数字减法运算溢出,交由运行时处理。

消息标识:subfovfl


该条件忽视局部变量的初始化

局部变量被忽视,所以无法进行初始化。 生成错误消息的代码示例:

void foo() 
{
int i=7;
switch(i) {
case 7:
break;
int j = 2;
default:// 该 case 忽视局部变量 j 的初始化
i = 8;
        }
}

消息标识:swuninit


模板参数需要类型参数

为该模板参数提供的类型无效,或未提供参数。 生成错误消息的代码示例:

template <class T, class K>
class B {
public:
T t;
K k;
};

B<int> b1; // 错误:B<T,K> 需要其它模板参数
B<int, 12345> b2; // 错误:12345 无效

消息标识:temargnotype


模板参数需要类型的表达式

表达式与模板参数的类型不匹配。更多//没有对对象类型引用的非类型模板参数应用转换。 生成错误消息的代码示例:

template <int i> class A {int i;};
;

A<3.141593> a1; // 错误:参数不是 int
A<3> a2; // ok



template<class T, char* p> class D { 
	D();
D(const char* q);
};

D<int,"penny"> x1; //  错误:字符串文字作为模板参数

char p[] = "dime";
D<int,p> x2;       //  OK

消息标识:temargnoval


空指针转换无法应用于模板参数

已经将错误类型的实际参数作为模板参数进行传递。通常,这意味着,NULL 指针已经作为指针类型的模板参数加以传递,进而会产生错误,因为不能对模板参数应用 NULL 指针转换。 生成错误消息的代码示例:

template <char * i> class A {};

int main() {
A<0> a;
}

消息标识:tempargnullptr


函数模板不能有缺省模板参数

类模板和类成员函数只能使用缺省的模板参数。 生成错误消息的代码示例:

template <class T=int>
T foo();

消息标识:temdefparms


非类型模板参数不允许用于函数模板

非类型模板参数不允许用于非成员函数。 生成错误消息的代码示例:

template <int x>
int foo();

消息标识:temfuncnontype


模板中参数太多,被忽略

模板的参数太多。

消息标识:temmanyargs


模板只能声明类或函数

只能将模板用于类和函数。 生成错误消息的代码示例:

template < class T >
int i;

消息标识:tempnotfunc


模板只能在全局级别声明

模板只能在全局级别声明。 生成错误消息的代码示例:

 
void foo() {
int i;
template <class T> class B { int j; }; // 错误
};

消息标识:temnotglob


模板嵌套太深(递归?)

模板的嵌套深度只能有 20 层。

消息标识:temtoodeep


不允许使用限定符

无法限定成员。

消息标识:tdefqual


异常规范包含两个相同的对象类型

异常规范包含两个相同的对象类型。 生成警告消息的代码示例:

void foo() throw(float i, float j);

消息标识:tltwice


不在当前的异常规范中

异常规范已经通过声明发生更改。异常规范必须匹配。 生成错误消息的代码示例:

void foo() throw(int i);

// . . .

void foo() throw(float i ) {} // 错误

消息标识:tnotinnew


不在以前的异常规范中

以前的异常规范不包含当前的参数类型。异常规范必须匹配。 生成错误消息的代码示例:

void foo() throw();

// . . .

void foo() throw(float i ) {} // 错误

消息标识:tnotinold


调用的参数太少

调用函数时使用的参数比声明函数时使用的参数少。 生成错误消息的代码示例:

void foo( int i, int j ) {}

int main()
{
foo(1); //错误:调用 foo() 时所用的参数不足
return 0;
}

消息标识:toofewargs


宏中的参数太少

调用宏时使用的参数比定义宏时使用的参数少。 生成警告消息的代码示例:

#define mask             0xffff00
#define getField(data, mask)  data & mask // 定义宏时使用 2 个参数

int field = getField( 1 ); // 错误:调用宏时使用 1 个参数

消息标识:toofewmargs


模板的参数太少

模板使用的参数比提供的参数多。 生成错误消息的代码示例:

template <class A1, class A2> class B {};

int main() {
B<int> b;
}

消息标识:toofewtargs


调用时使用的参数太多

调用函数时使用的参数比声明函数时使用的参数多。 生成警告消息的代码示例:

void foo( int i, int j ) {}

int main()
{
	foo( 1, 2, 3 )
return 0;
}

消息标识:toomanyargs


转换时使用的参数太多

遇到语法错误,传递给转换表达式的参数太多。 生成错误消息的代码示例:

class A {
public:
operator long ();
};

int main() {
long t = long(A(), 0); // 错误:转换为 long 时所用的参数太多
// 应该是:
// long t = long(A());
}

消息标识:toomanycargs


宏中的参数太多

调用宏时使用的参数比该宏定义的参数多。 生成错误消息的代码示例:

#define mask             0xff0000
#define getField(data,mask)  data & mask   // 使用 2 个参数定义宏

int field = getField( 1, 2, mask ); // 调用宏时使用 3 个参数

消息标识:toomanymargs


初始化程序太多

构造函数的初始化出现只能有一个参数。 生成错误消息的代码示例:

class A {
int i;
A():i(1,2) {}
};

消息标识:toomanynargs


模板参数太多

模板的参数太多。 生成错误消息的代码示例:

template< class T, class K > // 2 个模板参数
class A {
T t;
K k;
};

A<int, float, long> a; // 错误:3 个模板参数

消息标识:toomanytargs


只能将访问更改为公共的 (public) 或受保护的 (protected)

无法将类成员的访问级别更改为专用 (private)。只能将访问更改为公共的 (public) 或受保护的 (protected)。 生成错误的代码示例:

class A {
public:int i;
};

class B :A {
private:A::i;
};

消息标识:topubliconly


初始化两次

值已初始化两次。 生成错误消息的代码示例:

class A {
public:
static const int j = 9;
A() {}
};
const int A::j = 9; // A::j 已初始化两次

消息标识:twoinits


太复杂

表达式太复杂。 生成错误消息的代码示例:

void foo() {
int **************************i;
**************************i = 9; // 错误:太复杂,26 个“*”
}

消息标识:twtoocomp


遇到未预料到的类型名称

使用函数或类之前,尚未定义类型名称。 生成错误消息的代码示例:

template<class T>
class A {
	T t;
};

class B{
	int i;
};

int main() {
	A<float> a; // ok
	B<int> b; // 错误:未定义类型 B 的模板
}

消息标识:typenotall


变量尚未赋值

已经使用尚未赋值的变量。 生成警告消息的代码示例:

void foo() 
{
	int i;
	i++;
}

消息标识:unassigned


未定义

标识符已经使用,但尚未定义。 生成错误消息的代码示例:

void foo() 
{
int i;
j++; // 错误:未定义 j
}

消息标识:undefidenterr


未定义模板

将其用作模板类型参数之前,必须定义模板 生成错误消息的代码示例:

template <t_arg<int> > struct tmp {};   // 错误:未定义 t_arg

消息标识:undeftemperr


比较结果未使用

比较结果未使用。 生成警告消息的代码示例:

void foo() 
{
int i = 9;
i == 9; // 警告:结果未使用
	i++;
}

消息标识:unusedcomp


构造函数不能是虚拟的

不允许使用虚拟的构造函数。 生成错误消息的代码示例:

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

消息标识:virtconstr


虚拟友元函数需要合格的类名

虚拟友元函数需要限定类名。 生成错误消息的代码示例:

void foo() { return; }
void goo() { return; }

class A {
virtual friend void foo();    // 错误
	virtual friend void A::goo(); // ok
};

消息标识:virtfriend


应该返回一个值

函数应该返回一个值,但返回的是 void。 生成错误消息的代码示例:

int foo() 
{
	return; // 错误:返回类型应该是 int
}

消息标识:voidret


& 符号运算符只能应用于变量或其它左值

只能对变量或左值应用运算符的地址。要获取的地址必须存在。 生成错误消息的代码示例:

int *i = &3; // 错误:“3”不是左值

消息标识:wantvarname


ANSI C 要求位字段应该为有符号或无符号的整型

ANSI C 只支持带符号或无符号的 int 位字段。

消息标识:wbadbftype


以前尚未声明

运算符 new 或 delete 应该具有不同的链接。 生成警告消息的代码示例:

#include <new>

// 警告:new 应该是静态的(它已经声明为 extern)。
static void* operator new(size_t) throw(std::bad_alloc);

消息标识:wbadlinkage


空的声明(可能有多余的分号)

声明为空。最有可能的原因是有多余的分号。 生成错误消息的代码示例:

; // 警告:无声明

namespace NS{}; // 警告:名称空间 NS 在结尾处的分号多余

}; // 错误:右括号不匹配

消息标识:wemptydecl


声明没有指定标记或标识符

(Kernigan and Ritchie):声明中必须有标记或标识符。 生成错误消息的代码示例:

struct {};  // 错误

消息标识:wnothingdecl


赋值

将类型赋值给不兼容的类型。类对象类型可能需要构造函数、转换函数或重载赋值运算符。 生成警告消息的代码示例:

class B{
	int i;
};

class A:B {
	int j;
	
};

void foo() 
{
	A a;
	B b;	
	a = b; // 错误
	b = (B)a; // 错误:对类型 B 而言,A 中没有构造函数或转换函数。
	
	A *pa = &a;
	B *pb;
	pb = (B*)pa; // ok,pa* 已转换为指向基类的指针
}

消息标识:wbadasg


字符串文字在赋值中转换为 char*

赋值时,字符串文字已转换为 char*。 生成警告消息的代码示例:

void foo() {
char *s;
s  = "abcd"; // 警告
}

消息标识:wbadasgl


用来初始化

使用不同类型初始化类型时会发出警告。

消息标识:wbadinit


用来初始化 L

已经使用字符串文字初始化不同的兼容类型。

void foo() 
{
char * s = "f"; // 警告:使用常量 char* 初始化 E
}

消息标识:wbadinitl


应该返回一个值

(Kernigan and Ritchie):声明函数返回一个值,但没有返回。 生成错误消息的代码示例:

int foo() 
{ 
	return; // 错误:foo() 应该返回一个值
}

消息标识:wvoidret


隐藏

函数中的变量会隐藏类成员名称。 生成警告消息的代码示例:

class A {
int i;

void foo() {
int i; // 警告:i 会隐藏 A::i
        }
};

消息标识:wvarhidemem


在外部作用域隐藏相同名称

变量会在外部作用域隐藏变量名称。 生成警告消息的代码示例:

void foo() {
int i;
for ( int i = 0; // 警告:i 会在外部作用域隐藏变量。
	i < 10;
	++i ){};
}

消息标识:wvarhidenmem


在 #pragma init/fini 中,应该为没有参数的空函数

只能将没有参数的空函数作为参数传递给 init 或 fini pragma。 生成错误消息的代码示例:

void my_fini (int a) { }
#pragma fini(my_fini)

消息标识:prbadfunc


#pragma 中的列表为空

一些 pragma 要求至少传递一个参数。 生成错误消息的代码示例:

#pragma fini ()

消息标识:premptylist


对齐无效,有效值是: 1,2,4,8,16,32,64,128

对齐值必须是幂为 2 的非负整数,但其最大值必须为 128。 生成错误消息的代码示例:

#pragma align 256 ( an_int, a_ptr, a_struct, a_class )

消息标识:prbadalign


没有声明为函数

一些 pragma 要求其参数是函数。 生成错误消息的代码示例:

int my_fini;
#pragma fini(my_fini)   // 错误:my_fini 不是函数

消息标识:prnotfunc


在 #pragma 中引用的对象应该为全局的,并且已预先声明

如果函数在任何 pragma 参数列表中显示,则首先应该声明函数。 生成错误消息的代码示例:

#pragma fini(my_fini)   // 错误:应该首先声明 my_fini
void my_fini (int a) { }

消息标识:prnotdecl


pragma 中语法错误

Pragma 语句不正确。最有可能的是,忽视了必需的 pragma 参数。 生成错误消息的代码示例:

int a, b, c;
#pragma align (a, b, c)

消息标识:prsyntax


在 #pragma ident 之后需要字符串文字

#pragma ident 之后缺少字符串文字。

消息标识:prnostr


在 #pragma 列表中缺少","

用作 pragma 参数的分隔符的符号错误。 生成错误消息的代码示例:

void my_init1 () { }
void my_init2 () { }
void my_init3 () { }

#pragma init(my_init1,my_init2.my_init3)

消息标识:prnocomma


在 #pragma 中缺少"("

Pragma 参数列表应该以‘(’开头。 生成错误消息的代码示例:

void my_init1 () { }

#pragma init my_init1)

消息标识:prnolp


在 #pragma 中缺少")"

参数列表中缺少‘)’或符号错误。 生成错误消息的代码示例:

void my_init1 () { }
void my_init2 () { }
void my_init3 () { }

#pragma init(my_init1,my_init2.my_init3)

消息标识:prnorp


编译器使用该消息显示包含错误消息的行号。

消息标识:linetheword


Asm 语句没有字符串

asm 语句中必须包含字符串文字。 生成错误消息的代码示例:

void foo() 
{
asm( nop ); // 错误
}

消息标识:noasmstring


Asm 语句不允许出现在函数之外

asm 语句不允许在函数之外使用。 生成错误消息的代码示例:

asm(" nop  "); // 错误

void foo() 
{
asm(" nop "); // ok
}

消息标识:asmnotinfunc


标记需要值

指定的标记需要值。

消息标识:cmd_needvalue


警告:该标记不能与此标记一起使用

不能同时指定某些 CC 标记(例如,+e0 和 -compat=5)。

消息标识:cmd_badflag


没有输入文件

未传递输入文件时,ccfe 会发出该错误。

消息标识:noinpfile


无法打开输入文件

缺少或无法访问传递到编译器的文件,所以无法将其打开。

消息标识:openinpfile


无法打开输出文件

预处理程序无法打开输出文件。请检查文件权限和/或可用的磁盘空间。

消息标识:openoutfile


文件的最后一行没有用新行终止

该警告指出,文件没有以新行的字符结尾。

消息标识:nonewline


"mutable"不允许在类之外

不能在类之外使用关键字 mutable。使用 mutable,可以对声明为 const 的类对象中的字段进行修改。 生成错误消息的代码示例:

void foo() 
{
	mutable int i = 0; // 错误
}

class A {
	mutable int i; //ok
};

消息标识:mutclassonly


函数不能声明为 mutable

mutable 只能供成员数据使用。 生成错误消息的代码示例:

class A {
public: 
mutable int i; //ok
mutable void foo() {} // 错误
A() {}
};

消息标识:mutnofunc


常量名不能声明为 mutable

const 名称也不能声明为 mutable。 生成错误消息的代码示例:

class A {
public:
A(int j) { i = j; }; 
mutable const int i; // 错误
};

消息标识:mutnoconst


只有非静态数据成员可以是 mutable

静态数据成员不能是 mutable。 生成错误消息的代码示例:

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

消息标识:mutdatamems


必须使用 C++ 声明

必须使用 C++ 语言声明重载运算符

class A {};
extern "C" A& operator *(A&, A&);

消息标识:mustbecpp


友元声明中不允许有完整的类定义

不能在友元声明中指定类定义。 生成错误消息的代码示例:

class A {
friend class B {}; // 错误:友元声明中有类定义
};

消息标识:nofrienddef


之前未找到冒号

冒号之前没有类成员访问级别的说明。此处,冒号之后必须跟 Private、protected 和 public。 生成错误消息的代码示例:

class A {
public	// 错误:“:”之前没有 public
int i;
};

消息标识:nocolaftacc


在宏参数中遇到文件尾

在宏参数的结尾处发现文件尾。

#define foo( A, B, C )
foo(1, 2,     // 错误:缺少参数。
<EOF>

消息标识:eofinmargs


C++ 不支持隐式的 int

C++ 不支持使用隐式 int 声明的变量。应该指定该类型。 生成警告消息的代码示例:

i[] = {1, 2, 3};

消息标识:noimplint


之前应该有类或结构

模板声明中应该有类关键字。如果函数模板声明不正确,似乎是类模板声明,也会产生该错误。 生成错误消息的代码示例:

template <class T> A // 错误:缺少类关键字
{	
int i;
int j;  
};

template <class T> foo :/* . . . */ ; // 错误

消息标识:noclasskey


局部类型无法用作模板参数

局部定义的类型无法用作模板参数。 生成错误消息的代码示例:

template < class T >
class A {};

void foo() 
{
	class B {};
	enum E {one, two, three};
	A<B> a1; // 错误
	A<E> a2; // 错误
}

消息标识:nolocaltarg


模板参数不能是未命名的类型。

模板参数不能是未命名的类型。与此同时,也不能在模板参数中定义类型。 生成错误消息的代码示例:

template < class T >
class A {
T t;
};

A<class{}> a;	// 错误:结构没有类型名称。
		// 要使用用户定义的类型,请在使用前先定义该类型。

消息标识:nounnamedtarg


初始化程序列表中出现意外

分析构造函数的初始化列表时,已经检测到语法错误。 生成错误消息的代码示例:

class A {
int a;
long b;
int c[2];

A() :a(0) :b(0) {}    // 错误:初始化列表中出现意外的“:”
};

消息标识:unexpinitl


错误类文件格式,终止的代码

这是 Java 本地编译器使用的内部消息

消息标识:jdeadcode


找不到文件

这是 Java 本地编译器使用的内部消息

消息标识:jnoclass


找不到定义

这是 Java 本地编译器使用的内部消息

消息标识:jnomember


错误类文件格式,常量池入口

这是 Java 本地编译器使用的内部消息

消息标识:jbadcpool


错误类文件格式,类型代码

这是 Java 本地编译器使用的内部消息

消息标识:jbadtcode


错误类文件格式,非法字节代码

这是 Java 本地编译器使用的内部消息

消息标识:jbadbcode


导出忽略 -- 尚未执行

已经忽略导出。尚未执行该导出。

消息标识:exportnotimpl


模板关键字丢失

在模板声明中,在“<”之前找不到关键字 template。 生成错误消息的代码示例:

export <class T>  // 错误
class A {};

消息标识:notemplkey


旧的显式专门化语法

找到过时的显式专门化语法之后,已经发出该警告。 新的显式专门化语法如下: template-id:template-name < template-argument-listopt > template-name:identifier template-argument-list:template-argument template-argument-list , template-argument template-argument:assignment-expression type-id id-expression

消息标识:oldexpspecial


显式的非类、非函数的实例/专门化还未执行

尚未在该编译器中执行显式的非类、非函数实例化/专门化。

消息标识:noexpimpl


使用操作符 -> 无限递归

类已经重载“->”运算符。该运算符返回一个类类型的值。 生成错误消息的代码示例:

class A {
public:
int j;
A operator->(); // 返回 A
};

void foo() {
A a;      
a->j = 9; // 错误
};

消息标识:recurarrow


重载运算符应该返回指针

重载运算符 -> 应该返回执行类类型对象的指针。 生成错误消息的代码示例:

class B{
public:
int j;
B operator->(); // 返回 B
B& operator->();
};

void foo() {
B b;      
b->j = 7; // 错误:具有二义性,运算符 ->() 返回 B
};

消息标识:recurarrow2


可疑的返回类型

重载“->”运算符应该返回指向类类型对象的指针。 生成警告消息的代码示例:

class A {
public:
int* operator->(); // 警告 A:: 运算符 ->() 返回 int*
int k;
};

消息标识:arrowrtn


无法转换

尚未定义函数指针和对象指针之间的转换结果,但是,如果使用 Solaris,将会丢失信息。

消息标识:badcastw


类中的匿名联合不能是

类中的匿名联合不能包含一些说明符,如 extern、static 和 the like。 生成错误消息的代码示例:

class A {
static union {  // 错误:匿名联合不能是静态的
int a;
long b;
    };
};

消息标识:badclanon


名称空间无法在类作用域中声明

不允许在类中声明名称空间 生成错误消息的代码示例:

class A {
namespace ns {} // 错误:在类作用域中声明名称空间
};

消息标识:noclassns


不能在该作用域内重新声明模板参数

模板参数在该作用域内不能重新声明。最有可能的是,已经在模板作用域的声明中使用模板参数的名称。 生成错误消息的代码示例:

template <class t_arg> class A {
int t_arg;      // 错误:重新声明模板参数 t_arg
};

int main() {
A<int> a;
}

消息标识:templparamdecl


模板参数不能在创建的类型说明符中使用

禁止在创建的类型说明符中使用模板参数。 生成错误消息的代码示例:

template <class t_arg> class A {
class t_arg {};     // 错误:在创建的类型说明符中使用模板参数 t_arg
};

int main() {
A<int> a;
}

消息标识:templtypedecl


已创建类型说明符的非法语法

遇到语法错误。 生成错误消息的代码示例:

template <class t_arg> class A {};

typedef class A<int> my_type;   // 错误:语法非法 ...

消息标识:badelabtype


pragma 包的值必须为二的幂

pragma 包的有效值必须为二的幂。 生成错误消息的代码示例:

#pragma pack (3)

消息标识:prbadpack


模板声明无法有外部"C"链接

无法使用外部的 C 链接声明模板。 生成错误消息的代码示例:

extern "C" 
template <class t_arg> class A {}; // 错误:模板声明不能包含该链接

消息标识:temnotexternc


由模板参数限定的类型名要求"typename"

模板参数限定类型名称时,需要 typename 关键字 生成错误消息的代码示例:

class A {
public:
typedef int my_type;
};

template <class t_arg> class B {
public:
typedef t_arg::my_type my_type; // 警告
};

int main() {
B<A>::my_type c;
}

消息标识:typenameass


转换不明确

转换不明确。 生成错误消息的代码示例:

class A {};

class B :public A {};
class C :public A {};

class D:public B, public C {};

int main() {
D *d = new D;
A *a = (A*) d; // 错误:D 包含两个 A 实例
}

消息标识:ambigcast


不允许模板的友元声明

如果没有专门化,则无法将模板作为友元进行声明。 生成错误消息的代码示例:

template <class t_arg> class A {};

class B{
friend class A; // 错误:友元模板声明。应该是:
// 友元类 A<int>;
};

消息标识:nofriendtmpl


"friend"声明与函数模板不兼容

不能将模板函数作为友元进行声明。 生成错误消息的代码示例:

template<class t_arg> int foo () { return t_arg; }

class A {
friend int foo<int>(); // 错误:模板函数不能是友元
};

消息标识:nofunctmpl


全局作用域没有声明

在全局作用域中尚未找到声明为友元的函数。 生成错误消息的代码示例:

class A {
friend int ::foo ();    // 错误:没有在全局作用域中声明 foo
};

消息标识:noglobaldecl


警告:该标记不能与此标记一起使用

不能同时指定某些 CC 标记(例如,+e0 和 -compat=)。

消息标识:cmd_badflag_wrn


错误:该标记不能与此标记一起使用

不能同时指定某些 CC 标记(例如,-memtmpl 和 -compat=5)。

消息标识:cmd_badflag_err


无法具有指向位字段的非常量引用

指向位字段的引用不是常量 生成错误消息的代码示例:

struct C {
int x : 2 ;
};
 
C oc; 
int & xref = oc.x;   // 错误:xref 是非常量引用

消息标识:varbitref


无法为读取预先实例化的符号而打开库

无法打开选项 -preinstlib=<file-name> 指定的文件。

消息标识:openinstlib


无法从预先实例化的库中读取符号

无法从选项 -preinstlib=<file-name> 指定的文件中读取符号。

消息标识:readinstlib


不能使用模板类型参数声明成员函数

已尝试使用函数类型模板参数声明成员函数。 生成错误消息的代码示例:

template <class T> struct X { T t; };
 
typedef int F();
X < F > m1; // 错误:无法将‘t’声明为 int t()

消息标识:badtmplfunctyp


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

非类型的模板参数和非模板的模板参数不能具有指定的类型。有关详细信息,请参见 ISO C++ Standard 14.3.2。 生成错误消息的代码示例:

template<class T, int I> class X { };

X<int, 2.7> x;

消息标识:badtmplexparg


字符串文字不是可接受的模板参数

字符串文字 (lex.string) 不是可接受的模板参数,因为字符串文字是包含内部链接的对象。有关详细信息,请参见 ISO C++ Standard 14.3.2。 生成错误消息的代码示例:

template<class T, char* p> class X { };
 
X<int,"String"> x;

消息标识:tmplexpstrlit


数组元素的地址不是可接受的模板参数

数组元素和名称的地址或非静态类成员的地址不是可接受的模板参数。有关详细信息,请参见 ISO C++ Standard 14.3.2。 生成错误消息的代码示例:

template<int* p> class X { };
 
int a[10];
  
X<&a[2]> x;

消息标识:tmplexpaddarr


部分专门化不明确

用户指定与多个部分专门化匹配的实际模板参数列表。 生成错误消息的代码示例:

template<class T1, class T2, int I> class A             { };

template<class T1, class T2, int I> class A<T1*, T2, I> { }; // #1
template<class T1, class T2, int I> class A<T1, T2*, I> { }; // #2

A<int*, int*, 2> a5; // 不明确:与 #1 和 #2 匹配

消息标识:ambigpartial


没有部分专门化的主专门化

部分专门化之前,没有主专门化。用户始终应该提供主专门化,以便声明或定义部分专门化。 生成错误消息的代码示例:

template<class T>            class A<T, T*>   { };
 
template<class T1, class T2> class A          { };

消息标识:psnoprimary


部分专门化不能有缺省参数

专门化的模板参数列表不能包含缺省的模板参数值。原因是没有使用这些值的方法。 生成错误消息的代码示例:

template<class T1, class T2> class A          { };
template<class T = int>                  class A<T, T*>   { };   

消息标识:psdefaults


非类型参数不能用作表达式的一部分

非类型参数 %1 不能用作表达式的一部分。 生成错误消息的代码示例:

template<class T, int p, int c> class X { };
 
template<class T, int p > class X<T, p, p + 5> { };

消息标识:psntinexpr


部分专门化包含相同的参数

部分专门化不应该包含与主专门化相同的参数,因为无法使用这种构造。 生成错误消息的代码示例:

template<class T1, class T2> class A          { };
template<class T1, class T2 > class A<T1, T2>   { };

消息标识:pssameargs


专用参数的类型由另一个参数决定。

与专用的非类型参数对应的模板参数类型与专门化的参数无关。 生成错误消息的代码示例:

template< int X, int (*array_ptr)[X] > class A {};
 
int array[5];
  
template< int X > class A<X,&array> {};

消息标识:psargdeptype


参数中未使用部分专门化参数

用户提供一个或多个部分专门化参数,且不会在自身的专门化中使用这些参数。 生成错误消息的代码示例:

template<class T1, class T2> class A          { };
template<class T, class T2>  class A<T, T*>      { };   

消息标识:psargnotused


部分专门化没有执行

用户显式关闭部分专门化时,将会发出该消息。 生成错误消息的代码示例如下(仅限兼容模式):

template<class T1, class T2> class A          { };
template<class T>            class A<T, T*>   { };

消息标识:psnotimp


无法在 using 声明中使用特定的标识符

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

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

class D:public B
{
public:
using B::~B; // 错误 - using 无法引用析构函数
D() :j(0) { }
int j;
};
 
int main()
{
return 0;
}

消息标识:usingdestr


tdb_version 模板数据库与该编译器不兼容

编译器遇到与该编译器不兼容的 SunWS_cache 目录。早期的编译器遇到更新的编译器生成的模板数据库时,将会产生该错误。 使用更新的编译器编译源,或者使用 CCadmin -d -clean 清除该模板数据库。

消息标识:tdb_version


重复的 -I- 选项,忽略

在命令行找到的 -I- 选项不止一个。

消息标识:duplicate_i


badexplctinst 无法找到模板,与从显式实例化推导出的类型匹配

生成错误消息的代码示例如下:

template < class T > void copy ( T to ) { }
 
template int copy ( long ) ;    // 错误!

消息标识:badexplctinst


samemem 类成员与其类的名称相同

生成错误消息的代码示例如下:

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

消息标识:samemem


badenumsize 获取不完整枚举的成员大小

声明所有 sizeof 运算符的枚举器之前,不能对枚举类型应用该运算符。 生成错误消息的代码示例如下:

int mymain()
{
enum E { A, B = sizeof A }; // 错误 - 还无法应用 sizeof A
return 0;
}

消息标识:badenumsize


将指针 badarrptr 赋值给不兼容的数组类型

C++ 中,将指针赋值给完整或不完整的数组类型是错误的,反之亦然。 生成错误消息的代码示例如下:

extern int a_39W73zz[2];   // 大小既知
int (*p2)[] = &a_39W73zz;  // 错误 - 类型不匹配,对于 `p2`,大小未知。

消息标识:badarrptr


具有不完整返回类型 \"%2\" 的函数 \"%1\",编译程序无法在这种情况下生成虚拟表

如果虚拟函数的返回类型是没有定义的结构类型,且拒绝代码,则编译器无法处理这种情况。 生成错误消息的代码示例如下:

struct Fum; // 类型不完整
struct B {
Fum virtual f();
};
struct D :virtual B {
D();
};
D::D() { }

消息标识:incompletert


无法更改访问

无法通过这种方法对成员的访问进行更改。这是兼容模式下的警告,是标准模式下的错误。 生成错误消息的代码示例:

class C {
private:
class inner;
public:
class inner { }; // 使用其它访问重新声明
};

消息标识:badaccadjw


重载不明确

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

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

int main()
{
	foo (1, 2);                   //  ok:call  f(int, int)
foo ();                       //  错误:call f(int,int)  or  f()?
}
使用构造函数和转换运算符时,也会产生二义性问题:
struct A { A(int); };
struct B {
	B(int);
	operator int();
	operator double();
} b;

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

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

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

消息标识:manymatchover_w


无法访问

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

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

void foo() {
A a;      
a.i = 9; // 错误:错误:无法通过 foo() 调用 i
}


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

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

消息标识:inaccessible_w


忽略多余的 \";\"

在字段声明的结尾处检测到多余的分号 生成警告消息的代码示例:

struct S {
int ii;;
void f();;
};

消息标识:fieldsemicolonw


无法获取临时的地址

无法获取生成临时函数的编译器地址。 生成警告消息的代码示例:

struct C { C(int); };
void add( C *c );
void foo() { add( &C(6) ); }

消息标识:addressoftemp


在友元声明中不允许有存储类

生成警告消息的代码示例:

struct A {
friend static void foo(A arg);
};

消息标识:storeclassfriend


枚举名称 %1 作为作用域限定符

生成警告消息的代码示例:

class C {
C::C();
enum E { a, b } e;
};
C::C() {
switch(e) {
case E::a:// <-- 此处出错
break;
	    }
}

消息标识:enumasscope


语句无法执行

从未执行语句。 生成错误消息的代码示例:

int foo(int x) {
if ( x > 0 )
	return 1;
else
	return 2;
return 3;	// 警告:语句无法执行
}

消息标识:wunreachable


最后一条语句应该返回一个值

非空函数的最后一条语句应该返回一个值。 生成错误消息的代码示例:

int foo(int x) {
if ( x > 0 )
	bar();  // 警告:最后一条语句应该返回一个值
else
	return 2;
}

消息标识:wnoretvalue


else 分支语句应该返回一个值

if 语句的 else 分支语句应该返回一个值。 生成错误消息的代码示例:

int foo(int x) {
if ( x > 0 )  // 警告:else 分支语句应该返回一个值
	return 2;
}

消息标识:wnoelseretvalue


类中的匿名结构不能为

类中的匿名结构不能包含一些说明符,如 extern、static 和 the like。 生成错误消息的代码示例:

class A {
static struct {  // 错误:匿名结构不能是静态的
int a;
long b;
    };
};

消息标识:badclanonstruct


匿名结构具有相同的名称

匿名结构成员与其包含类的名称不能相同。 生成错误消息的代码示例:

class A {
struct {  
int i;
long j;
int A;  // 错误
  };
};

消息标识:sameanonstruct


匿名结构无法具有专用的或受保护的成员

匿名结构无法具有专用的或受保护的成员。 生成错误消息的代码示例:

static struct {
long j;
       
private: 
	int i; // 错误
}; 

消息标识:anonstructnoprivate


匿名结构不能包含成员函数

匿名结构不能包含函数成员。 生成错误消息的代码示例:

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

消息标识:anonstructnofunc


正在声明匿名结构

生成警告消息的代码示例:

union U {
struct {  
int a;
long b;
    };
};

消息标识:anonstruct


正在声明向前枚举类型

生成警告消息的代码示例:

enum  A; 

消息标识:forwardenum


声明与通过 using 声明引入的对象冲突

如果名称空间作用域或块作用域内的函数声明与 using 指令引入函数的的名称和参数类型相同,则说明程序的结构错误。 生成错误消息的代码示例:

namespace B {
void f(int);
}

namespace N {
using B::f;             //  将 B::f(int) 引入 N
void f(int);            //  错误:N::f(int) 与 B::f(int) 冲突
}

消息标识:ambigdecl


联合不能包含引用类型的成员

如果联合包含引用类型的成员,则表示程序的结构错误。 生成错误消息的代码示例:

union x {
int &i;
};

消息标识:nounionref


移位数太大

生成警告消息的代码示例:

unsigned long l;
void foo() 
{
l >> 32; // 应该获得警告
}

消息标识:largeshift


无法获取临时的地址

无法获取生成临时函数的编译器地址。

消息标识:compataddressoftemp


不能使用整数初始化枚举

生成警告消息的代码示例:

enum E { e1 = 5 };
struct S { E e; } s = { 5 }; // 警告

消息标识:wintenuminit


函数 %1 只能抛弃它所覆盖的函数 %2 所抛弃的异常

函数只能抛出它覆盖的函数允许的异常。生成错误消息的代码示例:

struct A
{
virtual void foo() throw(A);
};

struct B:A
{
virtual void foo();
};

消息标识:lessrestrictedthrow


隐藏

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

#include <new>

template<class t_arg> class A {
public:
	void  operator delete(void*, const std::nothrow_t&) throw();
};

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

消息标识:whideferr


从常量限定的函数进行不正确的成员访问

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

class A {
public:
	int a;
	void foo () const { a++; }
}

消息标识:constaccess


类 %1 的无效显式实例化声明

最有可能的是,显式实例化声明中缺少关键字‘class’。 生成错误消息的代码示例:

template  class X
{ 
}; 

template X ;  // 应该是:模板类 X ;

消息标识:explclassinst


不应使用临时来初始化非常量引用

不应使用临时来初始化非常量引用。 生成警告消息的代码示例:

struct C { C(int); };
void add( C& c );
void foo() { add( C(6) ); }

消息标识:reftotemp


表达式必须是常量值

模板表达式不能是非常量值。 生成错误消息的代码示例:

template  void f();

int main()
{
const int& ri = 12;
f();	// 错误
}

消息标识:tmplexpnotconst


函数 %1 只能抛弃它所覆盖的函数 %2 所抛弃的异常

函数只能抛出它覆盖的函数允许的异常。生成警告的代码示例:

struct A
{
virtual void foo() throw(A);
};

struct B:A
{
virtual void foo();
};

消息标识:wlessrestrictedthrow


返回自动变量的地址

返回指向局部自动变量的指针。 生成该警告消息的代码示例:

int* f() {
int k=5;
return &k;
}

消息标识:autoaddrreturn


参数类型与指向未知大小数组的指针有关

指针指向未知大小参数的数组 生成错误消息的代码示例:

typedef int UNKA[];
void f(UNKA *p);

消息标识:ptrarray0


参数类型与未知大小数组的引用有关

引用指向未知大小参数的数组 生成错误消息的代码示例:

typedef int UNKA[];
void f(UNKA &p);

消息标识:refarray0


实际参数由模板参数决定,而该模板参数不能在使用点导出

实际参数由模板参数决定 生成错误消息的代码示例:

void foo(...);
template T count(T t);
void bar() {
foo(count);
}

消息标识:dummyactualarg


应为标识符,而不是

应该是标识符。如果构造出错,则会出现该错误,但编译器可以有效地予以恢复。生成错误消息的代码示例:

enum A {a, };

消息标识:identexpected


具有相同的外部名称

两个函数定义不能具有相同的外部名称 生成错误消息的代码示例:

#pragma redefine_extname        fstat64 fstat

extern "C" 
{
int fstat(int fstat_int) 
{
return (fstat_int+2);
}
int fstat64(long fstat64_long) 
{
if (fstat64_long == 0)
return 0;
return -1;
}
}  // 错误,fstat64 与 fstat 的外部名称相同

消息标识:sameextname


在兼容性模式下,在整个程序优化中不允许有块局部静态变量

在兼容模式下对整个程序优化 (-xcrossfile or -xipo) 进行编译时,不允许在内部作用域内使用嵌套的静态变量。

示例如下

int f(int i)
{
	if (i != 0) {
		static int sv = 2;
		return sv + i;
	}
	return 0;
}
sv 将会触发该错误。

消息标识:nocrossstatic


静态数据成员定义使用派生类

静态数据成员定义使用派生类。 生成警告的代码示例:

struct BASE { static int static_data; };
struct DERIVED :public BASE { };
int DERIVED::static_data; 

消息标识:staticmemsearch


无法在类模板中分析字段声明:跳过字段

由于名称查找问题,可能无法在对模板类进行代表性的实例化时分析字段声明。该模板类呈现为无效。

例如:

template < class T >
struct base
{
typedef T b_type ;
} ;

template < class T >
struct derived :public base < T* >
{
typedef base < T* > Base ;
const b_type foo ( const T & t ) const { }
} ;
无法分析成员函数 foo,因为分析派生类的代表性实例化时,无法将 b_type 作为类型进行查找。

消息标识:skipfield


在 typedef 中不允许有异常规范

typedef 声明中不允许有异常规范

例如:

typedef void (*pf) () throw();

消息标识:badexceptionspec


函数指针只能抛弃已赋值的函数指针所抛弃的异常

函数指针只能抛出它赋值的函数指针抛出的异常。生成警告的代码示例:

void (*pf1)();
void (*pf2)() throw(int);
void f() {
pf2 = pf1; 
}

消息标识:fptrthrow


pragma 中只能显示一个 nowait、if、ordered、default 或 schedule 子句

生成消息的代码示例:int NE_C2_3() { int a = 1;

#pragma omp parallel if ( a > 1 ) if ( a < 5 )
    {
    }
    
return 0;
}

消息标识:omp_extraclause


openmp 结构的块中不允许有 return、goto、break 或 continue 语句

OpenMP 并行和共享作业构造之后必须跟结构化的块。结构化块是拥有一个 entry 和一个 exit 的语句。不允许使用造成跳转到块或跳转出块的语句。结构化块不能包含造成控制从块流出的 return、goto、break 或 continue 语句。 生成消息的代码示例:

int NE_C2_4_1_1()
{
int i;
#pragma omp for
for (i = 0 ; i < 10 ; i++ ) 
    {
	break ;
    }
return 0;
}

消息标识:omp_structblkviolation


omp for 循环的索引变量必须是带符号整数

OpenMP for 的索引变量必须具有带符号的整数类型 生成消息的代码示例:

int NE_C2_4_1_3()
{
unsigned int i;
#pragma omp for
for (i = 0 ; i < 10 ; i++ ) 
    {
    }
return 0;
}

消息标识:omp_forbadindxtype


section 指令不得显示在 sections 指令的词法范围之外

“section”OpenMP pragma 必须直接显示在“sections”块中。 生成消息的代码示例:

int NE_C2_4_2_1()
{
#pragma omp sections
    {
	;
    }
#pragma omp section
    {
    }
return 0;
}

消息标识:omp_sectionoutsidesections


在 flush 指令中指定的变量不得有引用类型

生成消息的代码示例:

int NE_C2_6_5_1()
{
int i = 5;
int & n = i;
#pragma omp parallel
    {
#pragma omp flush (n)
    }
return 0;
}

消息标识:omp_varhasreftype


在 non-ordered for 的词法范围内使用了 ordered 指令

排序的 OpenMP 指令不能在指令的动态范围内。其中,该指令尚未指定排序子句。 生成消息的代码示例:

int NE_C2_6_6_1()
{
int i;
#pragma omp for
for (i=0; i<10; i++)
    {
#pragma omp ordered
	{
	}
    }
return 0;
}

消息标识:omp_nonorderedfor


threadprivate 指令必须显示在文件作用域内

threadprivate 指令必须显示在文件作用域或名称空间作用域内,还必须显示在任何定义或声明之外。 生成消息的代码示例:

int a=0;

class A
{
#pragma omp threadprivate ( a )
};

int NE_C2_7_1_1b()
{
return a;
}

消息标识:omp_nonfilethreadprivate


threadprivate 指令必须位于所有变量引用之前

Threadprivate 指令必须按照字典方式位于列表中所有变量引用之前。 生成消息的代码示例:

int a = 1;

void foo() 
{
a--;
}

#pragma omp threadprivate ( a )
    
int NE_C2_7_1_1c()
{
return a;
}

消息标识:omp_threadprivateprecederef


变量不能具有引用类型

threadprivate 变量不能具有引用类型。 生成消息的代码示例:

int a;
int & b = a;

#pragma omp threadprivate (b)

int NE_C2_7_1_6a()
{
return 0;
}

消息标识:omp_varinprivateref


变量不能具有不完整的类型

生成消息的代码示例:

class A;

int foo(A & a)
{
#pragma omp parallel private(a)
    {
    }
return 0;
}

int NE_C2_7_2_1_3()
{
return 0;
}

消息标识:omp_varinprivateincomplete


该子句中不允许使用 threadprivate 变量

除 copyin、schedule 或 if 子句之外,threadprivate 变量不能出现在任何子句中。因此,不能在 private、firstprivate、lastprivate、shared 或 reduction 子句中使用这些变量。这些变量不受缺省子句的影响。 生成消息的代码示例:

int a;

#pragma omp threadprivate ( a )

int NE_C2_7_1_4a()
{
#pragma omp parallel private(a)
    {
    }
return 0;
}

消息标识:omp_threadprivatewrongclause


在子句中指定的变量不能有常量限定的类型

除非具有包含 mutable 成员的类类型,否则 private 子句中指定的变量不能具有常量限定的类型。 生成消息的代码示例:

class A
{
public:
A();
};

int NE_C2_7_2_1_2()
{
const A a;
#pragma omp parallel private(a)
    {
    }
    
return 0;
}

消息标识:omp_varmustnotbeconstqual


变量必须显式地列在封装 omp progma 的数据属性子句中

生成消息的代码示例:

int NE_C2_7_2_5_2()
{
int a;
#pragma omp parallel default (none)
    {
	a=1;
    }
return 0;
}

消息标识:omp_defaultviolated


约简变量的类型无效

对于 reduction 运算符,在 reduction 子句中指定的变量类型是有效的,除非从不允许使用指针类型。 生成消息的代码示例:

class A
{
};

int NE_C2_7_2_6_1a()
{
A a;
#pragma omp parallel reduction(+:a)
    {
    }
return 0;
}

消息标识:omp_reductionbadtype


简约变量不能有常量限定的类型

在 reduction 子句中指定的变量不能有常量限定的类型。 生成消息的代码示例:

int NE_C2_7_2_6_2()
{
const int a = 0;
#pragma omp parallel reduction (+:a)
    {
    }
return 0;
}

消息标识:omp_constreduction


不能在多个子句中指定变量

不能在多个子句中指定变量,除非该变量可以同时在 firstprivate 和 lastprivate 子句中指定。 生成消息的代码示例:

int NE_C2_7_2_6_4()
{
int a = 0;
#pragma omp parallel  shared (a) reduction (+:a)
    {
    }
    
return 0;
}

消息标识:omp_dupclause


copyin 变量不是 threadprivate 变量

在 copyin 子句中指定的变量必须是 threadprivate 变量。 生成消息的代码示例:

int x;

int NE_C2_7_2_7_2()
{
#pragma omp parallel copyin (x)
    {
    }
return 0;
}

消息标识:omp_copyinnotthreadprivate


不允许具有相同名称的 critical 指令相互嵌套

不允许具有相同名称的 critical 指令相互嵌套 生成消息的代码示例:

int NE_C2_9_3_1()
{
#pragma omp critical
    {
#pragma omp critical
	{
	}
    }
return 0;
}

消息标识:omp_badnestingcritical


在区域的动态范围中,不允许使用指令

不允许在 critical、ordered 和 masterfor 区域的动态范围内使用 for、sections 和 single 指令。 生成消息的代码示例:

int NE_C2_9_4_4()
{
#pragma omp master 
    {
#pragma omp for
	for ( int i=0 ; i < 10 ; i++ )
	{
	}
    }
return 0;
}

消息标识:omp_badnestingregion


绑定到相同 parallel 的 for、sections 和 single 指令不允许相互嵌套

绑定到相同 parallel 的 for、sections 和 single 指令不允许相互嵌套。 生成消息的代码示例:

int NE_C2_9_2_1()
{
#pragma omp parallel
{ int i;
#pragma omp for
	for (i=0 ; i < 10 ; i++)
	{  
#pragma omp sections
	    {
		;
	    } 
	}
    }
	
return 0;
}

消息标识:omp_badnestingparallel


包含 flush 指令的最小语句必须是块

包含 flush 指令的最小语句必须是块(或复合语句)。 生成消息的代码示例:

int NE_C2_6_5_2()
{
int i = 5;
#pragma omp parallel
    {
	if ( i > 0 )
#pragma omp barrier
    }
return 0;
}

消息标识:xomp_mustbeblock


当指定进度表(运行时)时,不能指定 chunk_size

当指定进度表(运行时)时,不能指定 chunk_size。 生成消息的代码示例:

int NE_C2_4_1_9()
{
int i;
#pragma omp for schedule(runtime, 2)
for (i=1;i<10;i++)
    {
    }
return 0;
}

消息标识:omp_chunksizemustnotbespecified


不允许在指令中使用子句

生成消息的代码示例:

int main(void)
{
#pragma omp for default(none)
for ( int i = 0; i < 10; i++ )
    {
    }
return 0;
}

消息标识:omp_badclause


跳过当前 pragma 的其它部分,转到新行上

跳过当前 pragma 的其它部分,转到新行上。这样做可以将与 OpenMP 有关的错误恢复和特定于 C++ 的错误恢复分开。 生成消息的代码示例:

int main(void)
{
#pragma omp for default(none)
for ( int i = 0; i < 10; i++ )
    {
    }
return 0;
}

消息标识:omp_skip


Line 指令必须是正值

Line 必须指定正整数。 生成错误消息的代码示例:

#line 0 "file.cc"

消息标识:poslinenum


已在封装 openmp pragma 中将变量指定为专用变量

不能在封装共享作业或并行指令的 private (firstprivate/lastprivate) 子句中指定在并行区域内为 private 的变量。因此,在共享作业或并行指令中指定为 private 的变量必须在封装的并行区域中进行共享。 生成消息的代码示例:

int main()
{
int i,j;
#pragma omp parallel private(j)
    {
	#pragma omp for lastprivate(j)
	for (i=0; i<10; i++)
	    j++;
    }
return 0;
}

消息标识:omp_varalreadyprivate


不允许嵌套 pragma

生成消息的代码示例:

int NE_C2_9_2_1()
{
#pragma omp parallel
{ int i;
#pragma omp for
for (i=0 ; i < 10 ; i++)
      {
#pragma omp sections
          {
              ;
          }
      }
    }

return 0;
}

消息标识:omp_badnesting


简约变量未共享

在 reduction 子句中指定的变量必须在封装的上下文中进行共享。 生成消息的代码示例:

int main()
{
int i;
#pragma omp parallel private(i)
	#pragma omp sections reduction(+:i)
	{
	   i++;
	}
return 0;
}

消息标识:omp_reductionnotshared


结构错误的 OpenMP pragma

在 OpenMP pragma 中发现通用语法错误时显示此消息。 生成消息的代码示例:

int main()
{
#pragma omp parallel private
  {
  }
return 0;
}

消息标识:omp_badlyformedomppragma


omp for 循环的控制表达式形式不规范

OpenMP for 的控制表达式必须采用规范的形式,如下: 生成消息的代码示例:

int main()
{
int i,j=0;
#pragma omp parallel for
for (i=0; j<10; i++) {
    }
return 0;
}

消息标识:omp_forbadcontrol


default 子句的值不正确

对于 default 子句,只有 none 或 shared 才是有效值。 生成消息的代码示例:

int main()
{
int i;
#pragma omp parallel default(private)
  {
	i++;
  }
return 0;
}

消息标识:omp_baddefault


schedule 子句的种类无效

schedule 子句的种类必须属于 static、dynamic、guided 或 runtime 之一。 生成消息的代码示例:

int main()
{
int i;
#pragma omp parallel for schedule(normal,1)
for (i=0;i<10;i++) {
  }
return 0;
}

消息标识:omp_badschedulekind


OpenMP pragma 无效

生成消息的代码示例:

int main()
{
#pragma omp unknown
return 0;
}

消息标识:omp_badomppragma


return、goto、break 或 continue 语句不允许进入或退出 openmp 结构的块

OpenMP 并行和共享作业构造之后必须跟结构化的块。结构化块是拥有一个 entry 和一个 exit 的语句。不允许使用造成跳转到块或跳转出块的语句。结构化块不能包含造成控制从块流出的 return、goto、break 或 continue 语句。 生成消息的代码示例:

int foo() {
#pragma omp parallel
    {
	return 1;
    }
}

消息标识:omp_strblkviolation


omp for 循环的迭代表达式形式不规范

OpenMP for 的迭代表达式的形式必须规范。 生成消息的代码示例:

int main() {
int i;
#pragma omp parallel for
for (i=0; i<10; foo(&i)) {
    }
return 0;
}

消息标识:omp_forbaditer


omp for 循环的初始化表达式形式不规范

OpenMP for 的 Init 表达式必须采用规范的形式,如下: = = 生成消息的代码示例:

int main() {
int i=0;
#pragma omp parallel for
for (; i<10; i++) {
    }
return 0;
}

消息标识:omp_forbadinit


OpenMP for pragma 的后面必须跟一个 for 语句

pragma OpenMP 的后面必须跟 for 语句。 生成消息的代码示例:

int main() {
int i=0;
#pragma omp parallel for
    {
while( 0 ){
	i++;    
    }
return 0;
}

消息标识:omp_forbadfollow


\"%1\" 的声明是一个函数而不是对象

\"%1\" 的声明在语法上不明确,但是标准将其解释为函数声明。无论如何,程序员一般都会声明对象。为了避免混淆,请使用语法上明确的方式重新编写声明。 生成警告消息的代码示例:

struct T { };
T t( T() ); // t 是函数
建议采用语法上明确的解决方法:
T t( (T()) ); // t 是对象(类型不能有多余的 parens)
T t = T(); // t 是对象(赋值样式的初始化)
T t( T(*)() ); // t 是函数(显式函数指针)

消息标识:ambigfuncdecl


schedule 子句中存在错误的 chunksize 表达式

chunksize 必须是整型循环固定非零正值。 生成错误消息的代码示例:

#pragma omp for schedule (static, 0)

消息标识:badchunksize


并行区域内的循环索引必须是专用变量

并行区域内的循环索引必须是该区域的专用变量。 生成消息的代码示例:

int main() {
int i=0;
#pragma omp parallel for shared(i)
for(i=0; i<4; i++){
         }
return 0;
     }

消息标识:omp_sharedforindex


类显示为空的虚拟基类

该文件中使用的类包含没有非静态数据成员的虚拟基类。在某些情况下,这会导致虚拟函数调用错误的函数。

消息标识:warn_empty_virt_base


引用返回值应当是左值(如果使用此函数的值,结果不可预测)

引用返回值应该为左值。标准允许函数返回一个指向要编写的左值的引用。但是,如果实际使用该值,则结果是难以预见的。

消息标识:nonvarrefww


试图调用纯虚拟函数总是失败

如果尝试从尚未覆盖纯虚拟函数的对象中调用该函数,将总是失败。基类的纯虚拟函数将不会通过虚拟调用机制进行调用。必须显式限定该调用,还必须在单独的函数定义中提供该函数的主体。示例:

struct T {
virtual int f() = 0;
T() { f(); }         // 警告,调用纯虚拟函数
~T() { T::f(); }     // ok,跳过虚拟调用机制
void g() { f(); }    // ok,如果从纯虚拟函数的派生类
};
int T::f() { return 0; } // 对象定义进行调用

消息标识:pure_virtual_w


不允许 pragma critical 以相同的名称嵌套在 critical 中

不允许具有相同名称的 critical 指令相互嵌套生成消息的代码示例:

void main(void) {
#pragma omp critical(foo)
#pragma omp critical(foo)
        ;
}

消息标识:omp_badcriticalnesting


以前未将方法声明为本地方法

必须使用 c++ 函数执行声明为本地方法的 Java 方法。如果方法之前没有作为 .class 文件中的本地方法进行声明,则提供该方法的 C++ 版本会产生错误。

消息标识:notjavanative


将非 POD 对象作为变量参数传递给函数

未定义将非 POD 对象作为变量参数传递的结果。

POD(平面旧数据)对象是一个不包含下列内容的对象:用户声明的构造函数、用户定义的析构函数、用户定义的复制运算符、虚拟函数、专用或受保护的非静态数据成员和指针到成员类型的非静态数据成员、非 POD 结构、非 POD 联合或引用。

void foo(int, ...);
struct T {
T();
~T();
};

extern T t;

int main()
{
foo(1, t); // 警告
}

消息标识:nonpodvarargw


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

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

namespace N {
	template  struct B { };
}
struct A {
friend struct N::B; //此处应该是错误,B 是模板,而不是结构
};

消息标识:wnofriendfield


友元声明可能必须添加<> 到语法

友元声明声明了非模板函数。 生成警告的代码示例:

template < class T > bool foo (T);
template < class T1 > class BC_base_identifier {
friend bool foo(T1);
};
int main()
{
BC_base_identifier bi;
foo(100);
}

消息标识:nontmplfriend


调用 #pragma dumpmacros 时传递的参数不正确

调用 #pragma dumpmacros 时使用的有效参数如下:defs、undefs、loc、conds 和 sys 生成错误消息的代码示例:

#pragma dumpmacros(definitions)

消息标识:prbadarg


模板嵌套深度没有

模板嵌套深度引用了函数模板的专门化,只有非模板函数才可用。 生成错误消息的代码示例:

template struct A {
void f(int);
};

template<> template<> void A::f(int) {} // spec 多余

消息标识:mismatchtmpdepth


转换 64 位类型值

移植为 64 位时,赋值、初始化或转换可能会截断数据。 生成错误消息的代码示例:

long l;
(int)l;

消息标识:truncwarn1


扩展符号

如果移植为 64 位,则赋值为无符号的 long 之前,可以扩展数据的符号。 生成错误消息的代码示例:

int i;
unsigned long ul = i;

消息标识:signextwarn


64 位类型位字段可能会更改

移植为 64 位时,long 或无符号 long 位字段声明可能会更改位字段包装。 生成错误消息的代码示例:

struct S {
unsigned long b1:20;
long b2:20;

};

消息标识:bitfield64


正在定义关键字

正在定义关键字。 生成警告的代码示例:

#define bool unsigned int

消息标识:nokeyworddefine


类型转换不明确

第二个操作数和第三个操作数可以相互转换

struct S {
S (int);
operator int () const;
};

int main (int i)
{
S s0(0);
i ? s0 :1; // 类型转换不明确
}

消息标识:questambigerr


在 threadprivate 指令中指定的块作用域变量必须是静态的

在 threadprivate 指令中指定的块作用域变量必须是静态的。 生成消息的代码示例:

int main() {
#pragma omp parallel
    {
int i;
#pragma omp threadprivate(i)
i = 50;
    }
}

消息标识:omp_threadprivatenotstatic


threadprivate 指令必须出现在变量的作用域中

静态块作用域变量的 threadprivate 指令必须出现在变量的作用域内,而不能出现在嵌套的作用域内。 生成消息的代码示例:

int main() {
static int i; 
#pragma omp parallel
    {
#pragma omp threadprivate(i)
i = 50;
    }
}

消息标识:omp_threadprivateinnested


if 子句表达式没有标量类型

在 OpenMP 并行区域的 if 子句中指定的表达式必须具有标量类型。 生成消息的代码示例:

int main() {
struct { float val; } good = {3.62};

#pragma omp parallel if(good)
good.val = 4.12;
}

消息标识:omp_badiftype


num_threads 子句表达式没有整型

在 OpenMP 并行区域的 num_threads 子句中指定的表达式必须具有整数类型。 生成消息的代码示例:

int main() {
int i = 0;
    
#pragma omp parallel num_threads(3.62)
i++;
}

消息标识:omp_badnumthreadstype


模板参数声明中不允许有完整的类定义

在模板参数声明中不能指定类定义。 生成错误消息的代码示例:

template  class S{};

消息标识:noclassdef


copyprivate 子句不能与 nowait 子句一起使用

copyprivate 子句不能与 nowait 子句一起使用。 生成消息的代码示例:

int main() {
int i = 42;
#pragma omp single nowait copyprivate(i)
    { 
i++;
    }
}

消息标识:omp_badusecopyprivate


在 copyprivate 子句中指定的变量在封装的上下文中必须为专用变量

如果在并行区域的动态范围内遇到使用 copyprivate 子句的一个指令,则在 copyprivate 子句中指定的所有变量必须是封装的上下文中的专用变量。 生成消息的代码示例:

int main() {
int i = 1;
#pragma omp parallel
    {
i = 42;
#pragma omp single copyprivate(i)
      {
i++;
      }
    }
}

消息标识:omp_notprivateincontext


常量限定符必须有声明符和初始化程序

必须使用声明符和初始化程序声明常量变量 生成消息的代码示例:

const enum E1 {a, b};		// 错误
const enum E2 {c, d} x = c;	// ok

消息标识:badconstdecl


volatile 限定符必须有声明符

volatile 变量必须使用声明符进行声明 生成消息的代码示例:

volatile enum E1 {a, b};		// 错误
volatile enum E2 {c, d} x;		// ok

消息标识:badvoldecl


存储类说明符必须有声明符

存储类说明符必须有 init 声明符列表 生成消息的代码示例:

register enum E4 { a4, b4 };	// 错误
register enum E5 { a5, b5 } e;  // ok

消息标识:badstgdecl


声明时需要声明符

这种类型的声明中需要 init 声明符列表 生成消息的代码示例:

typedef struct T { int i; };
typedef enum F { f1, f2 };

消息标识:declreq


在友元声明中不允许有存储类

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

struct A {
friend static void foo(A arg);
};

消息标识:storefrienderr


比较不同的枚举类型

生成警告消息的代码示例:

#include 

int main()
{
enum Shape { shape1=2, shape2};
enum Point { point1=4, point2};

Shape cylinder = shape1;
Point uper = point2;
if ( cylinder == uper ) // 警告
cout << “比较不同的枚举类型” << endl;
}

消息标识:diffenumtype


[提示:使用 -xarch=v8plus 编译的对象必须与 -xarch=v8plus 链接]

消息标识:demxarchv8plus


生成缺省参数表达式时无限递归

生成消息的代码示例 struct S { int f1(int = f2()); int f2(int = f1()); };

消息标识:recurseindefault


关键字 \"virtual\" 和 \"friend\" 不能出现在同一声明中

不能将虚拟函数声明为友元函数。 生成错误消息的代码示例:

void foo() { return; }
void goo() { return; }

class A {
virtual friend void foo();    // 错误
virtual friend void A::goo(); // 错误
};

消息标识:virtfriendfunction


函数 \"%1\" 已使用不完整的函数声明语法声明为 \"friend\"

仅使用函数名称声明了友元函数。 生成错误消息的代码示例:

namespace N {
void foo(char);
void foo ();
};

class A {
friend N::foo;
};

消息标识:friendfunc


将负值赋予隐式无符号位字段

生成警告消息的代码示例:

struct No_constructor {
int i : 30;
};

class Has_constructor {
int j : 30;
public:
Has_constructor():j(-2){}       // 第 8 行:警告
};

int main() {
struct No_constructor b = {1-2};// 第 12 行:警告
b.i = -1.8;                     // 第 13 行:警告
}

消息标识:negbitfield


对象或函数的名称不能是模板标识

生成警告消息的代码示例:

namespace N {
template struct ap {
ap(X* p = 0);
    };
};
using namespace N;
class A {};
A* a;
ap ap(a) ;

消息标识:baddeclare


在 OpenMP private、firstprivate 或 lastprivate 数据子句中使用类对象时,类必须具有缺省的构造函数。

生成警告消息的代码示例:

class A {

};
main()
{
A a(10);
#pragma omp parallel private(a)
    {
        ;
    }
}

消息标识:nodefctor


可能准备声明显式模板专门化或创建显式专门化的不明确语法不会产生影响。其它编译器可能会对代码产生不同的中断。

生成警告的代码示例:

template  class A { ... };
class A; // 警告:已忽略
template<> class A; // 声明显式专门化
template   class A; // 显式实例化指令

消息标识:oldspecialdecl


函数不是数据,所以不能具有 __thread 说明符。

生成警告的代码示例:

__thread void func();
struct type {
__thread void func();
};

消息标识:nothreadfuncs


__thread 变量的第一个声明必须这样表达。

生成警告的代码示例:

int changed;
__thread int changed;

消息标识:threaddeclfirst


__thread 变量不支持动态初始化程序。

__thread 变量不支持动态初始化程序。重要的构造函数、析构函数、基类或非常量初始化程序表达式可能会生成动态初始化程序。生成警告的代码示例:

struct nontrivial_constructor {
nontrivial_constructor();
};
__thread nontrivial_constructor unsupported1;
struct nontrivial_destructor {
nontrivial_destructor();
};
__thread nontrivial_destructor unsupported2;
struct nontrivial_base :nontrivial_constructor {
};
__thread nontrivial_base unsupported3;
extern int func();
__thread int unsupported4 = func();

消息标识:threaddyninit


自动变量不能是 __thread 变量。

生成警告的代码示例:

void func() {
__thread int a;
}

消息标识:noautothread


不能在模板的显式专门化内部使用类型名称

生成警告的代码示例:

template struct traits {
typedef T ty;
};

template struct tn {
typedef typename traits::ty tn_ty;
};

template<> struct tn {
typedef typename traits::ty tn_ty;
};

消息标识:explctspectypename


已尝试访问类中的专用成员。

生成警告的代码示例:

class A {
private:
int a;
} ;
struct B:A {
private:
A::a;	// 标准模式警告
} ;

消息标识:inaccessible_anach


不能在子句中指定专用变量

不能在绑定到并行构造的共享作业指令的 reduction 子句中指定并且区域中的专用变量。 生成消息的代码示例:

int main() {
int i;
#pragma omp parallel private(i)
#pragma omp sections reduction(+:i)
    {
i++;
    }
}

消息标识:omp_cant_be_in_private


不能在子句中指定约简变量

不能在绑定到并行构造的共享作业指令的 reduction 子句中指定并行指令 reduction 子句中出现的变量。 生成消息的代码示例:

int main() {
int i;
#pragma omp parallel reduction(+:i)
#pragma omp sections reduction(+:i)
    {
	i++;
    }
}

消息标识:omp_cant_be_in_reduction


在子句中指定的变量不能有常量限定的类型

除非具有包含 mutable 成员的类类型,否则在 private 子句中指定的变量不能具有常量限定的类型。 生成消息的代码示例:

class A
{
public:
A();
};

int NE_C2_7_2_1_2()
{
const A a;
#pragma omp parallel private(a)
    {
    }
    
return 0;
}

消息标识:omp_varmustnotbeconst_qual


每个 OpenMP 段必须是一个结构化块

如果段包含的语句不止一个,则这些语句必须位于 {} 生成消息的代码示例:

#pragma omp sections
{
// optional #pragma omp section
x = 5;
y = 10;
}

消息标识:omp_badsectionstructure


友元函数模板标识名称应该引用模板声明

友元函数名称尚未在最近的名称空间中声明模板,或者在当前的类中包含该模板。 生成错误消息的代码示例:

#include 
namespace M {
template < class T > void i(T);
class A {
template < class T > void i(T);
friend void i< > ( int );       //结构错误 - A::i
  };
template< typename T >
class Bar
  {
std::valarray< T > fVA ;
friend std::valarray< T > const
Fu< >( Bar< T > const & ) ;     // Fu<> has no declaration in a namespace M
  } ;
};

消息标识:wnotempdecl


内联函数没有外部链接

内联函数没有外部链接。 生成消息的代码示例:

int f();
inline int f() { return 0; }

消息标识:wbadlinkage_w


只有外部符号才可能有链接程序作用域。

生成警告的代码示例:

static __symbolic int variable;
static __hidden int function() {
__global int stackvar;
}

消息标识:ldscopeonlyextern


链接程序作用域只能有更多限制

链接程序作用域只能是多个限制或后续声明。链接程序作用域 __hidden 比 __symbolic 严格,而 __symbolic 比 __global 严格,而 __global 比未指定的链接程序作用域严格。生成警告的代码示例:

__hidden int function();
__symbolic int function();

消息标识:ldscoperestrict


不能在符号定义之后更改链接程序作用域。

生成警告的代码示例:

__symbolic int function() { }
__hidden int function();

消息标识:ldscopechanged


将 \"%1\" 值转换为 \"%2\" 导致截断

生成警告的代码示例:

char c[100000];
short i = sizeof(c);

消息标识:truncwarn2


具有引用成员的类必须具有用户定义的构造函数

具有引用成员的类必须具有用户定义的构造函数 生成错误消息的代码示例:

struct S {
int x&;
};


消息标识:refmemnoconstr


正在使用的 pch 文件没有正确的魔数

正在使用的 pch 文件没有正确的魔数

消息标识:pchbadmagicnumber


正在使用的 pch 文件在前页中的格式字符串不正确

正在使用的 pch 文件在前页中的格式字符串不正确

消息标识:pchbadformatstr


pch collect 和 use 模式编译器版本字符串不兼容

pch collect 和 use 模式编译器版本字符串不兼容

消息标识:pchbadreleasestr


pch 文件应该包含 defines

pch 文件应该包含 defines

消息标识:pchexpdefines


pch 文件应该包含 undefs

pch 文件应该包含 undefs

消息标识:pchexpundefs


pch collect 和 use 模式中的 defines 列表不同

pch collect 和 use 模式中的 defines 列表不同

消息标识:pchbaddefines


pch collect 和 use 模式中的 undefs 列表不同

pch collect 和 use 模式中的 undefs 列表不同

消息标识:pchbadundefs


pch collect 和 use 模式中的可用前缀不同

pch collect 和 use 模式中的可用前缀不是相同的 PRE>

消息标识:pchbadviableprefix


无效的模板嵌套深度

无效的模板嵌套深度 生成错误消息的代码示例:

template <class X> template <class Y>
void foo ();	// 错误:无效的模板嵌套深度

struct S {
template <class X> template <class Y>
void foo();	// 错误:无效的模板嵌套深度
}

消息标识:badnesttmpl


共享循环控制变量被声明为专用变量

在并行 for 结构中,循环控制使用的变量已隐式声明为专用变量。 因此,shared() 子句不会对这些变量产生影响。 生成消息的代码示例:

int main() {
int i,j;
#pragma omp parallel for shared(i,j)
for (i=0; i<10; i++) j = i;
	;
return 0;
}

消息标识:omp_shared_control_var


在平行区域中不允许有静态的非 POD 声明

在平行区域中不允许有静态的非 POD 声明 生成错误消息的代码示例:

class A {public:int i; A(){i = 10;};};
#pragma omp parallel
{
static A a;
    ;
}

消息标识:omp_staticclassdecl


U 字符串文字只能包含 ASCII

生成警告的代码示例:

unsigned short bar[] = U"é";

消息标识:ustronlyascii


U 字符串文字不能包含数字换码

生成警告的代码示例:

unsigned short bar[] = U"\351";

消息标识:ustrnoescape


可能缺少或位置错误 #pragma hdrstop or -xpchstop point

可能缺少或位置错误 #pragma hdrstop or -xpchstop point

消息标识:pchbadstoppoint


可用前缀中只能使用注释和某些预处理程序指令

可用前缀中只能使用注释和某些预处理程序指令

消息标识:pchbadviablepref


打开的文件太多

打开的文件太多,可能是一个包含自身的文件

消息标识:toomanyopenfiles


无法转换为 const 或 volatile

已尝试转换为 const 或 volatile。 生成错误消息的代码示例:

class B { virtual void foo(); };

class A:public B {};

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

extern int *const** p1;
int **const* p2 = reinterpret_cast<int **const*>(p1); // 错误

extern volatile int *pi;
int *pi2 = static_cast<int*>(pi); // 错误

消息标识:castawayconst


threadprivate 指令不能显示在定义或声明中

threadprivate 指令必须显示在定义或声明之外。 生成消息的代码示例:


class A
{
int a;
#pragma omp threadprivate ( a )
};

消息标识:omp_badthreadprivate


在主模板声明中不允许使用显式模板参数列表

在主模板声明中不允许使用显式模板参数列表 生成消息的代码示例:

template  void bar ();
template  void bar ();

消息标识:wexpltemplid


原子 pragma 之后必须跟表达式

原子 pragma 后面必须跟一个表达式语句。 生成消息的代码示例:


#pragma omp atomic
{               // 不允许有‘{’
i++;
}

消息标识:omp_badatomicfollow


声明为内联之前已经调用

函数在其声明为内联之前已经使用。这意味着, 所有的预先调用将会作为 extern 进行处理。后续调用 将会内联。 生成错误消息的代码示例:

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

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

inline
void A::foo () {}

消息标识:inlafteruse


带符号类型和无符号类型之间的比较

带符号类型和无符号类型之间的比较。 生成消息的代码示例:


int foo(unsigned ui, int i) {
if ( ui < i )
return 0;
else
return 1;
}

消息标识:wunsignedcomp


循环迭代执行的排序指令不能超过一个

包含 for 构造的循环迭代执行的 指令不能超过一个。 生成消息的代码示例:

int main () {
#pragma omp for ordered
for (int q = 0; q < 100; q++) {
#pragma omp ordered
        {
int a;
        }
#pragma omp ordered
        {
int b;
        }
    }
}      

消息标识:omp_badordered


局部类的友元 %1 必须在最深层的封装非类作用域中声明。

尚未在最深层的封装非类作用域中找到声明为友元或局部类的函数或类。 生成警告的代码示例:

void global_f();

class A {};

void f() {
extern void another_f();
class B {};
class local_class {
	friend void f();             // 警告
	friend void global_f();      // 警告
	friend void another_f();     // Ok
    	
	friend class A;              // 警告
	friend class B;              // Ok
    };
}

消息标识:badlocalfrienddecl


包含该指令的最小语句必须是块

可以显示的某些 OpenMP 指令受到限制 生成此消息的代码示例:

void foo() {
int i = 0;
label:
#pragma omp barrier
i++;
goto label;
}

消息标识:omp_mustbeblock


不能对该指令进行标记

不能对 barrier 和 flush standalone 指令进行标记 生成此消息的代码示例:

main() {
int i = 0;
#pragma omp parallel
  {
label:
#pragma omp flush
i++;
goto label;
  }
}

消息标识:omp_no_label


pch 文件应该包含 srcdir

pch 文件应该包含 srcdir

消息标识:pchexpsrcdir


pch collect 和 use 模式中的源目录不同

pch collect 和 use 模式中的源目录不同

消息标识:pchbadsrcdir


pch 文件应该包含 cwd

pch 文件应该包含 cwd

消息标识:pchexpcwd


pch collect 和 use 模式中的当前目录不同

pch collect 和 use 模式中的当前目录不同

消息标识:pchbadcwd


pch 文件应该包含选项

pch 文件应该包含选项

消息标识:pchexpoptions


pch collect 和 use 模式中的选项不同

pch collect 和 use 模式中的选项不同

消息标识:pchbadoptions


不能在 try 块中使用 OpenMP 构造

因为抛出异常的线程必须捕获 try, 所以不允许在 try 块中使用 OpenMP 构造 生成此消息的代码示例:

try {
#pragma omp parallel
  {
throw a();
  }
}
catch(...) {
printf("in catcher\n");
}			    }

消息标识:omp_in_guarded


段指令之后必须跟由 {} 绑定的段作用域

标准要求,omp 段构造之后必须跟 { section-sequence } 生成此消息的代码示例:

#pragma omp parallel sections
i = i + 5;

消息标识:omp_nosectionscope


原子构造的表达式无效

有关管理合法原子表达式的规则,请参见 OpenMP API 生成此消息的代码示例:

#pragma omp atomic
i = i + 5;

消息标识:omp_badatomicexpr


不能修改 OpenMP for 循环中的索引

标准禁止修改循环中 OpenMP for 索引 变量的值 生成此消息的代码示例:

#pragma omp parallel for
for (i = 0; i < 10; i++) {
i = i + 5;
  }

消息标识:omp_forindexmod


%1 的模板参数与以前的声明不匹配

模板的友元声明必须具有相同的参数数目 生成错误消息的代码示例:

template 
class X {
public:
X() { }

private:
template  friend class X ;              // 错误
template  friend class X ;  // Ok
};

X i;

消息标识:nomatchfrienddecl


不能在匿名联合中声明类型

不能在匿名联合中声明类型 生成错误消息的代码示例:

static union {
struct S {	// 错误
int i;
} s;
int j;
};

消息标识:anonnotype


局部类中包含友元函数定义

只能在非局部类中定义友元函数 生成错误消息的代码示例:

void f() {
class A {
friend int g() { return 1; }; // 错误
     };
};

消息标识:locfriendfunc


__declspec 语法无效

__declspec 语法无效 生成错误消息的代码示例:

extern __declspec dllimport) int bar;

消息标识:declspecsyntax


不应该是 __declspec 属性标识符

不应该是 __declspec 属性标识符 生成错误消息的代码示例:

extern __declspec(foo) int bar;

消息标识:declspecident


标记的语句不是结构化的块

结构化块的定义说明带有标记的语句 不是结构化的块。 生成消息的代码示例:

#pragma omp sections
{
// optional #pragma omp section
label:goto label;
}

消息标识:omp_labeledisntstructured


声明语句不是结构化的块

结构化块的定义说明声明语句 不是结构化的块。 生成消息的代码示例:

#pragma omp sections
{
// optional #pragma omp section
int a = 1;
}

消息标识:omp_declisntstructured


无法找到所需的匹配项

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

struct S { int &r; };
int main () {
struct S *x = new S(0); // 错误:未找到构造函数 S::S(int)
};
class A {
public:
int i;
A();
A(int a, int b);
};

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

消息标识:nomatchoverin


pragma 无法识别

编译器找到未知或拼写错误的 pragma 生成警告消息的代码示例:

#pragma some_unknown // ragma 未知
int main()
{
#pragma opm for // pragma 拼写错误
	for ( int i = 0; i < 10; i++ )
	{
	}
	return 0;
}

消息标识:unknownpragma


模板声明之后不能跟显式专门化声明

无法专门化内部模板,同时也无法专门化外部模板 生成错误消息的代码示例:

template  struct S {
template  struct I;
template  void foo();
};

template  template<> struct S::I; // 错误
template  template<> void S::foo(); // 错误

消息标识:nestexplspec


当前的作用域中不允许有显式专门化

只能在名称空间作用域内声明显式专门化 生成错误消息的代码示例:

struct S {
template  struct I;
template  void foo();

template<> struct I; // 错误
template<> void foo(); // 错误
};

消息标识:badexplspec


必须在包含模板的名称空间内声明显式专门化

必须在相同的名称空间中将模板的显式专门化声明为模板 生成错误消息的代码示例:

namespace N {
template  struct S {};
template  void foo();
}
template<> struct N::S; // 警告
template<> void N::foo(); // 警告

消息标识:badexplspecdecl


不允许在当前的作用域中定义显式专门化

可以在包含声明的名称空间或使用声明封装的名称空间内定义显式专门化 生成错误消息的代码示例:

namespace N {
template  struct S {};
template  void foo();

template<> struct S;
template<> void foo();
}
namespace M {
template<> struct N::S {}; // 警告
template<> void N::foo() {} // 警告
}

消息标识:badexplspecdef