注意：如果类中用户没有定义构造函数，系统会自动提供一个函数体为空的默认构造函数。
但是，只要类中定义了一个构造函数(不一定无参构造函数)，系统将不再给它提供
默认的构造函数。因为，默认的构造函数被类中的提供的构造函数给覆盖了。然而，
对象一建立，就需要初始化，所以，用户在程序中此时根据自己的需要来设置默认的
构造函数.....
//无参数的默认构造函数
//例 3.10
#include<iostream>
using namespace std;
class Location{
public:
// Location() //程序员自己设置的无参数(默认)的构造函数
// {
//
// }
Location() //程序员自己设置的无参数(默认)的构造函数
{
X = 0;
Y = 0;
}
Location(int m, int n)
{
X=m;
Y=n;
}
void init(int initX,int initY)
{
X=initX;
Y=initY;
}
int GetX()
{
return X;
}
int GetY()
{
return Y;
}
private:
int X;
int Y;
};
int main()
{
Location A; //对象一建立，就会调用无参数(默认)的构造函数，进行初始化
A.init(785,980);
cout<<A.GetX()<<","<<A.GetY()<<endl;
return 0;
}
//例3.11 关于计时器的例子
#include<iostream>
using namespace std;
class timer{
public:
timer() //无参数的构造函数，给seconds清0
{
seconds = 0;
}
timer(char *t)//含一个数字串参数的构造函数 char *t = "20"
{
seconds = atoi(t); //atio作用:把字符串转换成长整型数
}
timer(int t)//含一个整型参数的构造函数
{
seconds = t;
}
timer(int min, int sec)//含有两个整型参数的构造函数
{
seconds = min * 60+sec;
}
int gettime()
{
return seconds;
}
private:
int seconds;
};
int main()
{
timer a; //创建类timer的对象a，调用无参的构造函数
timer b(10);//创建类timer的对象b，调用含有一个整型参数的构造函数
timer c("20");//创建类timer的对象c，调用含有一个数字串参数的构造函数
timer d(1,10);//创建类timer的对象d，调用含有两个整型的参数的构造函数
cout<<"seconds1="<<a.gettime()<<endl;
cout<<"seconds2="<<b.gettime()<<endl;
cout<<"seconds3="<<c.gettime()<<endl;
cout<<"seconds4="<<d.gettime()<<endl;
return 0;
}
//带默认参数的构造函数
#include<iostream>
#include<cmath>
using namespace std;
class Complex{
public:
Complex(double r=0.0,double i=0.0); //在声明构造函数时指定默认参数值，初始化完成
double abscomplex();
private:
double real;
double imag;
};
Complex::Complex(double r,double i) //在类外定义构造函数时
{ real = r;imag = i;} //可以不再指定参数的默认值
double Complex::abscomplex()
{
double t;
t = real*real+imag*imag;
return sqrt(t);
}
int main()
{
Complex s1; //定义Complex类的对象s1，没有传递实参，全部用默认值
cout<<"复数1的绝对值是:"<<s1.abscomplex()<<endl;
Complex s2(1.1); //定义Complex类的对象s2，只传递一个实参
cout<<"复数2的绝对值是:"<<s2.abscomplex()<<endl;
Complex s3(1.1，2.2); //定义Complex类的对象s3，传递两个实参
cout<<"复数3的绝对值是:"<<s3.abscomplex()<<endl;
return 0；
}
分析：在类Complex中，构造Complex的两个参数均含有默认参数值0.0，因此，在定义对象
时可根据需要使用其默认值，在主函数main中定义了3个对象s1、s2、s3，它们都是
合法的对象。由于传递的参数的个数不同，使它们的私有成员real和imag取得不同的
值。由于定义对象s1时，没有传递参数，所以real和imag均取得函数的默认值为其赋值
因此，real和imag均为0.0;由于定义对象s2时，只传递一个参数，这个参数传递给构造
函数的第一个形参，而第二个形参去默认值，所以，对象s2的real取得值为1.1，imag值
取得0.0;由于定义对象s3时,传递了两个参数，这两个实参分别赋给了real和imag取得
1.1，2.2。
运行结果 复数1的绝对值是:0
运行结果 复数2的绝对值是:1.1
运行结果 复数3的绝对值是:2.45967
拓展知识点：
1、如果构造函数在类的声明外定以，那么默认参数应该在类内声明构造函数原型时指定，
而不能在类外构造函数定义时指定。
2、如果构造函数的全部参数都指定了默认值，则在定义对象时可以指定一个或几个实参，
也可以不给出实参，这时的构造函数也属于默认构造函数
例如: Comolex(double r=0.0, double i=0.0);
因为类中只能有一个默认的构造函数，因此，不能同时再声明一个无参的
构造函数如下：
Complex();
原因：如果创建一个对象 Complex s1;
编译系统将无法识别应该调用以上那一个构造函数，产生了二义性
3、在一个类中定义了全部是默认参数的构造函数后，不能再定义重载构造函数。
例如：
在一个类中有以下构造函数的声明：
Complex(double r=0.0, double i=0.0); //声明全部是默认参数的构造函数
Complex(double r);
原因：如果定义一个对象 Complex s2(1.1);
编译系统将无法判断应该调用哪个构造函数