对象和类

1.构造函数

1.C++规定，每个类必须有默认的构造函数，没有构造函数就不能创建对象。 

　　2.若没有提供任何构造函数，那么c++提供自动提供一个默认的构造函数，该默认构造函数是一个没有参数的构造函数，它仅仅负责创建对象而不做任何赋值操作。 

　　3.只要类中提供了任意一个构造函数，那么c++就不再自动提供默认构造函数。 

　　4.类对象的定义和变量的定义类似，使用默认构造函数创建对象的时候，如果创建的是静态或者是全局对象，则对象的位模式全部为0，否则将会是随即的。 

　　我们来看下面的代码：

#include <iostream>  
using namespace std;    
class Student  
{  
    public:  
    Student()//无参数构造函数  
    {  
        number = 1;  
        score = 100;  
    }  
    void show();  
  
    protected:  
    int number;  
    int score;  
  
};  
  
void Student::show()  
{  
    cout<<number<<endl<<score<<endl; 
}  
  
void main()  
{  
    Student a;  
    a.show();  
    cin.get();  
}

执行结果：1

        100

　　在类中的定义的和类名相同，并且没有任何返回类型的Student()就是构造函数，这是一个无参数的构造函数，他在对象创建的时候自动调用，如果去掉Student()函数体内的代码那么它和c++的默认提供的构造函数等价的。

　　构造函数可以带任意多个的形式参数，这一点和普通函数的特性是一样的！ 

下面我们来看一个带参数的构造函数是如何进行对象的始化操作的。 

　　代码如下：

#include <iostream>  
using namespace std;    
class Teacher  
{  
    public:  
    Teacher(char *input_name)//有参数的构造函数  
    {  
        name=new char[10];  
        //name=input_name;//这样赋值是错误的  
        strcpy(name,input_name);  
    }  
    void show();  
  
    protected:  
    char *name;  
  
};  
  
void Teacher::show()  
{  
    cout<<name<<endl; 
}  
  
void main()  
{  
         //Teacher a;//这里是错误的,因为没有无参数的构造函数  
    Teacher a("test");  
    a.show();  
    cin.get();  
}

执行结果：test

　 　我们创建了一个带有字符指针的带有形参的Teacher(char *input_name)的构造函数，调用它创建对象的使用类名加对象名称加扩号和扩号内参数的方式调用，这和调用函数有点类似，但意义也有所不同，因为 构造函数是为创建对象而设立的，这里的意义不单纯是调用函数，而是创建一个类对象。 

　　一旦类中有了一个带参数的构造函数而又没无参数构造函数的时候系统将无法创建不带参数的对象，所以上面的代码

Teacher a;

　　就是错误的！！！ 

　　这里还有一处也要注意：

//name=input_name;//这样赋值是错误的

　　因为name指是指向内存堆区的，如果使用name=input_name;会造成指针指向改变不是指向堆区而是指向栈区，导致在后面调用析构函数delete释放堆空间出错！(析构函数的内容我们后面将要介绍) 

　　如果需要调用能够执行就需要再添加一个没有参数的构造函数 

　　对上面的代码改造如下：

#include <iostream>  
using namespace std;    
class Teacher  
{  
    public:  
    Teacher(char *input_name)  
    {  
        name=new char[10];  
        //name=input_name;//这样赋值是错误的  
        strcpy(name,input_name);  
    }  
    Teacher()//无参数构造函数,进行函数重载  
    {  
      
    }  
    void show();  
  
    protected:  
    char *name;  
  
};  
  
void Teacher::show()  
{  
    cout<<name<<endl; 
}  
  
void main()  
{  
    Teacher test;  
    Teacher a("test");  
    a.show();  
    cin.get();  
}

执行结果：test

　　创建一个无阐述的同名的Teacher()无参数函数，一重载方式区分调用，由于构造函数和普通函数一样具有重载特性所以编写程序的人可以给一个类添加任意多个构造函数，来使用不同的参数来进行初始话对象。

现在我们来说一下，一个类对象是另外一类的数据成员的情况，如果有点觉得饶人那么可以简单理解成:类成员的定义可以相互嵌套定义，一个类的成员可以用另一个类进行定义声明。

　　c++规定如果一个类对象是另外一类的数据成员，那么在创建对象的时候系统将自动调用那个类的构造函数。 

　　下面我们看一个例子。 

　　代码如下：

