Homework11_ch8(2) 多态——运算符重载(1)

最新推荐文章于 2023-04-26 21:23:36 发布
最新推荐文章于 2023-04-26 21:23:36 发布
阅读量315 收藏 1
点赞数 1
分类专栏： 学习笔记c++ c++练习 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_52065936/article/details/124469287
版权
  1. 人民币类---运算符重载

题目描述如下：

设计人民币类，数据成员包含正负标志位、元、角、分 ，设计构造函数、重载＋、－、前置自增、后置自增、前置自减、后置自减、输出流插入运算符<<、输入流提取运算符>> . 其中前置自减、后置自减、<<和>>重载成友元函数。

       自增表示增加1分钱。自减表示减少1分钱。加减法和构造时的进位要考虑。

       编写主函数测试之。

功能说明：

  1. 所有的人民币的输入和输出都要使用重载的运算符<<和>>
  2. 所有的单目运算符的操作都是针对第一个人民币
  1. 关于人民币表示方法的说明：

（+m元n角k分），含义是正的m元n角k分，其中的m、n、k是无符号的；

       （-m元n角k分），含义是负的m元n角k分，其中的m、n、k是无符号的。

负的人民币值表示赤字。

       0元0角0分用+表示

输出样例：

请构造两个人民币：

+ 11 22 33

+9 8 18

请选择运算(A:+/S:-/Q:++i/H:i++/J:--i/K:i--/): A

(+13元5角3分) + (+ 9元9角8分) =（+23元5角1分）

请选择运算(A:+/S:-/Q:++i/H:i++/J:--i/K:i--/): S

(+13元5角3分) - (+ 9元9角8分) =（+3元5角5分）

请选择运算(A:+/S:-/Q:++i/H:i++/J:--i/K:i--/): Q

++(+13元5角3分) = (+13元5角4分)

请选择运算(A:+/S:-/Q:++i/H:i++/J:--i/K:i--/): H

 (+13元5角4分) ++ = (+13元5角4分)

人民币1：(+13元5角5分)

请选择运算(A:+/S:-/Q:++i/H:i++/J:--i/K:i--/): J

--(+13元5角5分) = (+13元5角4分)

请选择运算(A:+/S:-/Q:++i/H:i++/J:--i/K:i--/): K

 (+13元5角4分) -- = (+13元5角4分)

人民币1：(+13元5角3分)

您还要继续吗？(Y/N): Y

请构造两个人民币：

-1 2 33

+5 7 8

请选择运算(A:+/S:-/Q:++i/H:i++/J:--i/K:i--/): A

(-1元5角3分) + (+ 5元7角8分) =（+4元2角5分）

请选择运算(A:+/S:-/Q:++i/H:i++/J:--i/K:i--/): S

(-1元5角3分) - (+ 5元7角8分) =（-7元3角1分）

请选择运算(A:+/S:-/Q:++i/H:i++/J:--i/K:i--/): Q

++(-1元5角3分) = (-1元5角2分)

请选择运算(A:+/S:-/Q:++i/H:i++/J:--i/K:i--/): H

 (-1元5角2分) ++ = (-1元5角2分)

人民币1：(-1元5角1分)

请选择运算(A:+/S:-/Q:++i/H:i++/J:--i/K:i--/): J

--(-1元5角1分) = (-1元5角2分)

请选择运算(A:+/S:-/Q:++i/H:i++/J:--i/K:i--/): K

 (-1元5角2分) -- = (-1元5角2分)

人民币1：(-1元5角3分)

您还要继续吗？(Y/N): N

press any key to continue…

关于输出样例的说明：

带下划线的内容表示用户的输入。

提示：

可以把钱数转化成总分数，如：

+1元2角3分 = +123分

-1元2角3分 = -123分

对于分数再做各种运算，这样的运算要简单一些；

然后再把分数转换成元角分的形式

