构造函数与析构函数

一..对象的初始化：

     (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.22
Constructor called.23
Constructor called.24
Default constructor called.
Default constructor called.
Constructor called.25
Destructor called.25
Constructor called.26
Destructor called.26
Month=7,Day=22,Year=1998
Month=7,Day=23,Year=1998
Month=7,Day=24,Year=1998
Month=7,Day=25,Year=1998
Month=7,Day=26,Year=1998
Destructor called.26
Destructor called.25
Destructor called.24
Destructor called.23
Destructor 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;
}

Constructing
Constructing
A=5
B=15
Destructing
A=10
B=15
Destructing
Destructing
Destructing

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

#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;
}

Constructing
Constructing
A=5
B=15
A=10
B=15
Destructing
Destructing

#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.0
constructor called.5
destructor called.5
5
destructor called.5