【C++】类和对象【中】
目录
1.类的6个默认成员函数
如果一个类中什么成员都没有，简称空类
空类并不是什么都没有，编译器会自动生成6个默认成员函数。
默认成员函数：用户没有显式实现，编译器会生成的成员函数称为默认成员函数
?2.构造函数
2.1 概念
构造函数时一个特殊的成员函数，名字与类名相同，创建类类型对象时由编译器自动调用，以保证每个数据成员都有一个合适的初始值，并且在对象整个生命周期内只调用一次
class Date
{
public:
//无参构造
Date()
{
_year = 1;
_month = 2;
_day = 1;
}
//有参构造
Date(int year, int month, int day)
{
_year = year;
_month = month;
_day = day;
}
//全缺省的构造函数
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, 8, 2);//调用有参构造
d2.Print();
return 0;
}注意：如果通过无参构造函数创建对象时，对象后面不用跟括号，否则就变成了函数声明
Date d1();//这种写法是错误的
Date func();//函数声明
由于编译器会把它当成函数声明，所以通过无参构造函数创建对象时，不要加上括号
2.2 特性
构造函数是特殊的成员函数，需要注意的时，构造函数虽然名称叫构造，但是构造函数的主要任务并不是开空间创建对象，而是初始化对象
其特征如下：
1.函数名与类名相同
2.无返回值
3.对象实例化时编译器自动调用对应的构造函数
4.构造函数可以重载（本质就是我们可以写多个构造函数，提供多种初始化方式）
5.如果类中没有显式定义构造函数，则C++编译器会自动生成一个无参的默认构造函数，一旦用户显式定义编译器将不再生成
6.C++把类型分为内置类型（基本类型）和自定义类型。内置类型就是语言提供的数据类型，如 : int/char...,【注意：只要是指针就是内置类型】自定义类型就是我们使用class/struct/union等自己定义的类型，对自定义类型成员会自动调用它的默认构造函数；如果内置类型和自定义类型放在同一个类中，对于自定义类型不提供默认构造不会进行处理，需要使用初始化列表对自定义类型进行初始化
注意：C++11支持内置类型成员变量在类中声明时可以给默认值
7.无参的构造函数和全缺省的构造函数都称为默认构造函数，并且默认构造函数只能有一个。注意：无参构造函数、全缺省构造函数、我们没写编译器默认生成的构造函数，都可以认为是默认构造函数
总结：一般情况需要我们自己写构造函数，决定初始化方式，如果成员变量全是自定义类型可以考虑不写构造函数
3.析构函数
3.1 概念
析构函数:与构造函数功能相反，析构函数不是完成对对象本身的销毁,局部对象销毁工作是由编译器完成的。而对象在销毁时会自动调用析构函数，完成对象中资源的清理工作。
析构函数是特殊的成员函数,其特征如下:
1.析构函数名是在类名前加上字符~。
2.无参数无返回值类型。
3.一个类只能有一个析构函数。若未显式定义，系统会自动生成默认的析构函数。注意:析构函数不能重载
默认的析构函数-->内置类型的成员，不做处理；自定义类型的成员，会调用自定类型成员的析构
4.对象生命周期结束时, C++编译系统系统自动调用析构函数。
5.编译器生成的默认析构函数，对自定义类型成员调用它的析构函数
6.如果类中没有申请资源时，析构函数可以不写，可以直接使用编译器生成的默认析构函数；若有资源申请时，一定要写，否则会造成资源泄露
?析构顺序：数据都是存在函数栈帧中的，所以数据必须是先进后出，所以析构的顺序也是后进去的先析构，先进去的后析构
注意：一个类中既有内置类型又有自定义类型时，并且我们给自定义类型写有参数构造，此时编译器不会生成默认构造函数，就不会调用它的默认构造，当调用这个类（有内置类型和自定义类型）创建的对象时，系统会报错，解决方式：一种使用初始化列表的方式，另一种是给有参构造改为全缺省的构造函数。
栈类
class Stack
{
public:
Stack()
{
a = NULL;
capacity = size = 0;
}
~Stack()
{
cout << "~Stack()" << endl;
free(a);
a = NULL;
capacity = size = 0;
}
bool Empty()
{
return size == 0;
}
void Push(DataType x)
{
if (capacity == size)
{
int newCapacity = capacity == 0 ? 4 : capacity * 2;
DataType* tmp = (DataType*)realloc(a, sizeof(DataType) * newCapacity);
if (tmp == NULL)
{
perror("realloc fail");
return;
}
a = tmp;
capacity = newCapacity;
}
a[size++] = x;
}
void Pop()
{
assert(!Empty());
size--;
}
DataType Top()
{
assert(!Empty());
return a[size - 1];
}
int Size()
{
return size;
}
private:
DataType* a;
int capacity;
int size;
};对于有资源申请的类，比如栈类，一定要自己写析构函数，否则会出现下面这样的错误
浅拷贝问题（值拷贝）
两个对象中的_a是指向同一块儿空间，当main函数结束会分别调用析构函数，这块儿空间会被释放两次，所以会出现错误。
解决办法：
深拷贝
4.拷贝构造
4.1 概念
拷贝构造函数：只有单个形参，该形参是对本类类型对象的引用（一般常用const修饰），在用已存在的类类型对象创建新对象时由编译器自动调用
一个对象再给另外一个对象赋值的时候就会调用拷贝构造
4.2特征
拷贝构造函数也是特殊的成员函数，其特征如下：
1.拷贝构造函数是构造函数一个重载形式
2.拷贝构造函数的参数只有一个且必须是类类型对象【同类型的对象】的引用，使用传值方式编译器直接报错，因为会引发无穷递归调用
class Date
{
public:
//无参构造
Date()
{
_year = 1;
_month = 2;
_day = 1;
}
//拷贝构造
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;
Date d2(d1);
return 0;
}?会引发向下图的无穷递归
3.若未显式定义，编译器会生成默认的拷贝构造函数。默认的拷贝构造函数对象按内存存储按字节序完成拷贝，这种拷贝叫做浅拷贝，或者是值拷贝
注意：在编译器生成的默认拷贝构造函数中，内置类型是按照字节序方式直接拷贝的，而自定义类型是调用其拷贝构造函数完成拷贝的
4.编译器生成的默认拷贝构造函数已经可以完成字节序的值拷贝
5.拷贝构造函数典型调用场景
使用已存在对象创建新对象
函数参数类型为类类型对象?
函数返回值类型为类类型对象
自定义类型传值传参必须要调用拷贝构造，如果不调用就会发生浅拷贝问题【析构函数被多次调用，一块儿空间被多次释放，这是不允许的】
为了提高程序效率，一般对象传参时，尽量使用引用类型，返回时根据实际场景，能用引用尽量使用引用
我们不写拷贝构造函数，编译器默认生成的拷贝构造，跟之前的构造函数特性是不一样的
1.内置类型-->进行值拷贝
2.自定义类型-->调用自定义类型的拷贝构造
总结：Date类不需要我们实现拷贝构造，默认生成就可以用
? ? ? ? ? ?Stack类需要我们自己是实现拷贝构造【深拷贝】，默认生成的会将一块儿空间释放多次会出问题
5.赋值运算符重载
5.1运算符重载
C++为了增强代码的可读性引入了运算符重载，运算符重载是具有特殊函数名的函数，也具有其返回值类型，函数名字以及参数列表
函数名字为： 关键字operator后面接需要重载的运算符符号
函数原型：返回值类型 operator操作符（参数列表）
注意：
- 不能通过连接其他符号来创建新的操作符：比如operator@
- 重载操作符必须有一个类类型
- 用于内置类型的运算符，其含义不能改变，例如：内置的整型+，不能改变其含义
- 作为类成员函数重载是，其形参看起来比操作数数目少1，因为成员函数的第一个参数为隐藏的this
- “ . ”、“? ：：”、“ sizeof ”、“ ？：”，“ .* ”注意以上五个运算符不能重载
- 不能改变操作符的操作数个数，比如+是有两个操作数，不能将它改变为一个操作数的；一个操作符是几个操作数，那么重载的时候就有几个参数
5.2 赋值运算符重载
1、赋值运算符重载格式：
参数类型： const T& ，传递引用可以提高传参效率
返回值类型： T&，返回引用可以提高返回的效率，有返回值目的是为了支持连续赋值
检测是否自己给自己赋值
返回*this：要复合连续赋值的含义
2、赋值运算符只能重载成类的成员函数不能重载成全局函数，赋值运算符重载成全局函数，此时没有this指针，需要两个参数
原因：赋值运算符如果不显示实现，编译器会生成一个默认的。此时用户要再类外自己实现一个全局的赋值运算符重载，就和编译器再类中生成的默认赋值运算符重载冲突了，故赋值运算符重载只能是类的成员函数
3、用户没有显式实现时，编译器会生成一个默认赋值运算符重载，以值得方式逐字节拷贝。
注意：内置类型成员变量是直接赋值的，而自定义类型成员变量需要调用对应类的赋值运算符重载完成赋值
6.日期类
#include <iostream>
using namespace std;
class Date
{
public:
//获取某年某月的天数
int GetMonthDay(int year, int month)
{
int arr[13] = { 0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
if (month == 2 &&
((year % 100 != 0 && year % 4 == 0) || (year % 400 == 0)))
{
arr[month] = 29;
}
return arr[month];
}
//全缺省的构造函数
Date(int year = 1900, int month = 1, int day = 1)
{
_year = year;
_month = month;
_day = day;
}
//拷贝构造函数
Date(const Date& rd)
{
_year = rd._year;
_month = rd._month;
_day = rd._day;
}
//赋值运算符重载
Date& operator=(const Date& d)
{
//cout << "Date& operator=(const Date& d)" << endl;
if (*this != d)
{
this->_year = d._year;
this->_month = d._month;
this->_day = d._day;
}
return *this;
}
void Print()
{
cout << _year << "年" << _month << "月" << _day << "日" << endl;
}
//析构函数
~Date()
{
_year = 0;
_month = 0;
_day = 0;
}
//日期 += 天数
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;
}
//日期 + 天数
Date operator+(int day)
{
Date tmp(*this);
tmp += day;
return tmp;
}
日期 + 天数
//Date operator+ (int day)
//{
// Date tmp(*this);
// tmp._day += day;
// while (tmp._day > GetMonthDay(tmp._year, tmp._month))
// {
// tmp._day -= GetMonthDay(tmp._year, tmp._month);
// tmp._month++;
// if (tmp._month == 13)
// {
// tmp._year++;
// tmp._month = 1;
// }
// }
// return tmp;
//}
//Date& operator+=(int day)
//{
// *this = *this + day;
// return *this;
//}
// 日期 - 天数
Date operator-(int day)
{
Date tmp(*this);
tmp -= day;
return tmp;
}
//日期 -= 天数
Date& operator-=(int day)
{
if (day < 0)
{
return *this += (-day);
}
_day -= day;
while (_day < 1)
{
_month--;
if (_month < 1)
{
_year--;
_month = 12;
}
_day += GetMonthDay(_year, _month);
}
return *this;
}
//前置++ ++d1
Date& operator++()
{
*this += 1;
return *this;
}
//后置++ d1++
Date operator++(int)
{
Date tmp(*this);
*this += 1;
return tmp;
}
后置-- d1--;
Date operator--(int)
{
Date tmp(*this);
*this -= 1;
return tmp;
}
前置--
Date& operator--()
{
*this -= 1;
return *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;
}
//==运算符重载
bool operator==(const Date& d)
{
return this->_year == d._year
&& this->_month == d._month
&& this->_day == d._day;
}
//>= 运算符重载
bool operator>=(const Date& d)
{
if (*this > d || *this == d)
{
return true;
}
return false;
}
//<运算符重载
bool operator<(const Date& d)
{
if (*this == d||*this>d)
{
return false;
}
return true;
}
//<=运算符重载
bool operator<=(const Date& d)
{
if (*this > d)
{
return false;
}
return true;
}
// != 运算符重载
bool operator != (const Date& d)
{
return !(*this == d);
}
//日期-日期 得到之间相差的天数
int 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;
}
private:
int _year;
int _month;
int _day;
};7.const成员
将const修饰的“成员函数”称之为cons成员函数，const修饰类成员函数，实际修饰该成员函数隐含的this指针，表明再该成员函数中不能对类的任何成员进行修改。
思考：
const对象可以调用非const成员函数吗？
非const对象可以调用const成员函数吗？
const成员函数内可以调用其他的非const成员函数吗？
非const成员函数内可以调用其他的const成员函数吗？
const对象不可以调用非const成员函数-->权限放大
非const对象可以调用const成员函数-->权限缩小
const成员函数不可以调用其他的非const成员函数-->权限放大
非const成员函数内可以调用其他的const成员函数-->权限缩小
我们之前讲过权限可以平移，可以缩小，但是权限不可以放大
8.取地址及const取地址操作符重载
这两个默认成员函数一般不用重新定义，编译器一般会默认生成
#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
using namespace std;
class Date
{
public:
Date* operator& ()
{
return this;
}
const Date* operator&()const
{
return this;
}
private:
int _year;
int _month;
int _day;
};本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。 如若内容造成侵权/违法违规/事实不符，请联系我的编程经验分享网邮箱：chenni525@qq.com进行投诉反馈，一经查实，立即删除！
- Python教程
- 深入理解 MySQL 中的 HAVING 关键字和聚合函数
- Qt之QChar编码（1）
- MyBatis入门基础篇
- 用Python脚本实现FFmpeg批量转换
- ssh免密登录 ssh公钥分发 ssh密钥生成
- 操作系统--磁盘存储器的管理
- 基于Python的线上兼职平台系统的设计与实现-计算机毕业设计源码83320
- 怎么选择一款好用的ERP企业管理软件？看这六点就够了！
- [python]注释
- 如何在 Windows 10、11 上恢复删除、未保存或覆盖的 Excel 文件？
- 机器学习之卡方分布
- 一键在线获取APP公钥、包名、签名及备案信息方法介绍
- 【JS笔记】JavaScript语法 《基础+重点》 知识内容，快速上手（二）
- DP数字三角形模型