04 类和对象 2

目录

1. 类的6个默认成员函数
2. 构造函数
3. 析构函数
4. 拷贝构造函数
5. 赋值运算符重载
6. 日期类
7. const成员函数
8. 取地址及const取地址操作符重载

---

1. 类的6个构造函数

如果一个类中什么都没有，简称空类
空类中真的什么都没有吗？并不是，任何类在什么都不写时，编译器会自动生成以下6个默认成员函数

默认成员函数：用户没有显式实现，编译器会生成的成员函数称为默认成员函数

class Date {};

2. 构造函数

2.1 概念

对于以下Date类

class Date
{
public:
	void Init(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	void Print()
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1;
	d1.Init(2022, 7, 5);
	d1.Print();
	Date d2;
	d2.Init(2022, 7, 6);
	d2.Print();
	return 0;
}

对于Date类，可以通过Init公有方法给对象设置日期，但如果每次创建对象时都调用该方法设置信息，未免有点麻烦，能否在对象创建时，将信息设置进去呢？

构造函数是一个特殊的成员函数，名字与类相同，创建类类型对象时由编译器自动调用，保证每个数据成员由一个合适的初始值，并且在对象整个生命周期只调用一次

2.2 特性

构造函数是特殊的成员函数，需要注意的是，构造函数虽然名称叫构造，但是构造函数的主要任务并不是开空间创建对象，而是初始化对象

其特征如下：
1.函数名与类名相同
2.无返回值
3.对象实例化时编译器自动调用对应的构造函数
4.构造函数可以重载，一个类可以有多个构造函数

class Date
{
public:
	// 1.无参构造函数
	Date()
	{}

	// 2.带参构造函数
	Date(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}
private:
	int _year;
	int _month;
	int _day;
};

void TestDate()
{
	Date d1; // 调用无参构造函数
	Date d2(2015, 1, 1); // 调用带参的构造函数

	// 注意：如果通过无参构造函数创建对象时，对象后面不用跟括号，否则就成了函数声明
	// 以下代码的函数：声明了d3函数，该函数无参，返回一个日期类型的对象
	// warning C4930: “Date d3(void)”: 未调用原型函数(是否是有意用变量定义的?)
	Date d3();
}

5.如果类中没有显示定义构造函数，c++编译器会自动生成一个无参的默认构造函数，一旦用户显示定义将不在生成

class Date
{
public:
    /*
    // 如果用户显式定义了构造函数，编译器将不再生成
    Date(int year, int month, int day)
    {
    _year = year;
    _month = month;
    _day = day;
    }
    */

