面向对象编程–类的认识
之前我们学习了C语言知识,C语言是一种面向过程的程序设计语言,而C++语言呢是基于面向对象的一种程序设计语言,关注的是对象,即将一件事情拆分成不同的对象,靠对象间的交互完成。接下来就对C++中最重要的类进行详细的介绍。
面向对象的三个特性是:封装、继承、多态
1.类的基本认识
类简单来说就是由成员函数和成员变量构成的一个集合。类的定义和定义结构体是类似的。只不过定义类用的关键字是class。
需要留意的是:C语言中,结构体中只能定义变量,但是在C++语言中,结构体内不仅可以定义变量,也可以定义函数。这是结构体在不同语言下的差异。
类的定义:类体是由成员函数和成员变量组成。class为定义类的关键字,其后跟类名,{}中是类的主体,在括号外有一个分号:。具体定义如下:
class Date//关键字class 类名{};
{
public:
//类的成员函数
void setDate(int year, int month, int day)
{
_year = year;
_month = month;
_day = day;
}
private:
//类的成员变量
int _year;
int _month;
int _day;
};
这是类的一种定义方式,即将声明和定义全部放在类体中,需要注意的是,成员函数如果在类中定义,编译器可能会将其当成内联函数处理。
第二种类的定义方式是;将声明和定义分开写,即声明放在类的头文件.h中,定义放在类的实现文件.cpp中,具体如下所示:
在上面的代码解释中有public和private,接下来就具体说说这是什么东东。其实这是类的访问限定符,通过限定符做到某些访问权限程度的目的。
类的访问限定符有三种:public共有,private私有和protected保护。
被public修饰的成员在类外可以直接被访问,而protected和private修饰的成员在类外不能直接被访问。
class类的默认访问权限为private,而struct为public。
封装:C++实现封装的方式:用类将对象的属性和方法结合在一块,让对象更加完善,通过访问权限选择性的将其接口提供给外部的用户使用。其中类中的数据称为类的属性或者成员变量,类中的函数称为类的方法或者成员函数。
this指针: C++编译器给每个“非静态的成员函数“增加了一个隐藏的指针参数,让该指针指向当前对象(函数运行时调用该函数的对象),在函数体中所有成员变量的操作,都是通过该指针去访问。只不过所有的操作对用户是透明的,即用户不需要来传递,编译器自动完成。
this指针的特性
(1).this指针的类型:类类型* const
(2).只能在“成员函数”的内部使用
(3). this指针本质上其实是一个成员函数的形参,是对象调用成员函数时,将对象地址作为实参传递给this形参。所以对象中不存储this指针。
(4).this指针是成员函数第一个隐含的指针形参,一般情况由编译器通过ecx寄存器自动传递,不需要用户传递。
具体如下所示:
void setDate()
{
cout << _year << endl;
}
编译器处理成员函数隐含的this指针之后如下:
void setDate(Date* this)
{
cout << this->_year << endl;
}
类的实例化:用类类型创建对象的过程,称为类的实例化。特征有:
1.定义出来的类并没有分配实际的内存空间,类只是一个模型。
2.实例化出来的对象,占用实际的物理空间,存储类成员变量。
类的大小计算:
类的存储方式只保存成员变量,成员函数存放在公共的代码段。
类的大小实际就是该类中成员变量之和,也是需要内存对齐的。空类的大小是1。如下计算类的大小:
//类中有成员函数和成员变量
class A{
public:
void fun1()
{ }
private:
int _a;
double _c;
char _b;
};
//类中仅有成员函数
class B{
public:
void fun2()
{ }
};
//空类
class C
{};
void test()
{
cout << sizeof(A) << endl;//结果是24
cout << sizeof(B) << endl;//结果是1
cout << sizeof(C) << endl;//结果是1
}
类的作用域:类的所有成员都在类的作用域中,在类外定义成员,需要用::作用域解析符指明成员属于哪个类域。如下代码解释:
class Date{
public:
void setDate();
private:
int _year;
int _month;
int _day;
};
//这里需要制定setDate是属于Date这个类域
void Date::setDate()
{
cout << _year << "-" << _month << "-" << _day << endl;
}
2.类的默认成员函数(6个)
1.构造函数:主要完成初始化工作。构造函数也是一种特殊的成员函数,但是构造函数虽然名叫构造,需要注意的是构造函数的主要任务不是开空间创建对象,而是初始化对象。
构造函数的特性有:
(1)首先函数名和类名相同。
(2)构造函数没有返回值。
(3)对象实例化时编译器自动调用对应的构造函数。
具体如下代码解释:
class Date{
public:
//无参构造函数
Date(){}
//带参构造函数
Date(int year, int month, int day)
{
_year = year;
_month = month;
_day = day;
}
void setDate();
private:
int _year;
int _month;
int _day;
};
void testDate()
{
Date d1;//调用无参构造函数
Date d2(2021,3,10);//调用有参构造函数
}
需要注意的是:如果通过无参构造函数创建对象时,对象后面不用跟括号,否则就成了函数声明。
(4)构造函数也是可以重载的。
(5)构造函数如果在类中没有显示定义,则C++编译器会自动生成一个无参的默认构造函数,一旦用户显示定义编译器将不再生成。
析构函数:主要完成清理工作
(6) 无参的构造函数和全缺省的构造函数都称为默认构造函数,并且默认构造函数只能有一个。无参构造函数、全缺省构造函数、我们没写编译器默认生成的构造函数,都可以认为是默认成员函数。
2.析构函数: 完成类的一些资源清理工作。析构函数也是特殊的成员函数。
析构函数的特性有:
(1)析构函数名是在类名前面加上字符~。
(2)析构函数没有返回值。
(3)一个类有且只有一个析构函数,若没有显式定义,系统会自动生成默认的构造函数。
(4)对象生命周期结束时,C++编译器系统自动调用析构函数。
3.拷贝构造函数: 也是特殊的成员函数其特性有:
(1)拷贝构造函数是构造函数的一种重载形式。
(2)拷贝构造函数的参数只有一个且必须使用引用传参,使用传值方式会引发无穷递归调用。
(3)若为显示定义,系统生成默认的拷贝构造函数,默认的拷贝构造函数对象按内存存储,按字节序完成拷贝,此时的拷贝叫做浅拷贝,或者值拷贝。
4.赋值运算符重载函数:
运算符重载是具有特殊函数名的函数,是具有返回值类型,函数名字以及参数列表,其返回值类型与参数列表与普通的函数类似。函数名字为:关键字operator后面接需要重载的运算符符号。例如: operator++
完整的函数原型为:返回值类型 operator 操作符(参数列表),例如:
bool operator==(const Date& d)。
有以下几点需要注意:
(1)重载操作符必须有一个类类型或者枚举类型的操作数。
(2)不能通过连接其他符号来创建新的操作符,例如:operator@
(3)用于内置类型的操作符,其含义不能改变。
(4)作为类成员的重载函数时,其形参看起来比操作数数目少1成员函数的操作符有一个默认的形参this,限定为第一个形参。
(5)这5个运算符是不能重载的:*、::、sizeof、?:、. 。
赋值运算符主要有四点:
1.参数类型
2.返回值
3.检测是否自己给自己赋值
4.返回*this
5.一个类如果没有显示定义赋值运算符重载,编译器也会生成一个,完成对象按字节序的值拷贝。
案例:日期类的实现
class Date{
public:
//获取某年某月的天数
int GetMonthDay(int year, int month)
{
static int days[13] = {0,31,28,31,30,31,30,31,31,30,31,30,31};
int day = days[month];
if (month == 2 && ((year % 4 == 0 && year % 100 != 0) || (year % 400 == 0)))
{
day += 1;
}
return day;
}
//全缺省的构造函数
Date(int year = 2021, int month = 3, int day = 10)
{
//判断日期是否有效
if (year <= 0 || month <= 0 || month > 12 || day <= 0 || day > GetMonthDay(year, month))
{
year = 1;
month = 1;
day = 1;
cout << "日期无效,设为默认值为1-1-1" << endl;
}
else
{
_year = year;
_month = month;
_day = day;
}
}
//日期运算:Date+=int,
//左操作数+=右操作数:左操作数内容发生变化,返回的是相加之后的值
Date& operator+=(int day)
{
//判断日期是否为负数
if (day<0)
{
return *this -= -day;
}
_day += day;//相加天数
//判断天数是否溢出
while (_day > GetMonthDay(_year, _month))
{
//减去当月的天数
_day -= GetMonthDay(_year,_month);
//月份进位
++_month;
//判断月份是否溢出
if (_month == 13)
{
//下一年的1月份
//年份进位
++_year;
_month = 1;
}
}
//返回相加之后的结果
return *this;
}
//Date+int:返回相加之后的结果,操作数不能改变
Date operator+(int day)
{
Date copy(*this);
copy += day;
return copy;
}
//++Date,前置++
Date& operator++()
{
return *this += 1;
}
//Date++,后置++,此处的int是为了区分operator函数重载
Date operator++(int)
{
Date copy(*this);
*this += 1;
return copy;
}
//Date-=int
Date& operator-=(int day)
{
//判断日期是否为负数
if (day < 0)
{
return *this += -day;
}
_day -= day;//相减天数
//判断天数是否溢出
while (_day <= 0)
{
//用上一个月的天数回补
--_month;
//判断月份是否溢出(向下)
if (_month == 0)
{
//年份退位,到上一年的12月份
--_year;
_month = 12;
}
//加上上月的天数回补
_day += GetMonthDay(_year, _month);
}
//返回相减之后的结果
return *this;
}
//Date-int:返回相减之后的值,day不能变的
Date operator-(int day)
{
Date copy(*this);
copy -= day;
return copy;
}
//--Date,前置--
Date& operator--()
{
return *this -= 1;
}
//Date--,后置--
Date operator--(int)
{
Date copy(*this);
*this -= 1;
return copy;
}
//==
bool operator==(const Date& d)
{
return _year == d._year
&& _month == d._month
&& _day == d._day;
}
//>
bool operator>(const Date& d)
{
if (_year > d._year)
return true;
else if (_year == d._year)
{
if (_month > d._month)
return true;
else if (_month == d._month)
{
if (_day > d._day)
return true;
}
}
return false;
}
//<
bool operator<(const Date& d)
{
return !(*this >= d);
}
//>=,即>或者=
bool operator>=(const Date& d)
{
return *this>d || *this == d;
}
//<=,即>取反
bool operator<=(const Date& d)
{
return !(*this > d);
}
//!=,即等于取反
bool operator!=(const Date& d)
{
return !(*this==d);
}
//Date-Date:日期相减
int operator-(const Date& d)
{
Date max = *this;
Date min = d;
int flag = 1;
if (max < min)
{
max = d;
min = *this;
flag = -1;
}
int day = 0;
while (min < max)
{
++min;
++day;
}
return flag*day;
}
void printDate(const Date* this)
{
cout <<this-> _year << "-" <<this-> _month;
cout << "-" << this->_day << endl;
}
private:
int _year;
int _month;
int _day;
};
5.const修饰类的成员函数:
将const修饰的类成员函数称之为const成员函数,const修饰类成员函数,实际修饰该成员函数隐含的this指针,在该成员函数中不能对类的任何成员进行修改。如下代码解释:
void printDate()const
{
cout << _year << "-" << _month;
cout << "-" << _day << endl;
}
编译器对const成员函数的处理之后如下:
void printDate(const Date* this)
{
cout <<this-> _year << "-" <<this-> _month;
cout << "-" << this->_day << endl;
}
特别留意:
(1)const对象不可以调用非const成员函数。
(2)const成员函数内不可以调用其他的非const成员函数。
(3)非const对象可以调用const成员函数。
(4)非const成员函数内可以调用其它的const成员函数。