文章目录
- 二、类和对象
- 11. 析构函数（补）
- 12. 拷贝构造函数
- 13. 运算符重载
- 未完待续
二、类和对象
11. 析构函数（补）
析构函数并不是销毁对象，对象的销毁是由编译器完成的，析构函数的作用是清理，清理对象在堆上占用的空间。
析构函数的顺序：
#include<iostream>
using namespace std;
class A
{
public:
A(char a)
{
_a = a;
cout << "构造函数->" << _a << endl;
}
~A()
{
cout << "析构函数->" << _a << endl;
}
private:
char _a;
};
A e('e');
void func()
{
A c('c');
static A d('d');
}
static A f('f');
int main()
{
A a('a');
A b('b');
func();
return 0;
}
结果：
看生命周期，生命周期先结束的先析构，生命周期同时结束的，先构造的后析构。注意，局部的静态对象虽然声明周期属于全局，但是相比于正宗的全局对象，局部的静态对象先析构。
12. 拷贝构造函数
拷贝构造简单说就是，构造一个对象，但是这个对象的值是拷贝另一个已存在的对象的。所以拷贝构造函数的参数就是一个对象。
#include<iostream>
using namespace std;
class Date
{
public:
// 构造函数
Date(int year = 1111, int month = 1, int day = 1)
{
_year = year;
_month = month;
_day = day;
}
// 析构函数
~Date()
{
// 空
}
// 拷贝构造函数
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(2222, 2, 2);
Date d2(d1);
d1.Print();
d2.Print();
return 0;
}
就像这样，但是上面写法是不对的，会报错。
这是为什么呢？因为在C++当中，如果将一个自定义类型（结构体或者类）去传值传参时，由于形参是实参的临时拷贝，所以相当于形参要拷贝一份实参，拷贝拷贝，形参就是调用拷贝构造函数了。拷贝构造函数也是函数，如果形参也是传值传参时，拷贝构造函数就要去调用一个新的拷贝构造函数，无穷递归矣。所以拷贝构造函数的参数不能是传值传参，要使用引用传参。
使用了引用传参，注意要加上const哦，保护被拷贝的那个对象。
拷贝构造函数也是默认成员函数，我们不显式定义，编译器会自动生成。不过，它与构造函数和析构函数不一样，它对内置类型进行浅拷贝（也叫值拷贝，就是按字节一个一个拷贝），对自定义类型调用自定义类型的拷贝构造函数。咦？自定义类型最终也是属于内置类型，所以说，拷贝构造函数是不是不用写，编译器自动生成就很完美了呢？
当然不是，这涉及到了浅拷贝和深拷贝的问题了。让我们看下面一段程序：
#include<iostream>
using namespace std;
typedef int DataType;
class Stack
{
public:
// 初始化栈
Stack(size_t capacity = 10)
{
_array = (DataType*)malloc(capacity * sizeof(DataType));
if (nullptr == _array)
{
perror("malloc申请空间失败");
return;
}
_size = 0;
_capacity = capacity;
}
// 入栈
void Push(const DataType& data)
{
// CheckCapacity();
_array[_size] = data;
_size++;
}
// 析构
~Stack()
{
if (_array)
{
free(_array);
_array = nullptr;
_capacity = 0;
_size = 0;
}
}
private:
DataType* _array;
size_t _size;
size_t _capacity;
};
int main()
{
Stack s1;
s1.Push(1);
s1.Push(2);
s1.Push(3);
s1.Push(4);
Stack s2(s1);
return 0;
}
这个程序语法上没问题，但是编译出错了。为啥呢？这是s2拷贝完s1后的结果：
不知道大家有没有发现错误，错误就是，由于拷贝构造是浅拷贝的问题，按字节一个一个拷贝，于是指针的指向也被拷贝过去了，这使得两个指针指向同一块空间，s2先析构，析构会导致空间被释放，轮到s1析构的时候，该空间已被释放过了，再次释放就产生了错误。所以说：类中如果没有涉及资源申请时，拷贝构造函数是否写都可以；一旦涉及到资源申请时，则拷贝构造函数是一定要写的，否则就是浅拷贝。
拷贝构造函数也是特殊的成员函数，其特征如下：
- 拷贝构造函数是构造函数的一个重载形式。
- 拷贝构造函数的参数只有一个且必须是类类型对象的引用，使用传值方式编译器直接报错，因为会引发无穷递归调用。
- 若未显式定义，编译器会生成默认的拷贝构造函数。 默认的拷贝构造函数对象按内存存储按字节序完成拷贝，这种拷贝叫做浅拷贝，或者值拷贝。
13. 运算符重载
C++为了增强代码的可读性引入了运算符重载，运算符重载是具有特殊函数名的函数，也具有其返回值类型，函数名字以及参数列表，其返回值类型与参数列表与普通的函数类似。函数名字为：关键字operator后面接需要重载的运算符符号。
函数原型：返回值类型 operator操作符(参数列表)；
#include<iostream>
using namespace std;
class Date
{
public:
Date(int year = 1111, int month = 1, int day = 1)
{
_year = year;
_month = month;
_day = day;
}
~Date(){}
// 重载==
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(2222, 2, 2);
Date d2(2222, 2, 2);
cout << d1.operator==(d2) << endl;
// 也可以写成这样，由于流插入运算符优先级较高，所以要加上（）
cout << (d1 == d2) << endl;
return 0;
}
注意：
不能通过连接其他符号来创建新的操作符：比如operator@。
重载操作符必须有一个类类型参数。
用于内置类型的运算符，其含义不能改变，例如：内置的整型+，不能改变其含义。
作为类成员函数重载时，其形参看起来比操作数数目少1，因为成员函数的第一个参数为隐藏的this指针。
.*， :: ， sizeof ， ?:，. 注意以上5个运算符不能重载。
