构造函数、拷贝构造函数和析构函数的的调用时刻及调用顺序

      对象是由“底层向上”开始构造的，当建立一个对象时，首先调用基类的构造函数，然后调用下一个派生类的构造函数，依次类推，直至到达派生类次数最多的派生次数最多的类的构造函数为止。因为，构造函数一开始构造时，总是要调用它的基类的构造函数，然后才开始执行其构造函数体，调用直接基类构造函数时，如果无专门说明，就调用直接基类的默认构造函数。在对象析构时，其顺序正好相反。   下面简单介绍下这三个函数。

构造函数
      1.构造函数不能有返回值
      2.缺省构造函数时，系统将自动调用该缺省构造函数初始化对象，缺省构造函数会将所有数据成员都
初始化为零或空  
      3.创建一个对象时，系统自动调用构造函数

析构函数
析构函数没有参数，也没有返回值。不能重载，也就是说，一个类中只可能定义一个析构函数
如果一个类中没有定义析构函数，系统也会自动生成一个默认的析构函数，为空函数，什么都不做
  调用条件：1.在函数体内定义的对象，当函数执行结束时，该对象所在类的析构函数会被自动调用；
                 2.用new运算符动态构建的对象，在使用delete运算符释放它时。

拷贝构造函数
拷贝构造函数实际上也是构造函数，具有一般构造函数的所有特性，其名字也与所属类名相同。拷贝构造函数中只有一个参数，这个参数是对某个同类对象的引用。
！！！在三种情况下被调用：
     1.用类的一个已知的对象去初始化该类的另一个对象时；
     2.函数的形参是类的对象，调用函数进行形参和实参的结合时；
     3.函数的返回值是类的对象，函数执行完返回调用者。

实例：

#include <iostream.h>

class point

{

  private:

     int x,y;

  public:

     point(int xx=0,int yy=0)

 {

      x=xx;

      y=yy;

      cout<<"构造函数被调用"<<endl;

    }

      point(point &p);

      ~point(){cout<<"析构函数被调用"<<endl;}

 

       int get_x(){return x;}

       int get_y(){return y;}

};

point::point(point &p)

{

    x=p.x;

    y=p.y;

    cout<<"拷贝构造函数被调用"<<endl;

}

  void f(point p)

 {

   cout<<p.get_x()<<p.get_y<<endl;

 }

    point g()

 {

    point a(7,33);

    return a;

  }

void main()

{

point a(15,22);

point b(a);

cout<<b.get_x()<<""<<b.get_y()<<endl;

f(b);

b=g();

cout<<b.get_x<<""<<b.get_y()<<endl;

}

 

程序运行结果：

构造函数被调用  //point a(15,22);

拷贝构造函数被调用//point b(a);拷贝构造函数的第一种调用情况

15  22

拷贝构造函数被调用//f(b);拷贝构造函数的第二种调用情况

15  22

析构函数被调用//f(b);析构函数的第一种调用情况

构造函数被调用//b=g();的函数体内point a(7,33);创建对象a

拷贝构造函数被调用//b=g();拷贝构造函数的第三种调用情况，拷贝a的值赋给b。

析构函数被调用//拷贝构造函数对应的析构函数

析构函数被调用//b=g();的函数体内对象a析构

7  33

析构函数被调用//主函数体b对象的析构

析构函数被调用//主函数体a对象的析构

 

由此看出：析构函数的顺序与构造函数的顺序刚好相反

 

 

附录A：

定义一个基类、两个派生类，分别定义其对象，观察其构造、析构函数的调用顺序
 
代码如下：
/**//************************************************************************
* 基类、派生类的构造、析构函数的调用顺序
************************************************************************/
#include <iostream.h>

//基类
class CPerson
...{
    char *name;        //姓名
    int age;            //年龄
    char *add;        //地址
public:
    CPerson()...{cout<<"constructor - CPerson! ";}
    ~CPerson()...{cout<<"deconstructor - CPerson! ";}
};

//派生类(学生类)
class CStudent : public CPerson
...{
    char *depart;    //学生所在的系
    int grade;        //年级
public:
    CStudent()...{cout<<"constructor - CStudent! ";}
    ~CStudent()...{cout<<"deconstructor - CStudent! ";}
};

//派生类(教师类)
class CTeacher : public CPerson
...{
    char *major;    //教师专业
    float salary;    //教师的工资
public:
    CTeacher()...{cout<<"constructor - CTeacher! ";}
    ~CTeacher()...{cout<<"deconstructor - CTeacher! ";}
};

//实验主程序
void main()
...{
    CPerson person;
    CStudent student;
    CTeacher teacher;
}
  
  
运行结果：

  

 

附录C# 相关

