[C++] 自定义的类如何使用“cout“和“cin“?（含日期类实现）

已于 2023-08-11 07:21:05 修改
阅读量578 收藏 1
点赞数 1
分类专栏： C++ 文章标签： c++ 算法
于 2023-08-10 14:22:49 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_71071692/article/details/132207858
版权

一、引言

在C++中，“cin”和"cout"可以说是区别于C语言的一大亮点。

但是，它的自动识别类型，其本质不过是运算符重载。若真到了能够“自动识别”的那一天，人类大概也能进入新的纪元了罢。

对于我们自己写的类，想要用cout，cin，当然是可以的，我们只需自己写它的重载即可。

本文将以“cout”为例。

二、运算符重载

1、何为运算符重载 

运算符重载：

函数名： operator操作符
返回类型： 看操作符运算后返回值是什么
参数：操作符有几个操作数，它就有几个参数 

其中，有5 个符号是不能进行运算符重载的：::      sizeof         ?:      .      .* 

2、日期类

下面我们以日期类为例，熟悉运算符重载：

众所周知，如果直接在类中进行运算符重载，那么第一个操作数必定是隐含的this指针。

这样就会产生一个问题：本应是“cout<<d”，如今却要写成“d<<cout”

void Test3()
{
	Date d1(2023, 8, 9);
	Date d2(2023, 12, 20);
	Date d3(2003, 12, 1);

	d1 << cout;
	d2 << cout;
	d3 << cout;
}

int main()
{
	Test3();

	return 0;
}

class Date
{
	friend void operator<< (ostream& out, const Date& d);

public:

	// 获取某年某月的天数
	int GetMonthDay(int year, int month)
	{
		int days[13] = { 0,31,28,31,30,31,30,31,31,30,31,30,31 };
		if ((year % 4 == 0 && year % 100 != 0) || year % 400 == 0)
		{
			days[2] = 29;
		}
		return days[month];
	}

	// 全缺省的构造函数
	Date(int year = 1900, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;

		if (month < 1 || month > 12 || day < 1 || day > GetMonthDay(year, month))
		{
			cout << "非法日期" << endl;
		}
	}

	// 拷贝构造函数
    // d2(d1)
	Date(const Date& d)
	{
		_year = d._year;
		_month = d._month;
		_day = d._day;
	}

	// 赋值运算符重载
  // d2 = d3 -> d2.operator=(&d2, d3)
	Date& operator=(const Date& d)
	{
		_year = d._year;
		_month = d._month;
		_day = d._day;

		return *this;
	}

	// 析构函数
	~Date()
	{
		;
	}

	//打印
	void Print() const
	{
		cout << _year << "年" << _month << "月" << _day << "日" << endl;
	}

	// 日期+=天数
	Date& operator+=(int day)
	{
		if (day < 0)
		{
			*this -= (-day);
			return *this;
		}
		_day += day;

		while (_day > GetMonthDay(_year, _month))
		{
			_day -= GetMonthDay(_year, _month);
			_month++;

			if (_month > 12)
			{
				_year++;
				_month = 1;
			}
		}

		return *this;
	}

	// 日期+天数
	Date operator+(int day)
	{
		Date tmp = *this;
		tmp += day;
		return tmp;
	}

	// 日期-天数
	Date operator-(int day)
	{
		Date tmp = *this;
		tmp -= day;
		return tmp;
	}

	// 日期-=天数
	Date& operator-=(int day)
	{
		if (day < 0)
		{
			*this += (-day);
			return *this;
		}
		_day -= day;

		while (_day <= 0)
		{
			_month--;
			if (_month == 0)
			{
				_year--;
				_month = 12;
			}
			_day += GetMonthDay(_year, _month);

		}

		return *this;
	}

	// 前置++
	Date& operator++()
	{
		*this += 1;
		return *this;
	}

	// 后置++
	Date operator++(int)
	{
		Date tmp = *this;
		*this += 1;
		return tmp;
	}

