1. 构造函数
1.1定义
构造函数是特殊的成员函数，需要注意的是，构造函数虽然名称叫构造，但是构造函数的主要任务并不是开空间创建对象(我们常使⽤的局部对象是栈帧创建时，空间就开好了)，而是对象实例化时初始化对象。构造函数的本质是要替代我们以前Stack和Date类中写的Init函数的功能，构造函数自动调用的特点就完美的替代的了Init。简而言之，类比我们之前写的init函数。
1.2构造函数的特点
1.
函数名与类名相同。
2.
无返回值。 (返回值啥都不需要给，也不需要写void，C++规定如此)
3.
对象实例化时系统会自动调用对应的构造函数。
4.
构造函数可以重载。
5.
如果类中没有显式定义构造函数，则C++编译器会自动生成一个无参的默认构造函数，一旦用户显式定义编译器将不再生成。
6.
无参构造函数、全缺省构造函数、我们不写构造时编译器默认生成的构造函数，都叫做默认构造函数。但是这三个函数有且只有一个存在，不能同时存在。无参构造函数和全缺省构造函数虽然构成函数重载，但是调用时会存在歧义。
注意：很多人会认为默认构造函数是编译器默认生成那个叫默认构造，实际上无参构造函数、全缺省构造函数也是默认构造，总结一下就是不传实参就可以调用的构造就叫默认构造。
7.
我们不写，编译器默认生成的构造，对内置类型成员变量的初始化没有要求，也就是说是是否初始化是不确定的，看编译器。对于自定义类型成员变量，要求调用这个成员变量的默认构造函数初始化。如果这个成员变量，没有默认构造函数，那么就会报错，我们要初始化这个成员变量，需要用初始化列表才能解决，初始化列表，我们下个章节再细细讲解。
注：1.内置类型：int / double / char...../指针
自定义类型：class/struct/union....
2.只有类里面全是自定义函数，且里面的自定义类型有默认构造函数，只有在这种情况下，才 不用写构造函数。（下文会解释）
1.3默认构造函数
在C++中，默认构造函数是一种特殊的构造函数，它没有参数。如果一个类没有显式地定义任何构造函数，编译器会为该类自动生成一个默认构造函数。默认构造函数用于创建对象时初始化对象的成员变量。
#include<iostream>
using namespace std;
class Date
{
public:
// 1.⽆参构造函数
//Date()
//{
// _year = 1;
// _month = 1;
// _day = 1;
//}
//2.带参构造函数
//Date(int year, int month, int day)
//{
// _year = year;
// _month = month;
// _day = day;
//}
//3.全缺省构造函数
Date(int year = 1, int month = 1, int day = 1)
{
_year = year;
_month = month;
_day = day;
}
void print()
{
cout << _year << "/" << _month << "/" << _day << endl;
}
private:
int _year;
int _month;
int _day;
};
//函数声明
//Date func();
//Date func(int, int, int);
int main()
{
// 如果留下三个构造中的第⼆个带参构造，第⼀个和第三个注释掉
// 编译报错：error C2512: “Date”: 没有合适的默认构造函数可⽤
Date d1; // 调⽤默认构造函数
Date d2(2024, 11, 14);
// 注意：如果通过⽆参构造函数创建对象时，对象后⾯不⽤跟括号，否则编译器⽆法区分这⾥是函数声明
还是实例化对象 (对比第37行和49行）
// warning C4930: “Date d3(void)”: 未调⽤原型函数(是否是有意⽤变量定义的?)
Date d3(2024, 11);
//Date d4(); //会误以为是声明，导致后面没法打印
d1.print();
d2.print();
d3.print();
//d4.print();
return 0;
}注：若我们写了一个带参构造的，会出现以下报错：
所以我们第二个构造函数要注释掉，不能这样写。
但是，还有一个问题，当我们把第二个注释掉后，保留1和3时，编译器还会报错：
1>C:\Users\21098\Desktop\c++\test1114\test1114\test.cpp(45,7): error C2668: “Date::Date”: 对重载函数的调用不明确
这是因为编译器此时不知道调用哪个，举个例子，如果想要调用一个无参构造，第一个函数能调用，第三个函数也能调用，所以就不知道调用哪个了，就会产生混淆，从而报错！
故此，个人觉得写一个全缺省的就好，多功能的，省事（个人感觉）
我们在看一下上述这个点：
2.只有类里面全是自定义函数，且里面的自定义类型有默认构造函数，只有在这种情况下，才不用写构造函数。
不妨来举个例子：
#include<iostream>
using namespace std;
typedef int stdatatype;
class stack
{
public:
stack(int n = 4)
{
_a = (stdatatype*)malloc(sizeof(stdatatype) * n);
if (nullptr == _a)
{
perror("malloc fail!");
return;
}
_capacity = n;
_top = 0;
}
private:
stdatatype* _a;
size_t _capacity;
size_t _top;
};
// 两个Stack实现队列
class myqueue
{
public:
//编译器默认⽣成MyQueue的构造函数调⽤了Stack的构造，完成了两个成员的初始化
private:
stack pushst;
stack popst;
};
int main()
{
myqueue mq;
return 0;
}
2.析构函数
2.1定义
C++规定对象在销毁时会自动调用析构函数，完成对象中资源的清理释放工作。析构函数的功能类比我们之前Stack实现的Destroy功能，而像Date没有Destroy，其实就是没有资源需要释放，也就是说
只有经过动态开辟的才需要写析构，如上述例子中，日期类是不需要写析构的，栈需要写！
2.2析构函数的特点：
1.
析构函数名是在类名前加上字符 ~。
2.
无参数无返回值。 (这里跟构造类似，也不需要加void)
3.
一个类只能有一个析构函数。若未显式定义，系统会自动生成默认的析构函数。
4.
对象生命周期结束时，系统会自动调用析构函数。
5.
跟构造函数类似，如果我们不写，编译器自动生成的析构函数对内置类型成员不做处理，自定类型成员会调用他的析构函数。
6.
我们显示写析构函数，对于自定义类型成员也会调用他的析构，也就是说自定义类型成员无论什么情况都会自动调用析构函数。
7.
如果类中没有申请资源时，析构函数可以不写，直接使用编译器生成的默认析构函数，如Date；如果默认生成的析构就可以用，也就不需要显示写析构，如MyQueue；但是有资源申请时，一定要自己写析构，否则会造成资源泄漏，如Stack。
8.
一个局部域的多个对象，C++规定后定义的先析构。
#include<iostream>
using namespace std;
typedef int stdatatype;
class stack
{
public:
stack(int n = 4)
{
_a = (stdatatype*)malloc(sizeof(stdatatype) * n);
if (nullptr == _a)
{
perror("malloc fail!");
return;
}
_capacity = n;
_top = 0;
}
~stack()
{
free(_a);
_a = nullptr;
_top = _capacity = 0;
}
private:
stdatatype* _a;
size_t _capacity;
size_t _top;
};
// 两个Stack实现队列
class myqueue
{
// 不需要写构造，默认生成就可以用
// 不需要写析构，默认生成就可以用
public:
//编译器默认⽣成MyQueue的构造函数调⽤了Stack的构造，完成了两个成员的初始化
~myqueue()
{
cout << "~myqueue()" << endl;
}
private:
stack pushst;
stack popst;
};
int main()
{
myqueue mq;
return 0;
}3. 拷贝构造函数
3.1定义
在C++中，拷贝构造函数是一种特殊的构造函数，它用于创建一个对象作为另一个同类型对象的副本。当你需要将一个对象初始化为另一个对象的副本时，就会调用拷贝构造函数。如果程序员没有提供自定义的拷贝构造函数，编译器会生成一个默认的拷贝构造函数。如果一个构造函数的第一个参数是自身类类型的引用，且任何额外的参数都有默认值，则此构造函数也叫做拷贝构造函数，也就是说拷贝构造是一个特殊的构造函数。
3.2拷贝构造的特点：
-
参数类型：拷贝构造函数接受一个单一参数，该参数是对同类型对象的常量引用（
const）。这防止了在拷贝构造函数调用过程中对原始对象的修改。 -
参数数量：拷贝构造函数只能有一个参数，即使它是一个参数列表（即只有一个参数）。
-
默认行为：如果用户没有提供自定义的拷贝构造函数，编译器会生成一个默认的拷贝构造函数，该函数执行成员初始化列表中的浅拷贝。
-
调用时机：
- 当一个对象以另一个同类型对象初始化时。
- 当函数返回一个对象时（返回值优化可能会阻止拷贝构造函数的调用）。
- 当对象作为参数传递给函数时，如果参数是通过值传递的。
-
常量对象：如果一个对象被声明为常量，那么只能调用该对象的常量成员函数。因此，如果一个常量对象需要被拷贝，只能调用拷贝构造函数。
-
深拷贝与浅拷贝：
- 浅拷贝：简单地复制成员变量的值，如果成员是指针，则只复制指针的值，不复制指针指向的数据。
- 深拷贝：为指针成员分配新的内存，并复制指针指向的数据，确保新对象有自己的数据副本。
3.3代码实现
我们先基本实现一下，感受一下：
#include<iostream>
using namespace std;
class Date
{
public:
Date(int year = 1, int month = 1, int day = 1)
{
_year = year;
_month = month;
_day = day;
}
//Date d2(d1); this 就是 d2,d 就是d1
Date(const Date& d)
{
this->_year = d._year; //通常情况下，我们省略前面的this指针
_month = d._month;
_day = d._day;
}
void print()
{
cout << _year << "-" << _month << "-" << _day << endl;
}
private:
int _year;
int _month;
int _day;
};
int main()
{
Date d1(2024, 11, 14);
Date d2(d1);
return 0;
}调试观察一下：发现我们的d2已经成功拷贝了d1！
此时，细心的人会会有疑问，可不可以把引用换成指针呢？我们来试一下：
#include<iostream>
using namespace std;
class Date
{
public:
Date(int year = 1, int month = 1, int day = 1)
{
_year = year;
_month = month;
_day = day;
}
// Date d3(&d1);
Date(Date* d)
{
cout << "Date(Date& d)" << endl;
_year = d->_year;
_month = d->_month;
_day = d->_day;
}
void print()
{
cout << _year << "-" << _month << "-" << _day << endl;
}
private:
int _year;
int _month;
int _day;
};
int main()
{
Date d1(2024, 11, 14);
Date d2(d1);
Date d3(&d1);
d1.print();
d2.print();
d3.print();
return 0;
}
结果仍然是对的，但是这个不能称之为拷贝构造了，只能称之为构造！
4. 赋值运算符重载
4.1 运算符重载
•
当运算符被用于类类型的对象时，C++语言允许我们通过运算符重载的形式指定新的含义。C++归定类类型对象使用运算符时，必须转换成调用对应运算符重载，若没有对应的运算符重载，则会编译报错。
•
运算符重载是具有特名字的函数，他的名字是由operator和后面要定义的运算符共同构成。和其他函数一样，它也具有其返回类型和参数列表以及函数体。
•
重载运算符函数的参数个数和该运算符作用的运算对象数量一样多。一元运算符有一个参数，二元运算符有两个参数，二元运算符的左侧运算对象传给第一个参数，右侧运算对象传给第二个参数。（一个运算符或者运算数就是一元，以此类推）
•
如果一个重载运算符函数是成员函数，则它的第一个运算对象默认传给隐式的this指针，因此运算符重载作为成员函数时，参数比运算对象少一个。
•
运算符重载以后，其优先级和结合性与对应的内置类型运算符保持⼀致。
•
不能通过连接语法中没有的符号来创建新的操作符：比如operator@。
•
.* :: sizeof ?:（三目操作符） .
注意以上5个运算符不能重载。
•
重载操作符至少有一个类类型参数，不能通过运算符重载改变内置类型对象的含义，如： int
operator+(int x, int y)
•
重载++运算符时，有前置++和后置++，运算符重载函数名都是operator++，无法很好的区分。
C++规定，后置++重载时，增加一个int形参，跟前置++构成函数重载，方便区分。
•
重载<<和>>时，需要重载为全局函数，因为重载为成员函数，this指针默认抢占了第一个形参位
置，第一个形参位置是左侧运算对象，调用时就变成了 对象<<cout，不符合使用习惯和可读性。
重载为全局函数把ostream/istream放到第⼀个形参位置就可以了，第二个形参位置当类类型对象
现在我们来感受一下
#include<iostream>
using namespace std;
class Date
{
public:
Date(int year = 1, int month = 1, int day = 1)
{
_year = year;
_month = month;
_day = day;
}
void print()
{
cout << _year << "-" << _month << "-" << _day << endl;
}
//private:
int _year;
int _month;
int _day;
};
bool operator==(const Date& x1, const Date& x2)
{
return x1._year == x2._year
&& x1._month == x2._month
&& x1._day == x2._day;
}
int operator-(const Date& x1, const Date& x2)
{
return 0;
}
int main()
{
Date d1(2024, 11, 14);
Date d2(2024, 11, 11);
//bool ret0 = operator==(d1, d2); 这样也可以，但是我们不喜欢这样写
bool ret1 = d1 == d2;
cout << ret1 << endl;
return 0;
}我们解释一下 .* 的含义，并将其与普通函数指针类型对比：
#include<iostream>
using namespace std;
// 编译报错：“operator +”必须⾄少有⼀个类类型的形参
//int operator+(int x, int y)
//{
// return x - y;
//}
class A
{
public:
void func()
{
cout << "A::func()" << endl;
}
};
typedef void(A::* PF1)(); //成员函数指针类型
typedef void(*PF2)(); //函数指针类型
void func2()
{
cout << "func2()" << endl;
}
int main()
{
// C++规定成员函数要加&才能取到函数指针
PF1 pf1 = &A::func;
A obj;//定义ob类对象temp
(obj.*pf1)(); //可以简单理解为先将pf1解引用，再去寻找
PF2 pf2 = func2;
(*pf2)();
return 0;
}结果如下：
4.2 赋值运算符重载
赋值运算符
重载是一个默认成员函数，用于
完成两个
已经存在
的对象直接的拷贝赋值
，这里要注意跟拷贝构造区分，
拷贝构造用于一个对象拷贝
初始化
给另一个要创建的对象
。
4.2.1赋值运算符重载的特点：
1.
赋值运算符重载是一个运算符重载，规定必须重载为成员函数。赋值运算重载的参数建议写成
const 当前类类型引用，否则会传值传参会有拷贝
2.
有返回值，且
建议写成当前类类型引用
，引用返回可以提高效率，有返回值目的是为了支持连续赋值场景。
3.
没有显式实现时，编译器会自动生成一个默认赋值运算符重载，默认赋值运算符重载行为跟默认构造函数类似，对内置类型成员变量会完成值拷贝/浅拷贝(一个字节一个字节的拷贝)，对自定义类型成员变量会调用他的拷贝构造。
4.
类成员变量全是内置类型且没有指向什么资源，编译器自动生成的赋值运算符重载就可以完成需要的拷贝，所以不需要我们实现赋值运算符重载。
像Stack这样的类，虽然也都是内置类型，但是_a指向了资源，编译器自动生成的赋值运算符重载完成的值拷贝/浅拷贝不符合我们的需求，所以需要我们自己实现深拷贝(对指向的资源也进行拷贝)。
像MyQueue这样的类型内部主要是自定义类型Stack成员，编译器自动生成的赋值运算符重载会调⽤Stack的赋值运算符重载，也不需要我们实现MyQueue的赋值运算符重载。
总之而言之：如果一个类显示实现了析构并释放资源，那么他就需要显示写赋值运算符重载，否则就不需要。
我们看一下代码：
#include<iostream>
using namespace std;
class Date
{
public:
Date(int year = 1, int month = 1, int day = 1)
{
_year = year;
_month = month;
_day = day;
}
Date(const Date& d)
{
cout << "Date(const Date& d)"<<endl;
_year = d._year;
_month = d._month;
_day = d._day;
}
// 传引⽤返回减少拷⻉
// d1 = d2;
Date& operator=(const Date& d)
{
//this 就是指向d1的指针，d 是d2的别名（引用）
// 不要检查⾃⼰给⾃⼰赋值的情况
if (this != &d)
{
_year = d._year;
_month = d._month;
_day = d._day;
}
// d1 = d2表达式的返回对象应该为d1，也就是*this
return *this; //出了作用域，*this还在，故可以用引用返回，否之不能
}
void print()
{
cout << _year << "-" << _month << "-" << _day << endl;
}
private:
int _year;
int _month;
int _day;
};
int main()
{
Date d1(2024, 11, 16);
d1.print();
Date d2(d1);
d2.print();
Date d3(2024, 11, 14);
d1 = d3;
d1.print();
d3.print();
// 需要注意这⾥是拷⻉构造，不是赋值重载
// 请牢牢记住赋值重载完成两个已经存在的对象直接的拷⻉赋值
// ⽽拷⻉构造⽤于⼀个对象拷⻉初始化给另⼀个要创建的对象
Date d4 = d1;
return 0;
}
运行结果附上：
