1.**对象的初始化**

    • 类的数据成员不能在声明类时初始化。

      1. class Time{
      2.  hour=0;
      3.  min=0;
      4. }     //错误
      • 原因：类是抽象类型，不是实体，不占存储空间
    • 如类中所有成员都是公用的（public），则可在定义对象时对数据成员进行初始化
      1. class Time
      2. {public: //声明为公用成员
      3. int hour;
      4. int minute;
      5. int sec;
      6. };
      7. Time t1={14,56,30}; //将t1初始化为14:56:30

    2.构造函数的作用

    • 什么是构造函数？
      • 一种特殊的成员函数，不需要用户调用，也不能被用户调用，在建立对象时自动执行。
    • 构造函数有什么特点？
      • 构造函数必须与类名同名，不能任意命名；
      • 不具有任何类型，不返回任何值 ；
      • 功能由用户定义，用户根据初始化的要求设计函数体和参数。

    • 用构造函数初始化

      • 语法

        1. //类内定义构造函数
        2. class Time{
        3. public:
        4.     Time(){
        5.         h=0;
        6.     }
        8.     ~Time();
        9. private:
        10.      int  h;       
        11. }     
        12. //类外定义构造函数
        13. class Time{
        14. public:
        15.     Time()；
        17.     ~Time();
        18. private:
        19.      int  h;       
        20. }     
        21. Time::Time()
        22. {
        23.    h=0;
        24. }

      • 例

        1. #include <iostream>
        2. using namespace std;
        3. class Time
        4. {public:
        5. Time( ) //定义构造成员函数，函数名与类名相同
        6. {hour=0; //利用构造函数对对象中的数据成员赋初值
        7. minute=0;
        8. sec=0;}
        9. void set_time( ); //函数声明
        10. void show_time( ); //函数声明
        11. private:
        12. int hour; //私有数据成员
        13. int minute;
        14. int sec;
        15. };
        16. void Time∷ set_time( ) //定义成员函数，向数据成员赋值
        17. {cin>>hour;
        18. cin>>minute;
        19. cin>>sec;
        20. }
        21. void Time∷ show_time( ) //定义成员函数，输出数据成员的值
        22. {
        23. cout<<hour<<″:″<<minute<<″:″<<sec<<endl;
        24. }
        25. int main( )
        26. {
        27. Time t1; //建立对象t1，同时自动调用构造函数t1.Time( )
        28. t1.set_time( ); //对t1的数据成员赋值
        29. t1.show_time( ); //显示t1的数据成员的值
        30. Time t2; //建立对象t2，同时调用构造函数t2.Time( )
        31. t2.show_time( ); //显示t2的数据成员的值
        32. return 0;
        33. }

    • 构造函数说明

      • 在类对象进入其作用域时调用构造函数。
      • 构造函数的函数体中不仅可对数据成员赋初值，也可以包含其他语句。
      • 如用户自己没有定义构造函数，则C++系统会自动生成一个构造函数，这个构造函数的函数体是空的，也没有参数，不执行初始化操作。

    3.带参数的构造函数

    • 如何使不同的对象赋予不同的初值？
      • 可以采用带参数的构造函数，在调用不同对象的构造函数时，从外面将不同的数据传递给构造函数，以实现不同的初始化。
    • 语法： 构造函数名(类型1 形参1，类型2 形参2，。。。。)
    • 定义对象的格式： 类名 对象名(实参1，实参2，。。。。)；


    4.用参数初始化表对数据成员初始化**

    • 不在函数体内对数据成员初始化，而是在函数首部实现：
      1. Box∷ Box(int h,int w,int len):height(h)，width(w)，length(len){ }

    5.构造函数的重载

    • 在一个类中可定义多个构造函数以便对类对象提供不同的初始化方法，供用户选择

      这些构造函数的名字相同，而参数个数或参数的类型不同。

      1. #include <iostream>
      2. using namespace std;
      3. class Box
      4. {public:
      5. Box( ); //声明一个无参的构造函数
      6. Box(int h,int w,int len):height(h),width(w),length(len){ }
      7. //声明一个有参的构造函数，用参数的初始化表对数据成员初始化
      8. int volume( );
      9. private:
      10. int height;
      11. int width;
      12. int length;
      13. };
      14. Box∷ Box( ) //定义一个无参的构造函数
      15. {height=10;
      16. width=10;
      17. length=10;
      18. }
      19. int Box∷ volume( )
      20. {return(height*width*length);
      21. }
      22. int main( )
      23. {
      24. Box box1;
      25. cout<<″The volume of box1 is ″<<box1.volume( )<<endl;
      26. Box box2(15,30,25);
      27. cout<<″The volume of box2 is ″<<box2.volume( )<<endl;
      28. return 0;
      29. }
      30. 还可以定义其他重载构造函数，其原型声明可以为
      31. Box∷ Box(int h);
      32. Box∷ Box(int h,int w);

    6.**使用默认参数的构造函数**

    1. #include <iostream>
    2. using namespace std;
    3. class Box
    4. {public:
    5. Box(int h=10,int w=10,int len=10); //在声明构造函数时指定默认参数
    6. int volume( );
    7. private:
    8. int height;
    9. int width;
    10. int length;
    11. };
    12. Box∷ Box(int h,int w,int len) //在定义函数时可以不指定默认参数
    13. {height=h;
    14. width=w;
    15. length=len;
    16. }
    17. int Box∷ volume( )
    18. {return(height*width*length);
    19. }
    20. int main( )
    21. {
    22. Box box1; //没有给实参
    23. cout<<″The volume of box1 is ″<<box1.volume( )<<endl;
    24. Box box2(15); //只给定一个实参
    25. cout<<″The volume of box2 is ″<<box2.volume( )<<endl;
    26. Box box3(15,30); //只给定2个实参
    27. cout<<″The volume of box3 is ″<<box3.volume( )<<endl;
    28. Box box4(15,30,20); //给定3个实参
    29. cout<<″The volume of box4 is ″<<box4.volume( )<<endl;
    30. return 0;
    31. }
    • 说明
      • 在构造函数中使用默认参数相当于提供了建立对象时的多种选择，它的作用相当于几个重载的构造函数。
      • 在调用构造函数时没有提供实参值，将按照默认的参数值对对象进行初始化。
      • 应该在声明构造函数时指定默认值，而不能只在定义构造函数时指定默认值。
      • 在声明构造函数时，形参名可以省略。
      • 在一个类中定义了全部是默认参数的构造函数后，不能再定义重载构造函数。

    **