	// 后置--
	Date operator--(int)
	{
		Date tmp = *this;
		*this -= 1;
		return tmp;
	}

	// 前置--
	Date& operator--()
	{
		*this -= 1;
		return *this;
	}

	// >运算符重载
	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 _year == d._year && _month == d._month && _day == d._day;
	}

	// >=运算符重载
	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);
	}

	// !=运算符重载
	bool operator != (const Date& d)
	{
		return !(*this == d);
	}

	// 日期-日期 返回天数
	int operator-(const Date& d)
	{
		int num = 0;
		Date max = *this;
		Date min = d;
		int flag = 1;
		if (*this < d)
		{
			flag = -1;
			max = d;
			min = *this;
		}

		while (max > min)
		{
			num++;
			min++;
		}

		return flag * num;
	}

	void operator<< (ostream& cout) const
	{
		cout << _year << "年" << _month << "月" << _day << "日" << endl;
	}

private:

	int _year;
	int _month;
	int _day;

};

3、“cout<<d”

要想使得代码是“cout<<d”而非“d<<cout”，

其实也很简单。我们将<<的重载写在类的外面，就没有了“隐含的this指针”的限制。

但是这样又会产生一个问题：如何访问Date类的私有成员呢？

这时，我们可以利用“友元”来解决问题。

#include<iostream>
using namespace std;



class Date
{
//设置友元
	friend void operator<< (ostream& out, const Date& d);

public:

	// 获取某年某月的天数
	int GetMonthDay(int year, int month)
	{
		int days[13] = { 0,31,28,31,30,31,30,31,31,30,31,30,31 };
		if ((year % 4 == 0 && year % 100 != 0) || year % 400 == 0)
		{
			days[2] = 29;
		}
		return days[month];
	}

	// 全缺省的构造函数
	Date(int year = 1900, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;

		if (month < 1 || month > 12 || day < 1 || day > GetMonthDay(year, month))
		{
			cout << "非法日期" << endl;
		}
	}

	// 拷贝构造函数
    // d2(d1)
	Date(const Date& d)
	{
		_year = d._year;
		_month = d._month;
		_day = d._day;
	}

	// 赋值运算符重载
  // d2 = d3 -> d2.operator=(&d2, d3)
	Date& operator=(const Date& d)
	{
		_year = d._year;
		_month = d._month;
		_day = d._day;

		return *this;
	}

	// 析构函数
	~Date()
	{
		;
	}

	//打印
	void Print() const
	{
		cout << _year << "年" << _month << "月" << _day << "日" << endl;
	}

	// 日期+=天数
	Date& operator+=(int day)
	{
		if (day < 0)
		{
			*this -= (-day);
			return *this;
		}
		_day += day;

		while (_day > GetMonthDay(_year, _month))
		{
			_day -= GetMonthDay(_year, _month);
			_month++;

			if (_month > 12)
			{
				_year++;
				_month = 1;
			}
		}

		return *this;
	}

	// 日期+天数
	Date operator+(int day)
	{
		Date tmp = *this;
		tmp += day;
		return tmp;
	}

	// 日期-天数
	Date operator-(int day)
	{
		Date tmp = *this;
		tmp -= day;
		return tmp;
	}

	// 日期-=天数
	Date& operator-=(int day)
	{
		if (day < 0)
		{
			*this += (-day);
			return *this;
		}
		_day -= day;

		while (_day <= 0)
		{
			_month--;
			if (_month == 0)
			{
				_year--;
				_month = 12;
			}
			_day += GetMonthDay(_year, _month);

		}

		return *this;
	}

	// 前置++
	Date& operator++()
	{
		*this += 1;
		return *this;
	}

	// 后置++
	Date operator++(int)
	{
		Date tmp = *this;
		*this += 1;
		return tmp;
	}

	// 后置--
	Date operator--(int)
	{
		Date tmp = *this;
		*this -= 1;
		return tmp;
	}

