对象是由“底层向上”开始构造的，当建立一个对象时，首先调用基类的构造函数，然后调用下一个派生类的构造函数，依次类推，直至到达派生类次数最多的派生次数最多的类的构造函数为止。因为，构造函数一开始构造时，总是要调用它的基类的构造函数，然后才开始执行其构造函数体，调用直接基类构造函数时，如果无专门说明，就调用直接基类的默认构造函数。在对象析构时，其顺序正好相反。 下面简单介绍下这三个函数。
构造函数
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的内存管理机制，以及更好的管理系统中
- 的资源。
1902
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
