准备
博主:大大怪先森(记得关注哦!）
编程环境：vs2013
所示代码：码源
文章目录
前言
提示：以下是本篇文章正文内容，下面案例可供参考
一、类的默认的六个成员函数
如果一个类中什么成员都没有，简称为空类。空类中什么都没有吗？并不是的，任何一个类在我们不写的情况下，都会自动生成下面6个默认成员函数
class 类名{}；
二、初始化和清理
2.1.构造函数
2.1.1 概念
构造函数是一个特殊的成员函数，名字与类名相同,创建类类型对象时由编译器自动调用，>保证每个数据成员都有 一个合适的初始值，并且在对象的生命周期内只调用一次
举例：class A { public: A() { cout << "A()" << endl; _a = 0; } private: int _a; }; class Date { public: //void Init(Date* const this, int year, int month, int day) //void Init(int year, int month, int day) //{ // //Date::year = year;多此一举 // _year = year; // _month = month; // _day = day; //} //Date() //{ // _year = 0; // _month = 1; // _day = 1; //} //Date(int year, int month, int day) //{ // //Date::year = year;多此一举 // _year = year; // _month = month; // _day = day; //} // 语法上无参和全缺省的可以同时存在 // 但是如果存在无参调用，就会存在二义性 // 推荐实现全缺省或者半缺省，因为比较好用 Date(int year = 0, int month = 1, int day = 1) { _year = year; _month = month; _day = day; } void Print() { //this = nullptr; cout << _year << "-" << _month << "-" << _day << endl; // 一般情况，我们都不会像下面这样显示写 //cout << this->_year << "-" << this->_month << "-" << this->_day << endl; } private: int _year; int _month; int _day; A _aa; };
2.1.2特性
构造函数是特殊的成员函数，需要注意的是，构造函数的虽然名称叫构造，但是需要注>意的是构造函数的主要任务并不是开空间创建对象，而是初始化对象
特征如下：
- C++里面把类型分为两类：内置类型(基本类型)，自定义类型
- 内置类型：int/char/double/指针/内置类型数组 等等- 自定义类型：struct/class定义的类型
- 我们不写编译器默认生成构造函数，对于内置类型不做初始化处理
- 对于自定类型成员变量会去调用它的默认构造函数初始化，如果没有默认构造函数就会报错- 任何一个类的默认构造函数就是–不用参数就可以调用。
- 任何一个类的默认构造函数有三个，全缺省、无参、我们不写编译器默认生成的。
2.2.析构函数
2.2.1概念
析构函数：与构造函数功能相反，析构函数不是完成对象的销毁，局部对象销毁工作是由>编译器完成的。而对象在销毁时会自动调用析构函数，完成类的一些资源清理工作
2.2.1特性
析构函数是特殊的成员函数
特征如下：
- 析构函数名是在类名前加上字符 ~。
- 无参数无返回值。
- 一个类有且只有一个析构函数。若未显式定义，系统会自动生成默认的析构函数。
- 对象生命周期结束时，C++编译系统系统自动调用析构函数。
代码如下（示例）：class Stack { public: Stack(int capacity = 4) { _a = (int*)malloc(sizeof(int)*capacity); if (_a == nullptr) { cout << "malloc fail\n" << endl; exit(-1); } _top = 0; _capacity = capacity; } void Push(int x) {} ~Stack() { free(_a); _a = nullptr; _top = _capacity = 0; //cout << "~Stack()" << endl; } private: int* _a; size_t _top; size_t _capacity; };我们不写编译器默认生成析构函数（和构造函数类似，可以参上特性）
1.对于内置类型变量做处理
2.对于自定义类型变量可以调用它的析构函数
三、拷贝复制
拷贝构造函数也是特殊的成员函数，其特征如下：
- 拷贝构造函数是构造函数的一个重载形式。
- 拷贝构造函数的参数只有一个且必须使用引用传参，使用传值方式会引发无穷递归调用。
Date (const Date& d) { _year = d._year; _month = d._month; _day = d._day; }
编译器生成的默认拷贝构造函数已经可以完成字节序的值拷贝了
四、赋值运算符重载
4.1运算符重载
C++为了增强代码的可读性引入了运算符重载，运算符重载是具有特殊函数名的函数，>也具有其返回值类型，函数名字以及参数列表，其返回值类型与参数列表与普通的函数似。
函数名字为：关键字operator后面接需要重载的运算符符号。
函数原型：返回值类型 operator操作符(参数列表)
注意：
- 不能通过连接其他符号来创建新的操作符：比如operator@
- 重载操作符必须有一个类类型或者枚举类型的操作数
- .* 、:: 、sizeof 、?: 、. 注意以上5个运算符不能重载。这个经常在笔试选择题中出现
- 用于内置类型的操作符，其含义不能改变，例如：内置的整型+，不 能改变其含义
Date& Date::operator+=(int day) { _day += day; while (_day > GetMonthDay(_year, _month)) { _day -= GetMonthDay(_year, _month); ++_month; if (_month == 13) { _month = 1; _year++; } } return *this; }
4.2赋值符重载
Date& Date::operator-=(int day) { _day -= day; while(_day < 0) { _day += GetMonthDay(_year, _month - 1) + 1; _month--; } return *this; }赋值运算主要四点：
- 参数类型
- 返回值
- 检测是否自己给自己赋值
- 返回*this
- 一个类如果没有显式定义赋值运算符重载，编译器也会生成一个，完成对象按字节序的值拷贝。
编译器生成的默认赋值重载函数已经可以完成字节序的值拷贝了，但是只能实现浅拷贝
五、日期类的实现
头文件
#pragma once
#include<iostream>
using namespace std;
class Date
{
//友元函数
friend ostream& operator<<(ostream& out, const Date& d);
public:
Date(int year = 0, int month = 1, int day = 1);
void Print();
void PrintWeekDay() const;
int GetMonthDay(int year,int month);
bool operator>=(const Date& d) const;
bool operator<(const Date& d) const;
Date& operator=(const Date& d);
bool operator>(const Date& d) const;
bool operator==(const Date& d) const;
bool operator!=(const Date& d)const;
Date& operator+=(int day);
Date operator+(int day);
Date& operator-=(int day);
Date operator-(int day);
int operator-(const Date& d) const;
// ++d1;
Date& operator++();
// d1++; 后置为了跟前置++，进行区分
// 增加一下参数占位，跟前置++,构成函数重载
Date operator++(int);
private:
int _year;
int _month;
int _day;
};
ostream& operator<<(ostream& out, const Date& d);
函数的定义
#define _CRT_SECURE_NO_WARNINGS 1
#include"Date.h"
int Date::GetMonthDay(int year, int month)
{
static int monthArray[13] = { 0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
int day = monthArray[month];
//一年其实是365天 + 5个小时
if (month == 2 && ((year % 4 == 0 && year % 100 != 0)
|| year % 400 == 0))
{
day += 1;
}
return day;
}
Date::Date(int year, int month, int day)
{
_year = year;
_month = month;
_day = day;
if (!(_year >= 0 && (month > 0 && month < 13)
&& (day > 0 && day <= GetMonthDay(year, month))))
{
cout << "非法日期=》";
Print();
}
}
Date& Date::operator+=(int day)
{
_day += day;
while (_day > GetMonthDay(_year, _month))
{
_day -= GetMonthDay(_year, _month);
++_month;
if (_month == 13)
{
_month = 1;
_year++;
}
}
return *this;
}
Date Date :: operator+(int day)
{
Date ret(*this);
ret += day;
return ret;
}
Date& Date::operator-=(int day)
{
//_day -= day;
//while(_day < 0)
//{
// _day += GetMonthDay(_year, _month - 1) + 1;
// _month--;
//}
//return *this;
if (day < 0)
{
return *this += -day;
}
_day -= day;
while (_day <= 0)
{
--_month;
if (_month == 0)
{
--_year;
_month = 12;
}
_day += GetMonthDay(_year, _month);
}
return *this;
}
Date Date::operator-(int day)
{
Date ret(*this);
ret -= day;
return ret;
}
bool Date::operator>(const Date& d) const
{
if (_year > d._year)
{
return true;
}
else if (_year == d._year && _month > d._month
&& _day > d._day)
{
return true;
}
else if (_year == d._year && _month == d._month
&& _day > d._day)
{
return true;
}
else
{
return false;
}
}
int Date::operator-(const Date& d) const
{
Date max = *this;
Date min = d;
int flag = 1;
if (*this < d)
{
max = d;
min = *this;
flag = -1;
}
int count = 0;
while (min != max)
{
++min;
++count;
}
return count * flag;
}
Date& Date::operator=(const Date& d)
{
if (this != &d)
{
_year = d._year;
_month = d._month;
_day = d._day;
}
return *this;
}
bool Date::operator==(const Date& d) const
{
return _year == d._year
&& _month == d._month
&& _day == d._day;
}
bool Date::operator>=(const Date& d) const
{
return (*this > d) || (*this == d);
}
bool Date::operator<(const Date& d) const
{
return !(*this >= d);
}
bool Date::operator!=(const Date& d)const
{
return !(*this == d);
}
Date& Date::operator++()
{
*this += 1;
return *this;
}
Date Date::operator++(int)
{
Date ret(*this);
ret += 1;
return ret;
}
void Date::PrintWeekDay() const
{
const char* arr[] = { "星期一", "星期二", "星期三", "星期四", "星期五", "星期六", "星期天" };
int count = *this - Date(1900, 1, 1);
cout << arr[count % 7] << endl;
}
void Date::Print()
{
cout << _year << "-" << _month << "-" << _day << endl;
}
ostream& operator<<(ostream& out, const Date& d)
{
out << d._year << "/" << d._month << "/" << d._day << endl;
return out;
}
主函数
#define _CRT_SECURE_NO_WARNINGS 1
#include"Date.h"
int main()
{
/*TestDemo1();*/
Date d1(2022, 3, 3);
Date d2(2021, 4, 2);
cout << (d1 - d2) << endl;
cout << (d1 - 200) << endl;
d1.PrintWeekDay();
return 0;
}
六、cosnt成员
6.1const 修饰类的成员函数
将const修饰的类成员函数称之为const成员函数const修饰类成员函数，实际修饰该成员函数隐含的this指针，表明在该成员函数中不能对类的任何成员进行修改
七.取地址及const取地址操作符重载
这两个默认成员函数一般不用重新定义 ，编译器默认会生成
class Date
{
public :
Date* operator&()
{
return this ;
}
const Date* operator&()const
{
return this ;
}
private :
int _year ; // 年
int _month ; // 月
int _day ; // 日
};
结语
希望本篇文章能给各位带来帮助，如有不足还请指正！！！
码字不易，各位大大给个收藏点赞吧！！！
