C++ 类

 1 #include<iostream>
 2 using namespace std;
 3 class A{
 4 public:
 5     A(){
 6         i =5;
 7     }
 8     void show(){
 9         cout<<i<<endl;
10     }
11 private:
12     int i;
13 };
14 class B{
15 public:
16     B():i(5){
17     }
18     void show(){
19         cout<<i<<endl;
20     }
21 private:
22     int i;
23 };
24 int main(){
25     A().show();
26     B().show();
27 }
28 /*
29 输出：5
30       5
31     C++语言规定，不能在类体中直接指定数据成员的初值，所以对象的初始化工作
32     只能通过调用对象的构造函数来完成。在构造函数中，初始化列表扮演了十分
33     重要的角色。
34     对于普通的数据成员来言，使用初始化列表和在构造函数体内赋值，效果一样
35 
36 */

 1 #include<iostream>
 2 using namespace std;
 3 class A{
 4     int num;
 5 public:
 6     A(int i){
 7         num = i;
 8     }
 9     void show(){
10         cout<<num<<endl;
11     }
12 };
13 class B{
14     int &r;
15     const double PI;
16     A a;
17 public:
18     B(int i);
19     void show(){
20         cout<<r<<endl;
21         cout<<PI<<endl;
22         a.show();
23     }
24 };
25 int e = 5;
26 B::B(int i):r(e),PI(3.1515926),a(i){
27 }
28 int main(){
29     B(1).show();
30 }
31 
32 /*
33 有些情况：只能使用初始化列表对成员进行初始化。
34 如：数据成员是引用、常变量、类对象
35 */

 1 #include<iostream>
 2 using namespace std;
 3 class A{
 4 public:
 5     int num;
 6     A(int i){
 7         num = i;
 8         cout<<"In A constructor"<<endl;
 9     }
10 };
11 class B{
12 public:
13     int num;
14     B(int i){
15         num = i;
16         cout<<"In B constructor"<<endl;
17     }
18 };
19 class C{
20 protected:
21     int num;
22 public:
23     C(int i){
24         num = i;
25         cout<<"In C constructor"<<endl;
26     }
27 
28 };
29 class D:public C{
30     A a;
31     int num;
32     B b;
33 public:
34     D(int i):num(i++),b(i++),a(i++),C(i++){}
35     void show(){
36         cout<<"C::num="<<C::num<<endl;//因为C为基类，所以先执行基类的构造函数  第一个构造
37         cout<<"a.num="<<a.num<<endl;//a为数据成员，按声明顺序进行构造。 第二个构造
38         cout<<"num="<<num<<endl;//在初始化列表中存在，按声明顺序构造，为第三个构造
39         cout<<"b.num"<<b.num<<endl;//初始化列表中存在，按声明顺序构造，为第四个构造
40     }
41 };
42 int main(){
43     D d(1);
44     d.show();
45 }
46 
47 /*
48     很多类的构造函数根本没有使用初始化列表。但实际上，有些内容不管有没有显式
49     写进初始化列表中，都是会被“强行”加进去。
50     如：
51     1、如果该类是某个类的派生类，那么它的直接基类的构造函数一定要出现在初始化列表中。
52        要么是程序员显式地在初始化列表中调用直接类的构造函数，
53        否则编译器把直接基类的默认构造函数插入到初始化列表中。
54     2、如果该类包含其他类的对象作为其数据成员，那么这些对象的初始化
55        工作也一定要在初始化列表中完成，
56        要么是程序员显式地在初始化列表表中给出对象的构造形式，
57        否则编译器会在初始化列表中调用这些对象的默认构造函数来完成初始化。
58 
59        遵循规则：
60             基类的构造函数最先执行，其他的成员按照它们在类中声明的顺序依次
61             被初始化。
62 */

 1 #include<iostream>
 2 using namespace std;
 3 int *CreateArr(int n){
 4     int *p;
 5     p = new int[n];
 6     for(int i=0;i<n;i++){
 7         p[i] = i+1;
 8     }
 9     return p;
10 }
11 class A {
12     int arrsize;
13     const int*const arr;
14 public:
15     A(int n):arr(CreateArr(n)){
16         arrsize = n;
17     }
18     void show(){
19         for(int i =0;i<arrsize;i++){
20             cout<<arr[i]<<‘ ‘;
21         }
22         cout<<endl;
23     }
24     ~A(){delete[] arr;}
25 };
26 int main(){
27     A a(3);
28     a.show();
29 }
30 /*
31     在初始化列表中，无法完成为对象的数组成员进行初始化工作，原因是C++语言没有提供这样的机制。
32     在类中不能定义一个常量数组，因为无法为对象的常量数组成员初始化。
33 
34     在实际应用中，通常只会在类中定义静态的常量数组，这样就能可以完成数组的初始化工作。
35     或者在类中定义一个指向常量的指针常量，然后在初始化列表中为它初始化。
36 
37 */

 1 #include<iostream>
 2 using namespace std;
 3 class B;
 4 class A{
 5 public:
 6     A(B &obj){
 7         cout<<"Befor constructor,b‘s address is:"<<&obj<<endl;    
 8     }
 9 };
10 class B{
11     int num;
12 public:
13     B(){
14         cout<<"In constructor,b‘s address is:"<<this<<endl;
15     }
16     void show(){
17         cout<<num<<endl;
18     }
19 };
20 extern B b;//避免重复定义，它会寻找其他b
21 A a(b);
22 B b;
23 int main(){
24     cout<<"After constructor,b‘s address is:"<<&b<<endl;
25 }
26 /*
27     输出：
28     Befor constructor,b‘s address is:00D8F218
29     In constructor,b‘s address is:00D8F218
30     After constructor,b‘s address is:00D8F218
31 
32     对象分配空间和调用对象的构造函数是两个不同的工作。
33     构造函数不是用来为对象分配空间的，而是对数据成员
34     进行初始化的。使它们首次获得有意义的值。
35     进入对象的构造函数时，对象的空间分配的工作已经完成。
36 */