#include <iostream>  
using namespace std;    
class Teacher  
{  
    public:  
    Teacher()  
    {  
        director = new char[10];  
        strcpy(director,"王大力");  
    }  
    char *show();  
    protected:  
    char *director;  
};  
char *Teacher::show()  
{  
    return director;  
}  
class Student  
{  
    public:  
    Student()  
    {  
        number = 1;  
        score = 100;  
    }  
    void show();  
  
    protected:  
    int number;  
    int score;  
    Teacher teacher;//这个类的成员teacher是用Teacher类进行创建并初始化的  
  
};  
  
void Student::show()  
{  
    cout<<teacher.show()<<endl<<number<<endl<<score<<endl; 
}  
  
void main()  
{  
    Student a;  
    a.show();  
    Student b[3];  
    for(int i=0; i<sizeof(b)/sizeof(Student); i++)  
    {  
        b[i].show();  
    }  
    cin.get();  
}

执行结果：王大力

        1

        100

        王大力

        1

        100

        王大力

        1

        100

        王大力

        1

        100

　　上面代码中的Student类成员中teacher成员是的定义是用类Teacher进行定义创建的，那么系统碰到创建代码的时候就会自动调用Teacher类中的Teacher()构造函数对对象进行初始化工作！ 

　　这个例子说明类的分工很明确，只有碰到自己的对象的创建的时候才自己调用自己的构造函数。

　　一个类可能需要在构造函数内动态分配资源，那么这些动态开辟的资源就需要在对象不复存在之前被销毁掉，那么c++类的析构函数就提供了这个方便。 

2.构造函数列表

在构造函数中，可以使用初始化列表初始化数据域。如果数据域是一个对象，而且它没有无实参构造函数，那么就必须要使用初始化列表。

作为一个对象数据域，声明时对象并未创建。而在函数中声明一个对象局部变量，声明时就会创建对象。

