c++构造函数

对对象变量初始化，自动调用

构造函数不用用户来调用它，而是在建立对象时自动执行。
构造函数的名字必须与类同名，不可任意命名
构造函数不具有任何类型，也不返回任何值。

默认构造函数

/*基本默认构造*/
1class Student
{
public:
    //默认构造函数
    Student()
    {
       num=1001;
       age=18;     
    }
private:
    int num;
    int age;
};
int main()
{
    //用默认构造函数初始化对象S1
    Student s1;
    return 0;
}
/***默认实参的构造函数**确保，在调用构造函数的时候，就算没有提供参数值，构造函数仍然可以正确的初始化类的对象。
**如果构造函数的所有参数都指定了默认值，这时候的构造函数也属于默认构造函数**。
同一个类只能有一个默认构造函数，例如下面的类Time*/
class Time
{
public:
    Time( int = 0, int = 0, int = 0);
    Time(){}   //错误，只能有一个默认构造函数

private:
    int hour;
    int minute;
    int second;
} ;

默认参数的构造函数

class Time
{
public:
    Time( int h = 0, int m = 0, int s = 0)
    {
        setTime(h,m,s);
    }

    void setTime(int h, int m, int s)
    {
        setHour( h );
        setMinute( m );
        setSecond( s );
    }

    void setHour(int h)
    {
        hour = h;
    }
    int getHour()
    {
        return hour;
    }
    /////////////////////
    void setMinute( int m)
    {
        minute = m;
    }
    int getMinute()
    {
        return minute;
    }
    /////////////////////
    void setSecond( int s )
    {
        second = s;
    }
    int getSecond()
    {
        return second;
    }


private:
    int hour;
    int minute;
    int second;
} ;
int main()
{
    cout<<"Test in main"<<endl;
    Time t1;//所有参数都使用默认值
    Time t2( 2 );//时指定，分和秒为默认值
    Time t3( 21, 24 );//时和分指定，秒为默认值
    Time t4( 12, 25, 34 );//所有参数都指定

    cout<<"Time of t1："<<t1.getHour()<<" : "<<t1.getMinute()<<" : "<<t1.getSecond()<<endl;
    cout<<"Time of t2："<<t2.getHour()<<" : "<<t2.getMinute()<<" : "<<t2.getSecond()<<endl;
    cout<<"Time of t3："<<t3.getHour()<<" : "<<t3.getMinute()<<" : "<<t3.getSecond()<<endl;
    cout<<"Time of t4："<<t4.getHour()<<" : "<<t4.getMinute()<<" : "<<t4.getSecond()<<endl;

    system("pause");
    return 0;
}

构造函数初始化列表

class MyClass
{
public:
    //第一种形式 固定的，也是默认的
    MyClass() : m1_int(7), m2_double(0.8)
    {
        cout<<"Constructor 1 is called"<<endl;
    }

    //第二种形式  用户可自定义的
    MyClass(int m1, double m2) : m1_int(m1), m2_double(m2)
    {
        cout<<"Constructor 2 is called"<<endl;
    }

private:
    int m1_int;
    double m2_double;
} ;
/*类的数据成员被初始化的顺序是其定义的次序，而与构造函数初始化列表中的顺序无关。*/
int main()
{
    cout<<"Test in main"<<endl;
    MyClass myclass1;//调用第一种形式的构造函数
    MyClass myclass(2,0.3);//调用第二种形式的构造函数

    //或者用下面的方式创建对象
    MyClass myclass1 = MyClass();//调用第一种形式的构造函数
    MyClass myclass2 = MyClass(2,0.3);//调用第二种形式的构造函数

    system("pause");
    return 0;
}

重载构造函数

其实就是可以写一个多个同名构造函数，但是这多个构造函数里面的参数数量不同，可以初始化类中的第一或者第一和第二个….

组合初始化构造，一个类里面还有其他类作为成员

class teacher
{
    int a;
    public:
    teacher(int a)
    {
        this->a=a;
    }
}；
class people
{
     int b;
     teacher T;
     public:
     people(int a,int b):T(a)  //现在括号内部定义形参，再把它传个对象T，再调用teacher构造函数初始化
     {
            this->b=b;
    }
};