C++学习-构造函数(3)

C++规定：构造函数必须与相应的类同名，它可以带参数，也可以不带参数，与一般的成员函数定义相同，而且可以重载，构造函数的重载跟普通的成员函数的重载是一样的。

一.构造函数的重载

[cpp] /*构造函数的重载*/ 
#include <iostream>  
 
using namespace std; 
 
class CDate 
{ 
public: 
    CDate(); 
    CDate(int day); 
    CDate(int month, int day); 
    CDate(int year, int month, int day); 
    ~CDate(); 
    void printInfo() const; 
private: 
    int mYear; 
    int mMonth; 
    int mDay; 
}; 
 
CDate::CDate() 
{ 
    cout << "调用构造函数1" << endl; 
    mYear = 2012; 
    mMonth = 2; 
    mDay = 10; 
} 
 
CDate::CDate(int day) 
{ 
    cout << "调用构造函数2" << endl; 
    mYear = 2012; 
    mMonth = 2; 
    mDay = day; 
} 
 
CDate::CDate(int month, int day) 
{ 
    cout << "调用构造函数3" << endl; 
    mYear = 2012; 
    mMonth = month; 
    mDay = day; 
} 
 
CDate::CDate(int year, int month, int day) 
{ 
    cout << "调用构造函数4" << endl; 
    mYear = year; 
    mMonth = month; 
    mDay = day; 
} 
 
CDate::~CDate() 
{ 
    cout << "调用默认析构函数" << endl; 
} 
 
void CDate::printInfo() const 
{ 
    cout << "Date: " 
         << mYear << "年" 
         << mMonth << "月" 
         << mDay << "日" 
         << endl << endl; 
} 
 
int main() 
{ 
    CDate day1; 
    day1.printInfo(); 
 
    CDate day2(12); 
    day2.printInfo(); 
 
    CDate day3(2, 14); 
    day3.printInfo(); 
 
    CDate day4(2012, 2, 20); 
    day4.printInfo(); 
 
    return 0; 
} 
/*构造函数的重载 www.2cto.com */
#include <iostream>

using namespace std;

class CDate
{
public:
    CDate();
    CDate(int day);
    CDate(int month, int day);
    CDate(int year, int month, int day);
    ~CDate();
    void printInfo() const;
private:
    int mYear;
    int mMonth;
    int mDay;
};

CDate::CDate()
{
    cout << "调用构造函数1" << endl;
    mYear = 2012;
    mMonth = 2;
    mDay = 10;
}

CDate::CDate(int day)
{
    cout << "调用构造函数2" << endl;
    mYear = 2012;
    mMonth = 2;
    mDay = day;
}

CDate::CDate(int month, int day)
{
    cout << "调用构造函数3" << endl;
    mYear = 2012;
    mMonth = month;
    mDay = day;
}

CDate::CDate(int year, int month, int day)
{
    cout << "调用构造函数4" << endl;
    mYear = year;
    mMonth = month;
    mDay = day;
}

CDate::~CDate()
{
    cout << "调用默认析构函数" << endl;
}

void CDate::printInfo() const
{
    cout << "Date: "
         << mYear << "年"
         << mMonth << "月"
         << mDay << "日"
         << endl << endl;
}

int main()
{
    CDate day1;
    day1.printInfo();

    CDate day2(12);
    day2.printInfo();

    CDate day3(2, 14);
    day3.printInfo();

    CDate day4(2012, 2, 20);
    day4.printInfo();

    return 0;
}

执行结果：

[plain] 调用构造函数1 
Date: 2012年2月10日 
 
调用构造函数2 
Date: 2012年2月12日 
 
调用构造函数3 
Date: 2012年2月14日 
 
调用构造函数4 
Date: 2012年2月20日 
 
调用默认析构函数 
调用默认析构函数 
调用默认析构函数 
调用默认析构函数 
调用构造函数1
Date: 2012年2月10日

调用构造函数2
Date: 2012年2月12日

调用构造函数3
Date: 2012年2月14日

调用构造函数4
Date: 2012年2月20日

调用默认析构函数
调用默认析构函数
调用默认析构函数
调用默认析构函数
上面的例子使用了：void printInfo() const;
const在这里的作用是，保证在printInfo函数体中，不更改变量的值，若不小心设置了某变量的值，编译器会在编译的第一时间提醒用户程序出错，提高了开发效率。