//Money.h
#pragma once
#include<iostream>
using namespace std;
class Money {
public:
	Money(char c = '+', int y = 0, int j = 0, int f = 0);
	void standard();
	Money operator+(const Money& m);
	Money operator-(const Money& m);
	Money& operator++();
	Money operator ++(int);
	friend Money& operator--(Money& );
	friend Money operator--(Money& , int);
	friend ostream& operator << (ostream& os, const Money& m);
	friend istream& operator >>(istream& os, Money& m);
	void Show();
private:
	char sign;
	int yuan;
	int jiao;
	int fen;
};
//Money.cpp
#include"Money.h"
#include<iostream>
using namespace std;
Money::Money(char c, int y, int j, int f)
{
	sign = c;
	yuan = y;
	jiao = j;
	fen = f;
}
void Money::standard()
{
	jiao += fen / 10;
	fen %= 10;
	yuan += jiao / 10;
	jiao %= 10;
}

Money Money::operator+(const Money& m)
{
	Money mo;
	if (sign == m.sign) {
		mo.yuan = yuan + m.yuan;
		mo.jiao = jiao + m.jiao;
		mo.fen = fen + m.fen;
		mo.standard();
	}
	else {
		if (sign == '-') {
			Money tmp('+', yuan, jiao, fen);
			Money t = m;
			mo = t - tmp;
		}
		else {
			Money tmp('+', m.yuan, m.jiao, m.fen);
			mo = *this - tmp;
		}
	}
	return mo;
}

Money Money::operator-(const Money& m)
{
	Money mo;
	Money tmp = m;
	if (sign != m.sign) {
		if (m.sign == '-') {
			tmp.sign = '+';
		}
		else {
			tmp.sign = '-';
		}
		return *this + tmp;
	}
	if (yuan > m.yuan || (yuan == m.yuan && jiao > m.jiao) || (yuan == m.yuan && jiao == m.jiao && fen >= m.fen))
	{
		mo = *this; tmp = m;
	}
	else { mo = m; tmp = *this; mo.sign = (sign == '+') ? '-' : '+'; }
	if (mo.fen < tmp.fen) {
		mo.jiao--;
		mo.fen += 10;
	}
	mo.fen -= tmp.fen;
	if (mo.jiao < 0 || mo.jiao < tmp.jiao) {
		mo.yuan--;
		mo.jiao += 10;
	}
	mo.jiao -= tmp.jiao;
	mo.yuan -= tmp.yuan;
	return mo;
}

Money& Money::operator++() {    //前置
	Money m('+', 0, 0, 1);
	*this = *this + m;
	return *this;
}
Money Money::operator++(int) {
	Money m = *this;
	++(*this);
	return m;
}
Money& operator--(Money& x)
{
	Money m('+', 0, 0, 1);
	x = x - m;
	return x;
}

Money operator--(Money& x, int) {
	Money m = x;
	--(x);
	return m;
}
ostream& operator<<(ostream& os, const Money& m)
{
	os << m.sign << m.yuan << "元" << m.jiao << "角" << m.fen << "分";
	return os;
}
istream& operator>>(istream& os, Money& m)
{
	char c;
	int y, j, f;
	os >> c >> y >> j >> f;
	m.sign = c;
	m.yuan = y;
	m.jiao = j;
	m.fen = f;
	m.standard();
	return os;
}
void Money::Show()
{
	cout << sign << yuan << "元" << jiao << "角" << fen << "分" << endl;
}
//main.cpp
#include"Money.h"
#include<iostream>
using namespace std;
int main() {
	Money m1, m2;
	char op,t;
	do {
		cout << "请构造两个人民币：" << endl;
		cin >> m1 >> m2;
		int x = 6;
		while (x--) {
			cout << "请选择运算(A:+/S:-/Q:++i/H:i++/J:--i/K:i--/): ";
			cin >> t;
			if (t == 'A') {
				cout << "(" << m1 << ")+(" << m2 << ")=(";
				Money ans1 = m1 + m2;
				cout << ans1 << ")" << endl;
			}
			else if (t == 'S') {
				cout << "(" << m1 << ")-(" << m2 << ")=(";
				Money ans2 = m1 - m2;
				cout << ans2 << ")" << endl;
			}
			else if (t == 'Q') {
				cout << "++(" << m1 << ")=(";
				cout << ++m1 << ")" << endl;
			}
			else if (t == 'H') {
				cout << "(" << m1 << ")++=(";
				cout << m1++ << ")" << endl;
				cout << "人民币1：(" << m1 << ")" << endl;
			}
			else if (t == 'J') {
				cout << "--(" << m1 << ")=(";
				cout << --m1 << ")" << endl;
			}
			else if (t == 'K') {
				cout << "(" << m1 << ")--=(";
				cout << m1-- << ")" << endl;
				cout << "人民币1：(" << m1 << ")" << endl;
			}
		}
		cout << "您还要继续吗？(Y/N): ";
		cin >> op;
	} while (op == 'Y' || op == 'y');
	return 0;
}

 

 

