学习专栏:
《进击的C++》
在C++的学习中,类和对象章节的学习尤为重要,犹如坚固的地基,基础不牢,地动山摇;而默认成员函数的学习,在类和对象的学习里最为重要。所以要学好C++,学好默认成员函数是一道必经之路,这样后续才能很好的学习后续模板,继承,多态等知识。
如果一个类中什么成员都没有,简称为空类。
空类中真的什么都没有吗?并不是,任何类在什么都不写时,编译器会自动生成以下6个默认成员函数。
默认成员函数:用户没有显式实现,编译器会生成的成员函数称为默认成员函数。
先来简易实现一个日期类Date
class Date
{
public:
void Init(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;
d1.Init(2023, 12, 5);
d1.Print();
return 0;
}
我们发现,如果每次都要自己调用初始化函数,未免有点麻烦,并且容易忘记从而导致出错。那能否在对象创建时,就将信息设置进去呢?
那么,构造函数就可以完美解决这个问题。
构造函数(constructor)是一个特殊的成员函数,名字与类名相同,创建类类型对象时由编译器自动调用,以保证每个数据成员都有一个合适的初始值,并且在对象整个生命周期内只调用一次。
构造函数是特殊的成员函数,需要注意的是,构造函数虽然名称叫构造,但是构造函数的主要任务并不是开空间创建对象,而是初始化对象。
构造函数特性如下:
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;
}
void Print()
{
cout << _year << "-" << _month << "-" << _day << endl;
}
private:
int _year;
int _month;
int _day;
};
int main()
{
Date d1;//调用无参构造函数
d1.Print();
Date d2(2023, 12, 5);//调用带参构造函数
d2.Print();
//warning
Date d3();//函数声明
return 0;
}
注意:
上述简化写法:
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;
};
int main()
{
Date d1;
d1.Print();
Date d2(2023, 12, 5);
d2.Print();
return 0;
}
有人可能会疑惑,既然编译器会自动生成默认构造函数,那是不是就不用自己显式定义了呢?其实,并不然。
class Date
{
public:
void Print()
{
cout << _year << "-" << _month << "-" << _day << endl;
}
private:
int _year = 1;//声明时给默认值
int _month = 1;
int _day = 1;
};
int main()
{
Date d1;//调用默认构造函数
d1.Print();
return 0;
}
简单理解:不用传参,就是调用默认构造函数。
举个例子,请看下面代码:
class Date
{
public:
Date()
{
_year = 1;
_month = 1;
_day = 1;
}
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;
};
int main()
{
Date d1;//报错,对重载函数的调用不明确
d1.Print();
return 0;
}
分析:上述代码包含两个默认构造函数,在无参调用时,就会产生歧义。所以,才会规定一个类只能出现一个默认构造函数。
通过前面构造函数的学习,我们知道一个对象是怎么自动初始化的,那一个对象的内容又是如何自动销毁的呢?
析构函数(destructor):与构造函数功能相反,析构函数不是完成对对象本身的销毁,局部对象销毁工作是由编译器完成的。而对象在销毁时会自动调用析构函数,完成对象中资源的清理工作。
析构函数是特殊的成员函数,其特性如下:
简易实现一个栈类Stack
class Stack
{
public:
Stack(int capacity = 4)//构造函数
{
_a = (int*)malloc(sizeof(int) * capacity);
if (_a == nullptr)
{
perror("malloc fail");
return;
}
_top = 0;
_capacity = capacity;
}
void Push(int x)
{
//CheckCapacity();
_a[_top++] = x;
}
//...
~Stack()//析构函数
{
free(_a);
_a = nullptr;
_top = _capacity = 0;
}
private:
int* _a;
int _top;
int _capacity;
};
int main()
{
Stack st;
st.Push(1);
st.Push(2);
return 0;
}
回顾往期题目232.用栈实现队列(LeetCode),当时我们用C语言实现的队列,对比一下如今用C++实现。
C:
typedef struct
{
ST pushst;
ST popst;
} MyQueue;
MyQueue* myQueueCreate()
{
MyQueue* obj = (MyQueue*)malloc(sizeof(MyQueue));
if (obj == NULL)
{
perror("malloc fail");
return NULL;
}
STInit(&obj->pushst);
STInit(&obj->popst);
return obj;
}
C++:
class MyQueue
{
public:
void Push()
{}
//...
private:
Stack _pushst;
Stack _popst;
};
分析:
Date
类;有资源申请时,一定要写,否则会造成资源泄漏,比如Stack
类。在创建对象时,可否创建一个与已存在对象一模一样的新对象呢?
拷贝构造函数:只有单个形参,该形参是对本类类型对象的引用(一般常用const修饰),在用已存在的类类型对象创建新对象时由编译器自动调用。
拷贝构造函数也是特殊的成员函数,其特性如下:
class Date
{
public:
Date(int year = 1, int month = 1, int day = 1)
{
_year = year;
_month = month;
_day = day;
}
Date(const 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;
};
int main()
{
Date d1;
d1.Print();
Date d2(2023, 12, 5);
d2.Print();
Date d3(d2);//拷贝构造
d3.Print();
return 0;
}
大家可能会很疑惑,为什么只能是传引用,而不能是传值呢?
请看下面代码:
//传值传参
void Func1(Date d)
{}
//传引用传参
void Func2(Date& d)
{}
int main()
{
Date d;
Func1(d);//传值调用
Func2(d);//传引用调用
return 0;
}
经过调试,我们可以发现:在传值传参时,会调用拷贝构造函数;而在传引用传参时,并不需要。
那么,再看看写成传值传参的拷贝构造函数,是多么的恐怖。
Date(Date d)
{
_year = d._year;
_month = d._month;
_day = d._day;
}
分析:
那么,如果每次都直接使用默认生成的拷贝构造函数可以吗?答案是,当然不可以!
再来回顾一下栈类Stack
,试试默认生成的拷贝构造函数。
class Stack
{
public:
Stack(int capacity = 10)//构造函数
{
_a = (int*)malloc(sizeof(int) * capacity);
if (_a == nullptr)
{
perror("malloc fail");
return;
}
_top = 0;
_capacity = capacity;
}
void Push(int x)
{
//CheckCapacity();
_a[_top++] = x;
}
//...
~Stack()//析构函数
{
free(_a);
_a = nullptr;
_top = _capacity = 0;
}
private:
int* _a;
int _top;
int _capacity;
};
int main()
{
Stack s1;
s1.Push(1);
s1.Push(2);
s1.Push(3);
s1.Push(4);
Stack s2(s1);
return 0;
}
运行的时候会发现,上述程序会崩溃,这是为什么呢?
分析:
那么,这种情况就不是浅拷贝能解决的了,则必须显式定义拷贝构造函数进行深拷贝
深拷贝实现如下:
typedef int DataType;
class Stack
{
public:
Stack(int capacity = 4)
{
_a = (DataType*)malloc(capacity * sizeof(DataType));
if (_a == nullptr)
{
perror("malloc fail");
exit(-1);
}
_top = 0;
_capacity = capacity;
}
Stack(const Stack& st)//深拷贝
{
_a = (DataType*)malloc(st._capacity * sizeof(DataType));
if (_a == nullptr)
{
perror("malloc fail");
exit(-1);
}
_top = st._top;
_capacity = st._capacity;
}
~Stack()
{
free(_a);
_a = nullptr;
_top = _capacity = 0;
}
private:
DataType* _a;
int _top;
int _capacity;
};
内置类型可以直接使用运算符,那么自定义类型是否能使用运算符呢?
C++为了增强代码的可读性引入了运算符重载,运算符重载是具有特殊函数名的函数,也具有其返回值类型,函数名字以及参数列表,其返回值类型与参数列表与普通的函数类似。
函数名:关键字operator后面接需要重载的运算符符号。
函数原型:返回值类型 operator操作符(参数列表)
class Date
{
public:
Date(int year = 1, int month = 1, int day = 1)
{
_year = year;
_month = month;
_day = day;
}
//private:
int _year;
int _month;
int _day;
};
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;
Date d2(d1);
operator==(d1, d2);//一般不这样写
d1 == d2;//等价于上述函数调用
cout << (d1 == d2) << endl;
return 0;
}
这里,我们是直接将private取消,才让外部函数可以访问类的内置类型。但是,这样封装性又得不到保证了。
所以,我们可以把运算符重载定义为成员函数。
class Date
{
public:
Date(int year = 1, int month = 1, int day = 1)
{
_year = year;
_month = month;
_day = day;
}
// bool operator==(Date* this, const Date& d2)
// 这里需要注意的是,左操作数是this,指向调用函数的对象
bool operator==(const Date& d)
{
return _year == d._year
&& _month == d._month
&& _day == d._day;
}
private:
int _year;
int _month;
int _day;
};
int main()
{
Date d1;
Date d2(d1);
d1.operator==(d2);//一般不这样写
d1 == d2;//等价于上述写法
return 0;
}
注意:
.*
、::
、 sizeof
、 ?:
、 .
注意以上5个运算符不能重载。这个经常在笔试选择题中出现。前面讲完了运算符重载的前置知识,那么我们就来实现d1 = d2这样的赋值操作
赋值运算符重载格式
class Date
{
public:
Date(int year = 1, int month = 1, int day = 1)
{
_year = year;
_month = month;
_day = day;
}
void operator=(const Date& d)
{
_year = d._year;
_month = d._month;
_day = d._day;
}
private:
int _year;
int _month;
int _day;
};
int main()
{
Date d1(2022, 10, 24);
Date d2(2023, 5, 3);
d1 = d2;
return 0;
}
但是,要注意到赋值运算符的特殊场景
所以,我们有以下改进版本:
Date& operator=(const Date& d)
{
if (this != &d)
{
_year = d._year;
_month = d._month;
_day = d._day;
}
return *this;
}
注意:
#pragma once
#include
using namespace std;
class Date
{
friend ostream& operator<<(ostream& out, const Date& d)
{
out << d._year << "/" << d._month << "/" << d._day << endl;
return out;
}
friend istream& operator>>(istream& in, Date& d)
{
in >> d._year >> d._month >> d._day;
return in;
}
public:
Date(int year = 1, int month = 1, int day = 1);
void Print();
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);
Date& operator=(const Date& d);
Date& operator+=(int day);
Date operator+(int day);
Date& operator-=(int day);
Date operator-(int day);
int operator-(const Date& d);
Date& operator++();
Date operator++(int);
Date& operator--();
Date operator--(int);
private:
int _year;
int _month;
int _day;
};
#define _CRT_SECURE_NO_WARNINGS 1
#include"date.h"
int GetMonthDay(int year, int month)
{
int a[] = { 0,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;
}
return a[month];
}
Date::Date(int year, int month, int day)
{
if((month > 0 && month <= 12) && (day > 0 && day <= GetMonthDay(year, month)))
{
_year = year;
_month = month;
_day = day;
}
else
{
cout<<"日期非法"<<endl;
}
}
void Date::Print()
{
cout << _year << "/" << _month << "/" << _day << endl;
}
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)
{
return _year < d._year
|| (_year == d._year && _month < d._month)
|| (_year == d._year && _month == d._month && _day < d._day);
}
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);
}
Date& Date::operator=(const Date& d)
{
if (this != &d)
{
_year = d._year;
_month = d._month;
_day = d._day;
}
return *this;
}
//d1+=100
Date& Date::operator+=(int day)
{
if (day < 0)
{
*this -= -day;
return *this;
}
_day += day;
while (_day > GetMonthDay(_year, _month))
{
_day -= GetMonthDay(_year, _month);
_month++;
if (_month == 13)
{
_year++;
_month = 1;
}
}
return *this;
}
//d1+100
Date Date::operator+(int day)
{
Date tmp(*this);
tmp += day;
return tmp;
}
//d1-=100
Date& Date::operator-=(int day)
{
if (day < 0)
{
*this += -day;
return *this;
}
_day -= day;
while (_day <= 0)
{
_day += GetMonthDay(_year, _month);
_month--;
if (_month == 0)
{
_year--;
_month = 12;
}
}
return *this;
}
//d1-100
Date Date::operator-(int day)
{
Date tmp(*this);
tmp -= day;
return tmp;
}
//d1-d2
int Date::operator-(const Date& d)
{
Date max = *this;
Date min = d;
int flag = 1;
if (max < min)
{
max = d;
min = *this;
flag = -1;
}
int i = 0;
while (min != max)
{
++min;
++i;
}
return i * flag;
}
//++d1
Date& Date::operator++()
{
*this += 1;
return *this;
}
//d1++
Date Date::operator++(int)
{
Date tmp(*this);
*this += 1;
return tmp;
}
//--d1
Date& Date::operator--()
{
*this -= 1;
return *this;
}
//d1--
Date Date::operator--(int)
{
Date tmp(*this);
*this -= 1;
return tmp;
}
将const修饰的“成员函数”称之为const成员函数,const修饰类成员函数,实际修饰该成员函数隐含的this指针,表明在该成员函数中不能对类的任何成员进行修改。
举个例子:
class Date
{
public:
void Print()
{
cout << _year << "" << _month << "" << _day << endl;
}
private:
int _year = 1;
int _month = 1;
int _day = 1;
};
void Func(const Date& d)
{
d.Print();//err
}
int main()
{
Date d1;
Func(d1);
return 0;
}
分析:上述代码在Func函数内部(常引用,const修饰),调用Print函数(this指针没有const修饰),造成权限的放大,所以编译器报错。
那么,我们应该怎么做呢?
我们无法显式修饰const,所以语法规定了一种写法——在成员函数名后接const
class Date
{
public:
void Print() const
{
cout << _year << "" << _month << "" << _day << endl;
}
private:
int _year = 1;
int _month = 1;
int _day = 1;
};
注意:只对功能不改变对象本身的成员函数,进行const修饰。
那么请思考下面的几个问题:
下面是日期类实现中,const修饰后的版本:
class Date
{
public:
Date(int year = 1, int month = 1, int day = 1);
void Print() const;
bool operator==(const Date& d) const;
bool operator!=(const Date& d) const;
bool operator<(const Date& d) const;
bool operator<=(const Date& d) const;
bool operator>(const Date& d) const;
bool operator>=(const Date& d) const;
Date& operator=(const Date& d);
Date& operator+=(int day);
Date operator+(int day) const;
Date& operator-=(int day);
Date operator-(int day) const;
int operator-(const Date& d) const;
Date& operator++();
Date operator++(int);
Date& operator--();
Date operator--(int);
private:
int _year;
int _month;
int _day;
};
注意:声明与定义分离时,两边都要加上const修饰
这两个默认成员函数一般不用重新定义 ,编译器默认会生成。
class Date
{
public:
Date* operator&()
{
return this;
}
const Date* operator&() const
{
return this;
}
private:
int _year = 1;
int _month = 1;
int _day = 1;
};
int main()
{
Date d1;
cout << &d1 << endl;
const Date d2;
cout << &d2 << endl;
return 0;
}
这两个运算符一般不需要重载,使用编译器生成的默认取地址的重载即可,只有特殊情况,才需要重载,比如想让别人获取到指定的内容!
本节学习了类的6个默认成员函数,详细了解其中的特性与使用方法。
看到这里了还不给博主扣个:
⛳️ 点赞☀️收藏 ⭐️ 关注!
❤️
拜托拜托这个真的很重要!
你们的点赞就是博主更新最大的动力!
有问题可以评论或者私信呢秒回哦。