C++——类与对象2

类的6个默认成员函数

C++中，当类为空的时候（没有成员），编译器就什么都不做吗？

其实不是的，这时，编译器就会自动生成6个默认成员函数：

那么，什么是默认成员函数呢？
默认成员函数：用户没有显式实现，编译器会生成的成员函数称为默认成员函数

6个默认成员函数：

1.初始化和清理：构造函数，析构函数

2.拷贝复制：拷贝构造，赋值重载

3.取地址重载：普通对象和const取地址。

一：构造函数

1.构造函数主要是完成初始化的任务。

class Date
{
public:void Init(int year, int month, int day){_year = year;_month = month;_day = day;}
private:int _year;int _month;int _day;}
int main()
{Date d1;d1.Init(2021, 3, 9);Date d2;d2.Init(2024, 7, 6);return 0;
}

看上面，当我们定义了一个日期的类，我们可以定义一个初始化函数来实现对日期时间的设置，但是呢？这是不是有点麻烦，那么我们可不可以每次调用时之前，它就自动把日期设置初始化好？答案是有的，我们的构造函数就是为了这而生的。

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

特点：

ps:虽然它叫构造函数，但是它是不会开辟空间创建对象的，它的任务只是进行初始化。

1. 函数名与类名相同。

2. 无返回值。

class Date
{
public:Date(int year, int month, int day){_year = year;_month = month;_day = day;}
private:int _year;int _month;int _day;}int main()
{Date d1();     //第一种  “Date d1(void)”: 未调用原型函数(是否是有意用变量定义的?)Date d2(2022,2,2);   //第二种return 0;
}

说明：

如果使用第一种的话，是错误的，声明了d3函数，该函数无参，返回一个日期类型的对象。
它会出现上图的情况，这样调用寻找不到构造函数的，因为编译器会认为你再调用某个函数，所以会识别不到。

class Date
{
public:Date(){int _year=2022;int _month=2;int _day=2;
}private:int _year;int _month;int _day;}int main()
{Date d1;    return 0;
}

采用无参的时候，对象后面不用跟括号，否则就成了函数声明

当我们没有写构造函数时，它会出现什么呢？会发现是随机值

这里我们先来认识：

内置函数/基本类型：语言本身定义的类型eg：int,char,double/指针等等

自定义类型：用struct/class定义的类型

这里我们默认不写的话编译器就会自动生成，内置函数不做处理（虽然有些编译器会处理，但也只是个性化行为，不是所有的都是），自定义函数会自动去调用默认函数。

3. 对象实例化时编译器自动调用对应的构造函数。

4. 构造函数可以重载。

5. 如果类中没有显式定义构造函数，则C++编译器会自动生成一个无参的默认构造函数，一旦用户显式定义编译器将不再生成

