C++易错点总结

1.下面这段代码考察变量的作用域问题。

[cpp]  view plain copy

1. #include<iostream>  
2. using namespace std;  
3.   
4. void other()  
5. {  
6.     static int a = 2;  
7.     static int b;  
8.     int c = 10;  
9.     a += 2;  
10.     c += 5;  
11.     cout<<"----other-----"<<endl;  
12.     cout<<a<<" "<<b<<" "<<c<<endl;  
13.     b = a;  
14. }  
15.   
16. int main()  
17. {  
18.     static int a;  
19.     int b= -10, c= 0;  
20.   
21.     cout<<"----main-----"<<endl;  
22.     cout<<a<<" "<<b<<" "<<c<<endl;  
23.     c += 8;  
24.     other();  
25.     cout<<"----main-----"<<endl;  
26.     cout<<a<<" "<<b<<" "<<c<<endl;  
27.     other();  
28.     return 0;  
29. }  

答案如下：

----main-----
0 -10 0
----other-----
4 0 15
----main-----
0 -10 8
----other-----
6 4 15

考察点：

局部作用域中静态变量的特点是，它并不会随着每次函数调用而产生一个副本，也不会随着函数返回而失效。也就是说，当一个函数返回后，下一次再调用时，该变量还会保持上一回的值，即使发生了递归调用，也不会为该变量建立新的副本，该变量会在每次调用见共享。

解析：

第一次a=0，b=-10,c=0，之后调用other函数，因为a和b为静态局部变量，所以在other函数就有保持值的特点，这时，根据就近原则，a=4，b=0，c=15.

然后继续执行，发现a，b的改变都是在other中，而对main中的a，b没有影响，所以a，b值不变，c由于自加8，所以c=8.然后又进入other，因为a，b为局部静态变量，不会再每次进入相同函数时产生副本，所以进入时a=4，自加2，等于6，上次函数结束时b=a，所以b=4，这次再进入时b还是保持4不变，而c是动态局部变量，每次进入函数都要重新初始化，所以c=10，自加5等于15.所以a=6，b=4，c=15.

2.说明Arr类中，element元素返回一个引用对象的原因。

[cpp]  view plain copy

1. #include<iostream>  
2. #include<cstdio>  
3. #include<cassert>  
4. using namespace std;  
5.   
6. class Point  
7. {  
8. private:  
9.     int x, y;  
10. public:  
11.     Point():x(0), y(0)  
12.     {  
13.         cout<<"default called"<<endl;  
14.     }  
15.     Point(int x, int y):x(x), y(y)  
16.     {  
17.         cout<<"not default called"<<endl;  
18.     }  
19.     ~Point(){cout<<"destructor called"<<endl;}  
20.     int getx()const{return x;}  
21.     int gety()const{return y;}  
22.     void move(int newx, int newy)  
23.     {  
24.         x = newx;  
25.         y = newy;  
26.     }  
27.   
28. };  
29.   
30. class Arr  
31. {  
32. private:  
33.     Point *p;  
34.     int size;  
35.   
36. public:  
37.     Arr(int size):size(size)  
38.     {  
39.         p = new Point[size];  
40.     }  
41.     ~Arr()  
42.     {  
43.         cout<<"deleting"<<endl;  
44.         delete []p;  
45.     }  
46.   
47.     Point &element(int index)  
48.     {  
49.         assert(index >= 0 && index < size);  
50.         return p[index];  
51.     }  
52. };  
53.   
54. int main()  
55. {  
56.     int count;  
57.     cin>>count;  
58.     Arr points(count);  
59.     points.element(0).move(5, 0);  
60.     points.element(1).move(5, 2);  
61.     return 0;  
62. }  

答案：

因为我们创建的points对象是一个在类内部由动态数组实现的对象，而我们对数组的操作无非就是取元素，改变元素，如果element不返回一个引用时，那么我们可以认为这个元素是只读的，我们无法通过赋值等途径改变这个元素（其实是一个对象）的值，而我们返回一个引用的话，就相当于取出元素本身，就可以对它进行正常的读写操作。这样才符合数组的性质。

3.浅复制和深复制

[cpp]  view plain copy

1. #include<iostream>  
2. using namespace std;  
3.   
4. class A  
5. {  
6. private:  
7.     int len;  
8.     char *str;  
9. public:  
10.     A(int length, char *s)  
11.     {  
12.         len = length;  
13.         str = new char[length];  
14.         strcpy(str, s);  
15.     }  
16.     A(const A &p) //浅复制就是注释掉自定义复制拷贝函数（试试看？）  
17.     {  
18.         len = p.len;  
19.         str = new char[p.len]; //深复制  
20.         strcpy(str, p.str);  
21.     }  
22.     ~A()  
23.     {  
24.         delete str;  
25.     }  
26.     void show()  
27.     {  
28.         cout<<str<<endl;  
29.     }  
30. };  
31.   
32. int main()  
33. {  
34.     A a(10, "hello");  
35.     A b = a;  
36.     b.show();  
37.     return 0;  
38. }  

4.看看下面这个代码怎么错了？

[cpp]  view plain copy

1. #include<iostream>  
2. using namespace std;  
3.   
4. #define MAX 255  
5. int main()  
6. {  
7.     char p[MAX+1];  
8.     unsigned char ch;  
9.     for(ch=0;ch<=255;++ch)  
10.     {  
11.         p[ch]=ch;  
12.         cout<<ch<<"";  
13.     }  
14.     p[255]='\0';  
15.     cout<<ch<<endl;  
16. }  

错误在于ch<=255，这个条件。因为ch是unsigned char类型的，占据一个字节，所以最大值为255.当ch循环到255时候+1之后溢出，就变成0了。这样，就陷入了死循环。正确该法是ch<255.