类和对象（中）

目录

构造函数

析构函数

拷贝构造函数：

---

构造函数

class Date
{
public:
void Init(int year, int month, int day)
{

  _year = year;
_month = month;
_day = day;
}
void Print()
{
cout << _year << "-" << _month << "-" << _day << endl;
}
private:
int _year;
int _month;
int _day;
};
int main()
{
Date d1;
d1.Init(2022, 7, 5);
d1.Print();
Date d2;
d2.Init(2022, 7, 6);
d2.Print();
return 0;
}

 对于Date类，可以通过 Init 公有方法给对象设置日期，但如果每次创建对象时都调用该方法设置
信息，未免有点麻烦，而且有时候会存在忘记创建Init函数的情况。那能否在对象创建时，就将信息设置进去呢？构造函数就具有这种功能

构造函数是一个特殊的成员函数，名字与类名相同,创建类类型对象时由编译器自动调用，以保证
每个数据成员都有 一个合适的初始值，并且在对象整个生命周期内只调用一次。

特性：
构造函数是特殊的成员函数，需要注意的是，构造函数虽然名称叫构造，但是构造函数的主要任
务并不是开空间创建对象，而是初始化对象。
其特征如下：
1. 函数名与类名相同。
2. 无返回值。
3. 对象实例化时编译器自动调用对应的构造函数。
4. 构造函数可以重载。 （一个类可以有多个构造函数）

以上的代码就可以修改为

#include<iostream>
using namespace std;
class Date
{
public:
     Date()
        {
        _year = 1;
        _month = 1;
        _day = 1;
    }
    Date(int year, int month, int day)
    {
        _year = year;
        _month = month;
        _day = day;
        }
    void Print()
    {
        cout << _year << "-" << _month << "-" << _day << endl;
    }
    int _year;
    int  _month;
    int _day;
};
int main()
{
    Date d1;
    Date d2(2003, 2, 3);
    d1.Print();
    d2.Print();
}

注意：调用无参构造函数时，不能再后面加括号，否则编译器无法区分是构造函数的调用还是普通函数的声明 。

根据函数重载，上面两种构造函数的写法可以简化为一种形式

 在没有写构造函数时，编译器会自动调用一个构造函数，但是对这种内置类型并不起作用。

打印出了一堆随机值。 

  

C++把类型分成内置类型(基本类型)和自定义类型。内置类型就是语言提供的数据类
型，如：int/char...，自定义类型就是我们使用class/struct/union等自己定义的类型，而编译器生成的默认构造函数，只对自定义类型起作用。 

在 C++11 中针对内置类型成员不初始化的缺陷，做出了改进，即：内置类型成员变量在
类中声明时可以给默认值。

无参的构造函数和全缺省的构造函数都称为默认构造函数，并且默认构造函数只能有一个。否则编译器不知道去调用哪一个，会产生歧义。
注意：无参构造函数、全缺省构造函数、我们没写编译器默认生成的构造函数，都可以认为
是默认构造函数 

析构函数

概念：与构造函数功能相反，析构函数不是完成对对象本身的销毁，局部对象销毁工作是由
编译器完成的。而对象在销毁时会自动调用析构函数，完成对象中资源的清理工作。 

 特性：
析构函数是特殊的成员函数，其特征如下：
1. 析构函数名是在类名前加上字符 ~。
2. 无参数无返回值类型。
3. 一个类只能有一个析构函数。若未显式定义，系统会自动生成默认的析构函数。注意：析构
函数不能重载
4. 对象生命周期结束时，C++编译系统系统自动调用析构函数。

系统默认的析构函数和编译器自动调用的构造函数有相似的性质，只对自定义类型起作用，对内置类型不起作用。

例如stack类就是一个自定义类型：

typedef int DataType;
class Stack
{
public:
Stack(size_t capacity = 3)
{
_array = (DataType*)malloc(sizeof(DataType) * capacity);
if (NULL == _array)
{
perror("malloc申请空间失败!!!");
return;
}
_capacity = capacity;
_size = 0;
}
void Push(DataType data)
{
// CheckCapacity();
_array[_size] = data;
_size++;
}
// 其他方法...
~Stack()
{
if (_array)
{
free(_array);
_array = NULL;
_capacity = 0;
_size = 0；
}
}
private:
DataType* _array;
int _capacity;
int _size;
};
void TestStack()
{
Stack s;
s.Push(1);
s.Push(2); 

}

Time类和Date类

