类和对象（中2）

目录

1.析构函数

析构函数的特点：

1.2拷贝函数

2.运算符重载

2.1赋值运算符重载

1.析构函数

析构函数与构造函数功能相反，析构函数不是完成对对象本身的销毁，比如局部对象是存在栈帧的， 函数结束栈帧销毁，他就释放了，不需要我们管，C++规定对象在销毁时会自动调用析构函数，完成对 象中资源的清理释放工作。析构函数的功能类比我们之前Stack实现的Destroy功能，而像Date没有 Destroy，其实就是没有资源需要释放，所以严格说Date是不需要析构函数的。

析构函数的特点：

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

2. 无参数无返回值。 (这里跟构造类似，也不需要加void)

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

4. 对象生命周期结束时，系统会自动调用析构函数。

5. 跟构造函数类似，我们不写编译器自动生成的析构函数对内置类型成员不做处理，自定类型成员会 调用他的析构函数。

6. 还需要注意的是我们显示写析构函数，对于自定义类型成员也会调用他的析构，也就是说自定义类 型成员无论什么情况都会自动调用析构函数。

总结： 一般情况下显示申请了资源 才需要自己实现析构 ，其他情况基本不需要析构 后定义的栈先析构

1.2拷贝函数

如果⼀个构造函数的第⼀个参数是⾃⾝类类型的引⽤，且任何额外的参数都有默认值，则此构造函数也叫做拷⻉构造函数，也就是说拷⻉构造是⼀个特殊的构造函数。 拷贝函数的特点 1. 拷⻉构造函数是构造函数的⼀个重载。 2. 拷⻉构造函数的第⼀个参数必须是类类型对象的引⽤，使⽤传值⽅式编译器直接报错，因为语法逻 辑上会引发⽆穷递归调⽤。拷⻉构造函数也可以多个参数，但是第⼀个参数必须是类类型对象的引 ⽤，后⾯的参数必须有缺省值。 3. C++规定⾃定义类型对象进⾏拷⻉⾏为必须调⽤拷⻉构造，所以这⾥⾃定义类型传值传参和传值返 回都会调⽤拷⻉构造完成。 4. 若未显式定义拷⻉构造，编译器会⽣成⾃动⽣成拷⻉构造函数。⾃动⽣成的拷⻉构造对内置类型成 员变量会完成值拷⻉/浅拷⻉(⼀个字节⼀个字节的拷⻉)，对⾃定义类型成员变量会调⽤他的拷⻉构 造 5. 像Date这样的类成员变量全是内置类型且没有指向什么资源，编译器⾃动⽣成的拷⻉构造就可以完 成需要的拷⻉，所以不需要我们显⽰实现拷⻉构造。像Stack这样的类，虽然也都是内置类型，但 是_a指向了资源，编译器⾃动⽣成的拷⻉构造完成的值拷⻉/浅拷⻉不符合我们的需求，所以需要 我们⾃⼰实现深拷⻉(对指向的资源也进⾏拷⻉)。像MyQueue这样的类型内部主要是⾃定义类型 Stack成员，编译器⾃动⽣成的拷⻉构造会调⽤Stack的拷⻉构造，也不需要我们显⽰实现 MyQueue的拷⻉构造。这⾥还有⼀个⼩技巧，如果⼀个类显⽰实现了析构并释放资源，那么他就 需要显⽰写拷⻉构造，否则就不需要。 6. 传值返回会产⽣⼀个临时对象调⽤拷⻉构造，传值引⽤返回，返回的是返回对象的别名(引⽤)，没 有产⽣拷⻉。但是如果返回对象是⼀个当前函数局部域的局部对象，函数结束就销毁了，那么使⽤ 引⽤返回是有问题的，这时的引⽤相当于⼀个野引⽤，类似⼀个野指针⼀样。传引⽤返回可以减少 拷⻉，但是⼀定要确保返回对象，在当前函数结束后还在，才能⽤引⽤返回

2.赋值运算符重载

2.1运算符重载

当运算符被⽤于类类型的对象时，C++语⾔允许我们通过运算符重载的形式指定新的含义。C++规 定类类型对象使⽤运算符时，必须转换成调⽤对应运算符重载，若没有对应的运算符重载，则会编 译报错。 • 运算符重载是具有特殊名字的函数，他的名字是由operator和后⾯要定义的运算符共同构成。和其 他函数⼀样，它也具有其返回类型和参数列表以及函数体。 • 重载运算符函数的参数个数和该运算符作⽤的运算对象数量⼀样多。⼀元运算符有⼀个参数，⼆元 运算符有两个参数，⼆元运算符的左侧运算对象传给第⼀个参数，右侧运算对象传给第⼆个参数。 • 如果⼀个重载运算符函数是成员函数，则它的第⼀个运算对象默认传给隐式的this指针，因此运算 符重载作为成员函数时，参数⽐运算对象少⼀个。

• 运算符重载以后，其优先级和结合性与对应的内置类型运算符保持⼀致。 • 不能通过连接语法中没有的符号来创建新的操作符：⽐如operator@。

