《C++ Primer Plus（第六版）》（21）（第十一章 使用类 编程题答案2）

最新推荐文章于 2022-12-12 10:05:10 发布
最新推荐文章于 2022-12-12 10:05:10 发布
阅读量115 收藏
点赞数
文章标签： c/c++
原文链接：http://www.cnblogs.com/fablegame/p/6430243.html
版权

答案很长，所以分开两个文章。

4.

原来的代码：

Test.h

#ifndef _Test_H_  
#define _Test_H_  
#include <iostream>

class Time
{
public:
	Time();
	Time(int h, int m = 0);
	void AddMin(int m);
	void AddHr(int h);
	void Reset(int h = 0, int m = 0);
	Time operator+(const Time& t)const;
	Time operator-(const Time& t)const;
	Time operator*(double n)const;
	friend Time operator*(double m, const Time& t)
	{
		return t* m;
	}
	friend std::ostream& operator<<(std::ostream& os, const Time& t);
private:
	int hours;
	int minutes;
};
 

#endif
Test.cpp 

#include "Test.h"  
#include <iostream>  
#include <cmath>
  


Time::Time()
{
	hours = minutes = 0;
}

Time::Time(int h, int m /*= 0*/)
{
	hours = h;
	minutes = m;
}

void Time::AddMin(int m)
{
	minutes += m;
	hours += minutes / 60;
	minutes %= 60;
}

void Time::AddHr(int h)
{
	hours += h;
}

void Time::Reset(int h /*= 0*/, int m /*= 0*/)
{
	hours = h;
	minutes = m;
}

Time Time::operator+(const Time& t) const
{
	Time sum;
	sum.minutes = minutes + t.minutes;
	sum.hours = hours + t.hours + sum.minutes / 60;
	sum.minutes %= 60;
	return sum;
}

Time Time::operator-(const Time& t) const
{
	Time diff;
	int tot1 = t.minutes + 60 * t.hours;
	int tot2 = minutes + 60 * hours;
	diff.minutes = (tot2 - tot1) % 60;
	diff.hours = (tot2 - tot1) / 60;
	return diff;
}

Time Time::operator*(double mult) const
{
	Time result;
	long totalminutes = hours * mult * 60 + minutes * mult;
	result.hours = totalminutes / 60;
	result.minutes = totalminutes % 60;
	return result;
}

std::ostream& operator<<(std::ostream& os, const Time& t)
{
	os << t.hours << " hours, " << t.minutes << " minutes";
	return os;
}
main.cpp 

#include <iostream>     
#include "Test.h"  

using namespace std;


int main(int argc, const char * argv[])
{
	Time aida(3, 35);
	Time tosca(2, 48);
	Time temp;
	cout << "Aida and Tosca:\n";
	cout << aida << "; " << tosca << endl;
	temp = aida + tosca;
	cout << "Aida + Tosca: " << temp << endl;
	temp = aida * 1.17;
	cout << "Aida * 1.17: " << temp << endl;
	cout << "10.0 * Tosca: " << 10.0 * tosca << endl;
 
	return 0;
}

修改：

只修改Test.h和Test.cpp就行，不需要对使用的地方进行修改的。

Test.h

#ifndef _Test_H_  
#define _Test_H_  
#include <iostream>

class Time
{
public:
	Time();
	Time(int h, int m = 0);
	void AddMin(int m);
	void AddHr(int h);
	void Reset(int h = 0, int m = 0);
	friend Time operator+(const Time& a, const Time& b);
	friend Time operator-(const Time& a, const Time& b);
	friend Time operator*(const Time& t, double n);
	friend Time operator*(double m, const Time& t)
	{
		return t* m;
	}
	friend std::ostream& operator<<(std::ostream& os, const Time& t);
private:
	int hours;
	int minutes;
};
 

#endif
Test.cpp 

#include "Test.h"  
#include <iostream>  
#include <cmath>
  


Time::Time()
{
	hours = minutes = 0;
}

