c++错误.txt

次文档收集列出了平时在编写c++程序时出现的一些编译错误

最常见的20种VC++编译错误信息
1、fatal error C1010: unexpected end of file while looking for precompiled header directive。

寻找预编译头文件路径时遇到了不该遇到的文件尾。（一般是没有#include "stdafx.h"） 

2、fatal error C1083: Cannot open include file: 'R…….h': No such file or directory

不能打开包含文件“R…….h”：没有这样的文件或目录。

3、error C2011: 'C……': 'class' type redefinition

类“C……”重定义。

4、error C2018: unknown character '0xa3'

不认识的字符'0xa3'。（一般是汉字或中文标点符号）

5、error C2057: expected constant expression

希望是常量表达式。（一般出现在switch语句的case分支中）

6、error C2065: 'IDD_MYDIALOG' : undeclared identifier

“IDD_MYDIALOG”：未声明过的标识符。

7、error C2082: redefinition of formal parameter 'bReset'

函数参数“bReset”在函数体中重定义。

8、error C2143: syntax error: missing ':' before '{' 

句法错误：“{”前缺少“；”。

9、error C2146: syntax error : missing ';' before identifier 'dc'

句法错误：在“dc”前丢了“；”。

10、error C2196: case value '69' already used

值69已经用过。（一般出现在switch语句的case分支中）[/color][/size][/size][img]http://wanpp.com/AttFiles/MM/25/386/2006/1/3861811.jpg[/img] 
******************************************************************************************

 作者tag:其他 CSDN 推荐tag:c++ c/c++ vc++ visual c++ win32 win98 指针 函数 字符 编译 内存 分析 数据 语句 编译器 文本  
 c，vc常见错误 
http://www.vc91.com/bbs/dispbbs.asp?boardid=12&id=30

1.书写标识符时，忽略了大小写字母的区别。 main() { int a=5; printf("%d",A); } 编译程序把a和A认为是两个不同的变量名，而显示出错信息。C认为大写字母和小写字母是两个不同的字符。习惯上，符号常量名用大写，变量名用小写表示，以增加可读性。 

2.忽略了变量的类型，进行了不合法的运算。 main() { float a,b; printf("%d",a%b); } %是求余运算，得到a/b的整余数。整型变量a和b可以进行求余运算，而实型变量则不允许进行“求余”运算。 

3.将字符常量与字符串常量混淆。 char c; c="a"; 在这里就混淆了字符常量与字符串常量，字符常量是由一对单引号括起来的单个字符，字符串常量是一对双引号括起来的字符序列。C规定以“”作字符串结束标志，它是由系统自动加上的，所以字符串“a”实际上包含两个字符：‘a'和‘'，而把它赋给一个字符变量是不行的。

 

http://publishblog.blogchina.com/blog/tb.b?diaryID=3035523

 C语言之指针综合谈- -
                                       

　概述

　　Joel Spolsky认为，对指针的理解是一种aptitude，不是通过训练就可以达到的。虽然如此，我还是想谈一谈这个C/C++语言中最强劲也是最容易出错的要素。

　　鉴于指针和目前计算机内存结构的关联，很多C语言比较本质的特点都孕育在其中，因此，本篇和第六、第七两篇我都将以指针为主线，结合在实际编程中遇到的问题，来详细谈谈关于指针的几个重要方面。

　　指针类型的本质分析

　　1、指针的本质

　　指针的本质：一种复合的数据类型。下面我将以下面几个作为例子进行展开分析：

　　a)、int *p; 
　　b)、int **p; 
　　c)、int (*parValue)[3]; 
　　d)、int (*pFun)(); 

　　分析：

　　所谓的数据类型就是具有某种数据特征的东东，比如数据类型char，它的数据特征就是它所占据的内存为1个字节, 指针也很类似，指针所指向的值也占据着内存中的一块地址，地址的长度与指针的类型有关，比如对于char型指针，这个指针占据的内存就是1个字节，因此指针也是一种数据类型，但我们知道指针本身也占据了一个内存空间地址，地址的长度和机器的字长有关，比如在32位机器中，这个长度就是4个字节，因此指针本身也同样是一种数据类型，因此，我们说，指针其实是一种复合的数据类型，

　　好了，现在我们可以分析上面的几个例子了。

　　假设有如下定义：
int nValue; 


　　那么，nValue的类型就是int，也就是把nValue这个具体变量去掉后剩余的部分，因此，上面的4个声明可以类比进行分析：

　　a)、int * 

　　*代表变量（指针本身）的值是一个地址，int代表这个地址里面存放的是一个整数，这两个结合起来，int *定义了一个指向整数的指针，类推如下:

　　b)、int ** 

　　指向一个指向整数的指针的指针。

　　c)、int (*)[3] 

