C++中：构造函数,拷贝构造函数,析构函数,赋值运算符,重载的简绍



一.构造函数

构造函数的介绍：

是一种特殊的方法，主要用来在创建对象时初始化对象，构造函数的命名必须和类名完全相同，而一般方法则不能和类名相同

构造的特点:

构造区别

1.构造函数的命名必须和类名完全相同；在java中普通函数可以和构造函数同名，但是必须带有返回值。

2.构造函数的功能主要用于在类的对象创建时定义初始化的状态。它没有返回值，也不能用void来修饰。这就保证了它不仅什么也不用自动返回，而且根本不能有任何选择而 其他方法都有返回值，即使是void返回值。尽管方法体本身不会自动返回什么，但仍然可以让它返回一些东西，而这些东西可能是不安全的。

3.构造函数不能被直接调用，必须通过new运算符在创建对象时才会自动调用；而一般的方法是在程序执行到它的时候被调用的。

4.当定义一个类的时候，通常情况下都会显示该类的构造函数，并在函数中指定初始化的工作也可省略，不过Java编译器会提供一个默认的构造函数.此默认构造函数是不带参数的。而一般的方法不存在这一特点。

5.当一个类只定义了私有的构造函数，将无法通过new关键字来创建其对象，当一个类没有定义任何构造函数，C#编译器会为其自动生成一个默认的无参的构造函数。

构造函数

C++语言为类提供的构造函数可自动完成对象的初始化任务，全局对象和静态对象的构造函数在main()函数执行之前就被调用，局部静态对象的构造函数是当程序第一次执行到相应语句时才被调用。然而给出一个外部对象的引用性声明时，并不调用相应的构造函数，因为这个外部对象只是引用在其他地方声明的对象，并没有真正地创建一个对象。

C++的构造函数定义格式为：

class <类名>

{

public:

<类名>(参数表)      //...(还可以声明其它成员函数)

};

<类名>::<函数名>(参数表)

{

//函数体

}

如以下定义是合法的：

class T

{

public:

    T(int a=0)

        {i=a;}    //构造函数允许直接写在类定义内，也允许有参数表。

private:

    int i;

};

如果一个类中没有定义任何的构造函数，那么编译器只有在以下三种情况，才会提供默认的构造函数：

1、如果类有虚拟成员函数或者虚拟继承父类（即有虚拟基类）时；

2、如果类的基类有构造函数（可以是用户定义的构造函数，或编译器提供的默认构造函数）；

3、在类中的所有非静态的对象数据成员，它们对应的类中有构造函数（可以是用户定义的构造函数，或 编译器提供的默认构造函数）。

<类名>::<类名>(){}，即不执行任何操作。

构造函数例子

//注意若将本代码直接复制进编译器，可能会报错，原因是网页生成时会在代码前加一个中文占位符

//最好将代码再写一次

#include <iostream>

using namespace std;

class time

{

public:

     time()           //constructor.构造函数

    {

       hour=0;

      minute=0；

      sec=0;

     }

    void set_time();

    void show_time();

private:

    int hour;

    int minute;

    int sec;

};

int main()

{

     class time t1;

     t1.show_time();

     t1.set_time();

     t1.show_time();

    return 0;

}

void time::set_time()

{

     cin >>hour;

     cin >>minute;

     cin >>sec;

}

void time::show_time()

{

      cout<<hour<<":"<<minute<<":"<<sec<<endl;

}

程序运行情况：

0：0：0

10 11 11 回车

10：11：11

任何时候，只要创建类或结构，就会调用它的构造函数。类或结构可能有多个接受不同参数的构造函数。构造函数使得程序员可设置默认值、限制实例

二.拷贝构造函数

1.拷贝构造函数的介绍：

   拷贝构造函数，又称复制构造函数，是一种特殊的构造函数，它由编译器调用来完成一些基于同一类的其他对象的构建及初始化。其唯一的形参必须是引用，但并不限制为const，一般普遍的会加上const限制。此函数经常用在函数调用时用户定义类型的值传递及返回。拷贝构造函数要调用基类的拷贝构造函数和成员函数。如果可以的话，它将用常量方式调用，另外，也可以用非常量方式调用。

2.拷贝构造函数  

义项指多义词的不同概念，如 李娜 的义项：网球运动员、歌手等； 非诚勿扰 的义项：冯小刚执导电影、江苏卫视交友节目等。 查看详细规范>>

拷贝构造函数，又称复制构造函数，是一种特殊的构造函数，它由编译器调用来完成一些基于同一类的其他对象的构建及初始化。其唯一的形参必须是引用，但并不限制为const，一般普遍的会加上const限制。此函数经常用在函数调用时用户定义类型的值传递及返回。拷贝构造函数要调用基类的拷贝构造函数和成员函数。如果可以的话，它将用常量方式调用，另外，也可以用非常量方式调用。

