《c++从0到99》 三 类和对象 中
Posted AURORA_CODE
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了《c++从0到99》 三 类和对象 中相关的知识，希望对你有一定的参考价值。
0. 类的六个默认构造函数
定义一个空类：
class Date
{
}
经过编译器处理之后，类Date不在为空，它会自动的生成六个默认的成员函数，即使这六个成员函数什么也不做。（这些成员函数当我们没有定义时，编译器会显示的调用）处理之后相当于：
class Date
{
public:
Date();// 构造函数
Date(const Date& date);// 拷贝构造函数
~Date();// 析构函数
Date& operator=(const Date& date);// 赋值运算符重载
Date* operator &();// 取地址运算符重载
const Date* operator &() const;// const修饰的取地址运算符重载
}
1. 构造函数
概念：构造函数是一个特殊的成员函数，名字与类名相同，创建类类型对象的时候，由编译器自动调用，在对象的生命周期内只调用一次，以保证每个数据成员都有一个合适的初始值。
特性：
- 在一个对象的生命周期内只能调用一次
- 名字与类名相同
- 没有返回值
- 有初始化列表
- 编译器自动调用
- 构造函数可以重载，实参决定了调用哪个构造函数
- 如果没有显示的调用时，编译器会自己提供一个默认的构造函数。
- 无参构造函数和带有缺省值的构造函数都认为是缺省构造函数，并且缺省构造函数只能有一个
- 构造函数不能用const修饰。
初始化链表：
以冒号开始，接着是以逗号分隔的数据成员列表，每个数据成员后面跟一个放在圆括号中的初始化式。
初始化顺序：
- 数据成员在类中定义的顺序就是参数列表中的初始化顺序；
- 初始化列表仅用于初始化数据成员，并不指定这些数据成员的初始化顺序；
- 每个成员在初始化列表中只能出现一次；
- 尽量避免使用成员初始化成员，成员初始化顺序最好和成员的定义顺序保持一致
必须要在初始化列表进行初始化的成员有：引用数据类型，const修饰的数据类型，类类型成员。
默认构造函数：
默认构造函数使用与成员变量初始化相同规则初始化成员，对于内置类型和复合类型的成员，如组、指针，只对定义在全局定义作用于的对象初始化，对于局部作用域的内置和复合类型不作初始化。
explcit:
用explicit修饰构造函数，抑制由构造函数定义的隐式转换，explicit关键字类内部的构建声明上，在类的定义体外部的定义上不再重复。
2. 拷贝构造函数
概念：只有单个形参，且该形参是本类对象的引用，创建对象时使用已存在的同类对象来进行初始化。这种类型的构造函数被称为拷贝构造函数。
class Date
{
public:
Date(const Date& date)// 拷贝构造函数
{
_year = date._year;
_month = date._month;
_day = date._day;
}
private:
int _year;
int _month;
int _day;
}
特征：
- 是构造函数的重载
- 参数必须是本类对象的引用
- 如果不显式定义，系统将生成一个默认的拷贝构造函数。
3. 析构函数
概念：与构造函数功能相反，在对象被销毁时，由编译器自动调用，完成类的一些资源清理和善后工作。
特性：
析构函数是特殊的成员函数。
其特征如下：
- 析构函数名是在类名前加上字符 ~。
- 无参数无返回值。
- 一个类有且只有一个析构函数。若未显式定义，系统会自动生成默认的析构函数。
- 对象生命周期结束时，C++编译系统系统自动调用析构函数。
typedef int DataType;
class SeqList
{
public :
SeqList (int capacity = 10)
{
_pData = (DataType*)malloc(capacity * sizeof(DataType));
assert(_pData);
_size = 0;
_capacity = capacity;
}
~SeqList()
{
if (_pData)
{
free(_pData ); // 释放堆上的空间
_pData = NULL; // 将指针置为空
_capacity = 0;
_size = 0;
}
}
private :
int* _pData ;
size_t _size;
size_t _capacity;
};
4. 赋值运算符重载
C++为了增强代码的可读性引入了运算符重载，运算符重载是具有特殊函数名的函数，也具有其返回值类型，函数名字以及参数列表，其返回值类型与参数列表与普通的函数类似。
函数名字为：关键字operator后面接需要重载的运算符符号。
函数原型：返回值类型 operator操作符(参数列表)
注意：
- 不能通过连接其他符号来创建新的操作符：比如operator@
- 重载操作符必须有一个类类型或者枚举类型的操作数
- 用于内置类型的操作符，其含义不能改变，例如：内置的整型+，不能改变其含义
- 作为类成员的重载函数时，其形参看起来比操作数数目少1，成员函数的操作符有一个默认的形参this，限定为第一个形参
- .* 、:: 、sizeof 、?: 、. 注意以上5个运算符不能重载。
class Date
{
public :
Date(int year = 1900, int month = 1, int day = 1)
{
_year = year;
_month = month;
_day = day;
}
Date (const Date& d)
{
_year = d._year;
_month = d._month;
_day = d._day;
}
Date& operator=(const Date& d)
{
if(this != &d)
{
_year = d._year;
_month = d._month;
_day = d._day;
}
}
private:
int _year ;
int _month ;
int _day ;
};
主要注意：
- 参数类型
- 返回值
- 检测是否自己给自己赋值
- 返回*this
- 一个类如果没有显式定义赋值运算符重载，编译器也会生成一个，完成对象按字节序的值拷贝
5. const修饰的成员函数
将const修饰的类成员函数称之为const成员函数，const修饰类成员函数，实际修饰该成员函数隐含的this指针，表明在该成员函数中不能对类的任何成员进行修改。
使用方法：直接在要修饰的成员函数后面加const。
class Date
{
public:
void PrintDate()const// = void PrintDate(const Date* this)
{
cout<<_year<<"."<<_month<<"."<<_day<<endl;
}
private:
int _year;
int _month;
int _day;
}
注意：
- const对象不能调用非const成员函数。
因为const对象中的属性值不能发生改变，调用非const成员函数setA会导致对象的内容发生改变，编译器就会报错。const对象拥有只读权限，非const成员函数拥有可读可写权限，会将权限放大，不能调用。- 非const对象可以调用const成员函数。
因为a对象中的内容可读也可以修改，而const修饰的成员函数只能读取数据，满足a对象的权限，所以可以调用。从a对象的可读可写到成员函数的只读，权限缩小，可以调用- const成员函数内不能调用其它非const成员函数。
因为getA中的this只有只读权限，setA中this指针有可读可写权限，getA中的this指针满足不了setA中指针的全部权限。getA中this指针只读到setA中this指针可读可写，权限被放大，不能调用。
- 非const成员函数内可以调用其他const成员函数。
因为setA中的this指针有可读可写权限，getA中的this指针只有只读权限，setA中this指针拥有的权限可以满足getA中this指针的权限。setA中this指针可读可写到getA中this指针只读，权限缩小，可以调用。
6. 日期类的实现
class Date
{
public:
bool CheckLeap(int year);
// 获取某年某月的天数
int GetMonthDay(int year, int month);
// 打印年月日
void PrintYearMonthDay()
{
printf("%d.%d.%d\\n", _year, _month, _day);
}
// 全缺省的构造函数
Date(int year = 1900, int month = 1, int day = 1);
// 拷贝构造函数
Date(const Date& d);
// 赋值运算符重载
Date& operator=(const Date& d);
// 析构函数
~Date();
// 日期+=天数
Date& operator+=(int day);
// 日期+天数
Date operator+(int day);
// 日期-天数
Date operator-(int day);
// 日期-=天数
Date& operator-=(int day);
// 前置++
Date& operator++();
// 后置++
Date operator++(int);
// 后置--
Date operator--(int);
// 前置--
Date& operator--();
// >运算符重载
bool operator>(const Date& d);
// ==运算符重载
bool operator==(const Date& d);
// >=运算符重载
inline bool operator >= (const Date& d);
// <运算符重载
bool operator < (const Date& d);
// <=运算符重载
bool operator <= (const Date& d);
// !=运算符重载
bool operator != (const Date& d);
// 日期-日期 返回天数
int operator-(const Date& d);
private:
int _year;
int _month;
int _day;
};
bool Date::CheckLeap(int year)
{
if ((0 == year % 4 && 0 != year % 100) || 0 == year % 400)
return true;
return false;
}
// 获取某年某月的天数
int Date::GetMonthDay(int year, int month)
{
if (1 == month || 3 == month || 5 == month || 7 == month || 8 == month || 10 == month || 12 == month)
return 31;
else if (2 == month)
{
if (CheckLeap(year))
return 29;
else
return 28;
}
else
return 30;
}
// 全缺省的构造函数
Date::Date(int year, int month, int day)
{
_year = year;
_month = month;
_day = day;
}
// 拷贝构造函数
Date::Date(const Date& d)
{
_year = d._year;
_month = d._month;
_day = d._day;
}
// 赋值运算符重载
Date& Date::operator=(const Date& d)
{
_year = d._year;
_month = d._month;
_day = d._day;
return *this;
}
// 析构函数
Date::~Date()
{
}
// 日期+=天数
Date& Date::operator+=(int day)
{
_day += day;
while (_day > GetMonthDay(_year, _month))
{
_day -= GetMonthDay(_year, _month++);
if (_month > 12)
{
_year += _month / 12;
_month %= 12;
}
}
return *this;
}
// 日期+天数
Date Date::operator+(int day)
{
Date temp(*this);
temp._day += day;
while (temp._day > GetMonthDay(temp._year, temp._month))
{
temp._day -= GetMonthDay(temp._year, temp._month++);
if (temp._month > 12)
{
temp._year += temp._month / 12;
temp._month %= 12;
}
}
return temp;
}
// 日期-天数
Date Date::operator-(int day)
{
Date temp(*this);
temp._day -= day;
while (temp._day <= 0)
{
if (1 == temp._month)
{
temp._year = temp._year - 1;
temp._month = temp._month + 12;
}
temp._month = temp._month - 1;
temp._day = temp._day + GetMonthDay(temp._year, temp._month + 1);
}
return temp;
}
// 日期-=天数
Date& Date::operator-=(int day)
{
_day -= day;
while (_day <= 0)
{
if (1 == _month)
{
_year = _year - 1;
_month = _month + 12;
}
_month = _month - 1;
_day = _day + GetMonthDay(_year, _month + 1);
}
return *this;
}
// 前置++
Date& Date::operator++()
{
int carry = 0;
_day += 1;
carry = _day / GetMonthDay(_year, _month);
if (carry > 0)
{
_day %= GetMonthDay(_year, _month);
_month += carry;
carry = _month / 12;
if (carry > 0)
{
_month %= 12;
_year += carry;
}
}
return *this;
}
// 后置++
Date Date::operator++(int)
{
Date temp(*this);
int carry = 0;
_day += 1;
carry = _day / GetMonthDay(_year, _month);
if (carry > 0)
{
_day %= GetMonthDay(_year, _month);
_month += carry;
carry = _month / 12;
if (carry > 0)
{
_month %= 12;
_year += carry;
}
}
return temp;
}
// 后置--
Date Date::operator--(int)
{
Date temp(*this);
if (1 == _day)
{
if (1 == _month)
{
_year = _year - 1;
_month = _month + 12;
}
_month = _month - 1;
_day = _day + GetMonthDay(_year, _month + 1);
}
_day = _day - 1;
return temp;
}
// 前置--
Date& Date::operator--()
{
if (1 == _day)
{
if (1 == _month)
{
_year = _year - 1;
_month = _month + 12;
}
_month = _month - 1;
_day = _day + GetMonthDay(_year, _month + 1);
}
_day = _day - 1;
return *this;
}
// >运算符重载
bool Date::operator>(const Date& d)
{
if (_year < d._year || (_year == d._year && _month < d._month) || (_year == d._year && _month == d._month && _day <= d._day))
return false;
return true;
}
// ==运算符重载
bool Date::operator==(const Date& d)
{
if (_year == d._year && _month == d._month && _day == d._day)
return true;
return false;
}
// >=运算符重载
inline bool Date::operator >= (const Date& d)
{
if (_year < d._year || (_year == d._year && _month < d._month) || (_year == d._year && _month == d._month && _day < d._day))
return false;
return true;
}
// <运算符重载
bool Date::operator < (const Date& d)
{
if (_year > d._year || (_year == d._year && _month > d._month) || (_year == d._year && _month == d._month && _day >= d._day))
return false;
return true;
}
// <=运算符重载
bool Date::operator <= (const Date& d)
{
if (_year > d._year || (_year == d._year && _month 《c++从0到99》 二 类和对象 上