.*   ::  sizeof  ?:   .)注意以上5个运算符不能重载。(选择题⾥⾯常考，⼤家要记⼀ 重载操作符⾄少有⼀个类类型参数，不能通过运算符重载改变内置类型对象的含义，如：int  operator+(int x, int y) •⼀个类需要重载哪些运算符，是看哪些运算符重载后有意义，⽐如Date类重载operator-就有意 义，但是重载operator+就没有意义。 • 重载++运算符时，有前置++和后置++，运算符重载函数名都是operator++，⽆法很好的区分。 C++规定，后置++重载时，增加⼀个int形参，跟前置++构成函数重载，⽅便区分。 • 重载<<和>>时，需要重载为全局函数，因为重载为成员函数，this指针默认抢占了第⼀个形参位 置，第⼀个形参位置是左侧运算对象，调⽤时就变成了对象<<cout，不符合使⽤习惯和可读性。 重载为全局函数把ostream/istream放到第⼀个形参位置就可以了，第⼆个形参位置当类类型对 象。

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include<assert.h>
#include <stdlib.h>
#include <stdbool.h>
using namespace std;
//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 main3r()
//{
//Date d1;
//return 0;
//}

//析构函数
typedef int STDatatype;
class Stack
{
public :
void Init(int n = 4)
{
_a = (STDatatype*)malloc (sizeof(STDatatype) * n);
if (_a == nullptr)
{
perror("内存泄露\\n");
exit(1);
}
_capacity = n;
_top = 0;

}

//析构函数
~Stack()
{
cout << "~Stack ()" << endl;
free(_a);
_a = nullptr;
_top = _capacity = 0;
}

private :
STDatatype* _a;
size_t _top;
size_t _capacity;

};

//两个队列实现栈
class Myqueue
{
public :
/*~Myqueue ()
{
cout << "~Myqueue()" << endl;

}*/

/*编译器默认⽣成MyQueue的析构函数调⽤了
Stack的析构，释放的Stack内部的资源
显⽰写析构，也会⾃动调⽤Stack的析构*/
/*~MyQueue()
{}*/
private :
Stack pushst;
Stack popst;

};

int mai342n()
{
Stack st;
Myqueue my;
/*在函数调用后调用构造函数
先调用后面的函数*/

return 0;
}
//拷贝构造
class Date
{
public :
Date(int year = 1, int month = 1, int day = 1)
{
_year = year;
_month = month;
_day = day;

}
//Date d2 (d1) 拷贝函数必须这么写
/*Date(const Date& d)
{
_year = d._year;
_month = d._month;
_day = d._day;
}*/

Date f()
{
Date c;
//…
return c;

}

//这里用指针也可以 这里的指针就不是拷贝构造
/*Date(Date* d)
{
_year = d->_year;
_month = d->_month;
_day = d->_day;
}*/

private:
int _year;
int _month;
int _day;

};
void func(Date& d)//如果这里添加了&符号就会直接调用了
{

}

int mai432n()
{
Date d1(2026,7,25);
//拷贝函数的第一个参数必须是类类型引用的对象
Date d2(d1);//两个表示相同
Date d4 = d1;
//从编译器上可以看到已经拷贝成功

func(d1);
//c++规定传值传参要调用拷贝构造
// 先调用 Date （Date & d1） 后调用func(d1)

//每次调用拷贝构造之前都要先传值传参 传值传参会形成
// 一个新的拷贝构造，形成了无穷递归

return 0;
}

//引用返回不一定好
class Stack
{
public :
Stack( int n =4 )
{
_arr = (int*)malloc(sizeof(int) * n);
if (_arr == nullptr)
{
perror("mallco fail ");
exit(1);
}
_top = 0;
_capacity = n;
}
Stack(const Stack& d)
{
_arr = (int*)malloc(sizeof(int) * d._capacity);
if (_arr == nullptr)
{
perror("malloc fail");
exit(1);
}
memcpy(_arr, d._arr, sizeof(int) * d._capacity);
_capacity = d._capacity;
_top = d._top;
}

void* Push( int x )
{
if (_top == _capacity)
{
int newcapacity = _capacity * 2;
int* tmp = (int*)realloc(_arr,sizeof(int) * newcapacity);
if (tmp == nullptr)
{
perror("malloc fail ");
exit(1);
}
_arr = tmp;
_capacity = newcapacity;

}
_arr[_top++] = x;

}

~Stack()
{
cout << "~Stack ()" << endl;

free(_arr);
_arr = nullptr;
_capacity = _top = 0;
}

int Top()
{
assert(_top > 0);
return _arr[_top – 1];

}
private :
int* _arr;
size_t _top;
size_t _capacity;

};

Stack& Func()//引用返回
{
static Stack s1; //这里加入static就可以使用引用返回了
//如果不加的话就会报错
s1.Push(1);
s1.Push(2);
s1.Push(3);
s1.Push(4);

return s1;

}
int mai423n()
{
//编译器自己调用
/*Stack s1(10);
Stack st2(s1);*/
Stack ret = Func();
std::cout << ret.Top() << endl;

return 0;
}

//运算符的重载

class Date
{
public :
Date(int year = 1, int month = 1, int day =1 )
{
_year = year;
_month = month;
_day = day;

}
//如果我们把这个放在类里面 会发生什么？
//结果是显示operator 的函数参数太多了
//重载为成员函数时他的第一个函数就是this指针，
// 所以说我们传一个参数就可以

//下面的代码编译成功
bool 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;
}

//日期类
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 % 100 != 0 && year % 4 == 0)
|| (year % 400 == 0))
{
return 29;
}
else
{
return monthDayArray[month];
}
}

//int operator – (const Date & d);
Date operator + (int day)
{

}

private :
int _year;
int _month;
int _day;

};

//如果我们不把private 给注释掉来怎么解决这问题呢？
//1.提供对应getxxx函数
//2.友元
//3、重载为成员函数

int main()
{
Date d1(2027, 5, 6);
Date d2(2034, 4, 6);
//这两个写法都可以 但是还是推荐第二个
//bool ret1 = operator<(d1, d2);
bool ret2 = d1 < d2;
//掉换成对应的运算符重载函数
bool ret3 = d1.operator<( d2);
cout << ret2 << endl;
cout << ret3 << endl;
return 0;
}