3.概述

调用拷贝构造函数的情形

在C++中，下面三种对象需要调用拷贝构造函数(有时也称"复制构造函数"):

1) 一个对象作为函数参数，以值传递的方式传入函数体;

2) 一个对象作为函数返回值，以值传递的方式从函数返回;

3) 一个对象用于给另外一个对象进行初始化(常称为赋值初始化);

如果在前两种情况不使用拷贝构造函数的时候，就会导致一个指针指向已经被删除的内存空间。对于第三种情况来说，初始化和赋值的不同含义是拷贝构造函数调用的原因。事实上，拷贝构造函数是由普通构造函数和赋值操作符共同实现的。描述拷贝构造函数和赋值运算符的异同的参考资料有很多。

通常的原则是:①对于凡是包含动态分配成员或包含指针成员的类都应该提供拷贝构造函数;②在提供拷贝构造函数的同时，还应该考虑重载"="赋值操作符号。原因详见后文。

拷贝构造函数必须以引用的形式传递(参数为引用值)。其原因如下:当一个对象以传递值的方式传一个函数的时候，拷贝构造函数自动的被调用来生成函数中的对象。如果一个对象是被传入自己的拷贝构造函数，它的拷贝构造函数将会被调用来拷贝这个对象这样复制才可以传入它自己的拷贝构造函数，这会导致无限循环直至栈溢出(Stack Overflow)。除了当对象传入函数的时候被隐式调用以外，拷贝构造函数在对象被函数返回的时候也同样的被调用。

隐式地拷贝构造函数

如果在类中没有显式的声明一个拷贝构造函数，那么，编译器会自动生成一个来进行对象之间非static成员的位拷贝(Bitwise Copy)。这个隐含的拷贝构造函数简单的关联了所有的类成员。注意到这个隐式的拷贝构造函数和显式声明的拷贝构造函数的不同在于对成员的关联方式。显式声明的拷贝构造函数关联的只是被实例化的类成员的缺省构造函数，除非另外一个构造函数在类初始化或构造列表的时候被调用。

拷贝构造函数使程序更有效率，因为它不用再构造一个对象的时候改变构造函数的参数列表。设计拷贝构造函数是一个良好的风格，即使是编译系统会自动为你生成默认拷贝构造函数。事实上，默认拷贝构造函数可以应付许多情况。

引申:在这里，与C#是不同的。C#里面用已知的对象去初始化另一个对象，传递的是该已知对象的指针，而并不是隐式地拷贝构造函数。例如:

这里的输出会是"20,20"而不是C++里面的10,20。所以一定要跟C++区分开看。

4. 例述

复制初始化

以下讨论中将用到的例子:

语句"CExample theObjtwo=theObjone;"用theObjone初始化theObjtwo。

回顾一下此语句的具体过程:首先建立对象theObjtwo，并调用其构造函数，然后成员被复制初始化。

其完成方式是内存拷贝，复制所有成员的值。完成后，theObjtwo.pBuffer==theObjone.pBuffer。

即它们将指向同样的地方，指针虽然复制了，但所指向的空间并没有复制，而是由两个对象共用了。这样不符合要求，对象之间不独立了，并为空间的删除带来隐患。所以需要采用必要的手段来避免此类情况:可以在构造函数中添加操作来解决指针成员的这种问题。

所以C++语法中除了提供缺省形式的构造函数外，还规范了另一种特殊的构造函数:拷贝构造函数，一种特殊的构造函数重载。上面的语句中，如果类中定义了拷贝构造函数，在对象复制初始化时，调用的将是拷贝构造函数，而不是缺省构造函数。在拷贝构造函数中，可以根据传入的变量，复制指针所指向的资源。

拷贝构造函数的格式为:类名(const 类名& 对象名);//拷贝构造函数的原型，参数是常量对象的引用。由于拷贝构造函数的目的是成员复制，不应修改原对象，所以建议使用const关键字。

提供了拷贝构造函数后的CExample类定义为:

这样，定义新对象，并用已有对象初始化新对象时，CExample(const CExample& RightSides)将被调用，而已有对象用别名RightSides传给构造函数，以用来作复制。

对象按值传递

下面介绍拷贝构造函数的另一种调用:当对象直接作为参数传给函数时，函数将建立对象的临时拷贝，这个拷贝过程也将调用拷贝构造函数。例如:

BOOL testfunc(CExample obj);

testfunc(theObjone); //对象直接作为参数。

BOOL testfunc(CExample obj)

{

   //针对obj的操作实际上是针对复制后的临时拷贝进行的

}

