ARM CC编译错误和警告解释大全（1） 序列号0-1000

????????

0：未知错误

1：文件的最后一行结束，没有换行符

2：文件的最后一行以反斜杠结尾

3：#include 文件<实体>包括自身

4：内存不足

5：无法打开<实体>输入文件<文件名>：<原因>

例如：

#include <file.h>

结果显示以下消息：

Error: #5: cannot open source input file "file.h": No such file or directory

因为 file.h 在系统包含目录中不存在。

6：文件末尾未关闭的注释

注释以 /* 开头，但没有匹配的 */ 以关闭注释。

7：无法识别的令牌

8：缺少收盘报价

例如：

char foo[] = {"\"};

在此示例中，反斜杠导致将以下引号?“?视为文本字符，而不是关闭字符串。若要解决此问题，请使用：

char foo[] = {"\\"};

9：不允许嵌套注释

例如：

/*nested
/*comment*/

10：“#”此处不适用

11：无法识别的预处理指令

例如：

#foo

12：在上一个语法错误后，解析在此处重新启动

13：需要文件名

例如：

#include <>

14：预处理指令预期结束后的额外文本

例如：

#if EMBEDDED foo

艺术

#include <stdio.h> foo

艺术

#ifdef SOMETHING
:
#endif SOMETHING

#endif?不期望或不需要任何论据。将该行的尾部括在注释中可解决此问题：

#endif /* SOMETHING */

16：<entity> 不是有效的源文件名

17：预期为“]”

18：预期为“）”

19：预期数字结尾后的额外文本

例如：

int a = 37r;

20：标识符<实体>未定义

例如，当针对 C++ 编译时，代码：

void foo( arg ) { }

结果显示以下消息：

Error: #20: identifier <arg> is undefined

另一个可能导致此错误的代码示例是：

int foo(void)
{
  int a = 4;
  a = i;
}

这将导致以下消息：

Error: #20: identifier "i" is undefined

因为我没有被宣布。

21：类型限定符在此声明中毫无意义

22：十六进制数无效

23：整数常量过大

24：无效的八进制数字

例如：

int a = 0378;

25：带引号的字符串应至少包含一个字符

例如：

char a ='';

26：字符常量中的字符过多

例如，以下代码会生成此警告，因为多字节字符包含的字节数超出了?int?的容量：

int a ='abcde';

27：字符值超出范围

当十六进制常量描述的字符值太大而无法在?char?变量中表示时，可能会发生此错误，例如：

char x = '\x100';

28：表达式必须有一个常量值

29：期待一个表情

30：浮动常数超出范围

31：表达式必须具有整型

32：表达式必须具有算术类型

33：应为行号

34：行号无效

35：#error 指令：<实体>

36：缺少此指令的 #if

37：缺少此指令的 #endif

打开的 #if?仍处于活动状态，但在文件结束前未?#endif?关闭。

38：指令是不允许的 -- #else 已经出现

39：除以零

40：需要标识符

如果预处理器语句的格式不正确，例如，缺少必须紧跟在 #define?预处理器命令后面的标识符，则会引发此错误。

当代码使用关键字作为标识符时，也会发生此错误，例如：

int if =0;

41：表达式必须具有算术或指针类型

42：操作数类型不兼容（<type> 和 <type>）

44：表达式必须有指针类型

45：#undef 不得用于此预定义名称

46：<entity> 是预定义的;尝试的重新定义被忽略

47：不兼容的宏<实体>的重新定义

一个宏被定义了两次，具有不同的替换字符串。

例如：

#define TEST 0
#define TEST 1

使编译器生成：

Warning: #47-D: incompatible redefinition of macro "TEST" (declared at line 1)

如果需要执行此操作，请在第二个定义之前使用?#undef?取消定义宏。

如果要定义宏，除非它已经有定义，否则可以使用条件预处理，例如：

#ifndef TEST
#define TEST 0
#endif

使用?armcc -c foo.c?编译此内容将?TEST?定义为 0（默认值）。

使用 armcc -c?-DTEST=1 编译此内容，foo.c?将?TEST?定义为 1。

49：重复的宏参数名称

50：“##”在宏定义中可能不是第一个

51：“##”在宏定义中可能不是最后一个

52：应为宏参数名称

53：预期为“：”

54：调用<实体时的参数太少>

55：调用<实体的参数太多>

56：sizeof 的操作数可能不是函数

57：常量表达式中不允许使用此运算符

58：预处理表达式中不允许使用此运算符

59：常量表达式中不允许调用函数

60：整数常量表达式中不允许使用此运算符

61：整数运算结果超出范围

62：班次计数为负数

63：班次数过大

64：声明不声明任何内容

例如：

int; 

65：应为“;”

66：枚举值超出“int”范围

当枚举常量超出有符号 int 的范围时，编译器会生成此诊断消息。

例如，在 C 模式下编译以下代码时，编译器会生成此警告：

typedef enum
{
  Bit31 = 0x80000000
} Bits;

注意

此说明适用于 RVCT 2.2 及更高版本。

C模式：

• 生成警告，但编译器将常量提升为 unsigned

• 开关?--strict?始终将此消息生成为错误。

C++ 模式：

• 默认情况下，超出范围的常量会被提升为 unsigned 而不会发出警告，并且在使用 --strict?时也是如此

对于消息为错误的情况，请使用以下代码示例作为解决方法：

typedef enum
{
  Bit31 = (int)0x80000000
} Bits;

不再发生溢出，因此不会报告任何错误。

注意

Bit31?的值现在为负数，因为它是有符号的 int。

请参阅《armcc 用户指南》中的以下内容：

结构、联合、枚举和位域.

67：应为“}”

68：整数转换导致符号更改

该常量太大，无法用有符号的 long 表示，因此被赋予了无符号类型。

例：

long l = 2147483648;

69：整数转换导致截断

70：不允许输入不完整的类型

例：

typedef struct {
  unsigned char size;
  char string[];
} FOO;

如果不在结构中声明数组的大小，编译器就无法分配结构的大小。在 --gnu?和?--c99?模式下允许使用不完整的类型。

71：sizeof 的操作数可能不是位字段

75：\“*\” 的操作数必须是指针

76：宏的参数为空

77：此声明没有存储类或类型说明符

78：参数声明可能没有初始值设定项

79：预期类型说明符

表示可变参数函数的省略号（如?printf（））必须至少跟在一个参数后面。例如，更改：

int foo( ... );

自：

int foo( int bar, ... ); 

80：此处可能未指定存储类型

81：不能指定多个存储类型

82：存储类不是第一位的

83：多次指定类型限定符

84：类型说明符组合无效

类型名称或类型限定符不能与第二个类型名称或类型限定符在同一声明中使用。例如：

typedef int int;

85：参数的存储类无效

86：函数的存储类无效

87：此处不得使用类型说明符

88：不允许使用函数数组

89：不允许使用虚空数组

90：不允许函数返回函数

91：不允许函数返回数组