    void Print()
    {
        cout << _year << "-" << _month << "-" << _day << endl;
    }

private:
    int _year;
    int _month;
    int _day;
};

int main()
{
    // 将Date类中构造函数屏蔽后，代码可以通过编译，因为编译器生成了一个无参的默认构造函
    数
        // 将Date类中构造函数放开，代码编译失败，因为一旦显式定义任何构造函数，编译器将不再
        生成
        // 无参构造函数，放开后报错：error C2512: “Date”: 没有合适的默认构造函数可用
        Date d1;
    return 0;
}

6.关于编译器生成的默认成员函数，默认构造函数起什么作用？
内置类型是语言提供的数据类型，如int，自定义类型是自己定义的，struct。看看下面程序，默认构造函数对这两种类型怎么处理

class Time
{
public:
 Time()
 {
 cout << "Time()" << endl;
 _hour = 0;
 _minute = 0;
 _second = 0;
 }
private:
 int _hour;
 int _minute;
 int _second;
};
class Date
{
private:
 // 基本类型(内置类型)
 int _year;
 int _month;
 int _day;
 // 自定义类型
 Time _t;
};
int main()
{
 Date d;
 return 0;
}

注意：可以看出对于内置类型不赋值，自定义类型会调用它的构造函数。c++11中针对内置类型成员不初始化的缺陷打了补丁，内置类型可以在声明时给默认值

class Time
{
public:
 Time()
 {
 cout << "Time()" << endl;
 _hour = 0;
 _minute = 0;
_second = 0;
 }
private:
 int _hour;
 int _minute;
 int _second;
};
class Date
{
private:
 // 基本类型(内置类型)
 int _year = 1970;
 int _month = 1;
 int _day = 1;
 // 自定义类型
 Time _t;
};
int main()
{
 Date d;
 return 0;
}

7.无参的构造函数和全缺省的构造函数都称为默认构造函数，并且默认构造函数只能有一个。无参构造函数，全缺省构造函数，编译器自动生成的构造函数，都可以认为是默认构造函数

class Date
{
public:
 Date()
 {
 _year = 1900;
 _month = 1;
 _day = 1;
 }
 Date(int year = 1900, int month = 1, int day = 1)
 {
 _year = year;
 _month = month;
 _day = day;
 }
private:
 int _year;
 int _month;
 int _day;
};
// 以下测试函数能通过编译吗？
void Test()
{
 Date d1;
 }

3. 析构函数

3.1 概念

通过前面构造函数的学习，我们直到一个对象是怎么来的，那一个对象又是怎么没的呢？

析构函数：与构造函数功能相反，析构函数不是完成对象本身的销毁，局部对象销毁工作由编译器完成，而对象在销毁时会自动调用析构函数，完成对象资源的清理工作

3.2 特性

析构函数是特殊的成员函数，特征如下：
1.析构函数名是在类名前面加字符~
2.无参数无返回值类型
3.一个类只能有一个析构函数，若未显式定义，会生成默认的析构函数，注意：析构函数不能重载
4.对象生命周期结束，自动调用析构函数

typedef int DataType;
class Stack
{
public:
	Stack(size_t capacity = 3)
	{
		_array = (DataType*)malloc(sizeof(DataType) * capacity);
		if (NULL == _array)
		{
			perror("malloc申请空间失败!!!");
			return;
		}
		_capacity = capacity;
		_size = 0;
	}
	void Push(DataType data)
	{
		// CheckCapacity();
		_array[_size] = data;
		_size++;
	}
	// 其他方法...
	~Stack()
	{
		if (_array)
		{
			free(_array);
			_array = NULL;
			_capacity = 0;
			_size = 0;
		}
	}
private:
	DataType* _array;
	int _capacity;
	int _size;
};
void TestStack()
{
	Stack s;
	s.Push(1);
	s.Push(2);
}

5.编译器自动生成的析构函数，是否会完成一些事情

class Time
{
public:
 ~Time()
 {
 cout << "~Time()" << endl;
 }
private:
 int _hour;
 int _minute;
 int _second;
};
class Date
{
private:
 // 基本类型(内置类型)
 int _year = 1970;
 int _month = 1;
 int _day = 1;
 // 自定义类型
 Time _t;
};
int main()
{
 Date d;
 return 0;
}
// 程序运行结束后输出：~Time()
// 在main方法中根本没有直接创建Time类的对象，为什么最后会调用Time类的析构函数？
// 因为：main方法中创建了Date对象d，而d中包含4个成员变量，其中_year, _month, 
_day三个是
// 内置类型成员，销毁时不需要资源清理，最后系统直接将其内存回收即可；而_t是Time类对
象，所以在

// d销毁时，要将其内部包含的Time类的_t对象销毁，所以要调用Time类的析构函数。但是：
main函数
// 中不能直接调用Time类的析构函数，实际要释放的是Date类对象，所以编译器会调用Date
类的析构函
// 数，而Date没有显式提供，则编译器会给Date类生成一个默认的析构函数，目的是在其内部
调用Time
// 类的析构函数，即当Date对象销毁时，要保证其内部每个自定义对象都可以正确销毁
// main函数中并没有直接调用Time类析构函数，而是显式调用编译器为Date类生成的默认析
构函数
// 注意：创建哪个类的对象则调用该类的析构函数，销毁那个类的对象则调用该类的析构函数

和构造一样，默认生成的析构函数对内置类型不做处理，对自定义类型调用它的析构

6.如果类中没有申请资源，析构函数可以不写，直接使用生成的默认析构函数。比如Date类，有资源申请时，一定要写，否则会泄露

4. 拷贝构造函数

4.1 概念

用来创建一个和已存在对象一模一样的对象

只有单个形参，该形参是本类型对象的引用（一般用const修饰），用已存在的类对象创建新对象时由编译器自动调用

4.2 特征

1.是构造函数的一个重载形式
2.参数只有一个且必须是类类型对象的引用，使用传值方式编译器直接报错，会引发无穷递归调用

class Date
{
public:
	Date(int year = 1900, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	// Date(const Date& d)   // 正确写法
	Date(const Date& d)   // 错误写法：编译报错，会引发无穷递归
	{
		_year = d._year;
		_month = d._month;
		_day = d._day;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1;
	Date d2(d1);
	return 0;
}

3.若未显式定义，编译器会生成默认的拷贝构造函数，默认的拷贝构造函数按内存存储字节完成拷贝，这种叫浅拷贝

class Time
{
public:
 Time()
 {
 _hour = 1;
 _minute = 1;
 _second = 1;
}
 Time(const Time& t)
 {
 _hour = t._hour;
 _minute = t._minute;
 _second = t._second;
 cout << "Time::Time(const Time&)" << endl;
 }
private:
 int _hour;
 int _minute;
 int _second;
};
class Date
{
private:
 // 基本类型(内置类型)
 int _year = 1970;
 int _month = 1;
 int _day = 1;
 // 自定义类型
 Time _t;
};
int main()
{
 Date d1;
    
    // 用已经存在的d1拷贝构造d2，此处会调用Date类的拷贝构造函数
    // 但Date类并没有显式定义拷贝构造函数，则编译器会给Date类生成一个默认的拷贝构
造函数
 Date d2(d1);
 return 0;
}

注意：默认拷贝构造函数，内置类型按字节方式拷贝，自定义类型调用其拷贝构造函数完成拷贝

4.编译器生成的默认拷贝函数可以完成字节序的值拷贝，还需要自己实现吗？

typedef int DataType;
class Stack
{
public:
	Stack(size_t capacity = 10)
	{
		_array = (DataType*)malloc(capacity * sizeof(DataType));
		if (nullptr == _array)
		{
			perror("malloc申请空间失败");
			return;
		}
		_size = 0;
		_capacity = capacity;
	}
	void Push(const DataType& data)
	{
		// CheckCapacity();
		_array[_size] = data;
		_size++;
	}
	~Stack()
	{
		if (_array)
		{
			free(_array);
			_array = nullptr;
			_capacity = 0;
			_size = 0;
		}
	}
private:
	DataType* _array;
	size_t _size;
	size_t _capacity;
};
int main()
{
	Stack s1;
	s1.Push(1);
	s1.Push(2);
	s1.Push(3);
	s1.Push(4);
	Stack s2(s1);
	return 0;
}

注意：类中涉及资源申请时，拷贝构造函数一定要写，因为浅拷贝会造成两个资源指向同一块空间，当一个析构释放资源后后另一个会再析构会崩溃

5.拷贝构造函数调用场景

• 使用已存在对象创建新对象
• 函数参数类型为类类型
• 函数返回值类型为类类型

class Date
{
public:
 Date(int year, int minute, int day)
 {
 cout << "Date(int,int,int):" << this << endl;
 }
 Date(const Date& d)
 {
 cout << "Date(const Date& d):" << this << endl;
 }
 ~Date()
 {
 cout << "~Date():" << this << endl;
 }
private:
 int _year;
 int _month;
 int _day;
};
Date Test(Date d)
{
 Date temp(d);
 return temp;
}
int main()
{
 Date d1(2022,1,13);
 Test(d1);
 return 0;
}

为了提高效率，对象传参尽量用引用类型，能引用尽量引用

5. 赋值运算符重载

5.1 运算符重载

为了增强可读性引入了运算符重载，重载是具有特殊函数名的函数

函数名字为：关键字operator接需要重载的运算符符号
原型：返回值类型 operator操作符（参数列表）

注意：

• 不能通过连接其他符号来创建新的操作符，比如：operator@
• 必须有一个类类型参数
• 内置类型的运算符，含义不能改变，如+不能改变含义
• 类成员函数重载时，第一个参数为隐藏的this
• .* ：： sizeof ？： . 这5个运算符不能重载

// 全局的operator==
class Date
{ 
public:
 Date(int year = 1900, int month = 1, int day = 1)
   {
        _year = year;
        _month = month;
        _day = day;
   }    
//private:
 int _year;
 int _month;
 int _day;
};
// 这里会发现运算符重载成全局的就需要成员变量是公有的，那么问题来了，封装性如何保证？
// 这里其实可以用我们后面学习的友元解决，或者干脆重载成成员函数。
bool operator==(const Date& d1, const Date& d2)
{
    return d1._year == d2._year
   && d1._month == d2._month
        && d1._day == d2._day;
}
void Test ()
{
    Date d1(2018, 9, 26);
    Date d2(2018, 9, 27);
    cout<<(d1 == d2)<<endl;
}
class Date
{ 
public:
 Date(int year = 1900, int month = 1, int day = 1)
 {
        _year = year;
        _month = month;
        _day = day;
   }
    
    // bool operator==(Date* this, const Date& d2)
    // 这里需要注意的是，左操作数是this，指向调用函数的对象
    bool operator==(const Date& d2)
 {
        return _year == d2._year;
            && _month == d2._month
            && _day == d2._day;
 }
private:
 int _year;
 int _month;
 int _day;
};

5.2 赋值运算符重载

• 参数类型：const T&，传递引用可以提高效率
• 返回值类型：T&，返回引用可以提高效率，支持连续赋值
• 检测是否自己给自己赋值
• 返回*this，要复合连续赋值的含义

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;
       }
        
