C++面向对象(三)

一、与全局对象相比，使用静态数据成员有什么优势

优势：

（1）静态数据成员没有进入程序的全局命名空间，因此不存在程序中其他全局命名冲突的可能性。

（2）使用静态数据成员可以隐藏信息。因为静态数据成员可以是private成员，而全局对象不能

二、有哪几种情况只能用intialization list，而不能用assignment

　　无论是在构造函数初始化列表中初始化成员，还是在构造函数体中对它们赋值，最终结果都是相同的。不同之处在于，使用构造函数初始化列表初始化数据成员，没有定义初始化列表的构造函数体中对数据成员赋值。

　　对于const和reference类型成员变量，它们只能够被初始化而不能被赋值操作，因此只能使用初始化列表。

　　还有一种情况就是，类的构造函数需要调用其基类的构造函数的时候。

[cpp]  view plain  copy

1. #include <iostream>  
2.   
3. using namespace std;  
4.   
5. class A {                               //父类  
6.     int a;  
7. public:  
8.     A() {};  
9.     A(int x):a(x){}                     //带参数的构造函数对a的初始化  
10.     void printA()  
11.     {  
12.         cout<<"a = "<<a<<endl;  
13.     }  
14. };  
15.   
16. class B : public A{  
17.     int b;  
18. public:  
19.     B(int x, int y) : A(x)              //初始化A构造函数  
20.     {  
21.         //a = x;                        //a为private，B中无法调用  
22.         //A(x);                         //调用方式错误  
23.         b = y;  
24.     }  
25.     void printB()                         
26.     {  
27.         cout<<"b = "<<b<<endl;  
28.     }  
29. };  
30.   
31. int main()  
32. {  
33.     B b(2, 3);  
34.     b.printA();                         //调用子类的printA  
35.     b.printB();                         //调用自己的printB  
36.       
37.     return 0;  
38. }  

　　从上面程序中可以看到，如果在子类的构造函数中需要初始化子类的private成员，直接对其赋值是不行的，只有调用父类的构造函数才能完成对它的初始化。但在函数体内调用父类的构造函数也是不合法的，只有采用19行中的初始化列表调用子类的构造函数的方式。

输出：

[plain]  view plain  copy

1. a = 2  
2. b = 3  

三、静态成员的错误使用

[cpp]  view plain  copy

1. #include <iostream>  
2.   
3. using namespace std;  
4.   
5. class test {  
6. public:  
7.     static int i;  
8.     int j;  
9.     test(int a):i(1), j(a) {}  
10.     void func1();  
11.     static void func2();   
12. };  
13.   
14. void test::func1()  
15. {  
16.     cout<<i<<","<<j<<endl;  
17. }  
18.   
19. void test::func2()  
20. {  
21.     cout<<i<<","<<j<<endl;  
22. }  
23.   
24. int main()  
25. {  
26.     test t(2);  
27.     t.func1();  
28.     t.func2();  
29.   
30.     return 0;  
31. }  

这个程序有两个错误：

（1）代码第9行不能初始化i

（2）代码第21行，在静态成员函数中调用了非静态成员。
改正：

[cpp]  view plain  copy

1. #include <iostream>  
2.   
3. using namespace std;  
4.   
5. class test {  
6. public:  
7.     static int i;  
8.     int j;  
9.     test(int a):j(a) {}  
10.     void func1();  
11.     static void func2();   
12. };  
13.   
14. int test::i = 1;  
15.   
16. void test::func1()  
17. {  
18.     cout<<i<<","<<j<<endl;  
19. }  
20.   
21. void test::func2()  
22. {  
23.     cout<<i<< /*","<<j<<*/ endl;            //注释对j的调用  
24. }  
25.   
26. int main()  
27. {  
28.     test t(2);  
29.     t.func1();  
30.     t.func2();  
31.   
32.     return 0;  
33. }  

输出：

[cpp]  view plain  copy

1. 1,2  
2. 1