C++构造函数

构造函数是特殊的成员函数，只要创建类类型的新对象，都要执行构造函数，构造函数的工作是保证每个对象的数据成员具有合适的初值

本文地址：http://www.cnblogs.com/archimedes/p/cpp-constructor.html，转载请注明源地址

C++采用构造函数为对象初始化:

功能：初始化对象

函数名：与类名相同
参数：无

返回值：不指定返回值（不能写void ）

位置：通常作为public成员

内容：任意，通常只包含成员赋值语句

调用方法：通常创建对象时自动调用

Time time;
Time time = Time()；//OK

C++中的构造函数主要分为四类：

无参构造函数、有参构造函数、构造函数与参数初始化列表、默认构造函数、

无参构造函数

注意：

在实例化对象时自动调用

对象名后不能含有括号"类名  对象名( )"

在构造函数中不仅可以对数据成员赋初值，也可以包含其他语句(不提倡加入与初始化无关的语句)

#include<iostream>
using namespace std;

class Time
{
    public:
        Time();
        void display() const;
    private:
        int m_iHour;
        int m_iMinute;
        int m_iSec;
};
Time::Time()
{
    m_iHour   = 0;
    m_iMinute = 0;
    m_iSec    = 0;
}
void Time::display()const
{
    cout << m_iHour << ":"
       << m_iMinute << ":"
       << m_iSec << endl;
}

int main()
{
    Time time;
    time.display();

    Time obj = Time();
    obj.display();

    Time *p = new Time;
    p->display();
    delete p;
    p = NULL;return 0;
} 

有参构造函数

#include<iostream>
using namespace std;

class Time
{
    public:
        Time(int aHour, int aMinute, int aSec);
        void display() const;
    private:
        int m_iHour;
        int m_iMinute;
        int m_iSec;
};
Time::Time(int aHour, int aMinute, int aSec)
{
    m_iHour   = aHour;
    m_iMinute = aMinute;
    m_iSec    = aSec;
}
void Time::display()const
{
    cout << m_iHour << ":"
       << m_iMinute << ":"
       << m_iSec << endl;
}

int main()
{
    Time time(12,30,20);
    time.display();

    time = Time(0,0,0);
    time.display();

    Time *p = new Time(1,2,3);
    p->display();
    delete p;
    p = NULL;return 0;
} 

由于构造函数可含有参数，因此构造函数可以重载

#include<iostream>
using namespace std;

class Time
{
    public:
        Time();
        Time(int aHour, int aMinute, int aSec);
        void display() const;
    private:
        int m_iHour;
        int m_iMinute;
        int m_iSec;
};
Time::Time()
{
    m_iHour   = 0;
    m_iMinute = 0;
    m_iSec    = 0;

}
Time::Time(int aHour, int aMinute, int aSec)
{
    m_iHour   = aHour;
    m_iMinute = aMinute;
    m_iSec    = aSec;
}

void Time::display()const
{
    cout << m_iHour << ":"
       << m_iMinute << ":"
       << m_iSec << endl;
}

int main()
{
    Time time;
    time.display();
    Time Time(12,30,20);
    Time.display();
    system("pause");
    return 0;
} 

重载构造函数时一定要防止产生二义性。

Time();  //声明无参构造函数Time(int ,int);  //有两个参数的构造函数
Time(int ,int = 10, int=10);//有一个参数不是默认参数… …

Time time1;  
Time time2(15); //调用第三个Time time3(15,30); //Error，调用第二个还是第三个？

构造函数与初始化列表

Time::Time(int aHour, int aMinute, int aSec):m_iHour(aHour),m_iMinute(aMinute),m_iSec(aSec){}

注意：

const成员、引用成员及子对象成员必须使用初始化列表初始化

class ConstRef
{
    public:
        ConstRef(int aVal);
    private:
        int   m_iVal;
        const int m_ci;
        int   &m_r;
};
ConstRef::ConstRef(int aVal):m_ival(aVal)
{
    m_ci = aVal;     //Error    
    m_r  = m_iVal;  //Error
}