        return *this;
 }
private:
 int _year ;
 int _month ;
 int _day ;
};

2赋值运算符只能重载成类的成员函数不能重载成全局函数

  class Date
{
public:
 Date(int year = 1900, int month = 1, int day = 1)
 {
 _year = year;
 _month = month;
 _day = day;
 }
 int _year;
 int _month;
 int _day;
};
// 赋值运算符重载成全局函数，注意重载成全局函数时没有this指针了，需要给两个参数
Date& operator=(Date& left, const Date& right)
{
 if (&left != &right)
 {
 left._year = right._year;
 left._month = right._month;
 left._day = right._day;
 }
 return left;
}
// 编译失败：
// error C2801: “operator =”必须是非静态成员

赋值运算符如果不显示实现，会生成一个默认，此时再类外自己实现一个全局的就冲突了，所以赋值运算符只能是类的成员函数

赋值运算符必须定义为成员函数

3.用户没有显示实现时，编译器会生成一个默认的运算符重载，以值的方式逐字节拷贝。内置类型成员变量直接复制，自定义类型需要调用对应的赋值运算符重载

class Time
{
public:
	Time()
	{
		_hour = 1;

	_minute = 1;
	_second = 1;
 }
 //Time& operator=(const Time& t)
 //{
	// if (this != &t)
	// {
	//	 _hour = t._hour;
	//	 _minute = t._minute;
	//	 _second = t._second;
	// }
	// return *this;
 //}
public:
	int _hour;
	int _minute;
	int _second;
};
class Date
{
public:
	void setyear(int year)
	{
		_year = year;
	}
	void settime(int time)
	{
		_t._hour = time;
	}
private:
	// 基本类型(内置类型)
	int _year = 1970;
	int _month = 1;
	int _day = 1;
	// 自定义类型
	Time _t;
};
int main()
{
 Date d1;
 Date d2;
 d1 = d2;
 return 0;
}