Time::Time(int h, int m /*= 0*/)
{
	hours = h;
	minutes = m;
}

void Time::AddMin(int m)
{
	minutes += m;
	hours += minutes / 60;
	minutes %= 60;
}

void Time::AddHr(int h)
{
	hours += h;
}

void Time::Reset(int h /*= 0*/, int m /*= 0*/)
{
	hours = h;
	minutes = m;
}

Time operator+(const Time& a, const Time& b)
{
	Time sum;
	sum.minutes = a.minutes + b.minutes;
	sum.hours = a.hours + b.hours + sum.minutes / 60;
	sum.minutes %= 60;
	return sum;
}

Time operator-(const Time& a, const Time& b)
{
	Time diff;
	int tot1 = a.minutes + 60 * a.hours;
	int tot2 = b.minutes + 60 * b.hours;
	diff.minutes = (tot2 - tot1) % 60;
	diff.hours = (tot2 - tot1) / 60;
	return diff;
}

Time operator*(const Time& t, double mult)
{
	Time result;
	long totalminutes = t.hours * mult * 60 + t.minutes * mult;
	result.hours = totalminutes / 60;
	result.minutes = totalminutes % 60;
	return result;
}

std::ostream& operator<<(std::ostream& os, const Time& t)
{
	os << t.hours << " hours, " << t.minutes << " minutes";
	return os;
}

5.

原来的：

Test.h

#ifndef _Test_H_  
#define _Test_H_  
#include <iostream>

class Stonewt
{
public:
	Stonewt(double lbs);
	Stonewt(int stn, double lbs);
	Stonewt();
	~Stonewt();
	void show_lbs()const;
	void show_stn()const;
private:
	enum {Lbs_per_stn = 14};
	int stone;
	double pds_left;
	double pounds;
	
}; 
#endif
Test.cpp 

#include "Test.h"  
#include <iostream>  
#include <cmath>
  
using namespace std;
Stonewt::Stonewt(double lbs)
{
	stone = int(lbs) / Lbs_per_stn;
	pds_left = int(lbs) % Lbs_per_stn + lbs - int(lbs);
	pounds = lbs;
}

Stonewt::Stonewt(int stn, double lbs)
{
	stone = stn;
	pds_left = lbs;
	pounds = stn * Lbs_per_stn + lbs;
}

Stonewt::Stonewt()
{
	stone = pounds = pds_left = 0;
}

Stonewt::~Stonewt()
{

}

void Stonewt::show_lbs() const
{
	cout << stone << " stone, " << pds_left << " pounds\n";
}

void Stonewt::show_stn() const
{
	cout << pounds << " pounds\n";
}
main.cpp 
#include <iostream>     
#include "Test.h"  

using namespace std;

void display(const Stonewt& st, int n);
int main(int argc, const char * argv[])
{
	Stonewt incognito = 275;
	Stonewt wolfe(285.7);
	Stonewt taft(21, 8);
	cout << "The celebrity weighted ";
	incognito.show_stn();
	cout << "The detective weighted ";
	wolfe.show_stn();
	cout << "The President weighed ";
	taft.show_lbs();
	incognito = 276.8;
	taft = 325;
	cout << "After dinner, the celebrity weighed ";
	incognito.show_stn();
	cout << "After dinner, the President weighed ";
	taft.show_lbs();
	display(taft, 2);
	cout << "The wrestler weighed even more.\n";
	display(422, 2);
	cout << "No stone left unesrned\n";

	return 0;
}

void display(const Stonewt& st, int n)
{
	for (int i = 0; i < n; i++)
	{
		cout << "Wow! ";
		st.show_stn();
	}
}
修改：

Test.h

#ifndef _Test_H_  
#define _Test_H_  
#include <iostream>

using namespace std;
enum EMode
{
	EStone,//英石格式
	EPounds,//浮点磅格式
	EPoundsInt//整数磅格式
};
class Stonewt
{
public:
	