class Date
{
public:/*// 如果用户显式定义了构造函数，编译器将不再生成Date(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;return 0;
}

解释：隐藏了构造函数后，那么Date d1还能正常运行吗？

将Date类中构造函数屏蔽后，代码可以通过编译，因为编译器生成了一个无参的默认构造函
数
将Date类中构造函数放开，代码编译失败，因为一旦显式定义任何构造函数，编译器将不再
生成
无参构造函数，放开后报错：error C2512: “Date”: 没有合适的默认构造函数可用

在vs2022中，

我们可以发现：内置类型函数都要缺省值，且初始化符合我们的要求

发现：全是自定义类型的构造，且这些类型都默认构造函数。

不实现构造函数的情况下，编译器会生成默认的构造函数。但是看起来默认构造函数又没什么用？d对象调用了编译器生成的默认构造函数，但是d对象_year/_month/_day，依旧是随机值。也就说在这里编译器生成的默认构造函数并没有什么用？？

C++把类型分成内置类型(基本类型)和自定义类型。内置类型就是语言提供的数据类型，如：int/char...，自定义类型就是我们使用class/struct/union等自己定义的类型，看看下面的程序，就会发现编译器生成默认的构造函数会对自定类型成员_t调用的它的默认成员函数

简单来说：这里我们默认不写的话编译器就会自动生成，内置函数不做处理（虽然有些编译器会处理，但也只是个性化行为，不是所有的都是），自定义函数会自动去调用默认函数。

7. 无参的构造函数和全缺省的构造函数都称为默认构造函数，并且默认构造函数只能有一个。注意：无参构造函数、全缺省构造函数、我们没写编译器默认生成的构造函数，都可以认为是默认构造函数。

class Date
{
public:Date()   //1个{_year = 1900;_month = 1;_day = 1;}Date(int year = 1900, int month = 1, int day = 1)  //2个{_year = year;_month = month;_day = day;}
private:int _year;int _month;int _day;
}

上面出现了2个构造函数，这是不可以的，只能出现一个。

二：析构函数：

1.什么是析构函数呢？

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

特性：

1. 析构函数名是在类名前加上字符 ~。

2. 无参数无返回值类型。

3. 一个类只能有一个析构函数。若未显式定义，系统会自动生成默认的析构函数。注意：析构函数不能重载

ps：自动生成默认的析构函数：这里跟构造函数一样：内置函数不做处理，自定义函数会自动去找默认析构函数。

4. 对象生命周期结束时，C++编译系统系统自动调用析构函数

这里以之前写的栈的销毁函数为例：

class Stack
{
public:Stack(int Decapacity=4){cout << "Stack()" << endl;_a = (int*)malloc(sizeof(int) * Decapacity);if (_a == nullptr){perror("malloc fail");return;}_top = _capacity = 0;}~Stack(){cout << "~Stack()" << endl;free(_a);_a = nullptr;_top = _capacity = 0;}/*void Destory(){free(_a);_a = nullptr;_top = _capacity = 0;}*/
private:int* _a;int _top;int _capacity;
};int main()
{Stack st;return 0;

上面我们可以检验出来，构造函数和析构函数都是会自动去找的，不用特意去调用。

什么时候需要些析构函数？什么时候又不需要呢？

1.一般情况下，又动态申请的都需要显示写析构函数来释放资源

2. 没有动态申请的，就不需要写。

3.需要释放资源的成员都是自定义函数，则不需要写。

上面，为什么在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. 拷贝构造函数的参数只有一个且必须是类类型对象的引用，使用传值方式编译器直接报错，因为会引发无穷递归调用。

Date (const Date& d)
{_year=d._year;_month=d._month;_day=d._day;
}

若没有以引用，则会出现无限递归的情况。

3.ps:C++中，拷贝构造：内置类型直接拷贝，自定义类型必须要调用拷贝构造。

4.. 若未显式定义，编译器会生成默认的拷贝构造函数。默认的拷贝构造函数对象按内存存储按

字节序完成拷贝（如：内置类型），这种拷贝叫做浅拷贝，或者值拷贝

编译器生成的默认拷贝构造函数已经可以完成字节序的值拷贝了，还需要自己显式实现吗？当然像日期类这样的类是没必要的。但是像其他的是需要的：（如栈的拷贝构造）

1.Date和MyQueue不需要我们写

3.Stack需要我们写

class Stack
{
public:Stack(int Decapacity = 4){_a = (int*)malloc(sizeof(int) * Decapacity);if (_a == nullptr){perror("malloc fail");return;}_size = 0;_capacity = Decapacity;}int Push(int x){return _a[_size] = x;_size++;}~Stack(){free(_a);_a = nullptr;_size = _capacity = 0;}
private:int* _a;int _size;int _capacity;
};int main()
{Stack st;st.Push(1);st.Push(2);st.Push(3);st.Push(4);Stack st1(st);return 0;
}

这里为什么会崩溃呢？

答：因为这里st调用构造函数创建了4个空间之后，存了1，2，3，4数字。

当用st去拷贝构造st1时，Stack没有显示拷贝构造函数，所以他会自动去找默认拷贝构造函数，因为它们是内置类型，直接去拷贝的，即将st的值原封不动的拷贝到st1里，这是st和st1就会指向同一个空间，到了结束的时候，调用到了析构函数，首先要销毁的是st1，已经将st1的空间释放了，但是st并不知道已经释放了，所以它也会再次释放掉，就会重复释放问题，即一个空间多次释放，所以会崩溃。

所以，我们要想成功运行，必须存的时候不是在同一块空间。即：创建一个临时是数组空间。
Stack(Stack& s)
{_a = (int*)malloc(sizeof(int) * s._capacity);if (_a == nullptr){perror("malloc fail");return;}memcpy(_a, s._a, sizeof(int) * s._capacity);_size = s._size;_capacity = s._capacity;
}

好了，本次的分享到此结束了。