　　指向一个拥有三个整数的数组的指针。

　　d)、int (*)() 

　　指向一个函数的指针，这个函数参数为空，返回值为整数。

　　分析结束，从上面可以看出，指针包括两个方面，一个是它本身的值，是一个内存中的地址；另一个是指针所指向的物，是这个地址中所存放着具有各种各样意义的数据。

　　2、对指针本身值的分析

　　下面例子考察指针本身的值（环境为32位的计算机）：
void *p = malloc( 100 );


　　请计算sizeof ( p ) = ?
char str[] = “Hello” ;
char *p = str ;


　　请计算sizeof ( p ) = ?
void Func ( char str[100])
{
请计算 sizeof( str ) = ? //注意，此时，str已经退化为一个指针，详情见
//下一篇指针与数组
}

 

　　分析：上面的例子，答案都是4，因为从上面的讨论可以知道，指针本身的值对应着内存中的一个地址，它的size只与机器的字长有关（即它是由系统的内存模型决定的），在32位机器中，这个长度是4个字节。 

　　3、对指针所指向物的分析

　　现在再对指针这个复合类型的第二部分，指针所指向物的意义进行分析。

　　上面我们已经得到了指针本身的类型，那么将指针本身的类型去掉 “*”号就可得到指针所指向物的类型，分别如下：

　　a)、int 

　　所指向物是一个整数。

　　b)、int* 

　　所指向物是一个指向整数的指针。

　　c)、int ()[3] 

　　()为空，可以去掉，变为int [3]，所指向物是一个拥有三个整数的数组。

　　d)、int ()()

　　第一个()为空，可以去掉，变为int (),所指向物是一个函数，这个函数的参数为空，返回值为整数。

　　4、附加分析

　　另外，关于指针本身大小的问题，在C++中与C有所不同，这里我也顺带谈一下。

　　在C++中，对于指向对象成员的指针，它的大小不一定是4个字节，这主要是因为在引入多重虚拟继承以及虚拟函数的时候，有些附加的信息也需要通过这个指针进行传递，因此指向对象成员的指针会增大，不论是指向成员数据，还是成员函数都是如此，具体与编译器的实现有关，你可以编写个很小的C++程序去验证一下。另外，对一个类的静态成员（static member，可以是静态成员变量或者静态成员函数）来说，指向它的指针只是普通的函数指针，而不是一个指向类成员的指针，所以它的大小不会增加，仍旧是4个字节。
----------------------------------------------------------------------------

指针本身的相关问题

　　1、问题：空指针的定义

　　曾经看过有的.h文件将NULL定义为0L，为什么？

　　答案与分析：

　　这是一个关于空指针宏定义的问题。指针在C语言中是经常使用的，有时需要将一个指针置为空指针，例如在指针变量初始化的时候。
C语言中的空指针和Pascal或者Lisp语言中的NIL具有相同的地位。那如何定义空指针呢？下面的语句是正确的：
char *p1 = 0;
int *p2;
if (p != 0)
{
...
}
p2 = 0;


　　也就是说，在指针变量的初始化、赋值、比较操作中，0会被编译器理解为要将指针置为空指针。至于空指针的内部表示是否是0，则随不同的机器类型而定，不过通常都是0。但是在另外一些场合下，例如函数的参数原型是指针类型，函数调用时如果将0作为参数传入，编译器则不能将其理解为空指针。此时需要明确的类型转换，例如：
void func (char *p);
func ((char *)0);


　　一般情况下，0是可以放在代码中和指针关联使用的，但是有些程序员（数量还不少呦！也许就包括你在内）不喜欢0的直白，认为其不能表示作为指针的特殊含义，于是要定义一个宏NULL，来明确表示空指针常量。这也是对的，人家C语言标准就明确说：“ NULL应该被定义为与实现相关的空指针常量”。但是将NULL定义成什么样的值呢？我想你一定见过好几种定义NULL的方法：
#define NULL 0
#define NULL (char *)0
#define NULL (void *)0


　　在我们使用的绝大多数计算系统上，例如PC，上述定义是能够工作的。然而，世界上还有很多其它种类的计算机，其CPU也不是Intel的。在某些系统上，指针和整数的大小和内部表示并不一致，甚至不同类型的指针的大小都不一致。为了避免这种可移植性问题，0L是一种最为安全的、最妥帖的定义方式。0L的含义是： “值为0的整数常量表达式”。这与C语言给出的空指针定义完全一致。因此，建议采用0L作为空指针常量NULL的值。

　　其实 NULL定义值，和操作系统的的平台有关， 将一个指针定义为 NULL， 其用意是为了保护操作系统，因为通过指针可以访问任何一块地址， 但是，有些数据是不许一般用户访问的，比如操作系统的核心数据。 当我们通过一个空(NULL)的指针去方位数据时，系统会提示非法， 那么系统又是如何知道的呢？？ 