二.带默认参数的构造函数

构造函数与成员函数，都可以设置形参的默认参数。如果构造函数或成员函数在类中的声明初始化了默认参数，那么在类外定义的时候，形参不能写出默认值，具体看以下例子。

[cpp] /*带默认参数的构造函数*/ 
#include <iostream>  
 
using namespace std; 
 
class CDate 
{ 
public: 
    CDate(int year, int month = 2, int day = 8); 
    ~CDate(); 
    void printInfo() const; 
private: 
    int mYear; 
    int mMonth; 
    int mDay; 
}; 
 
CDate::CDate(int year, int month, int day) 
{ 
    cout << "调用构造函数" << endl; 
    mYear = year; 
    mMonth = month; 
    mDay = day; 
} 
 
CDate::~CDate() 
{ 
    cout << "调用默认析构函数" << endl; 
} 
 
void CDate::printInfo() const 
{ 
    cout << "Date: " 
         << mYear << "年" 
         << mMonth << "月" 
         << mDay << "日" 
         << endl << endl; 
} 
 
int main() 
{ 
    CDate day1(2012); 
    day1.printInfo(); 
 
    CDate day2(2012, 3, 15); 
    day2.printInfo(); 
 
    return 0; 
} 
/*带默认参数的构造函数*/
#include <iostream>

using namespace std;

class CDate
{
public:
    CDate(int year, int month = 2, int day = 8);
    ~CDate();
    void printInfo() const;
private:
    int mYear;
    int mMonth;
    int mDay;
};

CDate::CDate(int year, int month, int day)
{
    cout << "调用构造函数" << endl;
    mYear = year;
    mMonth = month;
    mDay = day;
}

CDate::~CDate()
{
    cout << "调用默认析构函数" << endl;
}

void CDate::printInfo() const
{
    cout << "Date: "
         << mYear << "年"
         << mMonth << "月"
         << mDay << "日"
         << endl << endl;
}

int main()
{
    CDate day1(2012);
    day1.printInfo();

    CDate day2(2012, 3, 15);
    day2.printInfo();

    return 0;
}
执行结果：

[plain] 调用构造函数 
Date: 2012年2月8日 
 
调用构造函数 
Date: 2012年3月15日 
 
调用默认析构函数 
调用默认析构函数 
调用构造函数
Date: 2012年2月8日

调用构造函数
Date: 2012年3月15日

调用默认析构函数
调用默认析构函数

(1).上面的例子是用了：CDate(int year, int month = 2, int day = 8);
被设置默认参数的形参都是靠后面的参数，那如果是：CDate(int year=2012, int month = 2, int day);这样可以吗？
经过编译器验证，这样声明是错误的。在声明一个对象时，一般都会省略后面的参数，而不会省略靠前面的参数，不然就乱套了。所以从这里可以得出一个概念：在构造函数或成员函数中，被设置默认参数的形参，后面绝对不允许出现没有设置默认参数的形参。
以CDate(int year, int month = 2, int day = 8)为例，设置默认参数有以下几种情况：
1.全部给形参设置默认参数
CDate(int year=2012, int month = 2, int day = 8);   正确

2.给一部分形参设置默认参数
CDate(int year, int month = 2, int day = 8);   正确
CDate(int year, int month, int day = 8);   正确
有且只有这3种情况出现，比如以下声明均是错误的：
CDate(int year, int month = 2, int day);   错误
CDate(int year=2012, int month = 2, int day);   错误

(2).带默认参数的函数的定义
1.构造函数的声明与定义分开，在类中声明：
CDate(int year, int month = 2, int day = 8);
在类外定义：

[cpp] CDate::CDate(int year, int month, int day) 
{ 
    cout << "调用构造函数" << endl; 
    mYear = year; 
    mMonth = month; 
    mDay = day; 
} 
CDate::CDate(int year, int month, int day)
{
    cout << "调用构造函数" << endl;
    mYear = year;
    mMonth = month;
    mDay = day;
}
在函数定义的时候，那些默认参数就不必写出来了。

2.在类中声明与定义
如果直接在类中声明并定义带默认参数的构造函数，直接定义：

[cpp] CDate(int year, int month = 2, int day = 8) 
{ 
    cout << "调用构造函数" << endl; 
    mYear = year; 
    mMonth = month; 
    mDay = day; 
} 

摘自 gzshun的专栏