92：identifier-list 参数只能在函数定义中使用

93：函数类型可能不是来自 typedef

94：数组的大小必须大于零

仅当处于 --gnu?模式时才允许使用零大小的数组，例如：

char name[0];

请参阅《armcc 用户指南》中的以下内容：

• GNU对C和C++语言的扩展.

95：数组太大

数组或结构的最大大小限制为 4GB。

96：一个翻译单元必须至少包含一个声明

97：函数不能返回此类型的值

98：数组中不能有此类型的元素

99：这里的声明必须声明一个参数

100：重复的参数名称

101：<entity> 已在当前范围内声明

102：枚举类型的正向声明不规范

103：类太大

104：结构或联合太大

数组或结构的最大大小限制为 4GB。

105：位字段大小无效

位字段不得大于类型的大小。

例如，使用 --strict：

struct X{
  int y:5000;
};

106：位字段的类型无效

位字段必须具有整数类型。

例：

struct X{
  float x:5;
  float y:2;
};

107：零长度位字段必须未命名

108：长度为 1 的有符号位字段

109：表观调用括号前的表达式必须具有（指向）函数类型

110：需要定义或标记名称

111：语句无法访问

112：预期的“而”

114：<entity> 被引用但未定义

115：continue 语句只能在循环中使用

116：break 语句只能在循环或开关中使用

例：

void foo(void){
  int a=0;
  continue;
}

艺术

void bar(void){
  int a=0;
  break;
}

117：non-void <entity> 应该返回一个值

118：void 函数不能返回值

119：不允许转换为类型 <type>

120：返回值类型与函数类型不匹配

121：外壳标签只能在交换机内使用

122：默认标签只能在交换机内使用

124：此开关中已出现默认标签

125：预期为“（”

126：表达式必须是左值

127：期待声明

128：无法访问循环

129：块范围函数只能有外部存储类