　　以windows2000系统为例， 该系统规定系统中每个进程的起始地址（0x00000000）开始的某个地址范围内是存放系统数据的，用户进程无法访问， 所以当用户用空指针（0）访问时，其实访问的就是0x00000000地址的系统数据，由于该地址数据是受系统保护的，所以系统会提示错误(指针访问非法)。

　　这也就是说NULL值不一定要定义成0，起始只要定义在系统的保护范围的地址空间内，比如定义成(0x00000001, 0x00000002)都会起到相同的作用，但是为了考虑到移植性，普遍定义为0 。 

　　2、问题：与指针相关的编程规则&规则分析 

　　指针既然这么重要，而且容易出错，那么有没有方法可以很好地减少这些指针相关问题的出现呢？

　　答案与分析：

　　减少出错的根本是彻底理解指针。

　　在方法上，遵循一定的编码规则可能是最立竿见影的方法了，下面我来阐述一下与指针相关的编程规则：

　　1) 未使用的指针初始化为NULL 。

　　2) 在给指针分配空间前、分配后均应作判断。

　　3) 指针所指向的内容删除后也要清除指针本身。

　　要牢记指针是一个复合的数据结构这个本质，所以我们不论初始化和清除都要同时兼顾指针本身（上述规则1，3）和指针所指向的内容（上述规则2，3）这两个方面。

　　遵循这些规则可以有效地减少指针出错，我们来看下面的例子：
void Test(void)
{
　char *str = (char *) malloc(100);
　strcpy(str, “hello”);
　free(str); 
　if(str != NULL)
　{
　　strcpy(str, “world”); 
　　printf(str);
　}
}


　　请问运行Test函数会有什么样的结果？

　　答：

　　篡改动态内存区的内容，后果难以预料，非常危险。因为free(str);之后，str成为野指针，if(str != NULL)语句不起作用。

　　如果我们牢记规则3，在free(str)后增加语句：
str = NULL;


　　那么，就可以防止这样的错误发生。

 

 

http://bbs.gliet.edu.cn/bbs/index.php?showtopic=116177

一．指针。
它的本质是地址的类型。在许多语言中根本就没有这个概念。但是它却正是C灵活，高效，在面向过程的时代所向披靡的原因所在。因为C的内存模型基本上对应了现在von Neumann（冯·诺伊曼）计算机的机器模型，很好的达到了对机器的映射。不过有些人似乎永远也不能理解指针【注1】。
注1：Joel Spolsky就是这样认为的，他认为对指针的理解是一种aptitude，不是通过训练就可以达到的

http://www.joelonsoftware.com/pr ... /fog0000000073.html