2. 十六进制数类---运算符重载

题目描述如下：

 设计1~4位的无符号十六进制数据类class HEX. 可以创建如 ABCD、1234、DF09、AB、26之类的1~4位的十六进制的正整数。可以输入输出十六进制数据，可以实现十六进制数据和十进制数据的互换，可以实现2个十六进制数据的+、-、*、/、%操作，各操作的要求请看程序注释。

下面给出了完整的类设计，但缺少了相关函数的实现，这些函数在程序注释中标出了。

请你根据题意，添加这些函数的实现。在实现这些函数时：可以调用已有的函数，但不要更改原来的类设计，并且使得经你补充以后的程序完全符合题意，也完全符合程序的输出。

#include <iostream.h>

#include <string>

#include <cmath>

#include <process.h>

char Hex_num[16] = {'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};

class HEX

{   char m_num[10];                               //可以存放10位十六进制数据，这样可以确保2个4位十六进制数据+和*的结果不会溢出

public:

       HEX();                                             //构造函数，初始化成全‘0’

HEX(unsigned n);                              //用无符号整数创建十六进制数据，（即无符号整数转换成十六进制数据）

       unsigned GetBit(int i);                        //获得每一位数据的十进制数值

       operator unsigned();                         //把十六进制数据转换成无符号的十进制数据

       int length();                                       //获得数据的长度

       HEX operator+(HEX n);                  //加法

       HEX operator-(HEX n);                      //减法运算要求被减数不小于减数

       HEX operator*(HEX n);                         //乘法

       HEX operator/(HEX n);                             //整除，即只要得到商

       HEX operator%(HEX n);                           //取模，即只要得到余数

       HEX& operator++();                                 //前置++

       HEX operator++(int);                                //后置++

       friend istream& operator>>(istream& i, HEX& n);        // 输入十六进制数

       friend ostream& operator<<(ostream& o, HEX n);        //  输出十六进制数

};

int main()

{     HEX n1,n2,n3;

       char repeat('Y');

       do

       {     n1 = 0; n2 = 0; n3 =0;

cin>>n1>>n2;

              n3 = n1+n2;

              cout<<n1<<'+'<<n2<<'='<<n3<<endl;

              n3 = n1-n2;

              cout<<n1<<'-'<<n2<<'='<<n3<<endl;

              n3 = n1*n2;

              cout<<n1<<'*'<<n2<<'='<<n3<<endl;

              n3 = n1/n2;

              cout<<n1<<'/'<<n2<<'='<<n3<<endl;

              n3 = n1%n2;

              cout<<n1<<'%'<<n2<<'='<<n3<<endl;

              cout<<"Repeat?(Y/N)";

              cin>>repeat;

       }while(repeat=='Y'||repeat=='y');

       return 0;

}

下面是一次运行时的程序输出：

Please input a Hex number(>=0,<=FFFF,Hex characters: 0-9 or A-F):

ABCD

Please input a Hex number(>=0,<=FFFF,Hex characters: 0-9 or A-F):

1234

ABCD+1234=BE01

ABCD-1234=9999

ABCD*1234=C374FA4

ABCD/1234=9

ABCD%1234=7F9

Repeat?(Y/N)Y

Please input a Hex number(>=0,<=FFFF,Hex characters: 0-9 or A-F):

FE

Please input a Hex number(>=0,<=FFFF,Hex characters: 0-9 or A-F):

12

FE+12=110

FE-12=EC

FE*12=11DC

FE/12=E

FE%12=2

Repeat?(Y/N)N

Press any key to continue

//HEX.h
#pragma once
#include <iostream>
#include<string>
#include<cmath>
#include<process.h>
static char Hex_num[16] = { '0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F' };
using namespace std;

class HEX {
	char m_num[10];
public:
	HEX(unsigned n=0);
	unsigned GetBit(int i);             //获得每一位数据的十进制数值
	operator unsigned();				//把十六进制数据转换成无符号的十进制数据
	int length();						//获得数据的长度
	HEX operator+(HEX n);			//加法
	HEX operator-(HEX n);				//减法运算要求被减数不小于减数
	HEX operator*(HEX n);				//乘法
	HEX operator/(HEX n);					//整除，即只要得到商
	HEX operator%(HEX n);				//取模，即只要得到余数
	HEX& operator++();					//前置++
	HEX operator++(int); 					//后置++
	friend istream& operator>>(istream& i, HEX& n);		// 输入十六进制数
	friend ostream& operator<<(ostream& o, HEX n);		//  输出十六进制数

};
//HEX.cpp
#include"HEX.h"

HEX::HEX(unsigned n)
{
	int cnt = 0;
	if (n == 0) m_num[cnt++] = '0';
	while (n) {
		m_num[cnt++] = Hex_num[n % 16];
		n /= 16;
	}
	for (int i = 0; i < cnt/2; i++) {
		swap(m_num[i], m_num[cnt - 1 - i]);
	}
	for (int i = cnt; i < 10; i++) m_num[i] = '\0';
}

unsigned HEX::GetBit(int i)
{
	if (m_num[i] == '\0') return 0;
	for (int j = 0; j < 16; j++) {
		if (m_num[i] == Hex_num[j]) {
			return j;
		}
	}
	return -1;
}

HEX::operator unsigned()
{
	unsigned int s = 0;
	int len = this->length();
	for (int i = 0; i < len; i++) {
		//cout << GetBit(i) * pow(16, len-i) << endl;
		s += GetBit(i) * pow(16, len-i-1);
	}
	return s;
}
int HEX::length()
{
	for (int i = 9; i >= 0; i--) {
		if (m_num[i] != '\0') return i+1;
	}
	return 0;
}

HEX HEX::operator+(HEX n)
{
	unsigned a = n;
	unsigned x = *this;
	return HEX(x+a);
}
HEX HEX::operator-(HEX n)
{
	unsigned x = *this;
	unsigned a = n;
	return HEX(x - a);
}
HEX HEX::operator*(HEX n)
{
	unsigned x = *this;
	unsigned a = n;
	return HEX(x * a);
}
HEX HEX::operator/(HEX n)
{
	unsigned x = *this;
	unsigned a = n;
	return HEX(x / a);
}
HEX HEX::operator%(HEX n)
{
	unsigned x = *this;
	unsigned a = n;
	return HEX(x % a);
}

HEX& HEX::operator++()
{
	unsigned s = *this;
	s=s+1;
	*this = HEX(s);
	return *this;
}
HEX HEX::operator++(int)
{
	HEX h = *this;
	++* this;
	return h;
}
istream& operator>>(istream& i, HEX& n)
{
	cout << "Please input a Hex number(>=0,<=FFFF,Hex characters: 0-9 or A-F):" << endl;
	i >> n.m_num;
	return i;
}
ostream& operator<<(ostream& o, HEX n)
{
	o << n.m_num;
	return o;
}
//main.cpp
#include"HEX.h"

int main()
{
	HEX n1, n2, n3;
	char repeat('Y');
	do
	{
		n1 = 0; n2 = 0; n3 = 0;
		cin >> n1 >> n2;
		n3 = n1 + n2;
		cout << n1 << '+' << n2 << '=' << n3 << endl;
		n3 = n1 - n2;
		cout << n1 << '-' << n2 << '=' << n3 << endl;
		n3 = n1 * n2;
		cout << n1 << '*' << n2 << '=' << n3 << endl;
		n3 = n1 / n2;
		cout << n1 << '/' << n2 << '=' << n3 << endl;
		n3 = n1 % n2;
		cout << n1 << '%' << n2 << '=' << n3 << endl;
		cout << "Repeat?(Y/N)";
		cin >> repeat;
	} while (repeat == 'Y' || repeat == 'y');
	return 0;
}

 

浅度断墨
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++小作业-定义一个人民币的类RMB(重载＋、－、＋＝、＋＋、输入输出流)
编程小鹏的博客
05-05 3461
人民币类的运算符、输入输出流重载
实验7 多态：运算符重载1
08-03
2.1 改进《实验三 面向对象初步》中的日期类 2.2 使用改进后的日期类，修改《实验四 对象作为数据成员》中的雇员类 2.3 测试 getMostFaith
【定义一个人民币的类(重载＋、－、＋＝、＋＋、输入输出流)】
武帝为此的博客
04-26 1196
【问题描述】定义一个人民币的类，其中成员数据包括元、角、分，成员函数包括构造及输出函数。要求增加适当的成员函数，重载＋、－、＋＝、＋＋、输入输出流，来实现人民币的直接运算。注意分、角、元的进位。键盘输入一个人民币数值，输出完成运算后的相应结果。【输入形式】输入元、角、分(整数之间用空格间隔)。【输出形式】完成运算后的相应结果。【评分标准】 3个评分点。
面向对象编程试验课随笔（运算符重载）
asjkfdf的博客
12-20 592
一、试验目的 1.掌握C++语言多态的基本概念 2.掌握运算符重载函数的声明和定义方法 二、试验内容 编写一个程序，实现两个复数的乘法 1.首先建立一个乘法的类，在其中定义实部和虚部，并添加构造函数 class Multiply { public: double real, imag; Multiply(double r = 0, double i = 0) { real = r; imag = i; } }; 2.自定义运算符“*”作为复数运算的乘法运算符 复数的乘法是复
operator++()和operator++(int)的区别
m0_37714594的博客
04-13 8136
https://blog.csdn.net/piaopiaohu123/article/details/7333771class UPInt { // "unlimited precision int"public:　UPInt&amp; operator++(); // ++ 前缀　const UPInt operator++(int); // ++ 后缀　UPInt&amp; operator...
实例003——操作符重载实现编译多态——复数的加法运算.zip
01-14
实例003——操作符重载实现编译多态——复数的加法运算 实例003——操作符重载实现编译多态——复数的加法运算 实例003——操作符重载实现编译多态——复数的加法运算
面向对象C++：ch05 运算符重载及多态.ppt
06-12
面向对象C++：运算符重载及多态 面向对象C++：运算符重载及多态是C++编程语言中的一项重要特性，它允许开发者对已有的运算符赋予多重含义，从而实现用户自定义类型的运算。 运算符重载是指将指定的运算表达式...
嵌入式Linux下C++程序设计--08多态，运算符重载，虚函数，抽象类.ppt
09-17
嵌入式Linux下C++程序设计--08多态，运算符重载，虚函数，抽象类.ppt
D11接口，多态.zip_d11接口_java接口_mannerglc_多态
09-21
接口是功能的集合，同样可看做是一种数据类型，是比抽象类更为抽象...Java中多态的代码体现在一个子类对象(实现类对象)既可以给这个子类(实现类对象)引用变量赋值，又可以给这个子类(实现类对象)的父类(接口)变量赋值。
现货程序.rar_1234_abcd
01-20
现货程序.rar_1234_abcd
DEVC++单文件实现十六进制数类运算
10-04
以单文件的形式，实现十六进制数类的构建，并通过运算符重载，定义十六进制数的加减乘除取整等运算。
C++人民币输出（输出运算符重载）
hhhertzzz的博客
06-06 5091
题目描述 定义一个人民币类，包括元、角、分三个非负整数属性，操作包括初始化和输出 初始化用构造函数实现，接收一个浮点数参数（精度为小数点后两位），并转化为元、角、分，例如输入1.23元，经过构造函数转为1元、2角、3分 输出函数对元角分进行输出，具体格式看示例 由于OJ编译器对double强制类型转换成int的处理精度有偏差，建议加0.5处理(例如数据1.38，由于误差，在内存中的存储值为1.379999） 可以用全局函数重载法（课本介绍的），或者友元方法，两种方法来尝试实现 输入 第一行输入t表示有t个.
C++ | 人民币输出（输出运算符重载）
山风的小角落
06-22 4267
人民币输出（输出运算符重载）时间限制: 1 Sec  内存限制: 128 MB提交: 842  解决: 404[提交][状态][讨论版]题目描述定义一个人民币类，包括元、角、分三个非负整数属性，操作包括初始化和输出初始化用构造函数实现，接收一个浮点数参数（精度为小数点后两位），并转化为元、角、分，例如输入1.23元，经过构造函数转为1元、2角、3分输出函数对元角分进行输出，具体格式看示例由于VC重...
运算符重载函数作为类的友元函数
chuainong8497的博客
05-23 440
编写程序，完成以下功能： 1）定义表示金额的类Money，有私有成员yuan、jiao、fen，分别代表元、角、分的值； 2）将+、-、*、/四个运算符重载为普通函数，然后声明为Money类的友元； 3）编写main函数，测试Money。 代码如下： #include<iost...
面向对象与C++程序设计第13次练习题（堆与复制构造函数）
嗡哇吉利达那玛的博客
06-16 2013
答案为博主本人自作或查询，仅供参考 2-1 在类的定义中，用于为对象分配内存空间，对类的数据成员进行初始化并执行其他内部管理操作的函数是 友元函数 虚函数 构造函数 析构函数 2-2 类的析构函数的作用是 一般成员函数的初始化 类的初始化 对象的初始化 删除类创建的对象 2-3 下列函数中，（ ）不能重载。 成员函数 非成员函数 析构函数 构造函数 2-4 下列关于类和对象的叙述中，错误的是 一个类只能有一个对象 对象是类的具体实例 类是对某一类对象的抽象 类和对象的关系是一种数据类型与变量的关系 2-5
设计一个时间类Time，要求： （1）包含时(hour)、分(minute)和秒(second)私有数据成员。 （2）包含构造函数，重载关于一时间加上另一时间的加法运算符+、重载关于一时间减去另一时间
热门推荐
u012653518的专栏
12-02 4万+
#include using namespace std; class Time { private: int hour; int minute; int second; public: Time(); Time(int h, int m ,int s); Time operator+(Time &t); Time operator-(Time &t); Time ope
//12、设计人民币类，其数据成员为fen(分)、jiao(角)、yuan(元)。重载这个类的加法、减法运算符，并给出主函数应用该类。
qq_46340608的博客
05-22 5411
//12、设计人民币类，其数据成员为fen(分)、jiao(角)、yuan(元)。重载这个类的加法、减法运算符，并给出主函数应用该类。 #include"iostream" using namespace std; class money { private: int yuan,jiao,fen; public: money(int x=0,int y=0,int z=0):yuan(x),jiao(y),fen(z){} money operator+(money m); ...
用c++写一个栈，要求实现判断栈是否为空、出栈入栈、遍历栈、返回元素、销毁栈等功能，实现多态、运算符重载和文件操作，并改为模板
最新发布
06-07
好的，我来为你编写一个C++模板类实现栈的功能，包括判断栈是否为空、出栈入栈、遍历栈、返回元素、销毁栈等功能，同时支持多态、运算符重载和文件操作。 ```c++ #include #include using namespace std; ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值