关于C++中的构造函数、拷贝构造函数、析构函数的总结

     C++ 中提到了构造函数、拷贝构造函数、析构函数这几个概念，在此我将对这几个概念进行简单的解释及总结。写的不全，请见谅

   一、构造函数

      1、构造函数：一种特殊的成员函数，用来初始化对象。

       2、构造函数的特点： a、函数名和类名相同。

                          b、无返回值，没有类型。（实际返回当前对象的引用）

                          c、构造函数不需要用户调用，也不能被用户调用，只会在新的对象被创建时，由编译器自动调用，且在对象的生命周期内仅调用一次，以保证每个数据成员都有一个合适的初始值。

                          d、有初始化列表（可以不用，只有构造函数有初始化列表）。

                          e、构造函数可以重载，实参决定调用哪个构造函数。

                          f、如果没有显示定义，系统会提供一个默认的构造函数。

                          g、无参构造函数和带有缺省值的构造函数都被认为是缺省构造函数，而且缺省构造函数只能有一个。

                          h、构造函数不能用const和volatile来修饰。

       3、使用构造函数需了解一下问题：

           a、构造函数不能用const修饰的原因：构造函数的作用是初始化对象，如果用const修饰构造函数，之后不能对该对象重新赋值。

           b、什么情况下系统会合成一个默认构造函数？

              有两个类，A和B，B类中含有A类的对象，A中显式定义了构造函数，B中无构造函数，此时，系统会在B类中合成一个默认构造函数。

                                            class A                                         
                                           {
                                             public:
                                                A();
                                           };

                                            class B
                                           {
                                             public:
                                                A a;
                                             char * ptr;
                                           };

                                             int main()
                                           {
                                                B b;

                                                return 0;

                                           }

           c、成员初始化列表只提供该类数据化成员的初始化，而在构造函数体内对数据成员设置值失忆个赋值操作。

      eg:

<span style="font-size:14px;">#include<iostream>
#include<stdio.h>
using namespace std;
class Time              //声明Time类
{
public:                 //公有函数
	Time()              //定义构造成员函数(函数名与类名相同)
	{
		hour = 0;       //利用构造函数对对象中的数据成员赋初始值
		minute = 0;
		second = 0;
	}
	void set_time();   //成员函数声明
	void show_time();   //成员函数声明
private:               //私有数据
	int hour;          //定义标识符
	int minute;
	int second;

};
void Time::set_time()      //定义成员函数，向数据成员赋值
{
	cin >> hour;
	cin >> minute;
	cin >> second;
}
void Time::show_time()      //定义成员函数，输出数据成员的值
{
	cout << hour << ":" << minute << ":" << second << endl;
}
int main()
{
	Time t1;       //建立对象t1，同时调用构造函数t1.Time()
	Time t2;       //建立对象t2，同时调用构造函数t2.Time()
	t1.set_time(); //对t1的数据成员赋值
	t1.show_time();//显示t1的数据成员的值
	t2.set_time();//对t2的数据成员赋值
	t2.show_time();//显示t2的数据成员的值
	system("pause");
	return 0;
}</span>

二、拷贝构造函数

    1、拷贝构造函数：一种特殊的构造函数，只有一个形参，而且该形参是对本类类型对象的引用，这样的构造函数称为拷贝构造函数。

    2、拷贝构造函数的特点：a、它是构造函数的重载。

                          b、只有一个参数。

                          c、由普通构造函数和赋值操作符共同实现。

                          d、它的参数必须使用同类型对象的引用传递。

                          e、如果没有显式定义，系统会自动合成一个默认的拷贝构造函数。默认的拷贝构造函数会依次拷贝类的数据成员完成初始化。

    3、拷贝构造函数的使用场景：  a、对象实例化对象

                               Time t1(21,55,32);

                               Time t2(t1);

                                b、传值方式作为函数的参数

                                void test(cost Time time)

                                {}

                                c、传值方式作为函数的返回值

                                Time test()

                                {

                                   Time time;

                                   return time;

                                }

    4、需了解：

          拷贝构造函数的参数必须使用同类型对象的引用传递的原因：避免拷贝构造函数无限制的递归下去。

三、析构函数

   1、析构函数：析构函数名也与类名相同，只是在函数名前面加一个位取反符~，例~Time(),以区别构造函数。

   2、析构函数的特点：a、析构函数与构造函数作用相反。

                      b、析构函数无参数，无返回值。

                      c、一个类有且只有一个析构函数。若未显式定义，系统会生成缺省的析构函数。

                      d、对象生命周期结束时，C++编译系统自动调用析构函数。

                      e、析构函数体内并不是删除对象，而是做一些清理工作。

   3、需了解：

                   a、由于析构函数没有函数参数，所以不能被重载。

                   b、系统自动生成的析构函数只是徒有析构函数的名称和形式，实际上什么操作都不进行。要让析构函数完成任何工作，都必须在定义的析构函数中指定。

eg:

#include<iostream>
#include<stdlib.h>
#include<string.h>
using namespace std;
class student//声明一个类
{
private://私有部分
int num;
char name[10];
char sex;
public://公用部分
student(int n, char nam[], char s)//构造函数
{
num = n;
strcpy(name,nam);
sex = s;
cout << "Constructor called." << endl;
    }
~student()   //析构函数
{
cout << "Distructor called." << endl;
    }
void display()//成员函数，输出对象的数据
{
cout << "num:" << num <<endl ;
cout << "name:" <<name<<endl;
cout << "sex:" << sex << endl;
}
};
int main()
{
student stud1(10010, "xue", 'f');//建立对象stud1
student stud2(10011, "jia", 'm');//建立对象stud2
stud1.display();//输出学生1的数据
stud2.display();//输出学生2的数据
system("pause");
return 0;
}