C++语言— 类中的构造函数和拷贝构造函数

拼搏现实的明天。 2022-09-26 15:56 299阅读 0赞

#  构造函数 #

在说这个之前我想问一个问题，如果成员变量是私有的，我们怎么初始化这些私有的成员变量？

其实这就是构造函数的存在的理由，因为这个成员变量为私有的，要对它们进行初始化，必须用一个

公有成员函数来进行。同时这个函数应该有且仅在定义对象时自动执行一次，这时调用的函数称为构

造函数（constructor）

下面就是构造函数的特征：

1.函数名与类名相同。

2.无返回值。

3.对象构造（对象实例化）时系统自动调用对应的构造函数。

4.构造函数可以重载。

5.构造函数可以在类中定义，也可以在类外定义。

6.如果类定义中没有给出构造函数，则C++编译器自动产生一个缺省的构造函数，但只要我们定义了一个

构造函数，系统就不会自动生成缺省的构造函数。

7.无参的构造函数和全缺省值的构造函数都认为是缺省构造函数，并且缺省的构造函数只能有一个。

下面我们举个例子：

定义一个Date类，在它尝试使用一下构造函数。

class Date
    {
    public:
    	// 1.无参构造函数
    	Date()
    	{}
    
    	// 2.带参构造函数
    	Date(int year, int month, int day)
    	{
    		cout << "我定义的构造函数成功运行了" << endl;
    		_year = year;
    		_month = month;
    		_day = day;
    	}
    	void Display()
    	{
    		cout << _year << " " << _month << " " << _day << endl;
    	}
    private:
    	int _year;
    	int _month;
    	int _day;
    };
    
    void TestDate1()
    {
    	Date d1;               // 调用无参构造函数
    	d1.Display();
    }
    int main()
    {
    	TestDate1();
    	system("pause");
    	return 0;
    }

由于并未对类中的成员进行初始化，也就是我们调用了无参的构造函数，不出所料出现的是随机值。

![Center][]

现在我们试试有参的构造函数：

class Date
    {
    public:
    	// 1.无参构造函数
    	Date()
    	{}
    
    	// 2.带参构造函数
    	Date(int year, int month, int day)
    	{
    		cout << "我定义的构造函数成功运行了" << endl;
    		_year = year;
    		_month = month;
    		_day = day;
    	}
    	void Display()
    	{
    		cout << _year << " " << _month << " " << _day << endl;
    	}
    private:
    	int _year;
    	int _month;
    	int _day;
    };
    
    void TestDate1()
    {
    	Date d2(2015, 1, 1);   // 调用带参的构造函数
    	d2.Display();
    }
    int main()
    {
    	TestDate1();
    	system("pause");
    	return 0;
    }

因为我们知构造函数是可以重载的，所以我们这次使用有参的构造函数。结果应该是我首先输出一段话

，然后依次打印出成员变量，我们来看看：

![Center 1][]

还有一种缺省参数的构造函数，我们分别来看看他们的结果：

class Date
    {
    public:
    	// 3.缺省参数的构造函数
    	Date(int year = 2000, int month = 1, int day = 1)
    	{
    		cout << "我调用成功了" << endl;
    		_year = year;
    		_month = month;
    		_day = day;
    	}
    
    	// 4.半缺省参数的构造函数（不常用）
    	Date(int year, int month = 1)
    	{
    		_year = year;
    		_month = month;
    		_day = 1;
    	}
    	void Display()
    	{
    		cout << _year << " " << _month << " " << _day << endl;
    	}
    private:
    	int _year;
    	int _month;
    	int _day;
    };
    
    void Test()
    {
    	Date d1;               // 调用缺省构造函数
    	d1.Display();
    }
    int main()
    {
    	Test();
    	system("pause");
    	return 0;
    }

看看结果，因为它早早地已经有自己的值了，所以就算没有参数也没有关系

![Center 2][]

class Date
    {
    public:
    	// 3.缺省参数的构造函数
    	Date(int year = 2000, int month = 1, int day = 1)
    	{
    		cout << "我调用成功了" << endl;
    		_year = year;
    		_month = month;
    		_day = day;
    	}
    
    	// 4.半缺省参数的构造函数（不常用）
    	Date(int year, int month = 1)
    	{
    		_year = year;
    		_month = month;
    		_day = 1;
    	}
    	void Display()
    	{
    		cout << _year << " " << _month << " " << _day << endl;
    	}
    private:
    	int _year;
    	int _month;
    	int _day;
    };
    //这里注意半缺席的构造函数，参数从前往后可以缺省，但是不能从最后一位开始缺省
    void Test()
    {
    	Date d2(2015,3,2);   // 调用缺省构造函数
    	d2.Display(); 
    }
    int main()
    {
    	Test();
    	system("pause");
    	return 0;
    }

![Center 3][]

备注：若缺省参数声明和定义分离，则可以在声明或定义中给默认参数。

#  拷贝构造函数 #

创建对象时使用同类对象来进行初始化，这时所用的构造函数称为拷贝构造函数（Copy Constructor）

，拷贝构造函数是特殊的构造函数。

特征：

1.拷贝构造函数其实是一个构造函数的重载。

2.拷贝构造函数的参数必须使用引用传参，使用传值方式会引发无穷递归调用。

3.若未显示定义，系统会默认缺省的拷贝构造函数。缺省的拷贝构造函数会，依次拷贝类成员进行初始化

举个Date类，练习一下拷贝构造。

class Date
    {
    public:
    		Date(int year, int month , int day)
    		{
    			cout << "构造调用成功了" << endl;
    			_year = year;
    			_month = month;
    			_day = day;
    		}
    	// 拷贝构造函数
    	Date(const Date& d)
    	{
    		cout << "拷贝构造被调用了" << endl;
    		_year = d._year;
    		_month = d._month;
    		_day = d._day;
    	}
    	void Display()
    	{
    		cout << _year << " " << _month << " " << _day << endl;
    	}
    private:
    	int _year;
    	int _month;
    	int _day;
    };
    
    void TestDate1()
    {
    	Date d1(2017,3,6);
    
    	// 下面两种用法都是调用拷贝构造函数，是等价的。
    	Date d2(d1);    // 调用拷贝构造函数
    	Date d3 = d1;    // 调用拷贝构造函数
    	d2.Display();
    	d3.Display();
    }
    int main()
    {
    	TestDate1();
    	system("pause");
    	return 0;
    }

这里我们可以看到调用一次构造函数，调用两次拷贝构造，然后让我们看看结果吧。

![Center 4][]

拷贝构造函数特征第二条，拷贝构造函数的参数必须使用引用传参，使用传值方式会引发无穷递归调用。

这个为什么不行呢？

思考一下，如果我们使用值传递，传参的时候是不是需要创建一个新的形参，而这个新的形参就值本身，

也就是自身的一个拷贝，然后呢，又调用了拷贝构造，然后就无穷递归了。

还有一个问题。

![Center 5][]

[Center]: /images/20220708/4584695a41ea471da31c2fc072a1348b.png
[Center 1]: /images/20220708/34bf725215e44811b123eb3cbed1c207.png
[Center 2]: /images/20220708/f1a4f8ade3ec45f0b72dfc03821303d7.png
[Center 3]: /images/20220708/06dd41a8de2d471581bc77de30905bd1.png
[Center 4]: /images/20220708/7983629a9629470e945e276f03fe03b2.png
[Center 5]: /images/20220708/8d75783768e24b5f84e870f21da261d6.png