目录
用户没有显示实现，编译器会生成一个默认赋值运算符，一致的形式逐字节拷贝
一. 类的6个默认成员函数
默认成员函数：用户没有显式实现，编译器会生成的成员函数称为默认成员函数。
二. 构造函数
构造函数是一个特殊的成员函数，名字与类名相同,创建类类型对象时由编译器自动调用，以保证每个数据成员都有 一个合适的初始值，并且在对象整个生命周期内只调用一次。
构造函数 并不是开空间创建对象，而是初始化对象
其特征如下：
-
函数名与类名相同。
-
无返回值。
-
对象实例化时编译器自动调用对应的构造函数。
-
构造函数可以重载。
-
如果类中没有显式定义构造函数，则C++编译器会自动生成一个无参的默认构造函数，一旦用户显式定义编译器将不再生成。
-
无参构造函数、全缺省构造函数、我们没写编译器默认生成的构造函数，都可以认为是默认构造函数。并且默认构造函数只能有一个。
-
内置类型成员变量在类中声明时可以给默认值。(补丁)
默认生成函数中，内置类型不会自动调用默认构造函数，自定义类型自动调用默认构造函数
如果用户显式定义了构造函数，编译器将不再生成默认构造函数
当构造函数调用完成后会调用内置类型，内置类型在没有初始化时，是随机值或者都是0
class Date{
public:
// 默认构造函数——不写函数，无参函数，全缺省函数(总结：不传参的就是默认构造函数)
//只能同时存在一个
// 1.无参构造函数
//Date()
//{}
//2.带参构造函数
Date(int year, int month, int day) {
_year = year;
_month = month;
_day = day;
}
//3.不写函数，编译器会默认生成函数
void Print() {
cout << _year << "-" << _month << "-" << _day << endl;
}
private:
//补丁——内置变量在类中声明可以给默认值
int _year = 1;
int _month = 1;
int _day = 1;
};
int main()
{
//Date d2;
Date d1(2024, 5, 9);
d1.Print();
//d2.Print();
return 0;
}C++把类型分成内置类型(基本类型)和自定义类型。内置类型就是语言提供的数据类型，如：int/char...， 自定义类型就是我们使用class/struct/union等自己定义的类型，会发现编译器生成默认的构造函数会对自定类型成员_t调用的它的默认成员函数。
三 .析构函数
对象在销毁时会自动调用析构函数，完成对象中资源的清理工作。
析构函数是特殊的成员函数，其特征如下：
-
析构函数名是在类名前加上字符 ~。
-
无参数无返回值类型。
-
一个类只能有一个析构函数。若未显式定义，系统会自动生成默认的析构函数。注意：析构函数不能重载
-
对象生命周期结束时，C++编译系统系统自动调用析构函数
-
关于编译器自动生成的析构函数，是否会完成一些事情呢？下面的程序我们会看到，编译器生成的默认析构函数，对自定类型成员调用它的析构函数。
-
如果类中没有申请资源时，析构函数可以不写，直接使用编译器生成的默认析构函数，比如Date类；有资源申请时，一定要写，否则会造成资源泄漏，比如Stack类。
//析构函数 ——清除数据 (Destory)
//不是所有的类都要析构函数，需要的 ：有数据的malooc / 文件打开
typedef int DataType;
class Stack
{
public:
Stack(size_t capacity = 4){
cout << "size_t capacity = 4" << endl;
_a = (DataType*)malloc(sizeof(DataType) * capacity);
if (nullptr == _a){
perror("malloc fail");
return;
}
_top = 0;
_capacity = capacity;
}
void Push(int x){
//扩容...
_a[_top++] = x;
}
int Top(){
return _a[_top - 1];
}
void Pop(){
_top--;
}
bool Empty(){
return _top == 0;
}
~Stack(){
cout << "~Stack" << endl;
if (_a) {
free(_a);
_a = nullptr;
_top = _capacity = 0;
}
}
private:
DataType* _a;
int _top;
int _capacity;
};
//自动生成析构函数——内置类型不做处理，自定义函数自动调用析构函数
class MyQueue {
private:
Stack st1;
Stack st2;
int _size = 0;
};
int main() {
//Stack st;
//结束后自动调用~Stack
//st.~Stack;//也可以显示 +调用析构函数
MyQueue q;
return 0;
}四 .拷贝构造函数
拷贝构造函数：只有单个形参，该形参是对本类类型对象的引用(一般常用const修饰)，在用已存在的类类型对象创建新对象时由编译器自动调用。
特征
-
拷贝构造函数是构造函数的一个重载形式。拷贝构造函数的参数只有一个且必须是类类型对象的引用，使用传值方式编译器直接报错，因为会引发无穷递归调用。
-
若未显式定义，编译器会生成默认的拷贝构造函数。
-
默认的拷贝构造函数对象按内存存储按字节序完成拷贝，这种拷贝叫做浅拷贝，或者值拷贝。
-
编译器生成的默认拷贝构造函数已经可以完成字节序的值拷贝了, 当然像日期类这样的类是没必要的。
-
拷贝构造函数典型调用场景：
使用已存在对象创建新对象
函数参数类型为类类型对象
函数返回值类型为类类型对象
注意：在编译器生成的默认拷贝构造函数中，内置类型是按照字节方式直接拷贝的，而自定义类型是调用其拷贝构造函数完成拷贝的
注意：类中如果没有涉及资源申请时，拷贝构造函数是否写都可以；一旦涉及到资源申请时，则拷贝构造函数是一定要写的，否则就是浅拷贝。
一般显示写析构函数，就要写拷贝构造
为了提高程序效率，一般对象传参时，尽量使用引用类型，返回时根据实际场景，能用引用尽量使用引用。
浅拷贝-值拷贝
//拷贝构造
class Date
{
public:
Date(int year, int month, int day) {
_year = year;
_month = month;
_day = day;
}
//可不写，自动形成拷贝函数
Date(const Date& d) {//拷贝构造必须写引用 (加const)
_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,5,10);
Date d2(d1);
// Date d2 = d1;
}深拷贝
typedef int DataType;
class Stack
{
public:
Stack(size_t capacity = 4){
cout << "size_t capacity = 4" << endl;
_a = (DataType*)malloc(sizeof(DataType) * capacity);
if (nullptr == _a){
perror("malloc fail");
return;
}
_top = 0;
_capacity = capacity;
}
//拷贝构造——深拷贝
Stack(const Stack& st){
cout << "const Stack& st" << endl;
_a = (DataType*)malloc(sizeof(DataType) * st._capacity);
if (nullptr == _a){
perror("malloc fail");
return;
}
memcpy(_a, st._a, sizeof(DataType) * st._capacity);
_top = 0;
_capacity = st._capacity;
}
void Push(int x){
//
_a[_top++] = x;
}
int Top(){
return _a[_top - 1];
}
void Pop(){
_top--;
}
bool Empty(){
return _top == 0;
}
~Stack(){
cout << "~Stack" << endl;
if (_a) {
free(_a);
_a = nullptr;
_top = _capacity = 0;
}
}
private:
DataType* _a;
int _top;
int _capacity;
};
//不写拷贝构造——内置类型完成浅拷贝，自定义函数自动调用拷贝构造
//一般显示写析构函数，就要写拷贝构造
class MyQueue {
private:
Stack st1;
Stack st2;
int _size = 0;
};
int main()
{
Stack st1(10);
st1.Push(1);
st1.Push(1);
Stack st2 = st1;//不写拷贝构造——崩溃——原因：析构两次，浅拷贝/值拷贝，需要深拷贝
st1.Push(2);
while (!st2.Empty()) {
cout << st2.Top() << " ";
st2.Pop();
}
cout << endl;
while (!st1.Empty()) {
cout << st1.Top()<<" ";
st1.Pop();
}
cout << endl;
MyQueue q1;
MyQueue q2 = q1;
return 0;
}五. 运算符重载
赋值运算符重载的格式
运算符重载——operator
参数类型：const T&，传递引用可以提高传参效率
返回值类型：T& 返回引用可以提高返回效率，有返回值目的是为了支持连续赋值
检测是否自己赋值给自己
返回*this，要想复合连续赋值的含义
//返回值Date 需要支持连续的赋值
Date& operator=(const Date& d) {
//用地址判断防止自己与自己赋值
if (this != &d) {
_year = d._year;
_month = d._month;
_day = d._day;
}
//this是d3的地址，*this是d3
return *this;
}
int main()
{
Date d1;
Date d2;
Date d3;
d3=d2=d1;
return 0;
}赋值运算符只能重载成类的成员函数不能重载成全局函数
当重载成全局函数时，注意重载成全局函数时没有了this指针，需要给两个参数
class Date {
public:
Date(int year = 1900, int month = 1, int day = 1) {
_year = year;
_month = month;
_day = day;
}
//隐含的this是d1，d是d2
bool operator==(const Date& d) {
//return this->_year == d._year
// && this->_month== d._month
// && this->_day == d._day
return _year == d._year
&& _month == d._month
&& _day == d._day;
}
//private:
int _year;
int _month;
int _day;
};
//重载成全局，无法访问私有成员
//1.提供这些成员的get和set
//2.友元-类中的函数前加friend
//3.一般用 重载成 成员函数(优先去类中找)
//bool operator==(const Date& d1, const Date& d2) {
// return d1._year == d2._year
// &&d1._month == d2._month
// &&d1._day == d2._day;
//}我们可以重载赋值运算符，不论形参是什么类型，赋值运算符都必须定义为成员函数。
//显式调用
d1.operator==(d2);
//一般用 转换调用
d1 == d2;用户没有显示实现，编译器会生成一个默认赋值运算符，一致的形式逐字节拷贝
内置函数成员变量是可以直接赋值的，
class Date {
public:
Date(int year,int month,int day)
:_year(year)
,_month(month)
,_day(day)
{}
void Print() {
cout << _year << "-" << _month << "-" << _day << endl;
}
private:
int _year;
int _month;
int _day;
};
int main()
{
Date d1(2020,12,2);
d1.Print();//d1(2020,12,2)
Date d2(2021, 2, 2);
d1 = d2;
d1.Print();//d1(2021-2-2)
return 0;
}但是自定义类型的成员变量需要调用队形的复制运算符重载完成赋值
如果不涉及资源管理，赋值运算符是可以自动实现的，一旦涉及资源管理则必须显示实现
class Date {
public:
Date(int year = 1900, int month = 1, int day = 1) {
_year = year;
_month = month;
_day = day;
}
Date(const Date& d) {
cout << "const Date& d" << endl;
_year = d._year;
_month = d._month;
_day = d._day;
}
//d3 = d1
//返回值Date 需要支持连续的赋值
Date& operator=(const Date& d) {
//用地址判断防止自己与自己赋值
if (this != &d) {
_year = d._year;
_month = d._month;
_day = d._day;
}
//this是d3的地址，*this是d3
return *this;
}
void Print() {
cout << _year << "-" << _month << "-" << _day << endl;
}
~Date() {
cout << "~Date" << endl;
_year = -1;
_month = -1;
_day = -1;
}
private:
int _year;
int _month;
int _day;
};
Date func() {
Date d(2024, 5, 16);
return d;
}
Date& fx() {
//static修饰局部变量，生命周期延长到整个程序运行(从栈区改变到静态区)
static Date d(2024, 5, 15);
return d;
}
//传值返回——出作用域就销毁(生成当前对象的拷贝)
//引用返回——生成对象的别名——底层是指针
//出了作用域，返回对象还在没有析构，那就可以用引用返回，减少拷贝
//1.返回对象生命周期到了，会析构，传值返回
//2.返回对象生命周期没到，不会析构，引用返回
int main()
{
//拷贝构造
//一个已经存在的对象，拷贝给另一个要创建初始化的对象
Date d1(2024, 5, 11);
Date d2 = d1;
cout << endl;
Date d3(2024,5,12);
//赋值构造
//一个已经存在的对象，拷贝赋值给另一个已经存在的对象
d3 = d1;
d3 = d2 = d1;
//Date ref1 = func();
//ref1.Print();
//cout << endl;
//Date& ref2 = fx();
//ref2.Print();
return 0;
}日期类的实现
类与对象——运算符重载 · 6523418 · 孟俊浩/Cpp代码 - Gitee.com
流插入和流提取
//流插入
//不建议使用，因为Date* this占据了一个参数的位置，使用的d<<cout不符合习惯
//void Date::operator<<(ostream& out) {
// out << _year << "年" << _month << "月" << _day << "日" << endl;
//}
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;
}const 成员
将const修饰的“成员函数”称之为const成员函数，const修饰类成员函数，实际修饰该成员函数隐含的this指针，表明在该成员函数中不能对类的任何成员进行修改。
建议将所有不对本身修改的函数后都加上const
六. 取地址及const取地址操作符重载
这两个运算符一般不需要重载，使用编译器生成的默认取地址的重载即可，只有特殊情况，才需
要重载，比如想让别人获取到指定的内容！
class Date
{
public :
Date* operator&()
{
return this ;
}
const Date* operator&()const
{
return this ;
}
private :
int _year ;
int _month ;
int _day ;
};
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