	Stonewt(double lbs);
	Stonewt(int stn, double lbs);
	Stonewt();
	~Stonewt();
	void setMode(EMode m);
	friend ostream& operator<<(ostream& os, Stonewt& st);
private:
	enum {Lbs_per_stn = 14};
	int stone;
	double pds_left;
	double pounds;
	int mode;//模式
	
}; 
#endif
Test.cpp 

#include "Test.h"  
#include <iostream>  
#include <cmath>
  
using namespace std;
Stonewt::Stonewt(double lbs)
{
	stone = int(lbs) / Lbs_per_stn;
	pds_left = int(lbs) % Lbs_per_stn + lbs - int(lbs);
	pounds = lbs;
	mode = EPounds;
}

Stonewt::Stonewt(int stn, double lbs)
{
	stone = stn;
	pds_left = lbs;
	pounds = stn * Lbs_per_stn + lbs;
	mode = EStone;
}

Stonewt::Stonewt()
{
	pounds = pds_left = stone = 0;
	mode = EPounds;
}

Stonewt::~Stonewt()
{

} 

void Stonewt::setMode(EMode m)
{
	mode = m;
}

ostream& operator<<(ostream& os, Stonewt& st)
{
	if (st.mode == EStone)
	{
		os << st.stone << " stone, " << st.pds_left << " pounds\n";
	}
	else if (st.mode == EPounds)
	{
		os << st.pounds << " pounds\n";
	}
	else if (st.mode == EPoundsInt)
	{
		os << int(st.pounds) << " pounds\n";
	}
	else
	{
		os << "error mode";
	}
	return os;
}
main.cpp 

#include <iostream>     
#include "Test.h"  

using namespace std;
 
int main(int argc, const char * argv[])
{
	Stonewt a(285.7);
	cout << a;
	a.setMode(EStone);
	cout << a;
	a.setMode(EPoundsInt);
	cout << a;
	return 0;
}

6.

Test.h

#ifndef _Test_H_  
#define _Test_H_  
#include <iostream>

using namespace std;
enum EMode
{
	EStone,//英石格式
	EPounds,//浮点磅格式
	EPoundsInt//整数磅格式
};
class Stonewt
{
public:
	
	Stonewt(double lbs);
	Stonewt(int stn, double lbs);
	Stonewt();
	~Stonewt();
	void setMode(EMode m);
	friend ostream& operator<<(ostream& os, Stonewt& st);
	friend bool operator<(Stonewt& a, Stonewt& b);
	friend bool operator<=(Stonewt& a, Stonewt& b);
	friend bool operator==(Stonewt& a, Stonewt& b);
	friend bool operator>(Stonewt& a, Stonewt& b);
	friend bool operator>=(Stonewt& a, Stonewt& b);
	friend bool operator!=(Stonewt& a, Stonewt& b);
private:
	enum {Lbs_per_stn = 14};
	int stone;
	double pds_left;
	double pounds;
	int mode;//模式
	
};  
#endif
Test.cpp 

#include "Test.h"  
#include <iostream>  
#include <cmath>
  
using namespace std;
Stonewt::Stonewt(double lbs)
{
	stone = int(lbs) / Lbs_per_stn;
	pds_left = int(lbs) % Lbs_per_stn + lbs - int(lbs);
	pounds = lbs;
	mode = EPounds;
}

Stonewt::Stonewt(int stn, double lbs)
{
	stone = stn;
	pds_left = lbs;
	pounds = stn * Lbs_per_stn + lbs;
	mode = EStone;
}

Stonewt::Stonewt()
{
	pounds = pds_left = stone = 0;
	mode = EPounds;
}

Stonewt::~Stonewt()
{

} 

void Stonewt::setMode(EMode m)
{
	mode = m;
}

ostream& operator<<(ostream& os, Stonewt& st)
{
	if (st.mode == EStone)
	{
		os << st.stone << " stone, " << st.pds_left << " pounds\n";
	}
	else if (st.mode == EPounds)
	{
		os << st.pounds << " pounds\n";
	}
	else if (st.mode == EPoundsInt)
	{
		os << int(st.pounds) << " pounds\n";
	}
	else
	{
		os << "error mode";
	}
	return os;
}