还有一种情况，也是与临时对象有关:当函数中的局部对象作为返回值被返回给函数调者时，也将建立此局部对象的一个临时拷贝，拷贝构造函数也将被调用。

CTest func()

{

   CTest theTest;

   return theTest;

}

总结:当某对象是按值传递时(无论是作为函数参数，还是作为函数返回值)，编译器都会先建立一个此对象的临时拷贝，而在建立该临时拷贝时就会调用类的拷贝构造函数。

 5.赋值重载

重载的必要性

下面的代码与上例相似

这里也用到了"="号，但与"复制初始化"中的例子并不同。"复制初始化"的例子中，"="在对象声明语句中，表示初始化。更多时候，这种初始化也可用圆括号表示。例如:CExample theObjthree(theObjone);。

而本例子中，"="表示赋值操作。将对象theObjone的内容复制到对象theObjthree，这其中涉及到对象theObjthree原有内容的丢弃，新内容的复制。

但"="的缺省操作只是将成员变量的值相应复制。由于对象内包含指针，将造成不良后果:指针的值被丢弃了，但指针指向的内容并未释放。指针的值被复制了，但指针所指内容并未被复制。

因此，包含动态分配成员的类除提供拷贝构造函数外，还应该考虑重载"="赋值操作符号。

重载的注意事宜

拷贝构造函数和赋值函数的功能是相同的，为了不造成重复代码，拷贝构造函数实现如下:

CExample::CExample(const CExample& RightSides)

{

                * this=RightSides; //调用重载后的"="

}

 6.格式示例

拷贝构造函数的格式

拷贝构造函数的声明:

class 类名

{

public:

类名(形参参数)//构造函数的声明/原型

类名(类名&对象名)//拷贝构造函数的声明/原型

...

};

拷贝构造函数的实现:

类名::类名(类名&对象名)//拷贝构造函数的实现/定义

{函数体}

三.析构函数

1.介绍：

析构函数(destructor) 与构造函数相反，当对象脱离其作用域时（例如对象所在的函数已调用完毕），系统自动执行析构函数。

析构函数往往用来做“清理善后”工作（例如在建立对象时用new开辟了一片内存空间，应在退出前在析构函数中用delete释放）。析构函数名也应与类名相同，只是在函数名前面加一个位取反符~，以区别于构造函数。它不能带任何参数，也没有返回值（包括void类型）。只能有一个析构函数，不能重载。如果用户没有编写析构函数，编译系统会自动生成一个缺省的析构函数（即使自定义了析构函数，编译器也总是会为我们合成一个析构函数，并且如果自定义了析构函数，编译器在执行时会先调用自定义的析构函数再调用合成的析构函数），它也不进行任何操作。所以许多简单的类中没有用显式的析构函数。

2.函数格式

C++当中的析构函数格式如下

class <类名>

public:

~<类名>();

<类名>::~<类名>()

//函数体

如以下定义是合法的：

class T

public:

~T()

T::~T()

//函数体

当程序中没有析构函数时，系统会自动生成以下析构函数：

<类名>::~<类名>(){}，即不执行任何操作。

下面通过一个例子来说明一下析构函数的作用：

#include<iostream>

using namespace std;

class T

public

~T(){cout<<"析构函数被调用。";} //为了简洁，函数体可以直接写在定义的后面。

int main()

T *t=new T;//建立一个T类的指针对象t

delete t

cin.get

最后输出

析构函数被调用。

cin.get() 表示从键盘读入一个字符，为了让我们能够看得清楚结果。当然，析构函数也可以显式的调用，如 （*t）.~T也是合法的。

语法实例

包含构造函数和析构函数的C++程序。

#include<cstring>

#include<iostream>

using namespace std;

class stud //声明一个类

private // 私有部分

int num

char name[10]

char sex 

public: //公用部分

stud(int n,char nam[],char s ) //构造函数

num = n

strcpy (name, nam)

sex = s

~stud( ) //析构函数

cout << "stud has been destructe!" << endl;//通过输出提示告诉我们析构函数确实被调用了

void display( ) //成员函数，输出对象的数据

cout<<"num: "<<num<<endl;

cout<<"name: "<<name<<endl;

cout<<"sex: "<<sex<<endl;

void main( )

stud stud1(10010, Wang-li, ), stud2(10011, Zhang-fun, m) //建立两个对象

stud1.display( ) //输出学生1的数据

stud2.display( ) //输出学生2的数据

//主函数结束的同时，对象stud1，stud2均应被“清理”，而清理就是通过调用了析构函数实现的。输出结果

num10010

name Wang-li

sex f

num 10011

name Zhang-fun

sex m

stud has been destructe!

stud has been destructe!