	// 前置--
	Date& operator--()
	{
		*this -= 1;
		return *this;
	}

	// >运算符重载
	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 _year == d._year && _month == d._month && _day == d._day;
	}

	// >=运算符重载
	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);
	}

	// !=运算符重载
	bool operator != (const Date& d)
	{
		return !(*this == d);
	}

	// 日期-日期 返回天数
	int operator-(const Date& d)
	{
		int num = 0;
		Date max = *this;
		Date min = d;
		int flag = 1;
		if (*this < d)
		{
			flag = -1;
			max = d;
			min = *this;
		}

		while (max > min)
		{
			num++;
			min++;
		}

		return flag * num;
	}


private:

	int _year;
	int _month;
	int _day;

};

//运算符重载
void operator<< (ostream& cout, const Date& d)
{
	cout << d._year << "年" << d._month << "月" << d._day << "日" << endl;
}

效果 

void Test3()
{
	Date d1(2023, 8, 9);
	Date d2(2023, 12, 20);
	Date d3(2003, 12, 1);

	cout << d1;
	cout << d2;
	cout << d3;

}

int main()
{
	Test3();

	return 0;
}

如此，我们就实现了将自定义的类使用cout输出了。 

4、连续使用

如果我们需要连续使用，那么就需要对其进行修改。

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

	return cout;
}
void Test3()
{
	Date d1(2023, 8, 9);
	Date d2(2023, 12, 20);
	Date d3(2003, 12, 1);

	cout << d1 << d2 << d3;

}

int main()
{
	Test3();

	return 0;
}

效果

 

