构造函数与析构函数

来源：互联网发布：mac信仰灯会影响屏幕吗编辑：程序博客网时间：2024/06/16 01:12

一..对象的初始化：

(1). 定义对象时对数据成员直接赋值

Complex c1={1.1,2.2};

(2). 调用普通的成员函数来完成

Complex A; //A为类中的普通成员函数

A.init(1.1,2.2);

(3). 调用构造函数来完成

二.构造函数：

1.构造函数的名字必须与类名相同

2.构造函数没有返回值

3.构造函数的函数体可写在类体内,也可写在类体外

4.构造函数在定义对象的同时被自动调用的

5.如果没有在类中定义构造函数，则编译系统自动地生成一个默认的构造函数

6.构造函数可以是不带参数的

三.构造函数的作用：

1.为对象分配空间

2. 为对象的数据成员进行初始化

3.其他指定的任务

四.构造函数给数据成员赋值：

1.类名对象名[(实参表)];

Complex A(1.1,2.2);

类名对象名实参表

2.类名 *指针变量名=new 类名[(实参表)];

Complex *pa = new Complex(1.1,2.2);

对象名: 匿名对象,或称对象名是(*pa)

五.析构函数的特点：

1.析构函数名与类名相同,但它前面必须加一个波浪号(~)

2.析构函数不返回任何值

3.析构函数没有参数,因此它不能被重载。一个类可以有多个构造函数,但是只能有一个析构函数

4.撤销对象时,编译系统会自动地调用析构函数

六.析构函数的作用：

1. 释放分配给对象的内存空间

2. 其他指定的任务

七.析构函数何时被调用：

1.（每个类必须有一个析构函数。若没有显式地为一个类定义析构函数，编译系统会自动地生成一个缺省的析构函数）

当撤消对象时，这个缺省的析构函数将释放分配给对象的内存空间

2.① 主程序main()运行结束。

② 如果一个对象被定义在一个函数体内,则当这个函数结束时,该对象的析构函数被自动调用。

③ 若一个对象是使用new运算符动态创建的,在使用delete运算符释放它时,delete会自动调用析构函数

八.用类给对象数组初始化的时候会调用析构函数,而普通对象只在使用结束时调用析构函数

部分数组元素初始化与赋值

DATE dates[5]={DATE(7,22,1998),DATE(7,23,1998),DATE(7,24,1998)};缺少的数组元素用默认构造函数进行初始化

dates[0]=DATE(7,22,1998);

dates[1]=DATE(7,23,1998);

dates[2]=DATE(7,24,1998);

数组元素通过匿名对象赋值，即：DATE d1(7,22,1998); dates[0]=d1;释放d1;

#include <iostream>using namespace std;class Date {public:    Date() {        month=day=year=0;        cout<<"Default constructor called."<<endl;    }    Date(int m,int d,int y) {        month=m;   day=d;   year=y;        cout<<"Constructor called."<<day<<endl;    }~ Date (){        cout<<"Destructor called."<<day<<endl;    }    void Print(){        cout<<"Month="<<month<<",Day="<<day               <<",Year="<<year<<endl;    }private:    int month, day ,year;};int main(){Date dates[5]={Date(7,22,1998),Date(7,23,1998),                             Date(7,24,1998)};    dates[3]= Date(7,25,1998);    dates[4]= Date(7,26,1998);    for(int i=0;i<5;i++)  dates[i].Print();    return 0;}

Constructor called.22Constructor called.23Constructor called.24Default constructor called.Default constructor called.Constructor called.25Destructor called.25Constructor called.26Destructor called.26Month=7,Day=22,Year=1998Month=7,Day=23,Year=1998Month=7,Day=24,Year=1998Month=7,Day=25,Year=1998Month=7,Day=26,Year=1998Destructor called.26Destructor called.25Destructor called.24Destructor called.23Destructor called.22

会调用4次析构函数

#include <iostream>using namespace std;class M{   int A;   static int B;   public:       M(int a)       {           A=a;           B=B+a;           cout<<"Constructing"<<endl;       }       static void f1(M m);       ~M()       {           cout<<"Destructing\n";       }};void M::f1(M m){    cout<<"A="<<m.A<<endl;    cout<<"B="<<B<<endl;}int M::B=0;int main(){    M p(5),Q(10);    M::f1(p);    M::f1(Q);    return 0;}

ConstructingConstructingA=5B=15DestructingA=10B=15DestructingDestructingDestructing

会调用两次析构函数（即主函数结束）

#include <iostream>using namespace std;class M{   int A;   static int B;   public:       M(int a)       {           A=a;           B=B+a;           cout<<"Constructing"<<endl;       }       static void f1(M &m);       ~M()       {           cout<<"Destructing\n";       }};void M::f1(M &m){    cout<<"A="<<m.A<<endl;    cout<<"B="<<B<<endl;}int M::B=0;int main(){    M p(5),Q(10);    M::f1(p);    M::f1(Q);    return 0;}

ConstructingConstructingA=5B=15A=10B=15DestructingDestructing

#include<iostream>using namespace std;class A{public:    A(int i=0)    {        m=i;        cout<<"constructor called."<<m<<endl;    }    void Set(int i)    {        m=i;    }    void Print() const{cout<<m<<endl;}    ~A() {cout<<"destructor called."<<m<<endl;}private:    int m;};int main(){    const int N=5;    A my;    my=N;    my.Print();    return 0;}

constructor called.0constructor called.5destructor called.55destructor called.5

0 0