class Student{
public:Student();private:string name;//声明时并未创建};int main(){string name;//声明时就会创建对象}

数据域在声明时是不能被赋值的：

class Student{public:Student();private:int age = 5;//错误string name("bobby");//错误}

正确的声明语句应该是：

class Student{public:Student() ;private:int age ;//正确string name;//正确}

当创建Studet类的对象时，构造函数自动调用string类的无参构造函数，创建name对象。

如果一个数据域是对象类型，无参构造函数会被自动调用，以创建该数据域的对象。如果没有无参构造函数，编译器会报告一个错误。如下例：

class Time{public:Time(int hour, int minute, int second){}private:int hour;int minute;int second;};class Action{public:Action(int hour, int minute, int second){time = Time(hour, minute, second);}private:Time time;};

为了修正这个错误，必须使用构造函数初始化列表，如下例：

class Time{public:Time(int hour, int minute, int second){}private:int hour;int minute;int second;};class Action{public:Action(int hour, int minute, int second)：time(hour, minute, second){ }private:Time time;};

使用构造函数初始化列表还能提高效率。如果不使用构造函数初始化列表，无实参构造函数会被自动调用，创建一个对象初始化对象数据域。有时我们希望使用其他构造函数初始化对象数据域而不是无参构造函数，必须创建一个新的对象——整个过程中创建了两个对象。而使用构造函数初始化列表，只需创建一个对象。

3. 不可变对象和不可变类

一个类能够称为不可变类，必须满足：所有数据域均为私有；没有更改器函数；没有访问器函数返回指向可变对象数据域的引用或指针

4. 避免重复声明

c++的#ifndef指令可以防止一个头文件被加载两次。例：Date.h

#ifndef DATA_H

#define DATA_H

XXXXXX//头文件内容

#endif

5. 实例成员和静态成员

实例变量是和特定对象联系在一起的，对于同一个类的不同对象，实例变量就是不同的，并不共享。如果希望一个类的所有实例共享数据，那么就应该用静态变量，也称为类变量。静态变量机制在一个共同的内存位置中保存多个对象的变量值，由于使用共同的内存位置，因此，如果一个对象改变了静态变量值，那么同一类所有对象的此变量的值都被改变了。c++也支持静态函数，调用静态函数无需创建一个类的实例。

5.1 静态数据成员

在类内数据成员的声明前加上关键字static，该数据成员就是类内的静态数据成员。先举一个静态数据成员的例子。

[cpp] view plain copy

1. #include<iostream>  
2. using namespace std;  
3.   
4. class Myclass  
5. {  
6. private:  
7.     int a , b , c;  
8.     static int sum;  //声明静态数据成员  
9. public:  
10.     Myclass(int a , int b , int c);  
11.     void GetSum();  
12. };  
13.   
14. int Myclass::sum = 0;   //定义并初始化静态数据成员  
15.   
16. Myclass::Myclass(int a , int b , int c)  
17. {  
18.     this->a = a;  
19.     this->b = b;  
20.     this->c = c;  
21.     sum += a+b+c;  
22. }  
23. void Myclass::GetSum()  
24. {  
25.     cout<<"sum="<<sum<<endl;  
26. }  
27.   
28. int main(void)  
29. {  
30.     Myclass M(1 , 2 , 3);  
31.     M.GetSum();  
32.     Myclass N(4 , 5 , 6);  
33.     N.GetSum();  
34.     M.GetSum();  
35.     return 0;  
36. }  

可以看出，静态数据成员有以下特点：

• 对于非静态数据成员，每个类对象都有自己的拷贝。而静态数据成员被当作是类的成员。无论这个类的对象被定义了多少个，静态数据成员在程序中也只有一份拷贝，由该类型的所有对象共享访问。也就是说，静态数据成员是该类的所有对象所共有的。对该类的多个对象来说，静态数据成员只分配一次内存，供所有对象共用。所以，静态数据成员的值对每个对象都是一样的，它的值可以更新；
• 静态数据成员存储在全局数据区。静态数据成员定义时要分配空间，所以不能在类声明中定义。在Example 5中，语句int Myclass::Sum=0;是定义静态数据成员；
• 静态数据成员和普通数据成员一样遵从public,protected,private访问规则；
• 因为静态数据成员在全局数据区分配内存，属于本类的所有对象共享，所以，它不属于特定的类对象，在没有产生类对象时其作用域就可见，即在没有产生类的实例时，我们就可以操作它；
• 静态数据成员初始化与一般数据成员初始化不同。静态数据成员初始化的格式为：
  ＜数据类型＞＜类名＞::＜静态数据成员名＞=＜值＞
• 类的静态数据成员有两种访问形式：
  ＜类对象名＞.＜静态数据成员名＞ 或 ＜类类型名＞::＜静态数据成员名＞
  如果静态数据成员的访问权限允许的话（即public的成员），可在程序中，按上述格式来引用静态数据成员 ；
• 静态数据成员主要用在各个对象都有相同的某项属性的时候。比如对于一个存款类，每个实例的利息都是相同的。所以，应该把利息设为存款类的静态数据成员。这有两个好处，第一，不管定义多少个存款类对象，利息数据成员都共享分配在全局数据区的内存，所以节省存储空间。第二，一旦利息需要改变时，只要改变一次，则所有存款类对象的利息全改变过来了；
• 同全局变量相比，使用静态数据成员有两个优势：

1. 静态数据成员没有进入程序的全局名字空间，因此不存在与程序中其它全局名字冲突的可能性；
2. 可以实现信息隐藏。静态数据成员可以是private成员，而全局变量不能；

5.2 静态成员函数

　　与静态数据成员一样，我们也可以创建一个静态成员函数，它为类的全部服务而不是为某一个类的具体对象服务。静态成员函数与静态数据成员一样，都是类的内部实现，属于类定义的一部分。普通的成员函数一般都隐含了一个this指针，this指针指向类的对象本身，因为普通成员函数总是具体的属于某个类的具体对象的。通常情况下，this是缺省的。如函数fn()实际上是this->fn()。但是与普通函数相比，静态成员函数由于不是与任何的对象相联系，因此它不具有this指针。从这个意义上讲，它无法访问属于类对象的非静态数据成员，也无法访问非静态成员函数，它只能调用其余的静态成员函数。下面举个静态成员函数的例子。

[cpp] view plain copy

1. #include<iostream>  
2. using namespace std;  
3.   
4. class Myclass  
5. {  
6. private:  
7.     int a , b , c;  
8.     static int sum;  //声明静态数据成员  
9. public:  
10.     Myclass(int a , int b , int c);  
11.     static void GetSum();  //声明静态成员函数  
12. };  
13.   
14. int Myclass::sum = 0;   //定义并初始化静态数据成员  
15.   
16. Myclass::Myclass(int a , int b , int c)  
17. {  
18.     this->a = a;  
19.     this->b = b;  
20.     this->c = c;  
21.     sum += a+b+c;    //非静态成员函数可以访问静态数据成员  
22. }  
23. void Myclass::GetSum()    //静态成员函数的实现  
24. {  
25.     //cout<<a<<endl;    //错误代码，a是非静态数据成员  
26.     cout<<"sum="<<sum<<endl;  
27. }  
28.   
29. int main(void)  
30. {  
31.     Myclass M(1 , 2 , 3);  
32.     M.GetSum();  
33.     Myclass N(4 , 5 , 6);  
34.     N.GetSum();  
35.     Myclass::GetSum();  
36.     return 0;  
37. }  

关于静态成员函数，可以总结为以下几点：

• 出现在类体外的函数定义不能指定关键字static；
• 静态成员之间可以相互访问，包括静态成员函数访问静态数据成员和访问静态成员函数；
• 非静态成员函数可以任意地访问静态成员函数和静态数据成员；
• 静态成员函数不能访问非静态成员函数和非静态数据成员；
• 由于没有this指针的额外开销，因此静态成员函数与类的全局函数相比速度上会有少许的增长；
• 调用静态成员函数，可以用成员访问操作符(.)和(->)为一个类的对象或指向类对象的指针调用静态成员函数，也可以直接使用如下格式：
  ＜类名＞::＜静态成员函数名＞（＜参数表＞）
  调用类的静态成员函数。

6. 析构函数

析构函数的定义:析构函数也是特殊的类成员函数，它没有返回类型，没有参数，不能随意调用，也没有重载（构造函数有重载），只有在类对象的生命期结束的时候，由系统自动调用。 

　　析构函数与构造函数最主要大不同就是在于调用期不同，构造函数可以有参数可以重载！ 

　 　我们前面例子中的Teacher类中就使用new操作符进行了动态堆内存的开辟，由于上面的代码缺少析构函数，所以在程序结束后，动态开辟的内存空间并 没有随着程序的结束而消失，如果没有析构函数在程序结束的时候逐一清除被占用的动态堆空间那么就会造成内存泄露，使系统内存不断减少系统效率将大大降低！

那么我们将如何编写类的析构函数呢？ 

　　析构函数可以的特性是在程序结束的时候逐一调用，那么正好与构造函数的情况是相反，属于互逆特性，所以定义析构函数因使用"~"符号(逻辑非运算符)，表示它为腻构造函数，加上类名称来定义。 

　　看如下代码：

#include <iostream>  
#include <string>  
using namespace std;    
class Teacher  
{  
    public:  
    Teacher()  
    {  
        director = new char[10];  
        strcpy(director,"王大力");  
        //director = new string;  
        // *director="王大力";//string情况赋值  
    }  
    ~Teacher()  
    {  
        cout<<"释放堆区director内存空间1次";  
        delete[] director;  
        cin.get();  
    }  
    char *show();  
    protected:  
    char *director;  
    //string *director;  
};  
char *Teacher::show()  
{  
    return director;  
}  
class Student  
{  
    public:  
    Student()  //在这里调用了Teacher的默认构造函数
    {  
        number = 1;  
        score = 100;  
    }  
    void show();  
  