class Time
{
public:
~Time()
{
cout << "~Time()" << endl;
}
private:
int _hour;
int _minute;
int _second;
};
class Date
{
private:
// 基本类型(内置类型)
int _year = 1970;
int _month = 1;
int _day = 1;
// 自定义类型
Time _t;
};
int main()
{
Date d;
return 0;
} 

 程序运行结束后输出：~Time()
 在main方法中根本没有直接创建Time类的对象，为什么最后会调用Time类的析构函数？
 因为：main方法中创建了Date对象d，而d中包含4个成员变量，其中_year, _month,
_day三个是内置类型成员，销毁时不需要资源清理，最后系统直接将其内存回收即可；而_t是Time类对象，所以在d销毁时，要将其内部包含的Time类的_t对象销毁，所以要调用Time类的析构函数。但是：main函数中不能直接调用Time类的析构函数，实际要释放的是Date类对象，所以编译器会调用Date类的析构函数，而Date没有显式提供，则编译器会给Date类生成一个默认的析构函数，目的是在其内部调用Time类的析构函数，即当Date对象销毁时，要保证其内部每个自定义对象都可以正确销毁main函数中并没有直接调用Time类析构函数，而是显式调用编译器为Date类生成的默认析构函数
 注意：创建哪个类的对象则调用该类的析构函数，销毁那个类的对象则调用该类的析构函数

析构函数的顺序：后定义的先析构。 

拷贝构造函数：

概念：拷贝构造函数：只有单个形参，该形参是对本类类型对象的引用(一般常用const修饰)，在用已存在的类类型对象创建新对象时由编译器自动调用。

简单的来说，就是创建一个和已存在对象一模一样的新对象。

特征：
拷贝构造函数也是特殊的成员函数，其特征如下：
1. 拷贝构造函数是构造函数的一个重载形式。
2. 拷贝构造函数的参数只有一个且必须是类类型对象的引用，使用传值方式编译器直接报错，
因为会引发无穷递归调用

void Func1(Date d)
{

}//先调用Date类的拷贝构造函数
void Func2(Date& d)
{

}//可以直接传参
对于内置类型，在传值传参时，可以直接拷贝，而自定义类型传值传参时，编译器无法直接拷贝，必须先调用拷贝构造函数。这时就会引起无穷递归，而传引用传参相当于起一个别名，可以直接拷贝。

class Date
{
public:
Date(int year = 1900, int month = 1, int day = 1)
{
_year = year;
_month = month;
_day = day;
}
// Date(const Date& d)  // 正确写法
  Date(const Date d)  // 错误写法：编译报错，会引发无穷递归

//引用权限只能缩小不能放大，所以要加const
{
_year = d._year;
_month = d._month;
_day = d._day;
}
private:
int _year;
int _month;
int _day;
};
int main()
{
Date d1;
Date d2(d1);//还可以写成Date d2=d1;
return 0;
} 

 

拷贝构造函数对于内置类型和自定义类型，如果自己不写，编译器会自动调用且都会起作用。

在编译器生成的默认拷贝构造函数中，内置类型是按照字节方式直接拷贝的，而自定
义类型是调用其拷贝构造函数完成拷贝的。

 编译器生成的默认拷贝构造函数已经可以完成字节序的值拷贝了，还需要自己显式实现吗？
当然像日期类这样的类是没必要的。但是有一种情况例外：

typedef int DataType;
class Stack
{
public:
Stack(size_t capacity = 10)
{
_array = (DataType*)malloc(capacity * sizeof(DataType));
if (nullptr == _array)
{
perror("malloc申请空间失败");
return;
}

_size = 0;
_capacity = capacity;
}
void Push(const DataType& data)
{
 CheckCapacity();
_array[_size] = data;
_size++;
}
~Stack()
{
if (_array)
{
free(_array);
_array = nullptr;
_capacity = 0;
_size = 0;
}
}
private:
DataType *_array;
size_t _size;
size_t _capacity;
};
int main()
{
Stack s1;
s1.Push(1);
s1.Push(2);
s1.Push(3);
s1.Push(4);
Stack s2(s1);
return 0;
}

 

 

Stack类发生异常，如下图所示

 

 这种情况下，必须手动生成一个构造函数，也就是完成深拷贝，

注意：类中如果没有涉及资源申请(需要析构函数清理空间)时，拷贝构造函数是否写都可以；一旦涉及到资源申请时，则拷贝构造函数是一定要写的，否则就是浅拷贝