【C++】类和对象(中篇)
几个成员函数
-
- 类的6个默认成员函数
- 构造函数
-
- 引例
- 特点
- 析构函数
-
- 概念
- 特点
- 拷贝构造函数
-
- 概念
- 特征
- 赋值运算符重载
-
- 赋值运算符重载
- 赋值运算符只能重载成类的成员函数不能重载成全局函数
- 前置++和后置++重载
- 日期类的实现
- const成员函数
- 取地址及const取地址操作符重载
类的6个默认成员函数
如果一个类中什么成员都没有，简称为空类。
空类中真的什么都没有吗？并不是，任何类在什么都不写时，编译器会自动生成以下6个默认成员函数。
默认成员函数：用户没有显式实现，编译器会生成的成员函数称为默认成员函数。
构造函数
引例
先写一个简单的例子：
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(2022, 7, 5);
d1.Print();
Date d2;
d2.Init(2022, 7, 6);
d2.Print();
return 0;
}
当我们还不知道构造函数是什么的时候，如果想要对一个类对象进行初始化操作，要么是向上面这样写一个公共的初始化的成员函数，要么就是将成员变量设置为公有的，在类外进行初始化。但是这些方法都有一些弊端，这时候就可以用到构造函数。
构造函数是一个特殊的成员函数，名字与类名相同,创建类类型对象时由编译器自动调用，以保证每个数据成员都有 一个合适的初始值，并且在对象整个生命周期内只调用一次。
特点
构造函数是特殊的成员函数，需要注意的是，构造函数虽然名称叫构造，但是构造函数的主要任务并不是开空间创建对象，而是初始化对象。
其特征如下：
- 函数名与类名相同。
- 无返回值。
- 对象实例化时编译器自动调用对应的构造函数。
- 构造函数可以重载。
来点例子：
直接初始化成0，但一般不用
这里给了参数，但是也不推荐用
全缺省构造，这个最推荐
全缺省用起来非常方便。
注意：如果通过无参构造函数创建对象时，对象后面不用跟括号，否则就成了函数声明。
上面直接把d1当成函数声明了。所以定义类对象的时候不能在后面跟上空括号。
- 如果类中没有显式定义构造函数，则C++编译器会自动生成一个无参的默认构造函数，一旦用户显式定义编译器将不再生成。
class Date
{
public:
int GetYear()
{
return _year;
}
int GetMonth()
{
return _month;
}
int GetDay()
{
return _day;
}
private:
int _year;
int _month;
int _day;
};
int main()
{
Date d1;
cout << d1.GetYear() << endl;
return 0;
}
我写下上面的代码，其中并没有给出构造函数。但是会自动生成一个默认构造函数。
这时候我们用Date创建对象时就相当于平常我们的int a；这种操作，不会对d1中的成员变量赋值，打印出来的是随机值。
- 关于编译器生成的默认成员函数，很多人会有疑惑：不实现构造函数的情况下，编译器会生成默认的构造函数。但是看起来默认构造函数又没什么用？d对象调用了编译器生成的默认构造函数，但是d对象_year/_month/_day，依旧是随机值。也就说在这里编译器生成的默认构造函数并没有什么用？？
解答：C++把类型分成内置类型(基本类型)和自定义类型。内置类型就是语言提供的数据类型，如：int/char…，自定义类型就是我们使用class/struct/union等自己定义的类型，看看下面的程序，就会发现编译器生成默认的构造函数会对自定类型成员_t调用的它的默认成员函数。
默认构造函数对内置类型（包括任意类型的指针）不做处理，对于自定义类型的成员，会去调用他的默认构造函数。如果没有默认构造函数的话会报错。
注意：C++11 中针对内置类型成员不初始化的缺陷，又打了补丁，即：内置类型成员变量在类中声明时可以给默认值。
像下面这样：
注意上面可不是在定义变量，而是直接给默认值。
- 无参的构造函数和全缺省的构造函数都称为默认构造函数，并且默认构造函数只能有一个。
注意：无参构造函数、全缺省构造函数、我们没写编译器默认生成的构造函数，都可以认为是默认构造函数。
但是全缺省构造函数和无参构造函数不能同时出现，不然调用的时候会出现歧义。
简单总结一下：
- 一般在写类的时候都不会让编译器生成默认构造函数，都会自己写，显示写一个全缺省，会好用很多。
- 特殊情况才会有默认构造函数，比如说上面的Date带Time的例子。
析构函数
概念
通过前面构造函数的学习，我们知道一个对象是怎么来的，那一个对象又是怎么没呢的？
析构函数：与构造函数功能相反，析构函数不是完成对象本身的销毁，局部对象销毁工作是由编译器完成的。而对象在销毁时会自动调用析构函数，完成对象中资源的清理工作。
特点
析构函数是特殊的成员函数，其特征如下：
- 析构函数名是在类名前加上字符 ~。
- 无参数无返回值类型。
- 一个类只能有一个析构函数。若未显式定义，系统会自动生成默认的析构函数。注意：析构函数不能重载。
- 对象生命周期结束时，C++编译系统系统自动调用析构函数。
class Stack
{
public:
Stack(int capacity = 3)
{
_data = (int*)malloc(sizeof(int) * capacity);
if (_data == NULL)
{
printf("malloc fail\n");
exit(-1);
}
_capacity = capacity;
_top = 0;
}
~Stack()
{
cout << "~Stack()" << endl;
free(_data);//最重要的是这个
_capacity = 0;//下面这两条 _size 和 _top 语句要不要是无所谓的
_top = 0;
}
private:
int* _data;
int _capacity;
int _top;
};
int main()
{
Stack s;
return 0;
}
- 关于编译器自动生成的析构函数，是否会完成一些事情呢？下面的程序我们会看到，编译器生成的默认析构函数，对自定类型成员调用它的析构函数。
class Time
{
public:
~Time()
{
cout << "~Time" << endl;
}
private:
int _hour;
int _minute;
int _second;
};
class Date
{
private:
// 基本类型(内置类型)
int _year;
int _month;
int _day;
// 自定义类型
Time _t;
};
int main()
{
Date d1;
return 0;
}
结果是这样的：
析构函数处理类型时，对于内置类型不处理(指针不敢随便处理)，自定义类型会去调用其析构(不管是默认的还是自定义的)。
- 如果类中没有申请资源时，析构函数可以不写，直接使用编译器生成的默认析构函数，比如Date类；有资源申请时，一定要写，否则会造成资源泄漏，比如Stack类
拷贝构造函数
概念
在现实生活中，可能存在一个与你一样的自己，我们称其为双胞胎。
那在创建对象时，可否创建一个与已存在对象一某一样的新对象呢？
拷贝构造函数：只有单个形参，该形参是对本类类型对象的引用(一般常用const修饰)，在用已存在的类类型对象创建新对象时由编译器自动调用。
特征
拷贝构造函数也是特殊的成员函数，其特征如下：
- 拷贝构造函数是构造函数的一个重载形式。
- 拷贝构造函数的参数只有一个且必须是类类型对象的引用，使用传值方式编译器直接报错，因为会引发无穷递归调用。
先看一下长啥样：
其实也可以传指针，但是调用拷贝构造函数的时候会比较别扭：
第二点
这里拷贝构造函数如果传值的话，传参数也是拷贝，又要调用拷贝构造函数。。。这样下去就会不断递归。
- 若未显式定义，编译器会生成默认的拷贝构造函数。 默认的拷贝构造函数对象按内存存储按字节序完成拷贝，这种拷贝叫做浅拷贝，或者值拷贝。
class Date
{
public:
void show()
{
cout << _year << "/" << _month << "/" << _day << endl;
}
Date(int year = 2023, int month = 5, int day = 4)
{
_year = year;
_month = month;
_day = day;
}
private:
int _year;
int _month;
int _day;
};
int main()
{
Date d1(2022, 5);
d1.show();
Date d2 = d1;
d2.show();
return 0;
}
结果：
这里虽然是正确的，但是当我们在使用一些会动态开辟内存的类的时候会导致两个类中的成员变量指向同一块空间，在最后调用析构函数的时候就会释放两次某一块动态开辟的空间，这样就会出问题。
程序直接崩掉了。
注意：类中如果没有涉及资源申请时，拷贝构造函数是否写都可以；一旦涉及到资源申请时，则拷贝构造函数是一定要自己写的，否则就是浅拷贝。
这种情况就是浅拷贝的情况。以后再讲深拷贝。
- 拷贝构造函数典型调用场景：
使用已存在对象创建新对象
函数参数类型为类类型对象
函数返回值类型为类类型对象
class Date
{
public:
Date(int year, int minute, int day)
{
cout << "Date(int,int,int):" << this << endl;
}
Date(const Date& d)
{
cout << "Date(const Date& d):" << this << endl;
}
~Date()
{
cout << "~Date():" << this << endl;
}
private:
int _year;
int _month;
int _day;
};
Date Test(Date d)
{
Date temp(d);
return temp;
}
int main()
{
Date d1(2022, 1, 13);
Test(d1);
return 0;
}
赋值运算符重载
讲赋值重载前，先说一个例子，当我们想要比较两个整数是否相等的时候可以直接用==来判断，但是判断两个日期是否相等的时候，是无法直接用==来判断的，这时候就需要用到运算符重载了，重载之后的==就可以直接进行判断。类似的，我们还可以比较大小、某个日期加上100天后的日期，某天到某天一共有多少天等等。这些都可以通过运算符重载来实现。
C++为了增强代码的可读性引入了运算符重载，运算符重载是具有特殊函数名的函数，也具有其返回值类型，函数名字以及参数列表，其返回值类型与参数列表与普通的函数类似。
函数名字为：关键字 operator 后面接需要重载的运算符符号。
函数原型：返回值类型 operator操作符(参数列表)
注意事项
不能通过连接其他符号来创建新的操作符：比如operator@
重载操作符必须有一个类类型参数
用于内置类型的运算符，其含义不能改变，例如：内置的整型+，不能改变其含义
作为类成员函数重载时，其形参看起来比操作数数目少1，因为成员函数的第一个参数为隐藏的this
.*（这是一个运算符） :: sizeof ? :（这是三目运算符）. 注意以上5个运算符不能重载。
给个例子：
当我们要判断两个日期是否相等的时候：
可以写在类内：
bool operator==(const Date& date)
{
return _year == date._year &&
_month == date._month &&
_day == date._day);
}
两种调用方法，可以直接调用函数，也可以直接调用重载的符号。
也可写在类外，参数就需要设置两个Date类了，而且需要在类内搞函数来获取日期，或者将成员变量设置为公有的。很简单，这里我就不写了。
赋值运算符重载
赋值运算符重载格式
参数类型：const T&，传递引用可以提高传参效率
返回值类型：T&，返回引用可以提高返回的效率，有返回值目的是为了支持连续赋值
检测是否自己给自己赋值
返回*this ：要符合连续赋值的含义
挨个来说。
先说效率高的问题。
参数：
参数为传值（会调用拷贝构造）
参数为引用（不会调用拷贝构造）
返回值：
返回值为传值（会调用拷贝）
返回值为传引用（不会调用拷贝）
再把两个都和到一块看看：
参数和返回值都为传值：
参数和返回值都为引用（一次拷贝都不会调用）
总结下：就是传值的时候会调用拷贝构造函数，影响了整体的速度。但是传引用不会调用拷贝构造函数，而且传引用对结果不会造成影响，所以用引用好。
再说返回值目的是为了支持连续赋值，先给例子：
如果返回值是void，仍然可以赋值：
但是，不能连续赋值。
但是我们平常的内置类型是能够做到的：
而我们重载的赋值运算符就相当于一个成员函数，是可以有返回值的。
所以我们可以给一个返回值来实现连续赋值的功能。
这个就解释到这。
检测是否自己给自己赋值
这个很简单，就是我们自己觉得不会出现这样的情况，可以说是几乎不可能发生的事情，但是如果发生了，就没必要再去挨个赋值了，这样能稍微提高一点效率。
返回*this ：要符合连续赋值的含义
就是第二点的解释。
赋值运算符只能重载成类的成员函数不能重载成全局函数
给个例子：
赋值运算符如果不显式实现，编译器会生成一个默认的。此时用户再在类外自己实现一个全局的赋值运算符重载，就和编译器在类中生成的默认赋值运算符重载冲突了，故赋值运算符重载只能是类的成员函数。
若用户未在类内显示实现赋值运算符，编译器会自动生成一个默认赋值运算符的重载，以值的方式逐字拷贝。在调用赋值运算符的时候内置类型成员变量会直接赋值，自定义类型成员变量要调用对应的赋值运算符重载，有动态内存开辟的才需要自己写赋值重载。这一点与拷贝构造函数一致。
比如说，栈：
int main()
{
Stack s1;
s1.Push(1);
s1.Push(2);
s1.Push(3);
s1.Push(4);
Stack s2;
s2 = s1;
return 0;
}
这里就涉及到了动态内存开辟，也就是深浅拷贝的问题。
跟拷贝构造一样，深拷贝以后讲。
最后声明一点：
前置++和后置++重载
再讲个稍微重要点的。
前置++，后置++。（前置–和后置–同理）
最重要的一点：前置++返回值是加之后的值，后置++返回值是加之前的值。
前置++
这里调用了拷贝，是因为d3初始化时拷贝的d2 + 1后的日期类（虽然返回的是引用，但是对d3要初始化）。
后置++
后置++为了和前置++区分，参数里多了个int，前置的参数里面没有。
这里调用了两次拷贝，是因为进入函数的时候tmp拷贝了一次，返回tmp并初始化d3的时候又将d3拷贝为返回的tmp。
日期类的实现
前面的运算符重载就讲那么多，就可以直接动手搞了。
日期类，可以加（和+=）天数，可以减（和-=天数），可以计算两个日期间的天数差，可以比较两天数的大小，可以判断两天数是否相等，还有上面的++和–。下面我就先给出这些声明，并逐一实现。
大家可以把声明自己复制一份自己实现一下，然后再看我实现的。
如果你想自己实现一下，我提示几点：
- 任何一个类，只需写一个 > == 或 < == 重载，剩下的比较运算符重载复用即可。
- 加号重载，先重载+=，再复用+=即可，这样拷贝构造函数调用的少。
- 自增和自减使用的时候优先考虑用前置（不影响结果的前提下），因为后置会有两次拷贝
声明
class Date
{
public:
Date(int year = 2023, int month = 5, int day = 7)
{
_year = year;
_month = month;
_day = day;
}
Date(const Date& date)
{
cout << "Date(const Date& date)" << endl;
_year = date._year;
_month = date._month;
_day = date._day;
}
void show();
Date& operator=(const Date& date);
Date operator++(int);
Date& operator++();
int GetMonthDay(int year, int month);
Date& operator+=(int day);
Date operator+(int day);
Date& operator-=(int day);
Date operator-(int day);
bool operator < (const Date& date);
bool operator <= (const Date& date);
bool operator > (const Date& date);
bool operator >= (const Date& date);
bool operator==(const Date& date);
private:
int _year;
int _month;
int _day;
};
实现
void Date::show()
{
cout << _year << "/" << _month << "/" << _day << endl;
}
bool Date::operator==(const Date& date)
{
return _year == date._year
&& _month == date._month
&& _day == date._day;
}
int Date::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 % 4 == 0 && year % 100 != 0) || (year % 400 == 0))
{
return 29;
}
return arr[month];
}
Date& Date::operator=(const Date& date)
{
cout << "Date & Date::operator=(const Date & date)" << endl;
if (!(*this == date))
{
_year = date._year;
_month = date._month;
_day = date._day;
}
return *this;
}
Date& Date::operator+=(int day)
{
if (day < 0)//这里考虑了day为负数的情况
{
*this -= -day;
}
_day += day;
while (_day > GetMonthDay(_year, _month))
{
_day -= GetMonthDay(_year, _month);
_month++;
if (_month == 13)
{
_year++;
_month = 1;
}
}
return *this;
}
Date Date::operator++(int)
{
Date tmp = *this;
*this += 1;//+=也是重载的函数，等会再讲
return tmp;
}
Date& Date::operator++()
{
*this += 1;//+=也是重载的函数，等会再讲
return *this;
}
Date Date::operator+(int day)
{
Date tmp = *this;
tmp += day;
return tmp;
}
Date& Date::operator-=(int day)
{
if (day < 0)//同+=，考虑day为负数的情况
{
*this += -day;
}
_day -= day;
while (_day <= 0)
{
--_month;
if (_month == 0)
{
_month = 12;
--_year;
}
_day += GetMonthDay(_year, _month);
}
return *this;
}
Date Date::operator-(int day)
{
Date tmp = *this;
tmp -= day;
return tmp;
}
bool Date::operator < (const Date& date)
{
if (_year < date._year)
{
return true;
}
else if (_year == date._year && _month < date._month)
{
return true;
}
else if (_year == date._year && _month == date._month && _day < date. _day)
{
return true;
}
return false;
}
bool Date::operator <= (const Date& date)
{
if (*this < date || *this == date)
return true;
return false;
}
bool Date::operator > (const Date& date)
{
if (!(*this <= date))
return true;
return false;
}
bool Date::operator >= (const Date& date)
{
if (!(*this < date))
return true;
return false;
}
bool Date::operator!=(const Date& date)
{
if (!(*this == date))
return true;
return false;
}
int Date::operator-(const Date& date)
{
int flag = 1;
int n = 0;
Date max = *this;
Date min = date;
if (max < min)
{
max = date;
min = *this;
flag = -1;
}
while (min != max)
{
++min;
++n;
}
return n * flag;
}
上面的有些函数是直接复用了别的函数，这样写起来会非常的方便。
我演示一下后置自增和前置自增：
上面打印了一堆Date的拷贝构造函数，就是因为后置自增每调用一次就要使用两次拷贝构造函数，这样就拖慢了程序运行的速度。
但是前置就不会调用拷贝构造函数：
const成员函数
这个直接给例子：
看：
这里的 &d1 和 &d2 可不是一个东西，因为d2是有const修饰的，其值无法被修改。但是d1没有const修饰，其值可以被修改。&d2 的类型相当于是const Date的，但是 &d1 的类型相当于是Date的，而this指针的类型是 Date * const 的this指针只是指向的地址不能被修改，但是指向的内容是可以被修改的，是可读可写的。但是 d2 是只读的，d2地址传过去的话，this就可以修改d2，权限就被放大了，所以不能传。d1 地址传过去，权限只是平移，没有放大。
这里的话，注意权限是可以缩小或平移的，不能放大。
那怎么才能调用其成员函数呢？
在成员函数后面加const就行（声明和实现都要加）。
此时 d1 和 d2 是都可以用的。
但是当我们定义了一个非const函数，一个const的函数呢？
答案是编译器会根据最匹配的情况去调用，也就是const对象调用const成员函数，非const对象调用非const成员函数。
那么说到这，就介绍的差不多了，那上方的场景会在哪里出现呢？
这里就要再介绍两个默认成员函数：取地址运算符重载（const和不带const）。
取地址及const取地址操作符重载
二者都是默认成员函数，不写的话二者都会自动生成，自动生成对所有需要取地址的情况都已经够用了，所以一般是不需要我们自己写的。
需要自己写的场景：不想让别人取到这个类型对象的地址，或者获得指定内容。
怎么做？
可以直接返回nullptr或者将二者设置为私有的或指定情况。
到此结束。。。