指针可以指向值、数组、函数，当然它也可以作为值使用。
看下面的几个例子：
int* p;//p是一个指针，指向一个整数
int** p;//p是一个指针，它指向第二个指针，然后指向一个整数
int (*pa)[3];//pa是一个指针，指向一个拥有3个整数的数组
int (*pf)();//pf是一个指向函数的指针，这个函数返回一个整数
后面第四节我会详细讲解标识符（identifier）类型的识别。
1.指针本身的类型是什么？
先看下面的例子：int a;//a的类型是什么？
对，把a去掉就可以了。因此上面的4个声明语句中的指针本身的类型为：
int* 
int**
int (*)[3]
int (*)()
它们都是复合类型，也就是类型与类型结合而成的类型。意义分别如下：
point to int（指向一个整数的指针）
pointer to pointer to int（指向一个指向整数的指针的指针）
pointer to array of 3 ints（指向一个拥有三个整数的数组的指针）
pointer to function of parameter is void and return value is int （指向一个函数的指针，这个函数参数为空，返回值为整数）
2.指针所指物的类型是什么？
很简单，指针本身的类型去掉 “*”号就可以了，分别如下：
int
int*
int ()[3]
int ()()
3和4有点怪，不是吗？请擦亮你的眼睛，在那个用来把“*”号包住的“()”是多余的，所以：
int ()[3]就是int [3]（一个拥有三个整数的数组）
int ()()就是int ()（一个函数，参数为空，返回值为整数）【注2】
注2：一个小小的提醒，第二个“()”是一个运算符，名字叫函数调用运算符（function call operator）。
3.指针的算术运算。
请再次记住：指针不是一个简单的类型，它是一个和指针所指物的类型复合的类型。因此，它的算术运算与之（指针所指物的类型）密切相关。
int a[8];
int* p = a;
int* q = p + 3;
p++;
指针的加减并不是指针本身的二进制表示加减，要记住，指针是一个元素的地址，它每加一次，就指向下一个元素。所以：
int* q = p + 3;//q指向从p开始的第三个整数。
p++;//p指向下一个整数。
double* pd;
……//某些计算之后
double* pother = pd – 2;//pother指向从pd倒数第二个double数。
4.指针本身的大小。
在一个现代典型的32位机器上【注3】，机器的内存模型大概是这样的，想象一下，内存空间就像一个连续的房间群。每一个房间的大小是一个字节（一般是二进制8位）。有些东西大小是一个字节（比如char），一个房间就把它给安置了；但有些东西大小是几个字节（比如double就是8个字节，int就是4个字节，我说的是典型的32位），所以它就需要几个房间才能安置。
注3：什么叫32位？就是机器CPU一次处理的数据宽度是32位，机器的寄存器容量是32位，机器的数据，内存地址总线是32位。当然还有一些细节，但大致就是这样。16位，64位，128位可以以此类推。
这些房间都应该有编号（也就是地址），32位的机器内存地址空间当然也是32位，所以房间的每一个编号都用32位的二进制数来编码【注4】。请记住指针也可以作为值使用，作为值的时候，它也必须被安置在房间中（存储在内存中），那么指向一个值的指针需要一个地址大小来存储，即32位，4个字节，4个房间来存储。
注4：在我们平常用到的32位机器上，绝少有将32位真实内存地址空间全用完的（232 ＝ 4G），即使是服务器也不例外。现代的操作系统一般会实现32位的虚拟地址空间，这样可以方便运用程序的编制。关于虚拟地址（线性地址）和真实地址的区别以及实现，可以参考《Linux源代码情景分析》的第二章存储管理，在互联网上关于这个主题的文章汗牛充栋，你也可以google一下。
但请注意，在C++中指向对象成员的指针（pointer to member data or member function）的大小不一定是4个字节。为此我专门编制了一些程序，发现在我的两个编译器（VC7.1.3088和Dev-C++4.9.7.0）上，指向对象成员的指针的大小没有定值，但都是4的倍数。不同的编译器还有不同的值。对于一般的普通类（class），指向对象成员的指针大小一般为4，但在引入多重虚拟继承以及虚拟函数的时候，指向对象成员的指针会增大，不论是指向成员数据，还是成员函数。【注5】。
注5：在Andrei Alexandrescu的《Modern C++ Design》的5.13节Page124中提到，成员函数指针实际上是带标记的（tagged）unions，它们可以对付多重虚拟继承以及虚拟函数，书上说成员函数指针大小是16，但我的实践告诉我这个结果不对，而且具体编译器实现也不同。一直很想看看GCC的源代码，但由于旁骛太多，而且心不静，本身难度也比较高（这个倒是不害怕），只有留待以后了。
还有一点，对一个类的static member来说，指向它的指针只是普通的函数指针，不是pointer to class member，所以它的大小是4。
5.指针运算符&和*
它们是一对相反的操作，&取得一个东西的地址（也就是指针），*得到一个地址里放的东西。这个东西可以是值（对象）、函数、数组、类成员（class member）。
其实很简单，房间里面居住着一个人，&操作只能针对人，取得房间号码；
*操作只能针对房间，取得房间里的人。
参照指针本身的类型以及指针所指物的类型很好理解。
小结：其实你只要真正理解了1，2，就相当于掌握了指针的牛鼻子。后面的就不难了，指针的各种变化和C语言中其它普通类型的变化都差不多(比如各种转型)。

 

http://bbs.ncre.cn/archiver/?tid-57374.html

yinbenli 2006-1-3 14:27

C常见错误新手看,高手闪

1.        数据溢出
int a = 32767;
a = a + 1; 

此时a的值为 –32768

2.        (-1)&&(-1) 值为：1
非0的数，逻辑值均为1
只有数0，逻辑值为0

3.        设a=5, b=6, c=7, d=8, m=2, n=2
执行 (m = a > b) && ( n = c > b)
结果：n 的值为 2
解析：&&是短路(shortway)运算符，当&&左边表达式的值为0时，
不再执行右边的表达式

4.        1 / 2 = 0 
1.0 / 2 = 0.5

5.        转义字符
遇到’\’字符应注意转义字符问题，比如’\\’,’\ddd’就是转义字符
常见考法：Q：”a\045+045\b”有几个字节？
                     A：8个字节（分别是’a’,’\045’,’+’,’0’,’4’,’5’,’\b’,’\0’）

字符串结束符
如上题，”a\045+045\b”含有最后的字符串结束符’\0’，因而长度为8个字节
注意：计算字符串长度时，sizeof会将’\0’计算在内，strlen()则不算

Main()
{
char b[] = “hello, you”;
b[5] = 0;
printf(“%s\n”, b);
} 

运行结果：hello
解析：b[5]=0 ;等价于 b[5] = ‘\0’;


6.        ++ i , i ++