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     一、若是该类是某个类的派生类，那么它的直接基类的构造函数必定要出如今初始化列表中。
52        要么是程序员显式地在初始化列表中调用直接类的构造函数，
53        不然编译器把直接基类的默认构造函数插入到初始化列表中。
54     二、若是该类包含其余类的对象做为其数据成员，那么这些对象的初始化
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 */