    protected:  
    int number;  
    int score;  
    Teacher teacher;  
  
};  
  
void Student::show()  
{  
    cout<<teacher.show()<<endl<<number<<endl<<score<<endl; 
}  
void main()  
{  
    Student a;  
    a.show();  
    Student b[3];  
    for(int i=0; i<sizeof(b)/sizeof(Student); i++)  
    {  
        b[i].show();  
    }  
    cin.get();  
}

执行结果：王大力

        1

        100

        王大力

        1

        100

        王大力

        1

        100

        王大力

        1

        100

        释放堆区director内存空间1次

        释放堆区director内存空间1次

        释放堆区director内存空间1次

        释放堆区director内存空间1次

　　创建Student类，先调用Teacher的默认构造函数，再调用Student的构造函数，而析构Student类，先调用student析构函数，再调用teacher析构函数。

上面的代码中我们为Teacher类添加了一个名为~Teacher()的析构函数用于清空堆内存。 

　　建议大家编译运行代码观察调用情况，程序将在结束前也就是对象生命周期结束的时候自动调用~Teacher() 

　　~Teache()中的delete[] director;就是清除堆内存的代码，这与我们前面一开始提到的。 

name=input_name;//这样赋值是错误的 

　　有直接的关系，因为delete操作符只能清空堆空间而不能清楚桟空间，如果强行清除栈空间内存的话将导致程序崩溃！

前面我们已经简单的说了类的构造函数和析构函数，我们知道一个类的成员可以是另外一个类的对象，构造函数允许带参数，那么我们可能会想到上面的程序 我们可以在类中把Student类中的teacher成员用带参数的形式调用Student类的构造函数，不必要再在Teacher类中进行操作，由于这 一点构想我们把程序修改成如下形式：

#include <iostream>    
#include <string>    
using namespace std;      
class Teacher    
{    
    public:    
    Teacher(char *temp)    
    {    
        director = new char[10];    
        strcpy(director,temp);  
    }  
    ~Teacher()    
    {    
        cout<<"释放堆区director内存空间1次";    
        delete[] director;    
        cin.get();    
    }    
    char *show();    
    protected:    
    char *director;    
};    
char *Teacher::show()    
{    
    return director;    
}    
class Student    
{    
    public:    
    Student()    
    {    
        number = 1;    
        score = 100;    
    }    
    void show();    
    
