构造函数
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对象的析构
由此看出：析构函数的顺序与构造函数的顺序刚好相反
附录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的内存管理机制，以及更好的管理系统中
的资源。
扫一扫
2027
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