既然编译器默认赋值重载已经完成值拷贝，还需要自己实现吗？

// 这里会发现下面的程序会崩溃掉？这里就需要我们以后讲的深拷贝去解决。
typedef int DataType;
class Stack
{
public:
 Stack(size_t capacity = 10)
 {
 _array = (DataType*)malloc(capacity * sizeof(DataType));
 if (nullptr == _array)
 {
 perror("malloc申请空间失败");
 return;
 }
_size = 0;
 _capacity = capacity;
 }
 void Push(const DataType& data)
 {
 // CheckCapacity();
 _array[_size] = data;
 _size++;
 }
 ~Stack()
 {
 if (_array)
 {
 free(_array);
 _array = nullptr;
 _capacity = 0;
 _size = 0;
 }
 }
private:
 DataType *_array;
 size_t _size;
 size_t _capacity;
};
int main()
{
 Stack s1;
 s1.Push(1);
 s1.Push(2);
 s1.Push(3);
 s1.Push(4);
 Stack s2;
 s2 = s1;
 return 0;
}

注意：如果类中未涉及资源管理，可以默认，涉及到资源就会发生浅拷贝崩溃

5.3 前置++和后置++重载

class Date
{
public:
 Date(int year = 1900, int month = 1, int day = 1)
 {
 _year = year;
 _month = month;
 _day = day;
 }
 // 前置++：返回+1之后的结果
 // 注意：this指向的对象函数结束后不会销毁，故以引用方式返回提高效率
 Date& operator++()
 {
 _day += 1;
 return *this;
 }
 // 后置++：
 // 前置++和后置++都是一元运算符，为了让前置++与后置++形成能正确重载
 // C++规定：后置++重载时多增加一个int类型的参数，但调用函数时该参数不用传递，编译器
自动传递
 // 注意：后置++是先使用后+1，因此需要返回+1之前的旧值，故需在实现时需要先将this保存
一份，然后给this+1
 //       而temp是临时对象，因此只能以值的方式返回，不能返回引用
 Date operator++(int)
 {
 Date temp(*this);
 _day += 1;
 return temp;
 }
private:
 int _year;
 int _month;
 int _day;
};
int main()
{
 Date d;
 Date d1(2022, 1, 13);
 d = d1++;    // d: 2022,1,13   d1:2022,1,14
 d = ++d1;    // d: 2022,1,15   d1:2022,1,15
 return 0;
}