    protected:    
    int number;    
    int score;    
    Teacher teacher("王大力");//错误，一个类的成员如果是另外一个类的对象的话，不能在类中使用带参数的构造函数进行初始化  
    
};    
    
void Student::show()    
{    
    cout<<teacher.show()<<endl<<number<<endl<<score<<endl;   
}    
void main()    
{    
    Student a;    
    a.show();    
    Student b[3];    
    for(int i=0; i<sizeof(b)/sizeof(Student); i++)    
    {    
        b[i].show();    
    }    
    cin.get();    
}

　　可是很遗憾，程序不能够被编译成功,为什么呢？ 

　　因为：类是一个抽象的概念，并不是一个实体，并不能包含属性值(这里来说也就是构造函数的参数了)，只有对象才占有一定的内存空间，含有明确的属性值！ 

　　这一个问题是类成员初始化比较尴尬的一个问题，是不是就没有办法解决了呢？呵呵。。。。。。 

　　c++为了解决此问题，有一个很独特的方法，下一小节我们将介绍。

　　对于上面的那个"尴尬"问题，我们可以在构造函数头的后面加上:号并指定调用哪那个类成员的构造函数来解决！ 

　　教程写到这里的时候对比了很多书籍，发现几乎所有的书都把这一章节叫做构造类成员，笔者在此觉得有所不妥，因为从读音上容易混淆概念，所以把这一小节的名称改为构造类的成员比较合适！

　　代码如下：

#include <iostream>    
using namespace std;      
class Teacher    
{    
    public:    
    Teacher(char *temp)    
    {    
        director = new char[10];    
        strcpy(director,temp);    
    }  
    ~Teacher()    
    {    
        cout<<"释放堆区director内存空间1次";    
        delete[] director;    
        cin.get();    
    }    
    char *show();    
    protected:    
    char *director;    
};    
char *Teacher::show()    
{    
    return director;    
}    
class Student    
{    
    public:    
    Student(char *temp):teacher(temp)  
    {    
        number = 1;    
        score = 100;    
    }    
    void show();    
    
    protected:    
    int number;    
    int score;    
    Teacher teacher;    
    
};    
    
void Student::show()    
{    
    cout<<teacher.show()<<endl<<number<<endl<<score<<endl;   
}    
void main()    
{    
    Student a("王大力");    
    a.show();    
    //Student b[3]("王大力");  //这里这么用是不对的,数组不能够使用带参数的构造函数,以后我们将详细介绍vector类型  
    // for(int i=0; i<sizeof(b) sizeof(student); i++)   <="" font="" style="word-wrap: break-word;"> 
    //{    
    //    b[i].show();    
    //}    
    cin.get();    
}

执行结果：王大力

        1

        100