c# 构造函数--构造函数名与类同名 1、缺省构造函数时： class TestClass { 　 public TestClass(): base() {} // 由CLR提供 } 2、实例构造函数 实例构造函数是实现对类中实例进行初始化的方法成员 3、静态构造函数 静态构造函数是实现对一个类进行初始化的方法成员。它一般用于对静态数据的初始化。静态构造函 数不能有参数，不能有修饰符而且不能被调用，当类被加载时，类的静态构造函数自动被调用。 声明了一个有静态构造函数的类Employee。注意静态构造函数只能对静态数据成员进行初始化，而不 能对非静态数据成员进行初始化。但是，非静态构造函数既可以对静态数据成员赋值，也可以对非静态数 据成员进行初始化。 4、如果类仅包含静态成员，你可以创建一个private的构造函数：private TestClass() {…}，但是 private意味着从类的外面不可能访问该构造函数。所以，它不能被调用，且没有对象可以被该类定义实 例化 ——————————————————————————————————————————— 在类的层次结构中（即继承结构中）基类和派生类的构造函数的使用方式。派生类对象的初始化由基 类和派生类共同完成：****基类的成员由基类的构造函数初始化，派生类的成员由派生类的构造函数初始 化。 当创建派生类的对象时，系统将会调用基类的构造函数和派生类的构造函数，****构造函数的执行次 序是：先执行基类的构造函数，再执行派生类的构造函数。****如果派生类又有对象成员，则，先执行基 类的构造函数，再执行成员对象类的构造函数，最后执行派生类的构造函数。 　　****至于执行基类的什么构造函数，缺省情况下是执行基类的无参构造函数，如果要执行基类的有参 构造函数，则必须在派生类构造函数的成员初始化表中指出。 class A { private int x; 　public A( ) { x = 0; } 　public A( int i ) { x = i; } }; class B : A { private int y; 　public B( ) { y = 0; } 　public B( int i ) { y = i; } 　public B( int i, int j ):A(i) { y = j; } }; B b1 = new B(); //执行基类A的构造函数A()，再执行派生类的构造函数B() B b2 = new B(1); //执行基类A的构造函数A()，再执行派生类的构造函数B(int) B b3 = new B(0,1); //执行执行基类A的构造函数A(int) ，再执行派生类的 　　构造函数B(int,int) 　　在这里构造函数的执行次序是一定要分析清楚的。另外，如果基类A中没有提供无参构造函数public A( ) { x = 0; }，则在派生类的所有构造函数成员初始化表中必须指出基类A的有参构造函数A(i)，如下 所示： class A { private int x; 　public A( int i ) { x = i; } }; class B : A { private int y; 　public B():A(i) { y = 0; } 　public B(int i):A(i) { y = i; } 　public B(int i, int j):A(i) { y = j; } }; ———————————————————————————————————————————— 析构函数和垃圾回收器在C#中的运用 　　析构函数是实现销毁一个类的实例的方法成员。析构函数不能有参数，不能任何修饰符而且不能被调 用。由于析构函数的目的与构造函数的相反，就加前缀‘~’以示区别。 　　虽然C#（更确切的说是CLR）提供了一种新的内存管理机制---自动内存管理机制（Automatic memory management），资源的释放是可以通过“垃圾回收器” 自动完成的，一般不需要用户干预，但在有些特 殊情况下还是需要用到析构函数的，如在C#中非托管资源的释放。 　　资源的释放一般是通过"垃圾回收器"自动完成的,但具体来说,仍有些需要注意的地方： 　　1. 值类型和引用类型的引用其实是不需要什么"垃圾回收器"来释放内存的,因为当它们出了作用域后 会自动释放所占内存，因为它们都保存在栈(Stack)中; 　　2. 只有引用类型的引用所指向的对象实例才保存在堆(Heap)中,而堆因为是一个自由存储空间,所以 它并没有像"栈"那样有生存期("栈"的元素弹出后就代表生存期结束,也就代表释放了内存),并且要注意的 是,"垃圾回收器"只对这块区域起作用; 　　然而,有些情况下，当需要释放非托管资源时,就必须通过写代码的方式来解决。通常是使用析构函数 释放非托管资源，将用户自己编写的释放非托管资源的代码段放在析构函数中即可。需要注意的是,如果 一个类中没有使用到非托管资源,那么一定不要定义析构函数,这是因为对象执行了析构函数,那么"垃圾回 收器"在释放托管资源之前要先调用析构函数，然后第二次才真正释放托管资源，这样一来，两次删除动 作的花销比一次大多的。下面使用一段代码来示析构函数是如何使用的： public class ResourceHolder { … ~ResourceHolder() { 　// 这里是清理非托管资源的用户代码段 } } 小结 　　构造函数与析构函数虽然是一个类中形式上较简单的函数，但它们的使用决非看上去那么简单，因此 灵活而正确的使用构造函数与析构函数能够帮你更好的理解CLR的内存管理机制，以及更好的管理系统中 的资源。