6. 日期类

#pragma once
#include <iostream>
using namespace std;

class Date {

	friend ostream& operator<<(ostream& out, Date d);
	friend istream& operator>>(istream& in, Date d);
public:
	Date(int year = 1990, int month = 1, int day = 1);
	void PrintDate() const;
	//获得天数
	int GetMonthDay(int year, int month) const;

	//重载运算符
	bool operator==(const Date& d) const;
	bool operator!=(const Date& d) const;
	bool operator<(const Date& d) const;
	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) const;
	Date& operator-=(int day);

	//d1-100
	Date operator-(int day) const;
	//d1-d2
	int operator-(const Date& d) const;
	//++d1
	Date& operator++();
	//d1++,int参数占位,为了区分
	Date operator++(int);
	// --d1 -> d1.operator--()
	Date& operator--();
	Date operator--(int);

private:
	int _year;
	int _month;
	int _day;
};

inline ostream& operator<<(ostream& out, Date d) 
{
	cout << d._year << "年" << d. _month << "月" << d._day << "日" << endl;
}

inline istream& operator>>(istream& in, Date d)
{
	cin >> d._year >> d._month >> d._day;
}

#include "Date.h"
#include <assert.h>

Date::Date(int year, int month, int day)
{
    if (month > 0 && month < 13 && (day > 0 && day <= GetMonthDay(year, month)))
    {
        _year = year;
        _month = month;
        _day = day;
    }
    else
    {
        cout << "非法日期" << endl;
    }
}

void Date::PrintDate() const
{
    cout << _year << "年" << _month << "月" << _day << "日"<<endl;
}