130：应为“{”

131：表达式必须具有指向类的指针类型

132：表达式必须具有指向结构或联合类型的指针

133：需要成员名称

134：需要字段名称

135：<实体>没有成员<实体>

136：<entity>没有字段 <entity>

137：表达式必须是可修改的左值

138：不允许取寄存器变量的地址

139：不允许取位字段的地址

140：函数调用中的参数过多

函数声明与早期函数原型中的参数数不匹配。

例：

extern void foo(int x);
void bar(void)
{
  foo(1,2);
}

141：当 body 存在时，不允许使用未命名的原型参数

142：表达式必须具有指向对象的指针类型

143：程序太大或太复杂，无法编译

144：<类型>的值不能用于初始化类型为 <type> 的实体

固定大小字符数组的初始化字符串与数组大小完全相同，没有留出终止?\0?的空间，例如：

char name[5] = "Hello";

name 数组最多可以容纳 5 个字符。“Hello”不适合，因为 C 字符串始终以 null 结尾（例如，“Hello\0”）。编译器报告：

Error: #144: a value of type "const char [6]" cannot be used to initialize an entity of type "char [5]"

如果指针隐式转换非零?int，也会引发类似的错误。

例如：

void foo_func( void )
{
  char *foo=1;
}

结果显示以下消息：

#144: a value of type "int" cannot be used to initialize an entity of type "char *"

对于强制转换，可以使用 --loose_implicit_cast?开关来抑制此错误。

145：<entity> 可能无法初始化

146：初始值设定项值过多

147：声明与<实体不相容>

以下不正确的 C 代码会导致所有模式下的错误。可以使用 --diag_warning 147?将其从错误降级为警告，或使用?--diag_suppress 147?完全禁止显示。

typedef enum { e } E;
typedef enum { f } F;
E g(void);
F g(void);

148：<entity> 已初始化

149：全局范围的声明可能没有此存储类

150：不能将类型名称重新声明为参数

151：不能将 typedef 名称重新声明为参数

152：将非零整数转换为指针

153：表达式必须具有类类型

154：表达式必须具有结构或联合类型

155：老式的赋值运算符

156：老式的初始化程序

157：表达式必须是整数常量表达式

158：表达式必须是左值或函数指示符

159：声明与先前的<实体不兼容>

160：外部名称与<实体的外部名称冲突>

161：无法识别的 #pragma

163：?无法打开临时文件 <实体>

164：临时文件目录名称过长 （<entity>）

165：函数调用中的参数太少

函数原型是用许多参数定义的，这些参数与函数调用中传递的参数数量不匹配。

例如：

extern void foo(int x);
void bar(void)
{
  foo();
}

166：无效的浮动常量

167：?<类型>的参数与<类型>的参数不兼容

168：此处不允许使用函数类型

169：期待声明

尝试使用 C 编译器而不是 C++ 编译器编译某些 C++ 头文件时，可能会发生这种情况。

170：基础对象外部的指针点

171：无效的类型转换

172：外部/内部链接与先前声明冲突

编译器会抑制有关链接差异的错误，其中函数被隐式声明为?extern，然后重新声明为?static，除非使用 --strict?选项。例如：

extern void foo(void);
static void foo(void){}

173：浮点值不适合所需的整数类型

174：表达式无效

175：下标超出范围

177：<entity> 已声明但从未被引用

默认情况下，未使用的声明警告会针对以下情况给出：

• 变量、typedef 和函数的局部（在函数中）声明。

• 标签（始终在函数中）。

• 顶级静态函数和静态变量。

--diag_suppress 177?选项禁止显示这些警告。

178：应用于数组的“&”不起作用

179：“%”的右操作数为零

180：参数与形式参数不兼容

181：参数与对应的格式字符串转换不兼容

例如，使用 --strict?进行编译时，代码如下：

unsigned long foo = 0x1234;
printf("%08X", foo);

导致警告：

Warning: #181-D: argument is incompatible with corresponding format string conversion

为避免出现警告，可以按如下方式重写代码：

unsigned long foo = 0x1234;
printf("%0lX", foo);

或者：

unsigned int foo = 0x1234;
printf("%0X", foo);

%0X?可用于?char、short?或?int。将?lX?用于长整数，即使?ints 和?longs 在 ARM 处理器上都是 32 位宽。

182：无法打开源文件<实体>（搜索列表中没有目录）

183：铸件类型必须是整体式的

184：强制转换类型必须是算术或指针

185：无法访问代码中的动态初始化

186：无符号整数与零的无意义比较

例如：

unsigned short foo;
if (foo<0) printf("This never happens");

发出警告，指出无符号值（例如?char?或?int）与零之间的比较结果始终为 false。

187：在“==”可能有意的地方使用“=”

例如：

int main(void)
{
  int a;
  const int b =1;
  if (a=b);
}

如果?if?语句中的赋值是有意为之，则可以通过添加显式比较来避免出现警告。例如，将示例中的?if?语句更改为：

  if ((a=b)!=0);

188：枚举类型与另一种类型混合

189：写入 <entity> 文件时出错

190：无效的中间语言文件

191：类型限定符对 cast 类型没有意义

C 规范指出，强制转换不会产生左值，因此强制转换为合格类型与强制转换为该类型的不合格版本具有相同的效果。此警告旨在通知您，尽管代码仍然合法，但类型限定符不起作用。该警告可通过 --diag_suppress 191?抑制。

例如：

val2 = (const float)val1;

相当于：

val2 = (float)val1;

192：无法识别的字符转义序列

此错误通常与尝试使用非 ASCII 字符集（如 16 位 Unicode 字符）相关联。编译器支持多字节字符集，例如 Unicode。源文件根据该计算机的所选区域设置进行编译。可以使用转义处理（根据 Kernighan 和 Ritchie 的建议，第 A2.5.2 节）来对特定值进行编码。

例如：

char *p = "\x12\x34\x56\x78"; // 12 34 56 78

在字符和字符串转义中，如果 \ 后面的字符没有特殊含义，则转义的值是字符本身，例如，\s 与?s?相同，并给出警告。

193：零用于未定义的预处理标识符 <entity>

194：应为 ASM 字符串

195：必须对 ASM 函数进行原型设计

196：ASM 函数可能没有省略号

219：删除文件时出错<实体>

220：整数值不适合所需的浮点类型

221：浮点值不适合所需的浮点类型

222：浮点运算结果超出范围

223：函数<实体>隐式声明

这是在没有函数原型的情况下发生的常见警告。

例如：

void foo(void)
{
  printf("foo");
}

要解决此问题，请添加?#include < stdio.h>?以包含?printf（）?的原型。

对于 ANSI C，可以使用 --diag_suppress 223?禁止显示此警告。这在 ANSI C 模式下编译旧式 C 时很有用。

224：格式字符串需要额外的参数

225：格式字符串在此参数之前结束

226：格式字符串转换无效

227：宏递归

228：尾随逗号不规范

229：bit 字段不能包含枚举类型的所有值

230：位字段的非标准型

在严格的 ANSI C90 中，位字段允许的唯一类型是 int、signed int?和?unsigned int。

例如：

struct X {
   char y:2;
};

231：声明在函数外部不可见

232：“void”的老式typedef被忽略了

233：左操作数不是包含此字段的结构或并集

234：指针不指向包含此字段的结构或并集

235：变量 <entity> 声明为永不完成的类型

236：控制表达式是常数

237：选择器表达式是常量

238：参数说明符无效

239：类声明外部的说明符无效

240：声明中的重复说明符

241：联合不允许有基类

242：不允许使用多个访问控制说明符

243：缺少类或结构定义

244：限定名不是类 <type> 或其基类的成员

245：非静态成员引用必须相对于特定对象

246：非静态数据成员不能在其类之外定义

247：<实体> 已定义

一个典型的例子是变量名称被多次使用。

在编译依赖于暂定声明的旧代码时，有时会发生这种情况。暂定声明允许将变量声明并初始化为单独的语句，例如：

int a;
int a = 1;

默认情况下，C 代码允许临时声明，但 C++ 代码会产生错误。

248：不允许指针引用

249：不允许引用引用

250：不允许引用 void

251：不允许使用引用数组

252：引用<实体>需要初始值设定项

253：预期为“，”

254：不允许使用类型名称

当在表达式中直接使用 typedef 名称时，会发生这种情况，例如：

typedef int footype;
int x = footype; // reports Error: #254: type name is not allowed

若要解决此问题，请首先创建该类型的实例，例如，新类型的变量：

typedef int footype;
footype bar = 1;
int x = bar;

255：不允许类型定义

256：类型名称 <entity> 的重新声明无效

257：const <entity> 需要初始值设定项

258：“this”只能在非静态成员函数内部使用

259：常量值未知

260：缺少显式类型（假定为“int”）

261：未指定访问控制（默认为<实体>）

262：不是类或结构名称

263：重复的基类名称

264：无效的基类

265：<entity> 无法访问

仅供C++，--diag_warning 265?选项将访问控制错误降级为警告。

例如：

class A { void f() {}; }; // private member
A a;
void g() { a.f(); } // erroneous access

结果显示以下消息：

Error: #265-D: function "A::f" is inaccessible

266：<实体>模棱两可

267：老式参数列表（不合时宜）

268：声明可能不会出现在块中的可执行语句之后

269：不允许转换为不可访问的基类 <type>

274：未正确终止的宏调用

276：name 后跟 “：：” 必须是类或命名空间名称

277：无效的好友声明

278：?构造函数或析构函数不能返回值

279：析构函数声明无效

280：声明与其类同名的成员

281：不允许使用全局范围限定符（前导“：：”）

282：全局范围没有<实体>

283：不允许使用限定名称

?284：不允许引用 NULL

285：初始化为“<...>“不允许用于 <type> 类型的对象

286：基类<类型>不明确

287：派生类 <type> 包含类 <type 的多个实例>

288：无法将指向基类 <type> 的指针转换为指向派生类 <type> 的指针 -- 基类是虚拟的

289：构造函数 <Entity> 的实例与参数列表不匹配

290：类 <Type> 的复制构造函数不明确

291：类 <type 不存在默认构造函数>

292：<Entity> 不是类 <type> 的非静态数据成员或基类

293：不允许间接非虚拟基类

294：无效的联合成员 -- 类<类型>具有不允许的成员函数

296：无效使用非左值数组

297：应为操作员

298：不允许继承成员

299：无法确定 <entity> 的哪个实例

300：指向绑定函数的指针只能用于调用该函数

301：typedef 名称已声明（类型相同）

302：<entity> 已定义

304：没有 <entity> 的实例与参数列表匹配

305：函数返回类型声明中不允许类型定义

306：默认参数不在参数列表的末尾

307：重新定义默认参数

308：<entity> 的多个实例与参数列表匹配：

309：构造函数 <Entity> 的多个实例与参数列表匹配：

310：<type> 类型的默认参数与 <type 类型的参数不兼容>

311：不能仅通过返回类型来重载函数

312：不存在从<type>到<type>的合适用户定义转换

314：只有非静态成员函数可以是虚拟的

315：对象具有与成员函数不兼容的类型限定符

316：程序太大，无法编译（虚函数太多）

317：返回类型与被覆盖的虚函数 <entity） 的返回类型 <type> 不相同或协变>

318：虚拟<实体>的覆盖不明确

319：纯说明符 （“= 0”） 只允许在虚拟函数上使用

320：格式不正确的纯说明符（只允许“= 0”）

321：不允许使用数据成员初始值设定项

322：不允许抽象类类型 <type> 的对象：

323：不允许函数返回抽象类 <type>：

324：重复好友声明

325：仅允许在函数声明上使用内联说明符

326：不允许使用“内联”

327：内联函数的存储类无效

328：类成员的存储类无效

329：本地类成员<实体>需要定义

330：<实体>无法访问

332：类<类型>没有复制构造函数来复制 const 对象

333：不允许定义隐式声明的成员函数

334：类<类型>没有合适的复制构造函数

335：不允许有联动规范

336：未知的外部链接规格

337：链接规范与以前的<实体不兼容>

如果使用与先前声明不兼容的规范重新声明函数的链接，则会产生此错误。

例如：

int foo(void);
int bar(void)
{
  int x;
  x = foo();
  return x;
}
extern "C" int foo(void)
{
  return 0;
}

结果显示以下消息：

Error: #337: linkage specification is incompatible with previous "foo" (declared at line 1)

338：重载函数 <entity> 的多个实例具有“C”链接

339：class <type> 具有多个默认构造函数

340：值复制到临时，引用临时使用

341：“operator<entity>”必须是成员函数

342：运算符不能是静态成员函数

343：用户定义的转换不允许任何参数

344：此运算符函数的参数过多

345：此运算符函数的参数太少

346：非成员运算符需要类类型的参数

347：不允许使用默认参数

348：从<type>到<type>的多个用户定义的转换适用：

349：没有运算符 <entity> 与这些操作数匹配

350：多个运算符 <entity> 匹配以下操作数：

351：分配函数的第一个参数必须为“size_t”类型

352：分配函数需要“void *”返回类型

353：释放函数需要“void”返回类型

354：释放函数的第一个参数必须为“void *”类型

356：type 必须是对象类型

357：基类<类型>已初始化

358：需要基类名称 -- 假定<类型>（不合时宜）

359：<entity> 已初始化

360：缺少成员或基类的名称

361：分配给“这个”（不合时宜）

362：使用“重载”关键字（不合时宜）

363：无效的匿名联盟 -- 不允许非公开成员

364：匿名联合无效 -- 不允许成员函数

365：全局或命名空间范围的匿名联合必须声明为静态

366：<entity> 不提供以下初始值设定项：

367：类 <type> 的隐式生成的构造函数无法初始化：

368：<entity> 未定义用于初始化以下内容的构造函数：

这表示您有一个?const?结构或一个包含?const?的结构。它作为友好警告发出，以帮助解决错误 369。如果结构的?const?成员已正确初始化，则可以安全地忽略这一点。

369：<entity> 具有未初始化的 const 或引用成员

这表示您有一个?const?结构的实例或一个包含尚未正确初始化的?const?的结构。您必须为每个实例正确初始化它，或者提供构造函数来初始化它。

370：<entity> 具有未初始化的 const 字段

371：类<类型>没有用于复制 const 对象的赋值运算符

372：class <type>没有合适的赋值运算符

373：类 <type> 的不明确赋值运算符

375：声明需要 typedef 名称

377：不允许使用“虚拟”

378：“静态”是不允许的

379：将绑定函数转换为正常函数指针（不合时宜）

380：表达式必须具有指向成员类型的指针

381：extra “;” 忽略

在 C 中，这可能是由声明行末尾的意外分号引起的，例如：

int x;;

使用宏时，可能会无意中发生这种情况。

同样，在 C++ 中，这可能是由以下结构引起的：

class X { ... } ; ;

这可能是由于某些宏用法导致的，例如：

#define M(c) class c { ... } ;
M(X);

额外的分号是非法的，因为空声明是非法的。

382：非静态成员的类内初始值设定项是非标准的

384：没有重载 <Entity> 的实例与参数列表匹配

386：没有<实体>实例与所需类型匹配

387：删除使用的数组大小表达式（不合时宜）

389：不允许强制转换为抽象类 <type>：

390：函数“main”不得调用或获取其地址

391：不能为数组指定 new-initializer

392：成员函数<实体>不能在其类之外重新声明

393：不允许指针指向不完整的类类型

394：不允许引用封闭函数的局部变量

395：用于后缀<实体>的单参数函数（不合时宜）

397：隐式生成的赋值运算符无法复制：

398：转换为数组类型是非标准的（被视为转换为<类型>）

399：<entity> 有一个运算符 new<entity>（），但没有默认运算符 delete<entity>（）

400：<entity> 有一个默认运算符 delete<entity>（），但没有运算符 new<entity>（）

401：基类 <entity> 的析构函数不是虚拟的

403：成员<实体的重新声明无效>

404：函数“main”不能以内联方式声明

405：与其类同名的成员函数必须是构造函数

406：使用嵌套<实体>（不合时宜）

407：析构函数可能没有参数

408：类 <type> 的复制构造函数可能没有 <type> 类型的参数

409：<entity> 返回不完整的类型 <type>

410：无法通过<类型>指针或对象访问受保护的<实体>

411：不允许使用参数

412：此处不允许使用“ASM”声明

413：不存在从<type>到<type>的合适转换函数

414：删除指向未完成类的指针

415：没有合适的构造函数将 <type> 转换为 <type>

416：多个构造函数适用于 <type> 转换为 <type>：

417：从<类型>到<类型>的多个转换函数适用：?

418：从<类型>到内置类型的多个转换函数适用：

424：构造函数或析构函数的地址可能没有被占用

426：临时用于引用非常量（不合时宜）的初始值

427：会员声明中不允许使用限定名称

428：枚举类型与另一种类型混合（不合时宜）

429：“new”中数组的大小必须为非负数

430：返回对本地临时的引用

432：不允许使用“枚举”声明

433：将类型<类型>绑定引用中的限定符删除到 <类型>

434：不能使用类型 <type> 的值初始化类型为 <type> 的引用（非常量限定）。

435：不能删除指向函数的指针

436：转换函数必须是非静态成员函数

437：此处不允许使用模板声明

438：期待“<”

439：期待“>”

440：缺少模板参数声明

441：缺少<entity>的参数列表

442：<实体的论据太少>

443：<实体的论据太多>

445：%n1 不用于声明 %n2 的参数类型

446：两个嵌套类型具有相同的名称：%no1 和 %nod2（前端兼容性）

447：在嵌套 %nod2 之后声明全局 %NO1（前端兼容性）

449：%n 的多个实例与所需类型匹配

450：“长长”型非标

451：省略<实体>是不标准的

452：不能在转换函数上指定返回类型

456：实例化 <entity 时过度递归>

457：<entity> 不是函数或静态数据成员

458：<type> 类型的参数与 <type> 类型的模板参数不兼容

459：不允许需要临时或转换的初始化

460：声明<实体>隐藏函数参数

461：引用非常量的初始值必须为左值

463：不允许使用“模板”

464：<type> 不是类模板

466：“main”不是函数模板的有效名称

467：对<实体>引用无效（联合/非联合不匹配）

468：模板参数不能引用本地类型

469：标记类型的<实体>与<实体的声明不兼容>

470：全局范围没有名为 <entity> 的标记

471：<entity> 没有名为 <entity 的标记成员>

472：成员函数 typedef（允许 cfront 兼容性）

473：<entity> 只能用于指向成员的指针声明

475：模板参数不能引用非外部实体

476：name 后跟“：：~”必须是类名或类型名

478：用作析构函数名称的类型与类型 <type> 不匹配

479：<entity> 在被调用后重新声明为“内联”

481：模板声明的存储类无效

482：%nd 是不可访问的类型（允许 cfront 兼容性）

484：无效的显式实例化声明

485：<entity> 不是可以实例化的实体

486：编译器生成的<实体>无法显式实例化

487：内联<实体>无法显式实例化

489：%n 无法实例化 -- 未提供模板定义

490：<entity> 无法实例化 -- 它已被显式专用化

493：没有 %n 的实例与指定的类型匹配

494：使用 typedef 声明 void 参数列表是不标准的

当编译器未处于 C99 模式时，此错误由函数声明?f（V）?生成，其中?V?是?void?类型。

仅在 C99 模式下允许使用作为 typedef?的参数来表示函数没有参数。

495：使用全局 %n1 代替 %n2（前端兼容性）

496：模板参数<实体>不能在此范围内重新声明

497：声明<实体>隐藏模板参数

498：模板参数列表必须与参数列表匹配

500：后缀 \“operator%s\” 的额外参数必须为 \“int\” 类型

501：必须将运算符名称声明为函数

502：不允许使用操作员名称

503：<实体>不能在当前范围内专门化

504：用于获取成员函数地址的非标准形式

C++ 标准要求使用限定符和 & 字符（例如?&A：：f）命名指向成员的指针。

505：模板参数太少 -- 与之前的声明不匹配（声明<实体>）

506：模板参数过多 -- 与之前的声明不匹配（声明<实体>）

507：不允许使用运算符 delete（void *） 的函数模板

508：类模板和模板参数的名称可能不同

510：模板参数不能引用未命名的类型

511：对枚举类型的此操作需要适用的用户定义运算符函数

512：不允许在引用类型上使用类型限定符

513：不能将 <type> 类型的值分配给 <type> 类型的实体

514：无符号整数与负常数的无意义比较

515：无法转换为不完整的类<类型>

516：const 对象需要初始值设定项

517：对象具有未初始化的常量或引用成员

518：非标准预处理指令

519：<entity> 可能没有模板参数列表

520：使用“<...聚合对象应为 >”

521：指向成员的指针选择类类型不兼容（<type> 和 <type>）

第522章?毫无意义的好友声明

523：\“.\” 代替 \“：：\” 以形成限定名称

524：const 对象调用非常量函数（不合时宜）

525：从属语句不能是声明

526：参数可能没有 void 类型

例如：

void foo(void a) { }

529：模板参数表达式中不允许使用此运算符

530：try 块至少需要一个处理程序

531：处理程序需要异常声明

532：处理程序被默认处理程序屏蔽

533：处理程序可能被类型 <type> 的上一个处理程序屏蔽

534：使用本地类型指定异常

535：异常规范中的冗余类型

536：异常规范与以前的<实体的异常规范不兼容>

540：禁用对异常处理的支持;使用 --exceptions 启用

541：允许所有例外与以前的<实体不兼容>

542：?无法创建实例化请求文件 <entity>

543：非类型模板参数中不允许非算术运算

544：使用局部类型声明非局部变量

545：使用局部类型声明函数

546：控制权的转移绕过了以下各项的初始化：

例：

int main(void){
   int choice = 1;
   int z =1;
   switch(choice)
   {
     case 1:
       int y = 1;
       z = y + z;
       break;
     case 2:
     break;
   }
   return 0;

在此示例中，y?是一个初始化的变量，该变量在作用域内，但在其他情况下未使用。从?switch?语句的条件到大小写标签的传输绕过?y?的初始化，与 C++ 标准冲突。

解决此问题的常用方法是将声明?y?的大小写括在大括号中。以下代码将?y?的范围限制为情况?1，因此尝试在其他地方使用它会导致错误：

case 1:   {
  int y = 1;
  z = y + z;
}
break;

由于?y?是普通旧数据 （POD） 类型，因此另一种方法是不使用初始化：

case 1:
 int y;
 y = 1;
 z = y + z;
 break;

这种方法的缺点是，如果案例?1 之外的代码使用?y，并且意外地期望它具有在案例?1 中分配的值，则不会发出警告。

548：将控制权转移到异常处理程序中

549：<entity> 在设置其值之前使用

550：<entity> 已设置但从未使用

551：<实体>不能在当前范围内定义

552：不允许异常规范

553：<实体的外部/内部联系冲突>

554：<entity> 不会被调用进行隐式或显式转换

555：<entity> 的标记类型与类型为 <type> 的模板参数不兼容

556：不允许使用运算符 new（size_t） 的函数模板

558：不允许指向类型 <Type> 的成员的指针

559：算子函数参数列表中不允许使用省略号

560：<entity> 保留供将来用作关键字

561：无效的宏定义：

562：无效的宏未定义：

563：无效<实体>输出文件<文件名>

564：无法打开<实体>输出文件<文件名>：<原因>

565：如果输入为

570：调试选项参数出错

571：无效选项：

572：后端需要 IL 文件的名称

573：无法打开IL文件

574：无效号码：

575：主机 CPU ID 不正确

576：无效的实例化模式：

578：无效的错误限制：

585：虚函数表只能在编译 C++ 时禁止显示

586：不合时宜选项只能在编译 C++ 时使用

587：实例化模式选项只能在编译 C++ 时使用

588：自动实例化模式只能在编译 C++ 时使用

589：隐式模板包含模式只能在编译 C++ 时使用

590：异常处理选项只能在编译 C++ 时使用

591：严格模式与K&R模式不兼容

592：严格模式与 cfront 模式不兼容

593：缺少源文件名

594：编译多个输入文件时，可能无法指定输出文件

595：命令行上的参数过多

596：指定了输出文件，但不需要任何输出文件

597：IL?显示需要 IL 文件的名称

598：模板参数可能没有 void 类型

599：由于全部实例化模式，%n 的递归实例化过多

600：严格模式与允许不合时宜不兼容

601：抛出表达式可能没有 void 类型

602：本地实例化模式与自动实例化不兼容

603：不允许使用抽象类类型 <type> 的参数：

604：不允许使用抽象类 <type> 的数组：

605：浮点模板参数不标准

606：此编译指示必须紧接在声明之前

607：此编译指示必须紧接在声明之前

608：此编译指示必须紧接在声明或声明之前

609：这里不能使用这种杂注

611：重载的虚函数<实体>在<实体中仅部分覆盖>

612：内联模板函数的具体定义必须在首次使用之前进行

613：诊断控制选项中的错误标记无效：

614：诊断控制选项中的错误号无效：

615：参数类型涉及指向未知边界数组的指针

616：参数类型涉及对未知边界数组的引用

617：指向成员函数的指针强制转换为指向函数的指针

618：struct 或 union 声明没有指定成员

619：非标准未命名字段

620：非标准未命名成员

624：<entity> 不是类型名称

625：无法打开预编译的头输入文件 <entity>： <reason>

626：预编译头文件 <entity> 无效或不是由此版本的编译器生成的

627：此目录中未生成预编译头文件 <entity>

628：用于生成预编译头文件<实体>的头文件已更改

629：?命令行选项与创建预编译头文件 <entity> 时使用的选项不匹配

630：预處指令的初始領序與預訂頭討文件<entity>的初始頻序不相容

631：无法获取<实体>的映射内存：<原因>

如果尝试使用大型预编译标头 （PCH），并且对 ARM 编译器工具链使用的?TMP?目录有大小限制，则可能会发生这种情况。一种可能的解决方法是删除?TMP?环境变量。这将强制工具在当前工作目录中创建临时文件。

请参阅《入门指南》中的以下内容：

临时文件目录的 TMP 和 TMPDIR 环境变量.

请参阅《armcc 用户指南》中的以下内容：

预编译头 （PCH） 文件.

632：“<entity>”：使用预编译的头文件“<entity>”

633：“<entity>”：创建预编译头文件“<entity>”

634：内存使用与预编译头文件冲突<实体>

如果由于编译器地址空间的必需部分不可用而无法将 PCH 文件映射回生成，则可能会发生这种情况。

另请参阅错误?631。

635：PCH 内存大小无效

636：PCH 选项必须首先出现在命令行中

637：PCH 内存分配内存不足

638：编译多个输入文件时，不得使用预编译头文件

639：预分配内存不足，无法生成预编译头文件（需要<实体>字节）

640：?程序中非常大的实体阻止生成预编译的头文件

641：<entity> 不是有效的目录

642：无法生成临时文件名

643：“限制”是不允许的

644：指针或对函数类型的引用不能由“限制”限定

646：此处可能未指定调用约定修饰符

647：冲突的调用约定修饰符

648：严格模式与 Microsoft 模式不兼容

649：前端模式与 Microsoft 模式不兼容

650：此处指定的调用约定将被忽略

651：嵌套声明器不得遵循调用约定

652：此类型忽略调用约定

654：声明修饰符与先前的声明不兼容

655：此声明中不允许使用修饰符<实体>

656：将控制权转移到 try 块中

657：内联规范与以前的<实体不兼容>

658：找不到模板定义的右大括号

659：wchar_t 关键字选项只能在编译C++时使用

660：无效的包装对齐值

661：预期为整数常量

662：纯虚函数的调用

正在调用纯虚函数，例如：

struct T { T(); virtual void pvfn() = 0; };
                   // a pure virtual function
T::T() { pvfn(); } // warning given here

默认情况下，调用纯虚函数会导致：

1. 调用库函数?__cxa_pure_virtual（）

2. __cxa_pure_virtual（）?函数引发信号?SIGPVFN

3. 信号被default_signal_handler捕获

4. 显示使用半托管在控制台上调用的纯虚拟 fn?的处理程序。

请参阅《armcc 用户指南》中的以下内容：

调用纯虚函数.

663：源文件标识符字符串无效

664：?不能在友元声明中定义类模板

665：“ASM”是不允许的

666：“ASM”必须与函数定义一起使用

667：“ASM”功能不标准

668：没有显式参数的省略号是非标准的

669：“&...”是非标准的

670：无效使用“&...”

672：临时用于引用常量易失性（不合时宜）的初始值

673：?<entity>类型的引用不能用 <entity> 类型的值进行初始化

674：引用 const volatile 的初始值必须为 lValue。

675：SVR4 C 兼容性选项只能在编译 ANSI C 时使用

676：使用超出范围的 <实体声明>

677：严格模式与SVR4 C模式不兼容

678：不能内联调用<实体>

679：<实体>不能内联

680：无效的 PCH 目录：

681：预期__except或__finally

682：__leave声明只能在__try内使用

688：<实体>在包对齐堆栈上找不到

689：空包装对齐堆栈

690：RTTI 选项只能在编译 C++ 时使用

691：<entity> 是无法访问的，这是已删除的副本所必需的

692：<entity>（已消除的复制所必需）不可调用，因为引用参数无法绑定到 rValue

在使用 typeid 之前，必须包含?693：<typeinfo>

694：<entity> 不能放弃 const 或其他类型的限定符

695：dynamic_cast中的类型必须是指向完整类类型的指针或引用，或者是 void *

696：指针dynamic_cast的操作数必须是指向完整类类型的指针

697：引用dynamic_cast的操作数必须是完全类类型的左值

698：运行时dynamic_cast的操作数必须具有多态类类型

699：bool 选项只能在编译 C++ 时使用

701：此处不允许使用数组类型

702：应为“=”

703：条件声明中的预期声明符

704：<entity>，在条件中声明，不得在此范围内重新声明

705：函数模板不允许使用默认模板参数

706：应为“”或“>”

707：需要模板参数列表

708：不推荐使用递增布尔值

709：不允许使用布尔类型

710：?类 <entity> 内基类 <entity> 的偏移量过大

711：表达式必须具有 bool 类型（或可转换为 bool）

712：数组 new 和 delete 选项只能在编译 C++ 时使用

713：<entity> 不是变量名称

此处不允许使用?714：__based 修饰符

715：__based 不在指针运算符之前，__based忽略

716：修饰符中的变量必须具有指针类型__based

717：const_cast中的类型必须是指向对象类型的成员的指针、引用或指针

718：A const_cast只能调整类型限定符;它不能更改基础类型

719：不允许可变

720：<实体>的重新声明不得改变其访问权限

722：使用替代令牌“<：”似乎是无意的

723：使用替代令牌“%：”似乎是无意的

724：不允许定义命名空间

725：name 必须是命名空间名称

726：不允许使用命名空间别名定义

727：命名空间限定的名称是必需的

728：不允许使用命名空间名称

729：DLL 属性组合无效

730：<entity> 不是类模板

731：元素类型不完整的数组是非标准的

732：分配运算符不能在命名空间中声明

733：不能在命名空间中声明释放运算符

734：<实体>与<实体的使用声明冲突>

735：使用<实体的声明>与<实体冲突>

736：命名空间选项只能在编译 C++ 时使用

737：using-declaration 忽略 -- 它指的是当前命名空间

738：需要类限定名称

742：%n 没有实际成员 %sq

744：指定不兼容的内存属性

745：忽略内存属性

746：内存属性后面可能没有嵌套的声明符

747：多次指定内存属性

748：多次指定的调用约定

749：不允许使用类型限定符

750：<entity> 在声明其模板之前使用

751：不能重载具有相同参数类型的静态和非静态成员函数

752：没有事先声明<实体>

753：不允许使用模板 ID

754：不允许使用类限定名称

755：<实体>不得在当前范围内重新声明

756：命名空间成员声明中不允许使用限定名

757：<entity> 不是类型名称

758：当前作用域中不允许显式实例化

759：<entity> 无法在当前作用域中显式实例化

760：<entity> 显式实例化了不止一次

761：typename 只能在模板中使用

762：special_subscript_cost 选项只能在编译C++时使用

763：typename 选项只能在编译 C++ 时使用

764：隐式类型名称选项只能在编译 C++ 时使用

765：类对象宏定义开头的非标准字符

766：虚拟<实体>的异常规范与覆盖的<实体的异常规范不兼容>

767：从指针到较小整数的转换

768：隐式声明的虚拟<实体>的异常规范与被覆盖的<实体的异常规范不兼容>

769：<entity>，隐式调用自 <entity>p2，是模棱两可的

770：选项“显式”只能在编译 C++ 时使用

771：“显式”是不允许的

772：声明与 <entity>（保留类名）冲突

773：只允许使用“（）”作为数组<实体的初始值设定项>

774：函数模板声明中不允许使用“虚拟”

775：无效的匿名联合 -- 不允许使用类成员模板

776：模板嵌套深度与之前的 <entity 声明不匹配>

777：此声明不能有多个“模板<...>“条款

778：控制 for-init 范围的选项只能在编译 C++ 时使用

在 for 循环初始化中声明的?779：<entity> 不能在此作用域中重新声明

780：引用是<实体> -- 在旧的 for-init 作用域规则下，它应该是 <entity>

781：控制 for-init 差异警告的选项只能在编译 C++ 时使用

782：这里需要虚拟<实体>的定义

783：空注释被解释为标记粘贴运算符“##”

784：好友声明中不允许使用存储类

785：此声明中不允许<实体>的模板参数列表

786：<entity> 不是有效的成员类或函数模板

787：无效的成员类或函数模板声明

788：包含模板参数列表的模板声明后不能跟显式专用化声明

789：<实体>的明确专业化必须在首次使用<实体之前进行>

790：当前范围内不允许显式专业化

791：不允许对<实体>进行部分专业化

792：<entity>不是一个可以明确专门化的实体

793：<实体>的明确专业化必须在首次使用之前

794：模板参数<实体>不能用于详述的类型说明符

795：特殊化<实体>需要“模板<>”语法

798：选项“old_specializations”只能在编译C++时使用

799：专门化<实体>没有“模板<>”语法是不标准的

800：此声明可能没有外部“C”联动

801：<entity> 不是当前作用域中的类或函数模板名称

802：在重新声明未引用的函数模板时指定默认参数是非标准的

803：不允许在重新声明已引用的函数模板时指定默认参数

804：无法将指向基类成员 <type> 的指针转换为指向派生类 <type> 成员的指针 -- 基类是虚拟的

805：异常规范与 <entity><entity> 不兼容

806：允许所有例外与 <实体不兼容>

807：默认参数表达式意外结束

808：不允许对引用进行默认初始化

809：未初始化的<entity>具有 const 成员

810：未初始化的基类 <type> 具有 const 成员

811：const <entity> 需要初始值设定项 -- 类 <type> 没有用户提供的默认构造函数

812：const 对象需要初始值设定项 -- 类 <type> 没有用户提供的默认构造函数

813：选项“implicit_extern_c_type_conversion”只能在编译C++时使用

814：严格模式与长保留规则不兼容

815：返回类型的类型限定符无意义

例如：

__packed void foo( void ) { }

忽略 __packed?限定符，因为无法__packed返回类型。

816：在函数定义中，不允许在“void”返回类型上使用类型限定符

817：此类中不允许使用静态数据成员声明

818：模板实例化导致函数声明无效

819：“......”是不允许的

?820：选项“extern_inline”只能在编译C++时使用

821：外部内联<实体>被引用但未定义

822：?类型 <type> 的析构函数名称无效

824：析构函数引用不明确 -- 可以使用<entity>和<entity>

825：虚拟内联<实体>从未定义过

826：<entity> 从未被引用

827：在构造函数初始值设定项列表中只能指定一个联合成员

828：禁用对“new[]”和“delete[]”的支持

829：“double”用于生成的 C 代码中的“long double”

830：<entity> 没有相应的运算符 delete<entity>（如果在初始化已分配对象期间引发异常，则调用）

831：对放置删除的支持已禁用

832：没有可见的适当运算符删除

833：不允许指针或引用不完整的类型

834：无效的部分专用化 -- <实体>已完全专用化

835：不兼容的异常规范

836：返回对局部变量的引用

837：省略显式类型是非标准的（假定为“int”）

已声明或定义没有返回类型的函数。

示例，代码如下：

foo(void){
    int a;
}

假定为?int?结果。

如果希望它不返回任何结果，请使用?void?作为返回类型。这在旧式 C 中很普遍。

--diag_suppress 837?选项禁止显示此警告。

另请参阅消息编号?938，这是?main（）?此消息的特例。

838：多个部分专用化与 <entity 的模板参数列表匹配>

840：在主模板的声明中不允许使用模板参数列表

841：部分专用化可能没有默认的模板参数

842：<entity>1 未用于或无法从 <entity 的模板参数列表中推导出>

844：部分专用化的模板参数列表包括一个非类型参数，其类型取决于模板参数

845：此部分专用化将用于实例化<实体>

846：这种部分特殊化会使<实体>的实例化变得模棱两可

847：表达式必须具有整数或枚举类型

848：表达式必须具有算术或枚举类型

849：表达式必须具有算术、枚举或指针类型

850：铸件类型必须为积分或枚举

851：强制转换类型必须为算术、枚举或指针

852：表达式必须是指向完整对象类型的指针

854：部分专用化非类型参数必须是非类型参数的名称或常量

855：?返回类型与被覆盖的虚函数 <entity> 的返回类型 <type>?不同

856：选项“guiding_decls”只能在编译C++时使用

857：类模板的部分专用化必须在它所属的命名空间中声明

858：<entity> 是一个纯虚函数

859：纯虚拟<实体>没有超凡者

忽略 860：__declspec 属性

861：输入行中的字符无效

862：函数返回不完整类型 <type>

863：此“#pragma 包”指令的效力是<实体的本地>

864：<实体>不是模板

865：好友声明不得声明部分专业化

866：忽略异常规范

867：“size_t”的声明与预期的类型 <type> 不匹配

868：嵌套模板参数列表的相邻“>”分隔符之间所需的空间（“>>”是右移位运算符）

869：?无法设置区域设置<实体>以允许处理多字节字符

870：无效的多字节字符序列

871：模板实例化导致意外的函数类型 <type>（自模板声明以来，名称的含义可能已更改 -- 模板的类型为 <type>）

872：不明确的指导性声明 -- 多个函数模板 <entity> 与类型 <type> 匹配

873：非类型模板参数中不允许非整型运算

874：选项“embedded_c++”只能在编译C++时使用

875：嵌入式 C++ 不支持模板

876：嵌入式 C++ 不支持异常处理

877：嵌入式 C++ 不支持命名空间

878：嵌入式 C++ 不支持运行时类型信息

879：嵌入式 C++ 不支持新的强制转换语法

880：嵌入式 C++ 不支持使用声明

881：嵌入式 C++ 不支持“可变”

882：嵌入式 C++ 不支持多重继承或虚拟继承

883：无效的 Microsoft 版本号：

884：已为 <entity?设置了指向成员表示的指针 <entity>>

885：<type> 不能用于指定 <type 的构造函数>

886：积分常数上的后缀无效

887：__uuidof操作数必须具有指定了 __declspec（uuid（\“...\”）） 的类或枚举类型

888：__declspec（uuid（\“...\”）） 中的 GUID 字符串无效

889：选项“vla”只能在编译 C 时使用

890：不允许使用未指定边界的可变长度数组

891：此声明中不允许使用显式模板参数列表

892：具有链接的实体不能具有涉及可变长度数组的类型

893：可变长度数组不能有静态存储持续时间

894：<实体>不是模板

896：预期为模板参数

898：非成员运算符需要具有类或枚举类型的参数

899：选项“enum_overloading”只能在编译C++时使用

901：析构函数名称 %t1 的限定符与类型 %t2 不匹配

902：类型限定符被忽略

903：选项“nonstd_qualifier_deduction”只能在编译C++时使用

904：声明为“dllimport\”的函数可能未定义

905：属性规范不正确;正确的形式是 __declspec（property（get=name1，put=name2））

906：属性已指定

907：__declspec（property）不允许在此声明中使用

908：成员是用 __declspec（property） 声明的，但没有指定 \“get\” 函数

909：?缺少 __declspec（property） \“get\” 函数 %sq

910：成员用 __declspec（property） 声明，但没有指定 \“put\” 函数

911：?缺少 __declspec（property） \“put\” 函数 %sq

912：模棱两可的类成员引用 -- <entity>优先于 <entity>

916：无法将指向派生类 <type> 成员的指针转换为指向基类 <type> 成员的指针 -- 基类是虚拟的

917：实例化文件的目录无效：

918：选项“one_instantiation_per_object”只能在编译C++时使用

921：编译多个输入文件时，不能指定实例化信息文件名

922：编译多个输入文件时，不能使用选项“one_instantiation_per_object\”

923：多个命令行选项与缩写“--<entity>”匹配：

925：忽略函数类型的类型限定符

927：迟到/早决选项只能在编译 C++ 时使用

928：不正确地使用va_start

如果在?PATH?环境变量上引用了较旧的 ARM 工具，并且对于以下 ARM 环境变量，则可能会生成此错误：

• ARMCONF
• ARMDLL
• ARMHOME
• ARMINC
• ARMLIB

删除这些环境变量以及?PATH?上对旧工具的任何引用，然后重复编译。

以下示例显示了?va_start（）?的用法：

#include <stdio.h>
#include <stdarg.h>

void error(char *fmt, ...)
{
        va_list args;

        va_start(args, fmt);
        vprintf(format, args);
        va_end(args);
}

929：不正确地使用va_arg

930：不正确地使用va_end

931：挂起的实例化选项只能在编译 C++ 时使用

932：#import 文件的目录无效：

933：?导入目录只能在 Microsoft 模式下指定

934：联合中不允许使用具有引用类型的成员

935：“typedef”此处可能未指定

936：重新声明<实体>改变其访问权限

937：类或命名空间限定名是必需的

938：在函数“main”的声明中省略了返回类型“int”

main（）?已声明或定义，没有返回类型。

例如：

main(void){
  int a;
}

如果使用?--strict?编译，则编译器会报告为错误。

如果希望它不返回任何结果，请使用?void?作为返回类型。这在旧式 C 中很普遍。

对于 ANSI C，--diag_suppress 938?选项禁止显示此警告。

对于 C++，这总是会导致错误。

有关更一般的情况，另请参阅消息编号?837。

939：指向成员表示的指针 <entity> 对于 <entity 来说限制性太强>

940：非无效<实体末尾缺少返回语句>

已为函数定义了返回类型，但未返回任何值。

例：

int foo(int a)
{
  printf("Hello %d", a);
}

941：忽略<实体>的重复 using-declaration

942：枚举位字段始终是无符号的，但枚举<类型>包括负枚举器

943：选项“class_name_injection”只能在编译C++时使用

944：选项“arg_dep_lookup”只能在编译C++时使用

945：选项“friend_injection”只能在编译C++时使用

946：“模板”后面的名称必须是模板

948：非标准局部类友元声明 -- 封闭范围内没有事先声明

949：在此声明中指定默认参数是非标准的

950：选项“nonstd_using_decl”只能在编译C++时使用

951：函数“main”的返回类型必须为“int”

952：?非类型模板参数可能没有类类型

953：?不能在类模板外部的类成员的声明中指定默认模板参数

954：?在构造函数的函数 try 块的处理程序中不允许使用 return 语句

955：普通指示符和扩展指示符不能组合在初始值设定项名称中

956：第二个下标不得小于第一个下标

957：选项“指示符”只能在编译 C 时使用?

958：选项“extended_designators”只能在编译 C 时使用

959：位字段的声明大小大于位字段类型的大小;截断为<实体>位

960：用作构造函数名称的类型与类型 <type> 不匹配

961：使用没有链接的类型来声明有链接的变量

962：使用没有链接的类型来声明函数

963：不能在构造函数上指定返回类型

964：不能在析构函数上指定返回类型

965：通用字符名称格式不正确

966：通用字符名称指定无效字符

967：通用字符名称不能指定基本字符集中的字符

968：标识符中不允许使用此通用字符

969：标识符__VA_ARGS__只能出现在可变参数宏的替换列表中

970：忽略此好友声明上的限定符

971：数组范围指示符不能应用于动态初始值设定项

972：属性名称不能出现在此处

973：忽略用作函数限定符的“内联”

974：选项“compound_literals”只能在编译C时使用

975：不允许使用可变长度的数组类型

976：整数常量表达式中不允许使用复合文字

977：不允许使用类型<type>的复合文字

978：?不能在本地类中声明模板友元声明

979：模棱两可的“？”操作：<type>类型的第二个操作数可以转换为第三个操作数类型<type>，反之亦然

980：调用类类型的对象，而没有适当的 operator（） 或将函数转换为指向函数类型的指针

982：有多种方法可以调用类型<type>的对象作为参数列表：

983：typedef 名称已声明（类型相似）

984：不能给予运算符 new 和运算符删除内部联动

985：匿名联合不允许存储类“可变”

986：预编译头文件无效

987：不允许将抽象类类型 <type> 作为 catch 类型：

988：?限定函数类型不能用于声明非成员函数或静态成员函数

989：?限定函数类型不能用于声明参数

990：无法创建指向限定函数类型的指针或引用

991：额外的大括号是非标准的

992：无效的宏定义：

在编译行中不正确地使用 -D，例如“-D##”

993：指针类型<type>和<type>的减法是不标准的

994：模板模板参数声明中不允许有空的模板参数列表

995：预期的“类”

996：声明模板模板参数时必须使用“class”关键字

997：<entity>被<entity>隐藏了——虚拟功能覆盖有意吗？

998：作为函数定义的友元声明不允许使用限定名

999：<entity> 与 <entity 不兼容>

1000：此处可能未指定存储类型

????????