现在把类的声明放在main函数之前，它的作用域是全局的。这样做可以使main函数更简练一些。在main函数中定义了两个对象并且给出了初值，然后输出两个学生的数据。当主函数结束时调用析构函数，输出stud has been destructe!。值得注意的是，真正实用的析构函数一般是不含有输出信息的。

在本程序中，成员函数是在类中定义的，如果成员函数的数目很多以及函数的长度很长，类的声明就会占很大的篇幅，不利于阅读程序。而且为了隐藏实现，一般是有必要将类的声明和实现（具体方法代码）分开编写的，这也是一个良好的编程习惯。即可以在类的外面定义成员函数，而在类中只用函数的原型作声明。

四.赋值运算符

赋值运算符的介绍

运算符重载的方法是定义一个重载运算符的函数，在需要执行被重载的运算符时，系统就自动调用该函数，以实现相应的运算。也就是说，运算符重载是通过定义函数实现的，运算符重载也是函数的重载

重载运算符的函数一般格式如下：

函数类型 operator 运算符名称（形参表列）

{对运算符的重载处理}

例如，想将“+”用于Complex（复数）的加法运算，函数的原型可以是这样的：

Complex operator + (Complex & c1,Complex &c2);

其中，operator是关键字，时候专门用于定义重载运算符的函数的，运算符名称就是C++提供给用户的预定运算符。

注意：函数名是由operator和运算符组成。

在定义了重载运算符后，即函数operator+重载了运算符+。

在执行复数相加的表达式c1+c2时（假设c1+c2都已被定义为Complex）,系统就会调用operator+函数，把c1+c2作为实参，与形参进行虚实结合。

为了说明把运算符重载后，执行表达式就是调用函数的过程，可以把两个整数相加也想象称为调用下面的函数：

代码如下:
int operator + (int a,int b)
{
          return (a+b);
}

#include<iostream>
using namespace std;
class Complex
{
 public:
  Complex()
  {
   real=0;
   imag=0;
  }
  Complex(double r,double i)
  {
   real=r;
   imag=i;
  }
  Complex operator + (Complex &c2);//声明运算符的"+"函数
  void display();
 private:
  double real;
  double imag;
};
Complex Complex::operator+(Complex &c2)
{
 Complex c;
 c.real=real+c2.real;
 c.imag=imag+c2.imag;
 return c;
}
void Complex::display()
{
 cout<<"("<<real<<","<<imag<<"i)"<<endl;
}
int main()
{
 Complex c1(3,4),c2(5,-10),c3;
 c3=c1+c2;
 cout<<"c1=";
 c1.display();
 cout<<"c2=";
 c2.display();
 cout<<"c3=";
 c3.display();
  return 0;
}

分析：

在main函数中,“c3=c1+c2;”在将运算符+重载为类的成员函数后，C++编译系统将程序中的表达式c1+c2解释为：

c1.operator+(c2)；//其中c1+c2是Complex类的对象

即以c2为实参调用c1的运算符重载函数operator+(Complex & c2)，进行求值，得到两个复数之和。

上面的“operator+”是一个函数名，它是类Complex的成员函数。

在实际工作中，类的声明和类的使用往往是分离的。假如在声明Complex类时，对运算符+，-，*，/都进行了重载，那么使用这个类的用户在编程时可以完全不考虑函数是怎么实现的，放心大胆地直接使用+，-，*，/进行复数的运算即可，显然十分方便。

对上面的运算符重载函数operator +还可以改写的更简练一些：代码如下:
Complex Complex::operator+(Complex &c2)
{

    return Complex(c2.real+real,c2.imag+imag);
}
return语句中的Complex(c2.real+real,c2.imag+imag)是建立一个临时对象，它没有对象名，是一个无名对象。

在建立临时对象过程中，调用构造函数。return语句将此临时对象作为函数返回值。那么，我们将+运算符进行了重载以后，可否将一个常量和一个复数相加呢？代码如下:
c3=3+c2;        //错误，与形参类型不匹配
这是行不通的，因为我们定义operator +函数的时候，形参是两个Complex的对象，也就是说，实参和形参匹配才可以调用函数。应写成对象形式，代码如下:
c3=Complex(3,0)+c2;     //正确，类型均为对象
还需要说明的是：运算符被重载后，其原有的功能仍然保留，没有丧失或改变。例如，运算符+被重载以后，仍然可以用于int，float，double，char类型数据的运算，同时又增加了用于复数相加的功能。编译系统根据表达式的上下文，即根据运算符两侧（如果是单目运算符则为一侧）的数据类型决定的。如，对于3+5，则执行整数加法；对于3.4+5.45，则执行双精度数加法；对于两个复数类相加，则执行复数加法。