int Date::GetMonthDay(int year, int month) const
{
    assert(month > 0 && month < 13);
    int ary[13] = { 0,31,28,31,30,31,30,31,31,30,31,30,31 };
    if (month == 2 && ((year % 4 == 0 && year % 100 != 0) || (year % 400 == 0)))
        return 29;
    return ary[month];
}

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);
}

bool Date::operator<(const Date& d) const
{
    if (_year < d._year)
    {
        return true;
    }
    else if (_year == d._year && _month < d._month)
    {
            return true;
    }
    else if (_year == d._year && _month == d._month && _day < d._day)
    {
        return true;
    }

   /* return _year < d._year
        || (_year == d._year && _month < d._month)
        || (_year == d._year && _month == d._month && _day < d._day);*/

    return false;
}

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+=(int day)
{
    if (day < 0)
    {
        *this = *this - (-day);
        return *this;
    }
    _day = _day + day;

    while (_day > GetMonthDay(_year, _month))
    {
        _day = _day - GetMonthDay(_year, _month);
        _month++;
        if (_month == 13)
        {
            _year++;
            _month = 1;
        }
    }
    return *this;

}

Date Date::operator+(int day) const
{
    Date temp(*this);

    temp += day;
    return temp;
}

Date& Date::operator-=(int day)
{
    if (day < 0)
    {
        *this += -day;
        return *this;
    }
    _day = _day - day;
    //day = 23,  -5,  -30
    while (_day <= 0)
    {
        _month--;
        if (_month == 0)
        {
            _year--;
            _month = 12;
        }
        _day += GetMonthDay(_year, _month);
    }
    
    return *this;
}

Date Date::operator-(int day) const
{
    Date temp(*this);

    temp -= day;
    return temp;
}

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 n = 0;
    while (min != max)
    {
        min++;
        n++;
    }

    return n * flag;
}

Date& Date::operator++()
{
    // TODO: 在此处插入 return 语句
    *this += 1;
    return *this;
}

Date Date::operator++(int)
{
    // TODO: 在此处插入 return 语句
    Date temp(*this);
    *this += 1;

    return temp;

}

Date& Date::operator--()
{
    // TODO: 在此处插入 return 语句
    *this -= 1;
    return *this;

}

Date Date::operator--(int)
{
    // TODO: 在此处插入 return 语句
    Date temp(*this);
    *this -= 1;

    return temp;

}

7. const成员

将const修饰的成员函数称为const成员函数，实际修饰隐含的this指针，表明该成员函数中不能 对类的任何成员修改

class Date
{
public:
 Date(int year, int month, int day)
 {
 _year = year;
 _month = month;
 _day = day;
 }
 void Print()
 {
 cout << "Print()" << endl;
 cout << "year:" << _year << endl;
 cout << "month:" << _month << endl;
 cout << "day:" << _day << endl << endl;
 }
 void Print() const
 {
 cout << "Print()const" << endl;
 cout << "year:" << _year << endl;
 cout << "month:" << _month << endl;
 cout << "day:" << _day << endl << endl;
 }
private:
 int _year; // 年
 int _month; // 月
 int _day; // 日
};
void Test()
{
 Date d1(2022,1,13);
 d1.Print();
 const Date d2(2022,1,13);
 d2.Print();
}

1.const对象不可以调用非const成员函数
2.非const对象可以调用const成员函数
3.const成员函数不可以调用其他非const成员函数
4.非const成员函数可以调用其他const成员函数

8. 取地址及const取地址操作符重载

这两个默认成员函数一般不用重新定义，编译器会默认生成

class Date
{ 
public :
 Date* operator&()
 {
 return this ;
  }
 const Date* operator&()const
 {
 return this ;
 }
private :
 int _year ; // 年
 int _month ; // 月
 int _day ; // 日
};

这两个运算符一般不需要重载，使用编译器生成的默认取地址重载即可，只有特殊情况才需要重载，比如想让别人获取指定的内容。