杯酒问苍天
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
C++:cout＜＜自定义类型输出
萧海的博客
11-25 980
1.自定义类型 struct Student{ int id; string name; Student(); Student(int ID,string Name){ id=ID; name=Name; } friend ostream & operator << (ostream &out,const Student &s) { out<<s.id&lt
C++中自定义类型使用标准输入cin输出cout
最新发布
肩上风骋的博客
02-19 436
当自己定义的数据为一些复杂数据，不再为基本数据类型，这时候要使用cout输出这些数据，就需要重载输出运算符
39114_20170620200252_C++操作符重载_
10-02
自定义一个类，实现这个类的+、-、cout、cin等操作符的重载
C++ 自己实现cout
Mount256的博客
08-04 1880
前排提示：阅读本篇文章需要至少学过类和对象以及重载运算符的概念。 文章目录一、cout是谁？二、什么是namespace？三、自己实现cout 接触这么久C++了，我想尝试写一个自己的cout了。在实现之前，先扯扯几个概念： 一、cout是谁？ 不就是输出语句嘛？！这个答案太浅显。正确答案：cout是类ostream的一个对象，而这个对象有一个成员重载运算符函数：operator <<。顺便一说，类ostream又属于iostream库中，iostream是标准的C++头文件。既然如此，那么这个
实现C++中的cout
不休的博客
08-20 1084
在学习C++时，一直很好奇cout输出时用 代码如下: out.h: #ifndef OUT_H #define OUT_H namespace mystd { class mycout { public: mycout operator (const char * str); }; extern mycou
C++ PPT第3章 类和对象(一).ppt
05-30
面向对象编程是C++的核心特性，它通过类和对象实现数据和操作的封装，从而提供更高级别的抽象和模块化。在C++中，类（Class）是定义对象（Object）蓝图的蓝图，包含了数据成员（Data Members）和成员函数（Member ...
C++自定义string字符串类
07-15
自定义`MyString`类不仅能够帮助我们理解C++面向对象编程的基本概念，如封装、继承和多态，还能加深对C++内存管理和标准库中`std::string`类的理解。通过实现这个类，我们可以更好地掌握字符串处理的核心技巧，这...
实例005——使用C++实现格式化数据的IO.zip
01-14
这个实例005——使用C++实现格式化数据的IO.zip文件，很可能包含了C++源代码示例，教你如何在实际项目中实现这一功能。下面将详细介绍C++中格式化数据IO的关键知识点。 1. **流（Stream）的概念**：C++中的IO操作...
C++自定义函数.ppt
10-16
在 C++ 程序中，自定义函数需要先声明后使用，格式为：返回类型 函数名（形式参数表）{ 局部变量说明部分；语句系列；}。 一、自定义函数的组成部分 1. 函数头：包括函数的返回类型、函数名和形式参数表。 2. 局部...
C++随手代码收藏 自定义实现 String 类.docx
04-16
在C++编程语言中，自定义实现`String`类是一个常见的练习，旨在理解对象导向编程的基本概念，如构造函数、赋值运算符重载、比较运算符重载以及字符串操作。以下是对给定代码片段的详细解释： 1. **类定义**： `...
C++ cout的使用，看这一篇就够了
Jasmine-Lily的博客
04-25 3万+
1 C++输入输出综述 C++ IO首先建立在为Unix环境开发的原始库函数上；ANSI C正式承认这个库时，将其称为标准输入/输出包； IO相关类定义在头文件iostream和fstream,这些类不是正式语言定义的组成部分，cin,istream都不是关键字。 1.1 流和缓冲 （1）流简介： C++程序将输入和输出看作字符流；对于输入来说，程序从输入流中抽取字符，对于输出来说，程序向输出流中插入字符； 输入流可以来自键盘、存储设备或者其他程序；输出流可以输出至显示器、打印机、存储设备或者其他程序。
C++中的 cout 和 printf 用法
攻城狮的博客
05-18 5192
C++是一种面向对象的编程语言，它继承了C语言的特点，同时也增加了许多新的特性。在C++中的cout 和 printf是两种常用的输出函数，它们都可以将数据显示在屏幕上，但是它们也有一些区别和优缺点。本文将详细说明这两种函数的区别及格式化输出的不同实现方法。
【c++程序】输入日期
平凡的世界
03-07 2180
#include using namespace std; struct Date { int year; int mon; int day; }; Date input() { Date d; cout<<"input the date (yyyy mm dd):"; cin>>d.year>>d.mon>>d.day; return d; } int main() { Da
c++运算符重载简单讲解 cout输出自定义数据类型
AKGWSB 's blog
05-28 4321
目录表达式与运算符运算符及其重载本质（附代码）两种重载运算符函数的方式以类成员函数的形式重载以友元函数的形式重载单目运算符的重载前++，即 ++a 的重载及（附代码）后++，即 a++ 的重载（附代码）双目运算符的重载（附代码）cout输出自定义类型（附代码） 表达式与运算符 一个表达式由 结果，左值，运算符，右值 构成，当然有的表达式也可以没有结果，比如++（自增）运算 我们可以轻易的使用以下语句来完成int类型变量的加法运算 int a = 114, b = 514; int c = a + b;
C++中cout的使用
热门推荐
九霄星河的博客
09-21 20万+
C++中cout的使用1. cout使用的三种方式2. cout和i/i++/++i的组合使用3. 以不同进制输出数字4. 输出数字位数的控制5. 强制显示小数点和正负号6. 设置宽度和对齐方式7. 设置填充字符8. iomanip库用法总结 cout 是C++中 ostream 类型的对象，该类被封装在 &amp;lt; iostream &amp;gt; 库中，该库定义的名字都在命名空间 std 中，所以 c...
cin的输入方式
java领域博主
04-25 7541
cin常用的有三种方法： cin>> cin.get() cin.getline()
如何让自定义类能像cout(ostream)那样输出数据
norman_irsa的博客
11-09 2109
相信不少C++程序员初次看到下面的写法时，一定留下了深刻印象： #include<iostream> using namespace std; int main() { cout << "Hello World!" << endl; } 至少，对于当时从C语言转向学习C++的我是深感震惊，如此形象直观的输出方式，简直是黑科技。 那么如何在自定义类...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

杯酒问苍天

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值