一、构造函数
构造函数是特殊的成员函数，用来对象实例化时初始化对象。构造函数的本质是要替代我们以前写的Stack和Date类中的Init函数的功能，构造函数自动调用的特点就完美地替代了Init函数。
构造函数的特点
·函数名和类名相同
·无返回值（不需要写void）
·对象实例化时系统会自动调用对应的构造函数
·构造函数可以重载
注意：如果通过无参构造函数创建对象时，对象后面不用加括号，否则编译器无法区分这里是函数声明还是实例化对象。
如果类中没有显示定义构造函数，那么C++编译器会自动生成一个无参的默认构造函数，一旦用户显示定义，那么编译器将不再生成。编译器生成的默认构造，对内置类型成员的初始化没有要求；对自定义类型成员变量，则要求调用这个成员变量的默认构造函数初始化（如果该成员变量没有默认构造函数，程序就会报错）我们初始化这个成员变量，需要初始化列表才能解决。
C++把类型分为内置类型(基本类型)和自定义类型。内置类型就是语言提供的数据类型（比如int / char / double），自定义类型就是我们使用class/struct等关键字自己定义的类型。
无参构造函数、全缺省构造函数、编译器默认生成的构造函数都叫做默认构造函数。这三个函数有且只有一个存在，不能同时存在。无参构造函数和全缺省构造函数虽然构成函数重载，但是在调用时会有歧义。要注意，很多初学者会认为默认构造函数就是编译器生成的那个叫默认构造，实际上无参构造函数、全缺省构造函数也是默认构造。总结一下就是不传实参就可以调用的构造就叫默认构造。
二、析构函数
析构函数与构造函数的功能相反，C++规定对象在销毁时会自动调用析构函数，完成对象中资源的清理释放工作。析构函数的功能类比我们之前Stack实现的Destroy功能，而像Date类没有Destroy函数，其实就是没有资源需要释放，所以严格来说Date是不需要析构函数的。
析构函数的特点
·析构函数名是在类名前加上字符~
·无参数无返回值（不需要加void）
·一个类只能有一个析构函数。若未显示定义，系统会自动生成默认的构造函数。
·对象生命周期结束时，系统会自动调用析构函数。
~Stack()
{
free(_a);
_a = nullptr;
_top = _capacity = 0;
}
注：一个局部域的多个对象，C++规定后定义的先析构。
三、拷贝构造函数
如果一个构造函数的第一个参数是自身类型的引用，且任何额外的参数都有默认值，则此构造函数也被称为拷贝构造函数，也就是说拷贝构造是一个特殊的构造函数。
拷贝构造的特点
·拷贝构造函数是构造函数的一个重载
·拷贝构造函数的第一个参数必须是类类型对象的引用，使用传值方式编译器直接报错，因为语法逻辑上会引发无穷递归调用。拷贝构造函数也可以有多个参数，但是第一个参数必须是类类型对象的引用，后面的参数必须有缺省值。
·C++规定自定义类型对象进行拷贝行为必须调用拷贝构造，所以自定义类型传值传参和传值返回都会调用拷贝构造来完成。
如果未显示定义拷贝构造，编译器会自动生成拷贝构造函数。自动生成的拷贝构造对内置类型成员变量会完成值拷贝/浅拷贝（一个字节一个字节地拷贝），对自定义类型成员变量会调用它的拷贝构造。
Date(const Date& d)
{
_year = d._year;
_month = d._month;
_day = d._day;
}
Stack(const Stack& st)
{
_a = (STDataType*)malloc(sizeof(STDataType) * st._capacity);
if (_a == nullptr)
{
perror("malloc fail");
return;
}
memcpy(_a, st._a, sizeof(STDataType) * st._top);
_top = st._top;
_capacity = st._capacity;
}
像Date这样的类，成员变量全是内置类型并且没有指向什么资源，编译器自动生成的拷贝构造就可以完成需要的拷贝，所以不需要我们显示实现拷贝构造。像Stack这样的类，虽然也都是内置类型，但是_a指向了资源，所以需要我们自己实现深拷贝（对指向的资源也进行拷贝）。总结一下就是如果一个类显示实现了析构并释放资源，那么就要显示写拷贝构造，否则就不需要。
四、赋值运算符重载
4.1 运算符重载
C++规定，类类型对象使用运算符时，必须转换成调用对应的运算符重载。运算符重载是具有特殊名字的函数，由operator和后面要定义的运算符共同构成，和其他函数一样，它也具有返回类型和参数列表以及函数体。
重载运算符函数的参数个数和该运算符作用的运算对象一样多。一元运算符有一个参数，二元运算符有两个参数，左侧运算对象传给第一个参数，右侧运算对象传给第二个参数。
这里简单实现一个判断日期类是否相等的重载函数：
bool operator==(const Date& x1, const Date& x2)
{
return x1._year == x2._year
&& x1._month == x2._month
&& x1._day == x2._day;
}
但是这样就带来一个问题，_year、_month和_day都是私有成员变量，没法直接访问。
重载为全局的面临对象访问私有成全变量的问题，通常有以下三种方法来解决：
① 提供Getxxx函数
② 友元函数（下一章讲解）
③ 作为成员函数，直接放在类里面
这里更推荐使用第三种解决方法。但是当我们直接把函数写在类里面之后，程序仍然编译报错：
程序提示我们函数参数太多，那为什么会这样呢？不要忘了，成员函数的参数部分还有一个隐藏的this指针，所以这里的成员函数其实有三个参数，而==运算符是二元运算符，所以才会提示参数过多。总结一下，如果一个重载运算符函数是成员函数，则它的第一个运算符对象默认传给隐式的this指针，因此运算符重载作为成员函数时，参数比运算对象少一个。正确的代码如下：
bool operator==(const Date& x)
{
return _year == x._year
&& _month == x._month
&& _day == x._day;
}
关于运算符重载，还有以下几点需要注意：
① 不能通过连接语法中灭有的符号来创建新的操作符，比如operator@
② 下面这五个运算符不能重载：.* / :: / sizeof / ? : / .
③ 重载操作符至少有一个内置类型，不能通过运算符重载改变内置类型对象的含义，比如 int operator+(int x, int y)
④ C++规定，后置++重载时，增加一个int形参，和前置++构成函数重载便于区分
⑤ 重载<< 和 >> 时，需要重载为全局函数。因为如果重载为成员函数，this指针默认抢占了第一个形参位置，调用时就变成了 对象 << cout，不符合使用习惯和可读性。重载为全局函数把ostream/istream放在第一个形参位置就可以了，第二个形参位置为当前类类型的对象。
4.2 赋值运算符重载
赋值运算符重载是一个默认的成员函数，用于完成两个已经存在的对象直接的拷贝赋值。这里要注意和拷贝构造区分，拷贝构造用于一个对象拷贝初始化给另一个要创建的对象。
赋值运算符重载的特点：
1、赋值运算符重载规定必须重载为成员函数，参数建议写成const当前类类型的引用，否则传值传参会有拷贝。
2、有返回值，并且建议写成当前类类型的引用。引用返回可以提高效率，有返回值目的是为了支持连续赋值的场景。
3、没有显示实现时，编译器会自动生成一个默认赋值运算符重载。默认赋值运算符重载行为和默认拷贝构造类似，对内置类型成员变量会完成浅拷贝，对自定义类型成员变量会调用它的赋值重载函数。
4、像Date这样的类成员变量全是内置类型且没有指向什么资源，就不需要我们显示实现。像Stack这样的类，_arr指向了资源，所以需要我们自己实现深拷贝。总结一下，如果一个类显示实现了析构并释放资源，那么就需要显示写赋值运算符重载，否则就不需要。
// d1 = d2
Date& operator=(const Date& d)
{
if (this != &d)
{
_year = d._year;
_month = d._month;
_day = d._day;
}
return *this;
}
4.3 日期类的实现
Date.h
#pragma once
#include <assert.h>
#include <iostream>
using namespace std;
class Date
{
//友元函数声明
friend ostream& operator<<(ostream& out, const Date& d);
friend istream& operator>>(istream& in, Date& d);
public:
int GetMonthDay(int year, int month)
{
assert(month > 0 && month < 13);
static int monthDayArray[13] = { -1,31,28,31,30,31,30,31,31,30,31,30,31 };
if (month == 2 && ((year % 4 == 0 && year % 100 != 0) || (year % 400 == 0)))
return 29;
else
return monthDayArray[month];
}
void Print();
Date(int year = 1, int month = 1, int day = 1);
Date& operator+=(int day);
Date operator+(int day);
Date& operator-=(int day);
// 日期-天数
Date operator-(int day);
Date& operator++();
Date operator++(int);
bool operator==(const Date& d);
bool operator!=(const Date& d);
bool operator<(const Date& d);
bool operator<=(const Date& d);
bool operator>(const Date& d);
bool operator>=(const Date& d);
// 日期-日期
int operator-(const Date& d);
private:
int _year;
int _month;
int _day;
};
ostream& operator<<(ostream& out, const Date& d);
istream& operator>>(istream& in, Date& d);
Date.cpp
#define _CRT_SECURE_NO_WARNINGS 1
#include "Date.h"
Date::Date(int year, int month, int day)
{
_year = year;
_month = month;
_day = day;
}
void Date::Print()
{
cout << _year << '/' << _month << '/' << _day << endl;
}
// d1 += 100
Date& Date::operator+=(int day)
{
if (day < 0)
{
return *this -= -day;
}
_day += day;
//进位
while (_day > GetMonthDay(_year, _month))
{
_day -= GetMonthDay(_year, _month);
_month++;
if (_month == 13)
{
_month = 1;
_year++;
}
}
return *this;
}
// d1 + 100
Date Date::operator+(int day)
{
//Date tmp(_year, _month, _day);
Date tmp(*this);
tmp += day;
return tmp;
}
// d1 -= 100
Date& Date::operator-=(int day)
{
if (day < 0)
{
return *this += -day;
}
_day -= day;
while (_day <= 0)
{
_month--;
if (_month == 0)
{
_month = 12;
_year--;
}
_day += GetMonthDay(_year, _month);
}
return *this;
}
// 日期-天数
// d1 - 100
Date Date::operator-(int day)
{
Date tmp(*this);
tmp -= day;
return tmp;
}
// ++d1
Date& Date::operator++()
{
*this += 1;
return *this;
}
// d1++
Date Date::operator++(int)
{
Date tmp(*this);
*this += 1;
return tmp;
}
bool Date::operator==(const Date& d)
{
return _year == d._year
&& _month == d._month
&& _day == d._day;
}
bool Date::operator!=(const Date & d)
{
return !(*this == d);
}
bool Date::operator<(const Date& d)
{
if (_year < d._year)
{
return true;
}
else if (_year == d._year && _month < d._month)
{
return true;
}
else if (_year == d._year && _month == d._month && _day < d._day)
{
return true;
}
return false;
}
bool Date::operator<=(const Date& d)
{
return *this < d || *this == d;
}
bool Date::operator>(const Date& d)
{
return !(*this <= d);
}
bool Date::operator>=(const Date& d)
{
return !(*this < d);
}
// 日期-日期
// d1 - d2
int Date::operator-(const Date& d)
{
Date max = *this;
Date min = d;
int flag = 1;
if (*this < d)
{
max = d;
min = *this;
flag = -1;
}
int n = 0;
while (min != max)
{
++min;
++n;
}
return n * flag;
}
ostream& operator<<(ostream& out, const Date& d)
{
out << d._year << "年" << d._month << "月" << d._day << "日" << endl;
return out;
}
istream& operator>>(istream& in, Date& d)
{
cout << "请依次输入年月日:";
in >> d._year >> d._month >> d._day;
return in;
}
test.cpp
#define _CRT_SECURE_NO_WARNINGS 1
#include "Date.h"
void test01()
{
Date d1(2025, 8, 24);
Date d2 = d1 + 100;
d1.Print();
d2.Print();
Date d3 = d1 += 100;
d1.Print();
d3.Print();
}
void test02()
{
Date d1(2025, 4, 24);
Date d2 = d1 -= 100;
d1.Print();
d2.Print();
Date d3(2025, 4, 26);
Date d4 = d3 - 10000;
d3.Print();
d4.Print();
}
void test03()
{
Date d1(2025, 4, 26);
Date d2 = d1++;
d1.Print();
d2.Print();
Date d3(2025, 4, 26);
Date d4 = ++d3;
d3.Print();
d4.Print();
}
void test04()
{
Date d1(2025, 4, 26);
Date d2(2025, 7, 1);
cout << (d1 < d2) << endl;
cout << (d2 < d1) << endl;
cout << (d1 == d2) << endl;
cout << d2 - d1 << endl;
}
void test05()
{
Date d1(2025, 4, 26);
Date d2(2025, 7, 1);
// 流插入
cout << d1; // operator<<
cin >> d1 >> d2;
cout << d1 << d2;
}
int main()
{
//test01();
//test02();
//test03();
//test04();
test05();
return 0;
}
五、取地址运算符重载
5.1 const成员函数
将const修饰的成员函数称之为const成员函数，const修饰成员函数放到成员函数参数列表的后面。只要不改变调用对象的函数，都建议加const。
5.2 取地址运算符重载
取地址运算符重载分为普通取地址运算符重载和const取地址运算符重载，一般这两个函数编译器自动生成的就可以够用了，不需要去显示实现。除非一些很特殊的场景，比如我们不想让他人取到当前类对象的地址，就可以自己实现一份。
class Date
{
public:
Date* operator&()
{
//return this;
return nullptr;
}
const Date* operator&() const
{
//return this;
return nullptr;
}
private:
int _year;
int _month;
int _day;
};
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