初始化列表只在实现时出现;

class ConstRef
{
    public:
        ConstRef(int aVal);
    private:
        int m_iVal;
        const int m_ci;
        int &m_r;
};
ConstRef::ConstRef(int aVal):m_iVal(aVal), m_ci(aVal), m_r(m_iVal){}
int main()
{
    ConstRef obj(4);
    return 0;
}

构造函数初始化列表不能指定初始化次序

class Point
{
    public:    
        Point(int aVal):m_iY(aVal), m_iX(m_iY){} //Error
    private:
        int m_iX;    
        int m_iY;
};

按照成员声明的顺序编写构造函数初始化列表。尽量避免使用成员初始化成员。

class Point
{
    public:
        Point(int aVal):m_iX(aVal), m_iY(m_iX){}
    private:
        int m_iX;    
        int m_iY;
};

默认构造函数

概念：初始化对象时不提供参数时所调用的构造函数

int main()
{
    Time time1;    
    Time time2(); //error    
    Time &r = *new Time;
    delete Time;
    return 0;
}

自定义的构造函数、由系统创建的构造函数、含默认参数的构造函数

自定义的构造函数:

#include<iostream>
using namespace std;
class Time
{
    public:
        Time();
        void display() const;
    private:
        int m_iHour;
        int m_iMinute;
        int m_iSec;
};
Time::Time()
{
    m_iHour   = 0;
    m_iMinute = 0;
    m_iSec    = 0;
}
void Time::display()const
{
    cout << m_iHour << ":"
       << m_iMinute << ":"
       << m_iSec << endl;
}
int main()
{
    Time time;
    time.display();

    Time obj = Time();
    obj.display();

    Time *p = new Time;
    p->display();
    delete p;
    p = NULL;
    system("pause");
    return 0;
} 

自定义的构造函数:

类体中若没有构造函数，则系统会生成一个默认构造函数。

#include<iostream>
using namespace std;

class Time
{
    public:
        void display() const;
    private:
        int m_iHour;
        int m_iMinute;
        int m_iSec;
};
void Time::display()const
{
    cout << m_iHour << ":"
       << m_iMinute << ":"
       << m_iSec << endl;
}
int main()
{
    Time time;
    time.display();
    system("pause");
    return 0;
} 

类体中若含有构造函数则系统不会生成默认构造函数；系统创建的默认构造函数就是函数体为空的无参构造函数Time::Time( ){}

含默认参数的构造函数：

#include<iostream>
using namespace std;

class Time
{
    public:
        Time(int aHour=0, int aMinute=0, int aSec=0);
        void display() const;
    private:
        int m_iHour;
        int m_iMinute;
        int m_iSec;
};
Time::Time(int aHour, int aMinute, int aSec)
{
    m_iHour = aHour;
    m_iMinute = aMinute;
    m_iSec = aSec;
}
void Time::display()const
{
    cout << m_iHour << ":"
       << m_iMinute << ":"
       << m_iSec << endl;
}
int main()
{
    Time time1;
    time1.display();
    Time time2(12,30,20);
    time2.display();
    system("pause");
    return 0;
} 

说明：

在声明构造函数时，形参名可以省略（不推荐）
    Time(int = 10,int =10,int =10);

一个类只能有一个默认构造函数
    Time ();  //声明无参构造函数
    Time (int aX=10,int aY=10,int aZ=10);
    Time box1;  //ERROR

推荐使用默认参数的默认构造函数，以提高代码重用。

一个类中只能含有一个默认构造函数

总结

构造函数的函数名与类名相同，不写返回值，因而不能指定包括void在内的任何返回值类型。

构造函数通常为public

构造函数是成员函数，它可在类体内或类体外实现。

构造函数可以重载，重载时防止产生“二义性”。

最好用参数初始化列表实现构造函数

类外实现构造函数时初始化列表在实现时出现！

无参构造函数和全部参数都含有默认值的构造函数都是默认构造函数

一个类只能含有一个默认构造函数

习惯上要求定义一个含默认参数的默认构造函数，以增强类的通用性