bool operator<(Stonewt& a, Stonewt& b)
{
	return a.pounds < b.pounds;
}
bool operator<=(Stonewt& a, Stonewt& b)
{
	return a.pounds <= b.pounds;
}
bool operator==(Stonewt& a, Stonewt& b)
{
	return a.pounds == b.pounds;
}
bool operator>(Stonewt& a, Stonewt& b)
{
	return a.pounds > b.pounds;
}
bool operator>=(Stonewt& a, Stonewt& b)
{
	return a.pounds >= b.pounds;
}
bool operator!=(Stonewt& a, Stonewt& b)
{
	return a.pounds != b.pounds;
}
main.cpp 

#include <iostream>     
#include "Test.h"  

using namespace std;
 
int main(int argc, const char * argv[])
{
	Stonewt a(11,0);
	cout << a;

	Stonewt b[6] = { 123, 23.32, 3.3 };
	for (int i = 3; i < 6; i++)
	{
		b[i] = rand();
	}
	Stonewt min;
	Stonewt max;
	for (int i = 0; i < 6; i ++)
	{
		if (i == 0)
		{
			min = b[i];
			max = b[i];
		}
		else
		{
			if (min > b[i])
			{
				min = b[i];
			}
			if (max < b[i])
			{
				max = b[i];
			}
		}
		if (b[i] >= a)
		{
			cout << "bigger than 11: " << b[i] << endl;
		}
	}
	cout << "Min: " << min << endl;
	cout << "Max: " << max << endl;
	return 0;
}

7.
Test.h 

#ifndef _Test_H_  
#define _Test_H_  
#include <iostream>

using namespace std;
namespace FableGame
{
	class Complex
	{
	public:
	
		Complex(double real, double imaginary = 0);
		Complex();
		~Complex();
		friend ostream& operator<<(ostream& os, Complex& st);
		friend istream& operator>>(istream& is, Complex& st);
		friend Complex operator+(Complex& a, Complex& b);
		friend Complex operator-(Complex& a, Complex& b);
		friend Complex operator*(Complex& a, Complex& b);
		friend Complex operator*(double a, Complex& b);
		friend Complex operator~(Complex& a ); 
	private:
		double _real;
		double _imaginary;
	
	};  
}
#endif
Test.cpp 

#include "Test.h"  
#include <iostream>  
#include <cmath>
  
using namespace std;

FableGame::Complex::Complex(double real, double imaginary)
{
	_real = real;
	_imaginary = imaginary;
}

FableGame::Complex::Complex()
{
	_real = 0;
	_imaginary = 0;
}

FableGame::Complex::~Complex()
{

}

ostream& FableGame::operator<<(ostream& os, FableGame::Complex& a)
{
	os << "(" << a._real << ", " << a._imaginary << "i)";
	return os;
}

istream& FableGame::operator>>(istream& is, FableGame::Complex& a)
{
	cout << "real: ";
	if (is >> a._real)
	{
		cout << "imaginary: ";
		is >> a._imaginary;
	}
	return is;
}
FableGame::Complex FableGame::operator+(FableGame::Complex& a, FableGame::Complex& b)
{
	FableGame::Complex c;
	c._real = a._real + b._real;
	c._imaginary = a._imaginary + b._imaginary;
	return c;
}
FableGame::Complex FableGame::operator-(FableGame::Complex& a, FableGame::Complex& b)
{
	FableGame::Complex c;
	c._real = a._real - b._real;
	c._imaginary = a._imaginary - b._imaginary;
	return c;
}
FableGame::Complex FableGame::operator*(FableGame::Complex& a, FableGame::Complex& b)
{
	FableGame::Complex c;
	c._real = a._real*b._real - a._imaginary*b._imaginary;
	c._imaginary = a._imaginary*b._real + a._real*b._imaginary;
	return c;
}

