构造函数与析构函数

一、构造函数     创建对象时：系统自动调构造函数

与类名一样。

class Date
{ 
   Date(int,int,int);  //后边略

};
Date：：Date(int y,int m,int t)  //带参数的构造函数
{  
  year=y; month=n; day=t;
} 

有带参和不带参的，默认构造函数的。

二、拷贝构造函数:

用已经存在的类的对象去构建一个新的对象，两个对象的数据成员值是完全相同的

（1）声明格式：Point（Point &) 或 Point（const Point &)

使用系统提供的拷贝构造函数（因为类中没有定义拷贝构造函数）：

#include <iostream>
#include<string>
#include<iomanip>
//使用系统提供的拷贝构造函数（因为类中没有定义拷贝构造函数）
using namespace std;
class Point
{
public:
    Point(int xx=0,int yy=0)
    {
        X=xx;
        Y=yy;
    }
    int GetX(){return X;}
    int GetY(){return Y;}
private :
    int X,Y;
};
int main()
{
    Point A(1,2);//创建一个A对象；
    Point B(A); //系统提供的拷贝函数被调用
    cout<<A.GetX()<<","<<A.GetY()<<endl;
    cout<<B.GetX()<<","<<B.GetY()<<endl;
    return 0;
}
 结果： 1，2
        1，2

构造函数被调用的情况：

#include <iostream>
//构造函数被调用的情况
using namespace std;
class Point
{
public:
    Point (int xx=0,int yy=0){X=xx;Y=yy;}
    Point (Point &p);  //拷贝构造
    int GetX(){return X;}
    int GetY(){return Y;}
    void SetX(int x){X=x;}
    void SetY(int y){Y=y;}

private:
    int X,Y;
};
Point::Point(Point &p)
{
    X=p.X; Y=p.Y;
}
Point Fun(Point p)  //返回类型为Point的函数
{
    Point p1;
    p1.SetX(p.GetX()+3);
    p1.SetY(p.GetY()+3);
    return p1;
}
int main()
{
    Point A(1,2);
    Point B(A);   //A等于p   所以 X=A.X
    Point C;
    C=Fun(A);
    cout<<B.GetX()<<","<<B.GetY()<<endl;
    cout<<C.GetX()<<","<<C.GetY()<<endl;
    return 0;
}

拷贝构造函数的3种情况：

1）用已经存在的对象初始化另一个对象；（Point B（A））

2）对象作为实参传递给形参；（Fun（A））

3）对象作为函数返回值；(上边：return p1)

三、析构函数  

用来完成对象被删除前的清楚工作；它的调用完成之后，对象消失，其内存空间释放。

要求：

1）“~”

2）析构函数没有参数，也没有返回值，不能用return返回一个值

3）一个类中只能有一个析构函数，且为public，不可重载

4）析构函数只能由系统调用，不能再程序中显示调用析构函数（就是自己就出来了，别管他了）

5）可以根据需要自定义析构函数

特点：以例子展现   构造函数与析构函数

#include <iostream>
//主要体现构造函数与析构函数顺序的体现
using namespace std;
class Time
{
private:
    int hour,minute,second;
public:
    Time(int h,int m,int s);
    ~Time();  //析构函数声明
};
Time::Time(int h,int m,int s)
{
    hour=h;minute=m;second=s;
    cout<<"这是时间："<<hour<<":"<<minute<<":"<<second<<endl;
}
Time::~Time()
{
    cout<<"我要释放了 看时间："<<hour<<":"<<minute<<":"<<second<<endl;
}
class Date
{
    private: int year,month,day;
    public:Date(int y,int m,int d);
    ~Date();
}yesterday(2022,4,2);   //!!!这是个全局变量，请注意！！！
Date::Date(int y,int m,int d)
{
    year=y;month=m;day=d;
    Time time(15,15,15);  //!!!在类Date定义构造函数中定义类Time的对象（局部）
    static Time time1(12,12,12); //!!!在。。。。定义静态对象（局部）
    cout<<"现在日期："<<year<<"-"<<month<<"-"<<day<<endl;
}
Date::~Date()
{
    cout<<"要释放了 日期："<<year<<"-"<<month<<"-"<<day<<endl;
}
int main()
{
    cout<<"是从这开始吗？你猜猜"<<endl;
    Date today(2023,13,25);
    cout<<"请问结束吗"<<endl;
    return 0;
}

结果：

这是时间：15:15:15
这是时间：12:12:12
现在日期：2022-4-2
我要释放了 看时间：15:15:15
是从这开始吗？你猜猜
这是时间：15:15:15
现在日期：2023-13-25
我要释放了 看时间：15:15:15
请问结束吗
要释放了 日期：2023-13-25
要释放了 日期：2022-4-2
我要释放了 看时间：12:12:12

！ 先构造后析构  后构造先析构 ！

1）全局对象：先调用构造函数，在所有函数之前（包括main)；当main函数执行完毕或调用exit函数时终止；调用析构函数。

2）静态局部对象：就出现一回；当main函数执行完毕或调用exit函数时终止；调用析构函数。

3）局部对象：出现就调用构造函数，函数完就调用析构函数。（比较折腾）