面向对象(OOP)思想和类(2)

(一)类的6个默认成员函数
1.构造函数
1.用处:用于初始化类的成员
语法
class Date{
Date()
{}
};
事实上这就完成了一个简单的构造函数,也就是传说中的无参构造
当创建Date类型的对象时候,编译器会自动调用构造函数,并且在整个对象的生命周期内只会调用一次
当然构造函数也有许多自己的特性,我在这里罗列一下
需要注意的是:构造函数并没有创造对象,只是完成对创建出来对象的初始化
构造函数的特性:
(1) 函数名与类名相同
(2)无返回值
(3)当对象实例化时编译器自动调用对应的构造函数
(4)构造函数支持重载
举个栗子
class Date{
public:
Date(){
_year=1;
_month=month;
_day=day;
}//无参构造
Date(int year,int month,int day)
{
_year=year;
_month=month;
_day=day;
}
//带参构造
private:
int _year;
int _month;
int _day;
};
void test()
{
Date d;//这里会调用无参构造
Date d1(1,2,3);//这里会调用带参构造
}
事实上当我们自己不去定义构造函数的时候,编译器会为我们自动生成一个无参的构造函数,而当我么自己取定义了构造函数时,编译器不会再生成
默认构造函数:
1.无参构造函数
2.全缺省构造函数
3.编译其默认生成的构造函数
事实上这里有个坑
我们看以下的代码
class Date{
public:
Date()
{}
Date(int year=1,int month=2,int day=3)
{
_year=year;
_month=month;
_day=day;
}
private:
int _year;
int _month;
int _day;
};
void test()
{
Date d;
}
事实上这里的编译是过不了的
为什么呢?
事实上我在上一张的面向对象和类的入门介绍中说过
永远不要让编译器去做判断!!
不要让它去做选择题
这里定义的d对象到底是应该调用Date()还是Date(int year=1,int month=2,int day=3)
这就是在给编译器出选择题
当然,编译器是不容许这么搞的
这里再说一个小插曲
在定义类成员变量的时候,定义的标识符尽量不要和普通的变量名一样,不然就会出现极为尴尬的情况
比如
class Date{
public:
Date (int year,int month ,int day)
{
year=year;
month=month;
day=day;
}
private :
int year;
int month;
int day;
};
这样搞就非常的生硬了
我的解决方法是定义的时候这样写
class Date{
private :
int _year;
int _month;
int _day;
};
这样就可以避免尴尬的
当然你也可以用别的方法(只要你的脑洞足够大就好)
2.析构函数
用处:在对象生命周期的时候清理资源
但是绝对不是销毁对象!!
特征:
1.析构函数的定义就是在类名前边加~
2.无参数无返回值
3.一个类只有一个析构函数,当然如果你不显式定义编译器也会自动生成
4.对象生命周期结束的时候编译器会自动调用
还是举个栗子
class Date()
{
public:
~Date ()
{}
这就是个析构函数
private:
int _year;
int _month;
int _day;
};
3.拷贝构造函数
事实上,这也是个构造函数
如果你仔细研究它只是构造函数的一个重载
我还是举个栗子
class Date{
public:
Date(Date& d)
{
_year=d._year;
_month=d._month;
_day=d._day;
}
private:
int _year;
int _month;
int _day;
};
这里要注意的是传参必须去传引用,不然就会引起无限递归
为啥呢
我们知道函数传参如果不传引用的话
在底层时间上是把实参拷贝一份作为形参放过去,那么这个拷贝过程就会又调用拷贝构造函数,从而形成无限递归
事实上如果不显示的去写拷贝构造,编译器会自动生成一个拷贝构造函数
但是这个拷贝构造只会完成浅拷贝(字节拷贝)
当遇到需要深拷贝的情形时,事实上这是极为尴尬的
举个栗子:
class String{
String()
{
_s=nullptr;
}

~String()
{
free(~s)
}
private:
char *_s;
}
void test()
{
String s1;
String s2(s1);
}
有没有发现问题呢
s1把_s的地址给了s2,因此事实上s2并没有创建出新的空间
当s1和s2生命周期结束的时候,会自动调用析构函数
这意味着s1指向的那块内存被释放了2次(极为尴尬)
因此这个程序就会GG
3.运算符重载
C++为了增强代码的可读性而设计的,其实和普通的函数并无过大区别
使用方法: operator后面加需要重载的运算符号
注意事项:
1.不能通过连接其他符号来创建新的运算符 比如operator@
2.重载函数操作符必须有一个类类型或者枚举类型的操作数(就是自定义类型)
3.用于内置类型的操作符号,其意义不能被改变,比如a+bn你不能让他是a乘b
4.作为类成员函数的时候,其形参看起来比实际操作数少一
其实很简单,类成员函数的第一个参数势必是this
5…丶sizeof丶?: 丶.五个运算符不能被重载(这个实际上也不用记忆,弄懂了他们的用途你就知道它为什么不能被重载)
至于这个东西的使用方法,你可以看我的博客那个Date类,这里不赘述
4.const成员函数
用const修饰的类成员函数事实上是修饰隐含的this指针,表面this指针指向的内容在该函数内部不能被修改
比如
class Date{
public :
void printfDate()const
{
cout<<_year<<month<<day<<endl;
}
private:
int _year;
int _month;
int _day;
};
这里函数体后边的const实际上是给this 加的把this 变成const Date * const this 这个类型
5.取地址及const取地址操作符重载
举个栗子一看就懂
class Date{
public :
Date operator&(){
return this;
}

const Date* operator&()const
{
return this;
}
};
这两个运算符一般不使用重载,使用编译器默认的重载即可,当然如果你只想让人家获取部分内容,可以自己定义,事实上,如果你可以这么搞,你已经买入了另外一闪门(is hk)