FableGame::Complex FableGame::operator*(double a, FableGame::Complex& b)
{
	FableGame::Complex c(a); 
	return c * b;
}

FableGame::Complex FableGame::operator~(FableGame::Complex& a)
{
	FableGame::Complex c;
	c._real = a._real;
	c._imaginary = -a._imaginary;
	return c;
}
main.cpp 

#include <iostream>     
#include "Test.h"  

using namespace std;
 
int main(int argc, const char * argv[])
{
	FableGame::Complex a(3, 4);
	FableGame::Complex c;
	cout << "Enter a complex number (q to quit):\n";
	while (cin>>c)
	{
		cout << "c is " << c << '\n';
		cout << "complex conjugate is " << ~c << "\n";
		cout << "a is " << a << endl;
		cout << "a + c is " << a + c << endl;
		cout << "a - c is " << a - c << endl;
		cout << "a * c is " << a * c << endl;
		cout << "2 * c is " << 2 * c << endl;
	}
	cout << "Done!" << endl;
	return 0;
}












转载于:https://www.cnblogs.com/fablegame/p/6430243.html

weixin_30569153
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C++ Primer Plus 第6版 中文版课后代码习题答案
03-10
《C++ Primer Plus 第6版 中文版》是一本深入浅出的C++学习书籍，其课后代码习题答案是学习过程中不可或缺的部分。这本书旨在帮助读者从零基础开始掌握C++编程语言，通过实例和习题来巩固理论知识，提升编程技能。...
c++ primer plus 第六版 课后习题答案
01-15
《C++ Primer Plus 第六版》是一本深受程序员喜爱的C++学习书籍，它深入浅出地介绍了C++编程语言的基础知识和高级特性。作为学习过程中不可或缺的一部分，课后习题是检验和巩固所学知识的关键。这本书的第六版课后...
c++PrimerPlus 第十一章
qq_36971581的博客
03-17 843
成员函数，重载运算符，对象和基本类型之间的转化
《C++ Primer Plus》第11章：使用类（2）
最新发布
weixin_40064300的博客
12-12 365
运算符重载，转换函数
【C++ Primer Plus】第11章 使用类
chaiky的博客
09-16 906
运算符重载。 友元函数。 重载
C++ Primer Plus第十一章摘要
stella_wy的博客
09-06 120
2020年8月20日 第十一章 使用类 运算符重载 友元函数 重载<<运算符，以便用于输出 状态成员 使用rand()生成随机值 类的自动转换和强制类型转换 类转换函数 1.“轻松地使用这种语言。不要觉得必须使用所有地特性，不要在第一次学习时就试图使用所有的特性。” 2.运算符重载： 是一种形式的C++多态 运算符函数：operator op(argument-list) Time operator+(const Time&a...
C++ primer plus 第11章 使用类
CHY1156957638的博客
01-07 215
1.添加加法运算符 operator+()函数的名称使得可以使用函数表示法或运算符表示法来调用它。 total=coding.operator+(fixing);//函数表示法 total=coding+fixing;//运算符表示法 多数C++运算符都可以用这样的方式重载。重载的运算符不必是成员函数，但必须至少有一个操作数是用户定义的类型。 重载运算符的限制：(1)重载后的运算符必须...
C++ Primer Plus 第六版 第6版 中文版 编程练习答案
08-17
C++ Primer Plus 第六版 第6版 中文版 编程练习答案 全面详细，助力深入理解C++精髓
C++PrimerPlus第六版第八章课后编程题参考代码.rar
04-30
《C++ Primer Plus第六版》是C++学习者的一本经典教材，其第八章主要涵盖了类和对象的深入探讨，包括类的封装、继承、多态等面向对象编程的核心概念。编程题通常用来巩固和深化对这些概念的理解，通过实际编写代码来...
C++PrimerPLus第六版中文版课后练习编程题答案第二章
11-06
### C++ Primer Plus 第六版第二章课后编程练习题解析 #### 题目背景 在《C++ Primer Plus》这本书的第二章中，作者介绍了C++的基础语法，包括变量声明、输入输出、基本的数据类型等。为了帮助读者更好地理解这些...
C++回炉之_C++PrimerPlus_第十一章 使用类
duaduac.com
03-25 348
运算符重载 运算符重载是多态的一种形式 C++允许赋予运算符多种含义 运算符重载可使使用自定义类型看起来更像基本的数据类型 一个例子 使用 operator声明重载函数 调用 z = x + y; 相当于 z = x.operator+(y); #pragma once class Point{ private: double m_x; double m_y; pr...
c++ primer plus 第11章 使用类
Hu_yilang的博客
02-27 303
一 般 来 说 ， 访 问 私 有 类 成员 的 唯 一 方 法 是 使 用 类 方 法 。 c + + 使 用 友 元 函 数 来 避 开 这 种 限制 。 要 让 函 数 成 为 友 元 ， 需 要 在 类 声 明 中 声 明 该 函 数 ， 并 在 声 明 前 加 上 关 键 字 friend 。 　　　c ＋＋扩展 了 对 运 算 符 的 重 载 ， 允 许 自 定 义 特 殊 的
敲代码的第三天：创建时间类实现功能（c++）
qq_58131187的博客
10-11 221
题目要求：再加两个功能：正数计时和倒数计时 #include<iostream> #include<windows.h> using namespace std; class Time { public: int hour; int minute; int sec; Time() { int hour=0; minute = 0; sec = 0; } Time(int h,int m, int s):hour(h),minute(m), s.
.h头文件中的ifndef/define/endif 的作用
欢迎交流
03-22 1953
防止该头文件被重复利用
Java基础笔试练习（九）
Coder编程的博客
09-25 1232
1.下面所示的java代码，运行时，会产生（）类型的异常 ？ int Arry_a[] = new int[10]; System.out.println(Arry_a[10]); A.ArithmeticException B.NullPointException C.IOException D.ArrayIndexOutOfBoundsException 答案： D 解析： 定义的数组长度...
#ifndef#define#endif的用法(整理)
热门推荐
放牛娃的专栏
07-27 1万+
1.头文件中的#ifndef头件的中的#ifndef，这是一个很关键的东西。比如你有两个C文件，这两个C文件都include了同一个头文件。而编译时，这两个C文件要一同编译成一个可运行文件，于是问题来了，大量的声明冲突。 还是把头文件的内容都放在#ifndef和#endif中吧。不管你的头文件会不会被多个文件引用，你都要加上这个。一般格式是这样的： #ifndef #define
must take either zero or one argument错误分析
zjq_smile的博客
06-05 7747
今天在整理笔记的时候，发现笔记本上只有“+”重载运算符的友元函数的形式，没有成员函数的重载形式，但是根据重载的规则，这个运算符也是可以用成员函数的重载方式的，便开始了自己的尝试，然后我发现了一个问题，会报错“must take either zero or one argument” 我的代码是这样子写的： String& String:: operator+(const String
头文件为什么要加#ifndef #define #endif
穿着帆布鞋也能走猫步
11-22 6127
一 #ifndef 在头文件中的作用一个大的软件工程里有多个文件同时包含一个头文件,当这些文件编译链接成一个可执行文件时，就会出现大量“重定义”的错误。这时在头文件中使用#ifndef #define #endif,就可以防止头文件的重复包含和编译. 例如,编写一个头文件test.h在头文件开头写上两行： #ifndef _TEST_H #define _TEST_H//一般
《C++ Primer Plus（第6版）中文版》编程练习答案汇总（第1-5章）
"《C++ Primer Plus（第6版）中文版》编程练习答案第1-5章" 本资源是《C++ Primer Plus（第6版）中文版》编程练习答案的集合，涵盖了第1-5章的编程练习答案。这些练习题是学习C++编程语言的基础，涵盖了基本语法、...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值