默认成员函数
默认成员函数就是用户没有显式实现，编译器会⾃动⽣成的成员函数称为默认成员函数。
C++有六个默认成员函数，不写的情况下编译器会默认⽣成以下6个默认成员函数，最重要的是前4个，最后两个了解⼀下即可。另外，C++11以后增加了两个默认成员函数， 移动构造和移动赋值，这里先不做介绍。
虽然编译器会自动生成成员函数，但不一定符合要求，是我们想要的，如果符合要求，那其生成的函数行为是什么？我们都需要了解。所以学习默认成员函数，我们有两大点要完成：
●不写时，了解编译器默认⽣成的函数⾏为。
●自己实现，要如何去写。
但一般情况都是我们自己实现，但有些情况下就不需要实现。
六个默认成员函数分别为：
构造函数
构造函数是特殊的成员函数，其功能是在对象实例化时自动调用初始化对象。其功能相当于栈中实现Init(初始化)一样，但构造函数就不需要再调用，在实例化时就会自动调用初始化好。
其函数与类名相同，且无返回值(其不需要再写void)，并且如果类中没有显式定义构造函数，则C++编译器会⾃动⽣成⼀个⽆参的默认构造函数，⼀旦用户显式定义编译器将不再⽣成。
cpp
#include<iostream>
class Date
{
public:
//无参构造函数
Date()
{
_year = _month = _day = 1;
}
//带参构造函数
Date(int year, int month, int day)
{
_year = year;
_month = day;
_day = day;
}
void Print()
{
std::cout << _year << '/' << _month << '/' << _day << std::endl;
}
private:
int _year;
int _month;
int _day;
};
int main()
{
//无参构造函数
Date d1;
d1.Print();
//有参构造函数
Date d2(2024, 5, 5);
d2.Print();
return 0;
}构造函数的可以是有参的也可以是无参的，既然可以是有参的，那就可以写为缺省的构造函数，更利于初始化。
cpp
#include<iostream>
class Date
{
public:
//全缺省构造函数
Date(int year = 1, int month = 1, int day = 1)
{
_year = year;
_month = month;
_day = day;
}
void Print()
{
std::cout << _year << '/' << _month << '/' << _day << std::endl;
}
private:
int _year;
int _month;
int _day;
};
int main()
{
//全缺省，就不用加括号
Date d1;
d1.Print();
//半缺省
Date d2(2024);
d2.Print();
Date d3(2024, 5, 5);
d3.Print();
return 0;
}要注意的是，⽆参构造函数、全缺省构造函数和编译器默认⽣成的构造函数，都叫做默认构造函 数。但是这三个函数有且只有⼀个存在，不能同时存在。⽆参构造函数和全缺省构造函数虽然构成 函数重载，但是调⽤时会存在歧义。
前面提到，一般都要自己写构造函数，因为编译器生成的构造函数一般不能满足需求。有时有些特殊情况下，就不需要写构造函数。如数据结构栈和队列中有道经典的题目，用两个栈实现队列、用两个队列实现栈这种情况下，其会自己生成默认构造函数去调用相对应的构造函数 (用栈实现队列会自己生成默认构造函数去调用队列的构造函数，用队列实现栈会自己生成默认构造函数去调用栈的构造函数)。
cpp
#include<iostream>
class Stack
{
public:
Stack(int n = 4)
{
_a = (int*)malloc(sizeof(int) * n);
_capacity = n;
_top = 0;
}
private:
int* _a;
int _capacity;
int _top;
};
// 两个Stack实现队列
class MyQueue
{
public:
//编译器默认生成MyQueue的构造函数调用了Stack的构造，完成了两个成员的初始化
//此处如果写了构造函数，也不会调用
private:
Stack pushst;
Stack popst;
};
int main()
{
MyQueue mq;
return 0;
}析构函数
析构函数与构造函数功能恰好相反，C++规定对象在销毁时会⾃动调⽤析构函数，完成对象中资源的清理释放⼯作。其功能相当于栈中实现Destroy(销毁)一样，但析构函数就不需要再调用，在销毁时就会自动调用。
析构函数名是在类名前加上字符~，其⽆参数⽆返回值(跟构造类似，也不需要加void)，若未显式定义，系统会⾃动⽣成默认的析构函数。
编译器⾃动⽣成的析构函数不对内置类型成员做处理，⾃定类型成员则会调⽤他的析构函数。也就是说⾃定义类型成员⽆论什么情况都会⾃动调⽤析构函数。如果类中没有申请资源时，析构函数可以不写，简单来说，析构函数就是用来清理释放申请的内存空间，并自动调用，防止未释放资源。
同样的，如果默认⽣成的析构函数就可以⽤，也就不需要显示写析构，如MyQueue。
cpp
#include<iostream>
class Stack
{
public:
Stack(int n = 4)
{
_a = (int*)malloc(sizeof(int) * n);
_capacity = n;
_top = 0;
}
~Stack()
{
free(_a);
_a = nullptr;
_capacity = _top = 0;
}
private:
int* _a;
int _capacity;
int _top;
};
// 两个Stack实现队列
class MyQueue
{
public:
//编译器默认生成MyQueue的构造函数调用了Stack的构造，完成了两个成员的初始化
//此处如果写了析构函数，也不会调用
private:
Stack pushst;
Stack popst;
};
int main()
{
Stack st;
MyQueue mq;
return 0;
}拷贝构造函数
如果⼀个构造函数的第⼀个参数是自身类类型的引⽤，且任何额外的参数都有默认值，则此构造函数也叫做拷⻉构造函数，也就是说拷⻉构造是⼀个特殊的构造函数。它在创建对象时，是使用同一类中之前创建的对象来初始化新创建的对象。
简单来看一下代码示例：
cpp
#include<iostream>
class Date
{
public:
//构造函数
Date(int year = 1, int month = 1, int day = 1)
{
_year = year;
_month = month;
_day = day;
}
//拷贝构造
Date(const Date& d)
{
_year = d._year;
_month = d._month;
_day = d._day;
}
void Print()
{
std::cout << _year << '/' << _month << '/' << _day << std::endl;
}
private:
int _year;
int _month;
int _day;
};
int main()
{
Date d1(2024, 5, 6);
d1.Print();
//调用拷贝构造
Date d2(d1);
d2.Print();
return 0;
}这里也可以写成这样的形式：
cpp
Date d2(d1);
//两者含义相同只是形式不同
Date d2 = d1;其要注意：
拷⻉构造函数的参数只有⼀个且必须是类类型对象的引⽤，使⽤传值⽅式编译器直接报错，因为语 法逻辑上会引发⽆穷递归调⽤。因为C++规定⾃定义类型对象进⾏拷⻉⾏为必须调⽤拷⻉构造，所以这⾥⾃定义类型传值传参和传值返回都会调⽤拷⻉构造完成。
如这段代码：
cpp
#include<iostream>
class Date
{
public:
//构造函数
Date(int year = 1, int month = 1, int day = 1)
{
_year = year;
_month = month;
_day = day;
}
//拷贝构造
Date(const Date& d)
{
_year = d._year;
_month = d._month;
_day = d._day;
}
void Print()
{
std::cout << _year << '/' << _month << '/' << _day << std::endl;
}
private:
int _year;
int _month;
int _day;
};
void Func1(Date d)
{
d.Print();
}
int main()
{
Date d1(2024, 5, 6);
d1.Print();
// C++规定自定义类型对象进行拷贝行为必须调用拷贝构造，所以这里的d1
// 传值传参给d要调用拷贝构造完成拷贝，传引用传参可以减少这里的拷贝。
Func1(d1);
return 0;
}函数func()在给d传值传参时就要调用拷贝构造，即先调用Date类的拷贝构造将d1的值拷贝给d，之后再调用func()函数进行打印。
所有拷贝构造的调用形式均是如此。所以拷贝构造函数一定不能使用传值的方式(并且使用传值的方式编译器会报错，不会通过编译)，要传引用的方式，否则会引发无穷递归。
若未显式定义拷贝构造，编译器会⽣成⾃动⽣成拷⻉构造函数。⾃动⽣成的拷⻉构造对内置类型成 员变量会完成值拷⻉/浅拷⻉(⼀个字节⼀个字节的拷⻉)，对⾃定义类型成员变量会调⽤他的拷⻉构 造(也就是说基本都要写拷贝构造函数)。
像Date这样的类成员变量全是内置类型且没有指向什么资源，编译器⾃动⽣成的拷⻉构造就可以完成需要的拷⻉，所以不需要我们显⽰实现拷⻉构造。
cpp
#include<iostream>
class Date
{
public:
//构造函数
Date(int year = 1, int month = 1, int day = 1)
{
_year = year;
_month = month;
_day = day;
}
void Print()
{
std::cout << _year << '/' << _month << '/' << _day << std::endl;
}
private:
int _year;
int _month;
int _day;
};
int main()
{
Date d1(2024, 5, 6);
d1.Print();
Date d2(d1);
d2.Print();
return 0;
}
但像Stack这样的类，虽然也都是内置类型，但是_a指向了资源，编译器⾃动⽣成的拷⻉构造完成的值拷⻉/浅拷⻉不符合我们的需求，所以需要 我们⾃⼰实现深拷⻉(对指向的资源也进⾏拷⻉)，如果这样的类不写拷贝构造函数会有问题出现。
如果不写拷贝构造：
cpp
#include<iostream>
class Stack
{
public:
Stack(int n = 4)
{
_a = (int*)malloc(sizeof(int) * n);
_capacity = n;
_top = 0;
}
~Stack()
{
std::cout << "析构" << std::endl;
free(_a);
_a = nullptr;
_top = _capacity = 0;
}
private:
int* _a;
int _capacity;
int _top;
};
int main()
{
Stack st1;
// Stack不实现拷贝构造，⽤自动⽣成的拷贝构造完成浅拷贝
Stack st2(st1);
return 0;
}
因为其示浅拷贝，所以两个_a指向的是同一块空间，造成在最后析构时释放的两次，导致程序崩溃。
所以我们要自己写拷贝构造，完成深拷贝。
cpp
#include<iostream>
class Stack
{
public:
Stack(int n = 4)
{
_a = (int*)malloc(sizeof(int) * n);
_capacity = n;
_top = 0;
}
Stack(const Stack& st)
{
_a = (int*)malloc(sizeof(int) * st._capacity);
memcpy(_a, st._a, sizeof(int) * st._top);
_top = st._top;
_capacity = st._capacity;
}
~Stack()
{
std::cout << "析构" << std::endl;
free(_a);
_a = nullptr;
_top = _capacity = 0;
}
private:
int* _a;
int _capacity;
int _top;
};
int main()
{
Stack st1;
Stack st2(st1);
return 0;
}像MyQueue这样的类我们依旧不需要实现，其内部主要是自定义类型Stack成员，编译器自动生成的拷贝构造会调用Stack的拷贝构造，不需要显示实现 MyQueue的拷贝构造。
cpp
#include<iostream>
class Stack
{
public:
Stack(int n = 4)
{
_a = (int*)malloc(sizeof(int) * n);
_capacity = n;
_top = 0;
}
Stack(const Stack& st)
{
_a = (int*)malloc(sizeof(int) * st._capacity);
memcpy(_a, st._a, sizeof(int) * st._top);
_top = st._top;
_capacity = st._capacity;
}
~Stack()
{
std::cout << "析构" << std::endl;
free(_a);
_a = nullptr;
_top = _capacity = 0;
}
private:
int* _a;
int _capacity;
int _top;
};
class MyQueue
{
public:
private:
Stack pushst;
Stack popst;
};
int main()
{
Stack st1;
MyQueue mq1;
MyQueue mq2(mq1);
return 0;
}赋值运算符重载函数
要了解这个，首先我们就要了解运算符重载。
运算符重载
在C++中，运算符重载是通过创建运算符函数来实现的，这些函数被指定为全局函数或者成员函数。当运算符被⽤于类类型的对象时，C++语⾔允许我们通过运算符重载的形式指定新的含义。
C++规 定类类型对象使⽤运算符时，必须转换成调⽤对应运算符重载，若没有对应的运算符重载，则会编译报错。
运算符重载是具有特殊名字的函数，他的名字是由operator和后⾯要定义的运算符共同构成。和其他 函数⼀样，它也具有其返回类型和参数列表以及函数体。其参数个数和该运算符作⽤的运算对象数量⼀样多。
cpp
#include<iostream>
class Date
{
public:
Date(int year = 1, int month = 1, int day = 1)
{
_year = year;
_month = month;
_day = day;
}
void Print()
{
std::cout << _year << '/' << _month << '/' << _day << std::endl;
}
//private:
int _year;
int _month;
int _day;
};
//由于在类外访问不到私有成员，所以先暂时改为公有
bool operator==(const Date& d1, const Date& d2)
{
return d1._year == d2._year && d1._month == d2._month && d1._day == d2._day;
}
int main()
{
Date d1(2024, 5, 5);
Date d2(2024, 6, 6);
operator==(d1, d2);
//该形式会自动转换为operator==(d1, d2)
d1 == d2;
return 0;
}写在类外有很多麻烦，所以将其写在类内。
但要注意，⼀元运算符有⼀个参数，⼆元 运算符有两个参数，如果⼀个重载运算符函数是成员函数，则它的第⼀个运算对象默认传给隐式的this指针，因此运算符重载作为成员函数时，参数比运算对象少⼀个。 则⼆元运算符的左侧运算对象传给第⼀个参数，右侧运算对象传给第⼆个参数。
cpp
#include<iostream>
class Date
{
public:
Date(int year = 1, int month = 1, int day = 1)
{
_year = year;
_month = month;
_day = day;
}
bool operator==(const Date& d)
{
return _year == d._year && _month == d._month && _day == d._day;
}
void Print()
{
std::cout << _year << '/' << _month << '/' << _day << std::endl;
}
private:
int _year;
int _month;
int _day;
};
int main()
{
Date d1(2024, 5, 5);
Date d2(2024, 6, 6);
d1.operator==(d2);
// 会转换成 d1.operator==(d2);
d1 == d2;
return 0;
}要注意，运算符重载以后，其优先级和结合性与对应的内置类型运算符保持⼀致、不能通过连接语法中没有的符号来创建新的操作符。
此外，c++中有5个不能重载的运算符：" ?: " 、" . " 、" :: " 、" sizeof " 、" .* " 。 " . " 和 " :: " 运算符如果重载，可能会出现混淆；" sizeof " 运算符不能重载是因为内部许多指针都依赖它；" .*" 运算符引用指向类成员的指针。
赋值运算符重载
赋值运算符重载是⼀个默认成员函数，⽤于完成两个已经存在的对象直接的拷⻉赋值，这⾥要注意跟拷⻉构造区分，拷⻉构造⽤于⼀个对象拷⻉初始化给另⼀个要创建的对象。
cpp
#include<iostream>
class Date
{
public:
Date(int year = 1, int month = 1, int day = 1)
{
_year = year;
_month = month;
_day = day;
}
//d1 = d2
void operator=(const Date& d)
{
_year = d._year;
_month = d._month;
_day = d._day;
}
void Print()
{
std::cout << _year << '/' << _month << '/' << _day << std::endl;
}
private:
int _year;
int _month;
int _day;
};
int main()
{
Date d1(2024, 5, 5);
Date d2(2024, 6, 6);
//赋值重载
d1.operator=(d2);
d1 = d2;
//拷贝构造
Date d3 = d1;
return 0;
}
一定要区分好拷贝构造和赋值重载。
赋值运算重载的参数建议写成const当前类类型引⽤，否则会传值传参会有拷⻉，写了可以提高效率。其有返回值，且建议写成当前类类型引⽤，引⽤返回可以提⾼效率，最重要的是有返回值⽬的是为了⽀持连续赋值场景。
上方代码不支持连续赋值。
所以修改为有返回值的
cpp
#include<iostream>
class Date
{
public:
Date(int year = 1, int month = 1, int day = 1)
{
_year = year;
_month = month;
_day = day;
}
//d1 = d2
Date& operator=(const Date& d)
{
_year = d._year;
_month = d._month;
_day = d._day;
return *this;
}
void Print()
{
std::cout << _year << '/' << _month << '/' << _day << std::endl;
}
private:
int _year;
int _month;
int _day;
};
int main()
{
Date d1(2024, 5, 5);
Date d2(2024, 6, 6);
//赋值重载
d1 = d2;
//拷贝构造
Date d3 = d1;
d1 = d2 = d3;
return 0;
}没有显式实现时，编译器会⾃动⽣成⼀个默认赋值运算符重载，默认赋值运算符重载⾏为跟默认构 造函数类似，对内置类型成员变量会完成值拷⻉/浅拷⻉(⼀个字节⼀个字节的拷⻉)，对⾃定义类型 成员变量会调⽤他的拷⻉构造。
cpp
#include<iostream>
class Date
{
public:
Date(int year = 1, int month = 1, int day = 1)
{
_year = year;
_month = month;
_day = day;
}
void Print()
{
std::cout << _year << '/' << _month << '/' << _day << std::endl;
}
private:
int _year;
int _month;
int _day;
};
int main()
{
Date d1(2024, 5, 5);
Date d2(2024, 6, 6);
d1.Print();
d2.Print();
//编译器自动生成的赋值重载
d1 = d2;
d1.Print();
d2.Print();
return 0;
}
和拷贝构造一样，像Date这样的类成员变量全是内置类型且没有指向什么资源，编译器⾃动⽣成的赋值运算符重载就可以完成需要的拷⻉，所以不需要我们显⽰实现赋值运算符重载。像Stack这样的类，虽然也都是内置类型，但是_a指向了资源，编译器⾃动⽣成的赋值运算符重载完成的值拷⻉/浅拷⻉不符合我 们的需求，所以需要我们⾃⼰实现深拷⻉(对指向的资源也进⾏拷⻉)。像MyQueue这样的类型内部主要是⾃定义类型Stack成员，编译器⾃动⽣成的赋值运算符重载会调⽤Stack的赋值运算符重载，也不需要我们显⽰实现MyQueue的赋值运算符重载。