类的构造函数

定义

构造函数是一种特殊的方法，用于初始化类的对象。在类的实例被创建时，构造函数会被自动调用。构造函数通常用来为对象的属性赋初值或执行其他必要的初始化操作。

意义：使对象被初始化

引入

假如我们有一个简单的日期类

#include <iostream>
using namespace std;

class Date
{
public:
	void Init(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	void Print()
	{
		cout << _year << "-" << _month<< "-" << _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};


int main()
{
	Date d1;
    d1.Init(2025,3,8)//对对象设置内容，进行初始化
	d1.Print();//打印日期
	
}

对于Date类，每次我们创建对象时，都必须调用Init给对象设置内容

而构造函数就是使我们在创建对象时，自动将要传递的内容放进去，替代Init

特征

构造函数是一个特殊的成员函数

1.名字与类名相同

2.无返回值

3.可以重载

4.对象实例化时编译器自动调用

创建构造函数

class Date
{
public:
//创建构造函数
	Date(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}
private:
	int _year;
	int _month;
	int _day;
};

使用构造函数（其中一种）

int main()
{
//使用构造函数
	Date d1(2025,3,8);
}

类型

1.自己实现的有参的构造函数

直接在所创建的对象后面进行传参

class Date
{
public:
//创建构造函数
	Date(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}

    void Print()
    {
	    cout << _year << "-" << _month<< "-" << _day << endl;
    }
private:
	int _year;
	int _month;
	int _day;
};

int main()
{
//使用构造函数
	Date d1(2025,3,8);
    d1.Print();
}

2.自己实现的无参的构造函数

不用传参

class Date
{
public:
//创建构造函数
	Date()
	{
		_year = 0;
		_month = 1;
		_day = 2;
	}

    void Print()
    {
	    cout << _year << "-" << _month<< "-" << _day << endl;
    }
private:
	int _year;
	int _month;
	int _day;
};

int main()
{
//使用构造函数
	Date d1;
    d1.Print();
}

3.自己实现的全缺省的构造函数

首先，我们如果定义同时一个有参和一个无参的构造函数，所创建的对象会根据是否传参而进行不同的初始化

class Date
{
public:
	//创建无参的构造函数
	Date()
	{
		_year = 0;
		_month = 1;
		_day = 2;
	}
	//创建有参的构造函数
	Date(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}

	void Print()
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};

int main()
{
	//使用构造函数
	Date d1;
	d1.Print();
	Date d2(2025, 3, 8);
	d2.Print();
}

现在，有一种方法可以将有参和无参的构造函数变为一个函数，那就是全缺省的构造函数

class Date
{
public:
	
	//创建全缺省的构造函数
	Date(int year=0, int month=1, int day=2)
	{
		_year = year;
		_month = month;
		_day = day;
	}

	void Print()
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};

int main()
{
	//使用构造函数
	Date d1;
	d1.Print();
	Date d2(2025, 3, 8);
	d2.Print();
}

4.编译器自动生成的构造函数

如果有我们定义的构造函数，它就不会存在

注意：

其不对内置类型（int,char,double...）的成员变量进行处理，只对自定义类型的成员变量，调用自定义类型成员自己的构造函数（并且这个构造函数不能带参）（双标）

下面，我们先定义一个Time类，并且定义Time的构造函数

//定义Time类
class Time
{
public:
	//定义time自己的无参构造函数
	Time()
	{
		_hour = 0;
		_minute = 0;
		_second = 0;
		//调用Time构造函数时打印
		cout << _hour << "-" << _minute << "-" << _second << endl;
	}

private:
	int _hour;
	int _minute;
	int _second;
};

在Date类的成员中加入Time类的对象

class Date
{
public:
//此处去掉了Date的构造函数
	void Print()
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}

private:
	int _year;
	int _month;
	int _day;
	//加入Time类型成员
	Time _t;
};

运行

int main()
{
	Date d1;
	d1.Print();
}

其中，Date类中_year,_month,_day为随机值，_t中的_hour=_minute=_second=0,完成了初始化

此时，如果加入Date的有参构造函数，就不会再有默认构造函数了，创建Date类型的对象时就必须传递参数，但是其中的Time类型成员仍会完成初始化

//定义Time类
class Time
{
public:
	//定义time自己的无参构造函数
	Time()
	{
		_hour = 0;
		_minute = 0;
		_second = 0;
		//调用Time构造函数时打印
		cout << _hour << "-" << _minute << "-" << _second << endl;
	}

private:
	int _hour;
	int _minute;
	int _second;
};

class Date
{
public:
	//此处增加了Date的有参构造函数
	Date(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}

	void Print()
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}


private:
	int _year;
	int _month;
	int _day;
	Time _t;
};

int main()
{
//必须传参
	Date d1(2025,3,8);
	d1.Print();
}

补充：

1.调用构造函数不传参时，创建的对象后不用加空括号

2.全缺省的构造函数与无参的构造函数不能同时存在，因为在不传参数的情况下调用会有歧义