目录
三、类和对象(中)
3.析构函数
析构函数与构造函数功能相反,析构函数不是完成对对象本身的销毁,比如局部对象是存在栈帧的,函数结束栈帧销毁,这样就完成释放,
而C++规定对象在销毁时会自动调用析构函数,完成对象中资源的清理释放⼯作
。
析构函数的功能可以类比我们之前Stack实现的Destroy功能,但是像Date却没有Destroy,其实就是没有资源需要释放,所以严格说Date是不需要析构函数的。
析构函数的特点:(主要是编译器的特性决定了析构函数的调用)
- 析构函数名是在类名前加上字符 ~。(主要表达是与构造函数用法相反的意思)
- 无参数无返回值。 (这里跟构造类似,也不需要加void)
- ⼀个类只能有⼀个析构函数。若未显式定义,系统会自动生成默认的析构函数。
- 对象生命周期结束时,系统会自动调用析构函数。
- 跟构造函数类似,我们不写且编译器自动生成的析构函数,对内置类型成员不做处理,自定类型成员会调用他的析构函数。
- 还需要注意的是我们显示写析构函数,对于自定义类型成员也会调用他的析构,也就是说自定义类型成员无论什么情况都会自动调用析构函数。
- 若类中没有申请资源时,析构函数可不写,直接使用编译器生成的默认析构函数,如Date;如果默认生成的析构就可以用,也就不需要显示写析构,如MyQueue;但有资源申请时,⼀定要自己写析构,否则会造成资源泄漏,如Stack。
- ⼀个局部域的多个对象,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申请空间失败"); return; } _capacity = n; _top = 0; } ~Stack() { cout << "~Stack()" << endl; free(_a); _a = nullptr; _top = _capacity = 0; } private: STDataType* _a; size_t _capacity; size_t _top; }; // 两个Stack(栈)实现队列 class MyQueue { public: //编译器默认⽣成MyQueue的析构函数调⽤了Stack的析构,释放的Stack内部的资源 // 显⽰写析构,也会⾃动调⽤Stack的析构 /*~MyQueue() {}*/ private: Stack pushst; Stack popst; }; int main() { Stack st; MyQueue mq; return 0; }
下面为该代码程序的运行结果:该结果从而验证了编译器默认生成MyQueue的析构函数调用了Stack的析构,释放的Stack内部的资源;显示写析构,也会自动调用Stack的析构。
结论:一般情况下显示申请了资源(比如栈),才需要自己实现析构,其他情况基本都不需要显示写。
对比一下用C++和C实现的Stack解决之前括号匹配问题isValid,我们发现有了构造函数和析构函数确实方便了很多,不会再忘记调用Init和Destory函数了,也方便了不少。
#include<iostream>
using namespace std;
// ⽤最新加了构造和析构的C++版本Stack实现
bool isValid(const char* s)
{
Stack st;
while (*s)
{
if (*s == '[' || *s == '(' || *s == '{')
{
st.Push(*s);
}
else
{
// 右括号⽐左括号多,数量匹配问题
if (st.Empty())
{
return false;
}
// 栈⾥⾯取左括号
char top = st.Top();
st.Pop();
// 顺序不匹配
if ((*s == ']' && top != '[')
|| (*s == '}' && top != '{')
|| (*s == ')' && top != '('))
{
return false;
}
}
++s;
}
// 栈为空,返回真,说明数量都匹配 左括号多,右括号少匹配问题
return st.Empty();
}
// ⽤之前C版本Stack实现
bool isValid(const char* s)
{
ST st;
STInit(&st);
while (*s)
{
// 左括号⼊栈
if (*s == '(' || *s == '[' || *s == '{')
{
STPush(&st, *s);
}
else // 右括号取栈顶左括号尝试匹配
{
if (STEmpty(&st))
{
STDestroy(&st);
return false;
}
char top = STTop(&st);
STPop(&st);
// 不匹配
if ((top == '(' && *s != ')')
|| (top == '{' && *s != '}')
|| (top == '[' && *s != ']'))
{
STDestroy(&st);
return false;
}
}
++s;
}
// 栈不为空,说明左括号⽐右括号多,数量不匹配
bool ret = STEmpty(&st);
STDestroy(&st);
return ret;
}
int main()
{
cout << isValid("[()][]") << endl;
cout << isValid("[(])[]") << endl;
return 0;
}
4.拷贝构造函数
如果⼀个构造函数的第一个参数是自身类类型的引用,且任何额外的参数都有默认值,则此构造函数也叫做拷贝构造函数,也就是说拷贝构造是⼀个特殊的构造函数。
拷贝构造的特点:
- 拷贝构造函数是构造函数的⼀个重载。
- 拷贝构造函数的第⼀个参数必须是类类型对象的引用,使用传值方式编译器直接报错,因为语法逻辑上会引发无穷递归调用。 拷贝构造函数也可以多个参数,但是第⼀个参数必须是类类型对象的引用,后面的参数必须有缺省值。
- C++规定自定义类型对象进行拷贝行为必须调用拷贝构造,所以这里自定义类型传值传参和传值返回都会调用拷贝构造完成。
- 若未显式定义拷贝构造,编译器会生成自动生成拷贝构造函数。⾃动生成的拷贝构造对内置类型成员变量会完成值拷贝/浅拷贝(⼀个字节⼀个字节的拷贝),对自定义类型成员变量会调用他的拷贝构造。
- 像Date这样的类成员变量全是内置类型且没有指向什么资源,编译器自动生成的拷贝构造就可以完成需要的拷贝,所以不需要我们显示实现拷贝构造。像Stack这样的类,虽然也都是内置类型,但是_a指向了资源,编译器⾃动⽣成的拷⻉构造完成的值拷⻉/浅拷⻉不符合我们的需求,所以需要我们⾃⼰实现深拷贝(对指向的资源也进行拷贝)。像MyQueue这样的类型内部主要是自定义类型Stack成员,编译器自动生成的拷贝构造会调⽤Stack的拷⻉构造,也不需要我们显⽰实现MyQueue的拷⻉构造。小技巧:如果一个类显示实现了析构并释放资源,那么他就需要显示写拷贝构造,否则就不需要。
int main() { Date d1(2024,8,17); Date d2 = d1; Stack st1(10); Stack st2(st1); return 0; }
- 传值返回会产生⼀个临时对象调用拷贝构造;传引用返回,返回的是返回对象的别名(引用),没有产生拷贝。但如果返回对象是⼀个当前函数局部域的局部对象,函数结束就销毁了,那么使⽤引⽤返回是有问题的,这时的引用相当于⼀个野引用,类似⼀个野指针⼀样。传引⽤返回可以减少拷贝,但是⼀定要确保返回对象,在当前函数结束后还在,才能⽤引⽤返回。比如像下面的传引用返回就不行,想要用传引用返回的话就必须得使用static去修饰栈使当前函数还存在后才可以使用:
Stack& Func() { Stack st; st.push(1); st.push(2); st.push(3); //... return st; } int main() { Stack ret = Func(); cout<< ret.Top() << end1; return 0; }
#include<iostream> using namespace std; class Date { public: Date(int year = 1, int month = 1, int day = 1) { _year = year; _month = month; _day = day; } // 编译报错:error C2652: “Date”: ⾮法的复制构造函数: 第⼀个参数不应是“Date” //Date(Date d) Date(const Date& d) { _year = d._year; _month = d._month; _day = d._day; } //使用指针的话就不是拷贝构造了,而是普通构造 Date(Date* d) { _year = d->_year; _month = d->_month; _day = d->_day; } void Print() { cout << _year << "-" << _month << "-" << _day << endl; } private: int _year; int _month; int _day; }; void Func1(Date d) { cout << &d << endl; d.Print(); } // Date Func2() Date& Func2() { Date tmp(2024, 7, 5); tmp.Print(); return tmp; } int main() { Date d1(2024, 7, 5); // C++规定⾃定义类型对象进⾏拷⻉⾏为必须调⽤拷⻉构造,所以这⾥传值传参要调⽤拷⻉构造 // 所以这⾥的d1传值传参给d要调⽤拷⻉构造完成拷⻉,传引⽤传参可以较少这⾥的拷⻉ Func1(d1); cout << &d1 << endl; // 这⾥可以完成拷⻉,但是不是拷⻉构造,只是⼀个普通的构造 Date d2(&d1); d1.Print(); d2.Print(); //这样写才是拷⻉构造,通过同类型的对象初始化构造,⽽不是指针 Date d3(d1); d2.Print(); // 也可以这样写,这⾥也是拷⻉构造 Date d4 = d1; d2.Print(); // Func2返回了⼀个局部对象tmp的引⽤作为返回值 // Func2函数结束,tmp对象就销毁了,相当于了⼀个野引⽤ Date ret = Func2(); ret.Print(); return 0; }
#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申请空间失败");
return;
}
_capacity = n;
_top = 0;
}
Stack(const Stack& st)
{
// 需要对_a指向资源创建同样⼤的资源再拷⻉值
_a = (STDataType*)malloc(sizeof(STDataType) * st._capacity);
if (nullptr == _a)
{
perror("malloc申请空间失败!!!");
return;
}
memcpy(_a, st._a, sizeof(STDataType) * st._top);
_top = st._top;
_capacity = st._capacity;
}
void Push(STDataType x)
{
if (_top == _capacity)
{
int newcapacity = _capacity * 2;
STDataType* tmp = (STDataType*)realloc(_a, newcapacity * sizeof(STDataType));
if (tmp == NULL)
{
perror("realloc fail");
return;
}
_a = tmp;
_capacity = newcapacity;
}
_a[_top++] = x;
}
~Stack()
{
cout << "~Stack()" << endl;
free(_a);
_a = nullptr;
_top = _capacity = 0;
}
private:
STDataType* _a;
size_t _capacity;
size_t _top;
};
// 两个Stack实现队列
class MyQueue
{
public:
private:
Stack pushst;
Stack popst;
};
int main()
{
Stack st1;
st1.Push(1);
st1.Push(2);
// Stack不显⽰实现拷⻉构造,⽤⾃动⽣成的拷⻉构造完成浅拷⻉
// 会导致st1和st2⾥⾯的_a指针指向同⼀块资源,析构时会析构两次,程序崩溃
Stack st2 = st1;
MyQueue mq1;
// MyQueue⾃动⽣成的拷⻉构造,会⾃动调⽤Stack拷⻉构造完成pushst/popst
// 的拷⻉,只要Stack拷⻉构造⾃⼰实现了深拷⻉,他就没问题
MyQueue mq2 = mq1;
return 0;
}
重点:C++规定:类类型传值传参必须调用拷贝构造。
5.赋值运算符重载
5.1运算符重载
- 当运算符被⽤于类类型的对象时,C++语⾔允许我们通过运算符重载的形式指定新的含义。C++规定类类型对象使⽤运算符时,必须转换成调用对应运算符重载,若没有对应的运算符重载,则会编译报错。
- 运算符重载是具有特殊名字的函数,他的名字是由operator和后面要定义的运算符共同构成。和其他函数⼀样,它也具有其返回类型和参数列表以及函数体。
- 重载运算符函数的参数个数和该运算符作用的运算对象数量⼀样多。⼀元运算符有⼀个参数,⼆元运算符有两个参数,⼆元运算符的左侧运算对象传给第⼀个参数,右侧运算对象传给第⼆个参数。
- 若⼀个重载运算符函数是成员函数,则它的第⼀个运算对象默认传给隐式的this指针,因此运算符重载作为成员函数时,参数比运算对象少⼀个。
- 运算符重载以后,其优先级和结合性与对应的内置类型运算符保持⼀致。
- 不能通过连接语法中没有的符号来创建新的操作符:比如operator@。
- 重点:注意以上5个运算符不能重载。(选择题里面常考,大家要记⼀下)
- 重载操作符至少有⼀个类类型参数,不能通过运算符重载改变内置类型对象的含义,如:
int operator+(int x, int y)
- ⼀个类需要重载哪些运算符,是看哪些运算符重载后有意义。比如Date类重载operator-就有意义,但是重载operator*就没有意义。
- 重载++运算符时,有前置++和后置++,运算符重载函数名都是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; }; // 重载为全局的⾯临对象访问私有成员变量的问题 // 有⼏种⽅法可以解决: // 1、成员放公有 // 2、Date提供getxxx函数 // 3、友元函数 // 4、重载为成员函数 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, 7, 5); Date d2(2024, 7, 6); // 运算符重载函数可以显⽰调⽤ operator==(d1, d2); // 编译器会转换成 operator==(d1, d2); d1 == d2; return 0; }