        释放堆区director内存空间1次

　　大家可以发现最明显的改变在这里 

Student(char *temp):teacher(temp) 

　 　冒号后的teacher就是告诉调用Student类的构造函数的时候把参数传递给成员teacher的Teacher类的构造函数，这样一来我们就成 功的在类体外对teacher成员进行了初始化，既方便也高效，这种冒号后指定调用某成员构造函数的方式，可以同时制定多个成员，这一特性使用逗号方式， 例如： 

Student(char *temp):teacher(temp),abc(temp),def(temp) 

　　由冒号后可指定调用哪那个类成员的构造函数的特性，使得我们可以给类的常量和引用成员进行初始化成为可能。 

　　我们修改上面的程序，得到如下代码：

#include <iostream>    
#include <string>    
using namespace std;      
class Teacher    
{    
    public:    
    Teacher(char *temp)    
    {    
        director = new char[10];    
        strcpy(director,temp);    
    }  
    ~Teacher()    
    {    
        cout<<"释放堆区director内存空间1次";    
        delete[] director;    
        cin.get();  
    }    
    char *show();    
    protected:    
    char *director;    
};    
char *Teacher::show()    
{    
    return director;    
}    
class Student    
{    
    public:    
    Student(char *temp,int &pk):teacher(temp),pk(pk),ps(10)  
    {    
        number = 1;    
        score = 100;  
    }    
    void show();    
    
    protected:    
    int number;    
    int score;    
    Teacher teacher;  
    int &pk;  
    const int ps;  
    
};    
    
void Student::show()    
{    
    cout<<teacher.show()<<endl<<number<<endl<<score<<endl<<pk<<endl<<ps<<endl;   
}    
void main()    
{    
    char *t_name="王大力";  
    int b=99;  
    Student a(t_name,b);  
    a.show();  
    cin.get();  
}

执行结果：王大力

        1

        100

        99

        10

        释放堆区director内存空间1次

　　改变之处最重要的在这里Student(char *temp,int &pk):teacher(temp),pk(pk),ps(10) 

　　调用的时候我们使用 

Student a(t_name,b); 

　　我们将b的地址传递给了int &pk这个引用，使得Student类的引用成员pk和常量成员ps进行了成功的初始化。 

但是细心的人会发现，我们在这里使用的初始化方式并不是在构造函数内进行的，而是在外部进行初始化的，的确，在冒号后和在构造函数括号内的效果是一样的， 但和teacher(temp)所不同的是，pk(pk)的括号不是调用函数的意思，而是赋值的意思，我想有些读者可能不清楚新标准的c++对变量的初始 化是允许使用括号方式的，int a=10和int a(10)的等价的，但冒号后是不允许使用=方式只允许()括号方式，所以这里只能使用pk(pk)而不能是pk=pk了。

　　这一小节的内容是说对象构造的顺序的，对象构造的顺序直接关系程序的运行结果，有时候我们写的程序不错，但运行出来的结果却超乎我们的想象，了解c++对对象的构造顺序有助于解决这些问题。 

　　c++规定，所有的全局对象和全局变量一样都在主函数main()之前被构造，函数体内的静态对象则只构造一次，也就是说只在首次进入这个函数的时候进行构造！ 

　　代码如下：

#include <iostream>    
#include <string>    
using namespace std;      
  
class Test  
{  
public:  
    Test(int a)  
    {  
        kk=a;  
        cout<<"构造参数a:"<<a<<endl; 
    }  
public:  
    int kk;  
};  
  
void fun_t(int n)  
{  
    static Test a(n);  
    //static Test a=n;//这么写也是对的  
    cout<<"函数传入参数n:"<<n<<endl; 
    cout<<"对象a的属性kk的值:"<<a.kk<<endl; 
}  
Test m(100);  
void main()  
{  
    fun_t(20);  
    fun_t(30);  
    cin.get();  
}

执行结果：构造参数a:100

        构造参数a：20

        函数传入参数n：20

        对象a的属性kk的值：20

        函数传入参数n：30

        对象a的属性kk的值：20

　　下面我们来看一下，类成员的构造顺序的问题。 

　　先看下面的代码：

#include <iostream>    
using namespace std;      
  
class Test  
{  
public:  
    Test(int j):pb(j),pa(pb+5)  
    {  
          
    }  
public:  
    int pa;  
    int pb;  
};  
void main()  
{  
    Test a(10);  
    cout<<a.pa<<endl; 
    cout<<a.pb<<endl; 
    cin.get();  
}

执行结果：-858993455

        10

　　上面的程序在代码上是没有任何问题的，但运行结果可能并不如人意。 

　　pa并没有得到我们所希望的15而是一个随机的任意地址的值。 

　　这又是为什么呢？ 

　　类成员的构造是按照在类中定义的顺序进行的，而不是按照构造函数说明后的冒号顺序进行构造的，这一点需要记住！