数据成员初始化，函数重载

1.数据成员初始化：
基于对象的程序中，在定义对象时，需要做初始化工作，即对数据成员赋值，类是一种抽象类型，并不占存储空间，不能容纳数据。如果一个类中的所有成员都是公用的，则可以在定义对象时对数据成员进行初始化。
构造函数实现数据成员的初始化。不需要用户调用它，而是在建立对象时自动执行。
例如：声明一个时间类，实现构造函数对类的数据成员初始化：

#include <iostream>
using namespace std;
class Time            //声明Time类
{
public:
    Time()
    {
        hour = 0;           //定义构造函数，函数名与类名相同
        min = 0;            //利用构造函数对对象中的数据成员赋初值
        sec = 0;
    }
    void set_time();        //成员函数声明
    void show_time();
private:               //私有数据
    int hour;               
    int min;
    int sec;
};
void Time::set_time()           //定义成员函数，向成员函数赋值
{
    cin >> hour;
    cin >> min;
    cin >> sec;
}
void Time::show_time()     //定义成员函数，输出数据成员的值
{
    cout << hour << ":" << min << ":" << sec << endl;
}
int main()
{
    Time t1;              //建立对象t1，同时调用构造函数t1.Time()
    t1.set_time();        //对t1的数据成员赋值
    t1.show_time();       //显示t1的数据成员的值
    Time t2;
    t2.show_time();
    Time t3;
    t3.set_time();
    t3.show_time();
    system("pause");
    return 0;
}

2.带参数的构造函数：
带参的构造函数中的形参，其对应的实参是在建立对象时给定的，即在建立对象时同时指定数据成员的初值。
定义不同对象时用的实参是不同的，它们反映不同对象的属性。用这种方法可以方便地实现对不同对象进行不同的初始化。使用起来方便，直观，从定义语句中可以直接看到数据成员的初值。例如：

#include <iostream>
using namespace std;
class Box
{
public:
    Box(int, int, int);   //声明带参数的构造函数
    //Box::Box(int h, int w, int l) :_height(h), _width(w), _length(l){}
    //用参数初始化表对成员数据初始化，与类外定义构造函数初始化效果等价
    int volume();  //声明计算体积的函数
private:
    int _height;   //类的成员变量，习惯前加"_"或"m_"表示类的成员
    int _width;
    int _length;
};
Box::Box(int h, int w, int l)    //在类外定义带参数的构造函数
{
    _height = h;
    _width = w;
    _length = l;
}
int Box::volume()         //定义计算体积的函数
{
    return(_height*_width*_length);
}
int main()
{
    Box V1(10, 10, 3);      //建立对象V1，并指定长宽高
    cout << V1.volume() << endl;
    system("pause");
    return 0;
}  

3.参数初始化表
用参数初始化表对数据成员初始化，这种方法不在函数体内对数据成员初始化，而是在函数首部实现，如：Box::Box(int h, int w, int l) :_height(h), _width(w), _length(l){}，即在原来函数首部末尾加冒号，然后列出参数的初始化表，上面初始化表示：用形参h的值初始化数据成员_height,用形参w的值初始化数据成员_width,用形参l的值初始化数据成员_length,后面的花括号是空的，即函数体是空的，没有任何执行语。用参数初始化表法可以减少函数体的长度，是结构函数显得精炼简单。这样就可以直接在类体中定义构造函数。尤其当需要初始化的数据成员较多时更显优越性。
类名::构造函数名([参数表])[:成员初始化表]
{
[构造函数体]
} //其中方括号内为可选项(可有可无)
如果数据成员是数组，则应当在构造函数的函数体中用语句对其赋值，而不能在参数初始化列表中对其初始化，如：

#include <iostream>
#include <string.h>
using namespace std;
class Student
{
public:
    Student(int n, char s, char nam[]) :num(n), sex(s)
    { strcpy_s(name, nam); }
    void Display()
    {
        cout << num <<" "<< sex <<" "<<name << endl;
    }
private:
    int num;
    char sex;
    char name[20];
};
int main()
{
    Student s1(1021, 'm', "lily");
    s1.Display();
    system("pause");
    return 0;
}

4.函数重载：
在同一个作用域类，一组函数的函数名相同，参数列表不同（个数/类型不同）,返回值可同可不同。函数重载与返回类型无关，通过参数类型，调用不同的函数。
构造函数的重载 在一个类里可以定义多个构造函数，以便为对象提供不同的初始化方法，供用户选用，这些构造函数具有相同的名字，而参数的个数或参数类型可以不同。

#include <iostream>
using namespace std;
class Box
{
public:
    Box();    //声明一个无参的构造函数
    Box(int h, int w, int l) :_height(h), _width(w), _length(l){}
  //定义一个有参的构造函数，用参数的初始化表对数据成员初始化
    int volume();
private:
    int _height;
    int _width;
    int _length;
};
Box::Box()
{
    _height = 10;
    _width = 10;
    _length = 10;
}
int Box::volume()
{
    return (_height*_width*_length);
}
int main()
{
    Box box1;//建立一个box1对象，不对其进行赋值，则其值则是构造函数初始化中的值
    cout << box1.volume() << endl;
    Box box2(12, 1, 2);//建立对象box2，指定3个实参
    cout << box2.volume() << endl;
    system("pause");
    return 0;
}