C++类和对象【2】（构造函数，析构函数，拷贝构造，赋值运算符重载等相关介绍演示）
在上篇文章讲了类的组成，如果类中什么也没有就被称为空类，但在c++中即使类里什么也没有，编译器也会自动生成6个默认成员函数。
默认函数的定义：
用户没有显式实现，编译器会生成的成员函数称为默认成员函数
1.初始化和清理
构造函数完成初始化
析构函数完成清理
2.拷贝复制
拷贝构造利用同类对象初始化创建对象
复制重载将一个对象赋值给另一个对象
3.取地址重载
普通对象和const对象取地址（多由编译器实现）
文章目录
- 1.构造函数
-
- 1.函数名与类名相同且都无返回值
- 2.对象实例化时编译器自动调用对应的构造函数
- 3.构造函数可以重载
- 4.系统默认生成的构造函数
- 5. 在内置类型的成员变量声明时给缺省值
- 6. 初始化列表初始化
- 2.析构函数
- 3.拷贝构造
-
- 拷贝构造特性
- 4.赋值运算符重载
- 5.取地址及const取地址操作符重载
1.构造函数
定义：构造函数是特殊的成员函数，构造函数的主要目的不是开空间创建对象，而是初始化对象。
1.函数名与类名相同且都无返回值
class Date
{
public:
Date()//与类名相同
{
_year = 1;
_month = 1;
_day = 1;
}
//Date(int year, int month, int day)//与类名相同
//{
// _year = year;
// _month = month;
// _day = day;
//}
private:
int _year;
int _month;
int _day;
};
2.对象实例化时编译器自动调用对应的构造函数
class Date
{
public:
Date()
{
_year = 1;
_month = 1;
_day = 1;
}
//Date(int year, int month, int day)
/*{
_year = year;
_month = month;
_day = day;
}*/
private:
int _year;
int _month;
int _day;
};
int main()
{
Date d1;//对象实例化后，由系统自动调用，构造函数
return 0;
}
3.构造函数可以重载
注意的是默认的构造函数不能同时存在无参的构造函数或全缺省的构造函数在类中，调用时会出现二义性。
例如下面这段代码，调用时编译器无法识别调用谁？
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;
}
private:
int _year;
int _month;
int _day;
};
但是除此之外就可以构成：
class Date
{
public:
Date()
{
_year = 1;
_month = 1;
_day = 1;
}
Date(int year, int month, int day)//或者缺省的构造函数也可以
{
_year = year;
_month = month;
_day = day;
}
private:
int _year;
int _month;
int _day;
};
int main()
{
Date d1;//调用的是 Date() 为无参构造函数对象后面不用括号，否则就成了函数声明
Date d2();//为函数声明；
Date d2(2019, 5, 3);//调用的是Date(int year, int month, int day)；
return 0;
}
4.系统默认生成的构造函数
c++中如果自己不写构造函数，那么c++编译器会自动生成一个无参的默认构造函数，如果用户显式定义编译器将不再生成。
我们构造对象但没有传值构造，那么初始化的数据为随机值：
5. 在内置类型的成员变量声明时给缺省值
对于编译器生成的默认成员函数，大家会有疑惑：不实现构造函数的情况下，编译器会生成默认的构造函数。但感觉默认构造函数又没什么用？生成的默认依旧是随机值。也就说在这里编译器生成的默认构造函数并没有什么用？
那么在C++中把类型分成内置类型(基本类型)和自定义类型。内置类型是语言提供的数据类型，如：int/char…，自定义类型就是我们使用class/struct/union等自己定义的类型，编译器生成默认的构造函数会对自定类型成员调用的它的默认成员函数。那么就留下了对内置类型不初始化的缺陷。
因此在++11中针对内置类型不处理初始化为随机值的问题，提出解决办法：内置类型成员变量在类中声明可以给默认值，甚至可以给动态开辟的缺省值，但缺点是不能判断空间是否开辟成功。
class Date
{
public:
void print()
{
cout << _year << _month << _day << endl;
}
private:
int _year=1;
int _month=1;
int _day=1;
int* wrr = (int*)malloc(sizeof(int) * 9);
};
int main()
{
Date d1;
d1.print();
return 0;
}
需要注意的时这个特性只能用于解决默认构造函数初始化为随机值的问题。不能解决对象的多种初始化方式，所以这也是构造函数支持重载的原因，构造函数尽量还是得自己写。
6. 初始化列表初始化
那么上面讲的c++11解决了内置类型初始化的问题，那么在这之前是如何解决的？
这里就引出了初始化列表，初始化列表是类的所有成员变量定义的位置，不管是否显示在初始化列表写，编译器都会在初始化列表定义初始化，命名是以**：开始以,**号分隔
1.在对象中每个成员变量是在初始化列表部分进行初始化，而函数体内的行为是对成员函数赋初值。
2.没有在初始化列表里显示初始化某个成员变量，对内置类型，有缺省值用缺省值，无缺省值初始化为随机值；而对于自定义类型将会调用它的默认构造函数，没有找到默认构造将会报错。
3.引用、const、无默认构造函数的自定义类型必须通过初始化列表初始化。
4.成员变量在类中声明次序是在初始化列表中的初始化顺序，与在初始化列表中的先后次序无关。
class Date
{
public:
Date()
:_year(1) //成员变量的定义
,_month(1)
,_day(1)
,b(1)
{
}
void print()
{
cout << _year << _month << _day << endl;
}
private:
int _year=1;
int _month=1;
int _day=1;
const int b;
};
2.析构函数
定义：
与构造函数功能相反，析构函数并不是完成对对象本身的销毁，局部对象销毁工作是由编译器完成的。对象在销毁时会自动调用析构函数，完成对象中资源的清理工作。 相当于C语言数据结构写的destroy函数。
析构函数相关特性
析构函数是特殊的成员函数。
其特征如下：
1.析构函数名是在类名前加上字符 ~，无参数无返回值。
class Date
{
public:
Date()
:_year(1)
,_month(1)
,_day(1)
,b(1)
{
}
void print()
{
cout << _year << _month << _day << endl;
}
~Date()
{
cout << "~Date" << endl;
}
private:
int _year=1;
int _month=1;
int _day=1;
const int b;
};
int main()
{
Date d1;
d1.print();
return 0;
}
这样运行的结果为
说明调用了析构函数，那么真正需要析构函数清理的是哪些呢？例如这里定义的年月日变量则不需要资源清理，因为出了函数栈帧就销毁，真正需要清理的是malloc、new、fopen这些。
2.一个类有且只有一个析构函数。若未显式定义，系统会自动生成默认的析构函数。（析构函数不能重载）
3.对象生命周期结束时，C++编译系统系统自动调用析构函数，不用自己取调用
4.编译器生成的默认析构函数，和构造函数一样，内置类型不处理，自定义类型会去调用它的析构函数
class Stack
{
public:
Stack(int capacity = 10)
{
_a = (int*)malloc(sizeof(int) * capacity);
assert(_a);
_top = 0;
_capacity = capacity;
}
~Stack()
{
cout << "~Stack():" << this << endl;
free(_a);
_a = nullptr;
_top = _capacity = 0;
}
private:
int* _a;
int _top;
int _capacity;
};
class stack2
{
public:
void push(int x)
{}
int pop()
{}
private:
Stack _s2;
};
int main()
{
stack2 q;
}
运行结果
3.拷贝构造
在我们使用类的时候需要将一个对象复制成另一个对象时，难道需要我们自己一个一个复制吗？
例如这样：
int main()
{
Date d1(2020,2,9);
Date d2(d1);
return 0;
}
此时d2调用的函数就是拷贝构造。
定义：
拷贝构造函数：只有单个形参，该形参是对本类类型对象的引用(一般常用const修饰)，在用已存在的类类型对象创建新对象时由编译器自动调用。
拷贝构造特性
- 拷贝构造函数是构造函数的一个重载形式。
- 拷贝构造函数的参数只有一个且必须使用引用传参，使用传值方式会引发无穷递归调用。
我们来看下拷贝构造函数：
Date(Date& d1)//这里（）内只能且必须只有一个，使用的了引用传参，否则将会发生无穷递归
{
_year = d1._year;
_month = d1._month;
_day = d1._day;
}
没有引用：
Date(Date (d1))//此时就会再次调用Date（）一直循环
{
_year = d1._year;
_month = d1._month;
_day = d1._day;
}
这里我们可以加上const可以保护d1，所以较好的写法为：
Date(const Date& d1)
{
_year = d1._year;
_month = d1._month;
_day = d1._day;
}
- 如果没有显示定义，系统会生成默认的拷贝构造函数。 默认的拷贝构造函数对象按内存存储按字节序完成拷贝，这种拷贝
int main()
{
Date d1(2020,2,9);
Date d2(d1);
return 0;
}
我们叫做浅拷贝，或者值拷贝。
在默认的拷贝构造中对于内置类型，使用浅拷贝即可，系统默认生成的就可以，不用动手写拷贝构造函数。但是浅拷贝对于成员变量是动态开辟或fopen的资源是，指针虽然被拷贝过去，但内容没有复制过去，依旧是那一块空间，因此析构时就会存在同一块空间被释放两次的问题，这是我们需要进行深拷贝。而深拷贝的拷贝构造函数就必须自己实现。
class Stack
{
public:
Stack(int capacity=100)
{
_capacity = capacity;
_top = 0;
_arr = (int*)malloc(sizeof(int) * 5);//这里进行了动态开辟，因此需要进行深拷贝
if (_arr == nullptr)
{
perror("malloc fail");
exit(-1);
}
}
Stack(const Stack& st)//深拷贝
{
_capacity = st._capacity;
_top = st._top;
_arr = (int*)malloc(sizeof(int) * st._top);
if (_arr == nullptr)
{
perror("malloc fail");
exit(-1);
}
memcpy(_arr, st._arr,sizeof(int)*st._top);
}
~Stack()
{
_capacity = 0;
_top = 0;
free(_arr);//对动态开辟的进行释放
_arr = nullptr;
}
private:
int _top;
int _capacity;
int* _arr;
};
int main()
{
Stack d1(10);
Stack d2(d1);
return 0;
}
这里我们要注意，析构的顺序，构造的顺序应该是d1 d2，但是析构的顺还是d1 d2吗？
类的析构函数调用一般按照构造函数调用的相反顺序进行调用，但是要注意如果有static对象的存在，因为static改变了对象的生存作用域，需要等待程序结束时才会析构释放对象，全局对象先于局部对象进行构造，局部对象按照出现的顺序进行构造，无论是否为static。
因此析构的顺序按照构造的相反顺序析构，只需注意static改变对象的生存作用域之后，会放在局部对象之后进行析构
4.赋值运算符重载
在C++中为了增强代码的可读性引入了运算符重载，运算符重载是具有特殊函数名的函数，也具有其
返回值类型，函数名字以及参数列表，其返回值类型与参数列表与普通的函数类似。
用法：函数名字为：关键字operator后面接需要重载的运算符符号
注意事项：
1.不能通过连接其他符号来创建新的操作符：比如operator@ 。
2.重载操作符必须有一个类类型参数。
3.用于内置类型的运算符，其含义不能改变，例如：内置的整型+，不 能改变其含义。
4.作为类成员函数重载时，其形参看起来比操作数数目少1，因为成员函数的第一个参数为隐藏的this。
5. . * :: sizeof ? : .等5个运算符不能重载。
class Date
{
public:
Date(int year=1, int month=1, int day=1)
{
_year = year;
_month = month;
_day = day;
}
Date(Date& d1)
{
_year = d1._year;
_month = d1._month;
_day = d1._day;
}
bool operator==(const Date& d2)
{
return _year == d2._year
&& _month == d2._month
&& _day == d2._day;
}
private:
int _year;
int _month;
int _day;
};
int main()
{
Date d1(2020,2,9);
Date d2(2020,2,8);
return 0;
}
赋值运算符重载注意事项
1、参数为：const T&，传引用可以减少一次拷贝构造。
2、返回值是 *this 的引用，引用返回，减少一次拷贝构造，有返回值是为了支持函数的链式访问。
3、需要检查是否支持自己给自己赋值。
4、赋值运算符重载必须是类中的默认成员函数，不能写在全局。
5、系统默认生成的赋值运算符重载会完成值拷贝。
5.取地址及const取地址操作符重载
class Date
{
public :
Date* operator&()
{
return this ;
}
const Date* operator&()const
{
return this ;
}
private :
int _year ;
int _month ;
int _day ;
};
上面这两个默认成员函数一般不用重新定义 ，编译器默认会生成。只有想让别人通过取地址操作符获取到特定值（自己在重载函数内部写）或屏蔽类地址。