C++ Primer Plus第六版第十五章友元、异常和其他编程练习答案

1.
main

#include "TV.h"

int main()
{
	using std::cout;
	Tv s42;
	Remote grey;
	cout << "Initial settings for 42\" TV:\n";
	s42.settings();
	grey.show_r_mode();
	s42.change_r_mode(grey);
	s42.onoff();
	s42.chanup();
	cout << "\nAdjusted settings for 42\" TV:\n";
	s42.chanup();
	cout << "\nAdjusted settings for 42\" TV:\n";
	s42.settings();

	s42.change_r_mode(grey);

	grey.set_chan(s42, 10);
	grey.volup(s42);
	grey.volup(s42);
	cout << "\n42\" settings after using remote:\n";
	s42.settings();

	s42.change_r_mode(grey);

	Tv s58(Tv::On);
	s58.set_mode();
	grey.set_chan(s58, 28);
	cout << "\n58\" settings:\n";
	s58.settings();
	grey.show_r_mode();
	s58.change_r_mode(grey);
	return 0;
}

TV.h

#include 
class Remote;
class Tv
{
public:
	enum { Off, On };
	enum { MinVal, MaxVal = 20 };
	enum { Antenna, Cable };
	enum { TV, DVD };
	friend class Remote;
	Tv(int s = Off, int mc = 125) : state(s), volume(5), maxchannel(mc), channel(2), mode(Cable), input(TV) {}
	void onoff() { state = (state == On) ? Off : On; }
	bool ison() const { return state == On; }
	bool volup();
	bool voldown();
	void chanup();
	void chandown();
	void set_mode() { mode = (mode == Antenna) ? Cable : Antenna; }
	void set_input() { input = (input == TV) ? DVD : TV; }
	void settings() const;
	void change_r_mode(Remote & r);
private:
	int state;
	int volume;
	int maxchannel;
	int channel;
	int mode;
	int input;
};

class Remote
{
	friend class Tv;
private:
	int mode;
	int r_mode;
public:
	enum { Regular, Interact };
	Remote(int m = Tv::TV, int f = Regular) : mode(m), r_mode(f) {}
	bool volup(Tv & t) { return t.volup(); }
	bool voldown(Tv & t) { return t.voldown(); }
	void onoff(Tv & t) { t.onoff(); }
	void chanup(Tv & t) { t.chanup(); }
	void chandown(Tv & t) { t.chandown(); }
	void set_chan(Tv & t, int c) { t.channel = c; }
	void set_mode(Tv & t) { t.set_mode(); }
	void set_input(Tv & t) { t.set_input(); }
	void show_r_mode() const { std::cout << "Now the remote mode is " << (r_mode == Regular ? "Regular" : "Interact") << ".\n"; }
};

inline void Tv::change_r_mode(Remote & r)
{

	if (ison())
	{
		r.r_mode = r.r_mode == Remote::Regular ? Remote::Interact : Remote::Regular;
		r.show_r_mode();
	}
	else
	{
		std::cout << "The tv is off, please turn it on!\n";
	}
}
bool Tv::volup()
{
	if (volume < MaxVal)
	{
		volume++;
		return true;
	}
	else
		return false;
}
bool Tv::voldown()
{
	if (volume > MinVal)
	{
		volume--;
		return true;
	}
	else
		return false;
}
void Tv::chanup()
{
	if (channel < maxchannel)
		channel++;
	else
		channel = 1;
}
void Tv::chandown()
{
	if (channel > 1)
		channel--;
	else
		channel = maxchannel;
}
void Tv::settings()const
{
	using std::cout;
	using std::endl;
	cout << "Tv is " << (state == Off ? "off" : "on") << endl;
	if (state == On)
	{
		cout << "Volume setting = " << volume << endl;
		cout << "Channel setting = " << channel << endl;
		cout << "Mode = "
			<< (mode == Antenna ? "antenna" : "cable") << endl;
		cout << "Input = "
			<< (input == TV ? "TV" : "DVD") << endl;
	}
}

2.
main.cpp

#include "test.h"
double hmean(double a, double b);
double gmean(double a, double b);
int main()
{
	using std::cout;
	using std::cin;
	using std::endl;
	double x, y, z;
	cout << "Enter two numbers: ";
	while (cin >> x >> y)
	{
		try {
			z = hmean(x, y);
			cout << "Harmonic mean of " << x << " and " << y
				<< " is " << z << endl;
			cout << "Geometric mean of " << x << " and " << y
				<< " is " << gmean(x, y) << endl;
			cout << "Enter next set of numbers : ";
		}
		catch (bad_hmean & bg)
		{
			cout << bg.what();
			bg.mesg();
			cout << "Try again.\n";
			continue;
		}
		catch (bad_gmean & hg)
		{
			cout << hg.what();
			hg.mesg();
			cout << "Values used: " << hg.v1 << ", "
				<< hg.v2 << endl;
			cout << "Sorry, you don't get to play any more.\n";
			break;
		}

	}
	cout << "Bye!\n";
	return 0;
}
double hmean(double a, double b)
{
	if (a == -b)
		throw bad_hmean(a, b);
	return 2.0 * a * b / (a + b);
}
double gmean(double a, double b)
{
	if (a < 0 || b < 0)
		throw bad_gmean(a, b);
	return std::sqrt(a * b);
}

test.h

#ifndef test_H_
#define test_H_
#include
#include
class bad_hmean :public std::logic_error
{
private:
	double v1;
	double v2;
public:
	bad_hmean(double a = 0, double b = 0, const std::string & s = "Index error in bad_hmenan\n")
		:std::logic_error(s), v1(a), v2(b) {}
	void mesg();
};
inline void bad_hmean::mesg()
{
	std::cout << "hmean(" << v1 << ", " << v2 << "): "
		<< "invalid arguments: a = -b\n";
}
class bad_gmean :public std::logic_error
{
public:
	double v1;
	double v2;
	bad_gmean(double a = 0, double b = 0, const std::string & s = "Index error in bad_hmenan\n")
		:std::logic_error(s), v1(a), v2(b) {}
	const char * mesg();
};
inline const char * bad_gmean::mesg()
{
	return "gmean() arguments should be >= 0\n";
}
#endif

3.

#include "test.h"
#include
double hmean(double a, double b);
double gmean(double a, double b);
int main()
{
	using std::cout;
	using std::cin;
	using std::endl;
	double x, y, z;
	cout << "Enter two numbers: ";
	while (cin >> x >> y)
	{
		try {
			z = hmean(x, y);
			cout << "Harmonic mean of " << x << " and " << y
				<< " is " << z << endl;
			cout << "Geometric mean of " << x << " and " << y
				<< " is " << gmean(x, y) << endl;
			cout << "Enter next set of numbers : ";
		}
		catch (bad &b)
		{
			if (typeid(b) == typeid(bad_hmean))
			{
				cout << b.what();
				b.mesg();
				cout << "sorry, you don't get to play any more.\n";
				break;
			}
			else if (typeid(b) == typeid(bad_gmean))
			{
				cout << b.what();
				b.mesg();
				cout << "sorry, you don't get to play any more.\n";
				break;
			}
			cout << b.what();
			cout << " Try again.\n";
			continue;
		}
	}
	cout << "Bye!\n";
	return 0;
}
double hmean(double a, double b)
{
	if (a == -b)
		throw bad_hmean("error in hmean\n", a, b);
	return 2.0 * a * b / (a + b);
}
double gmean(double a, double b)
{
	if (a < 0 || b < 0)
		throw bad_gmean("error in gmean\n", a, b);
	return std::sqrt(a * b);
}

#ifndef test_H_
#define test_H_
#include
#include
class bad :public std::logic_error
{
public:
	double v1;
	double v2;
	explicit bad(const std::string & s = "bad error!", double a = 0, double b = 0)
		:logic_error(s), v1(a), v2(b) {}
	virtual ~bad() {}
	virtual void mesg() { std::cout << "Error happened!\n"; }

};
class bad_hmean :public bad
{
public:
	bad_hmean(const std::string & s = "Index error in bad_hmenan\n", double a = 0, double b = 0)
		:bad(s, a, b) {}
	void mesg();

};
inline void bad_hmean::mesg()
{
	std::cout << "hmean(" << v1 << ", " << v2 << "): "
		<< "invalid arguments: a = -b\n";
}

class bad_gmean :public bad
{
public:
	bad_gmean(const std::string & s = "Index error in bad_hmenan\n", double a = 0, double b = 0)
		:bad(s, a, b) {}
	void mesg();
};
inline void bad_gmean::mesg()
{
	std::cout << "value: " << v1 << " " << v2;
	std::cout << "\ngmean() arguments should be >= 0\n";

}
#endif

4.

sales.h

#include "sales.h"
#include
int main()
{
	using std::cout;
	using std::cin;
	using std::endl;
	double vals1[12] =
	{
		1220, 1100, 1122, 2212, 1232, 2334,
		2884, 2393, 3302, 2922, 3002, 3544
	};

	double vals2[12] =
	{
		12, 11, 22, 21, 32, 34,
		28, 29, 33, 29, 32, 35
	};
	Sales sales1(2011, vals1, 12);
	LabeledSales sales2("Blogstar", 2012, vals2, 12);
	LabeledSales::nbad_index *l;

	cout << "First try block:\n";
	try
	{
		int i;
		cout << "year = " << sales1.Year() << endl;
		for (int i = 0; i < 12; ++i)
		{
			cout << sales1[i] << ' ';
			if (i % 6 == 5)
				cout << endl;
		}
		cout << "Year = " << sales2.Year() << endl;
		cout << "Label = " << sales2.Label() << endl;
		for (i = 0; i <= 12; ++i)
		{
			cout << sales2[i] << ' ';
			if (i % 6 == 5)
				cout << endl;
		}
		cout << "End of try block 1.\n";
	}
	catch (Sales::bad_index & bad)
	{
		if ((l = dynamic_cast<LabeledSales::nbad_index*>(&bad)))
		{
			cout << l->what();
			cout << "Company: " << l->label_val() << endl;
			cout << "bad index: " << l->bi_val() << endl;
		}
		else
		{
			cout << bad.what();
			cout << "bad index: " << bad.bi_val() << endl;
		}
	}
	cout << "\n Next try block:\n";
	try
	{
		sales2[2] = 37.5;
		sales1[20] = 23345;
		cout << "End of try block 2.\n";
	}
	catch (Sales::bad_index & bad)
	{
		if ((l = dynamic_cast<LabeledSales::nbad_index*>(&bad)))
		{
			cout << l->what();
			cout << "Company: " << l->label_val() << endl;
			cout << "bad index: " << l->bi_val() << endl;
		}
		else
		{
			cout << bad.what();
			cout << "bad index: " << bad.bi_val() << endl;
		}
	}
	cout << "done\n";
	return 0;
}

#ifndef Sales_H_
#define Sales_H_
#include
#include
#include

class Sales
{
public:
	enum { MONTHS = 12 };;
	class bad_index : public std::logic_error
	{
	private:
		int bi;
	public:
		explicit bad_index(int ix, const std::string & s = "Index error in Sales object\n");
		int bi_val() const { return bi; }
		virtual ~bad_index() throw() {}
	};
	explicit Sales(int yy = 0);
	Sales(int yy, const double * gr, int n);
	virtual ~Sales() {}
	int Year() const { return year; }
	virtual double operator[](int i) const;
	virtual double & operator[](int i);
private:
	double gross[MONTHS];
	int year;
};

class LabeledSales : public Sales
{
public:
	class nbad_index : public Sales::bad_index
	{
	private:
		std::string lbl;
	public:
		nbad_index(const std::string & lb, int ix, const std::string & s = "Index error in LabeledSales object\n");
		const std::string & label_val() const { return lbl; }
		virtual ~nbad_index() throw() {}
	};
	explicit LabeledSales(const std::string & lb = "none", int yy = 0);
	LabeledSales(const std::string & lb, int yy, const double * gr, int n);
	virtual ~LabeledSales() {}
	const std::string & Label() const { return label; }
	virtual double operator[](int i) const;
	virtual double & operator[](int i);
private:
	std::string label;
};
Sales::bad_index::bad_index(int ix, const std::string & s) : std::logic_error(s), bi(ix) {}

Sales::Sales(int yy)
{
	year = yy;
	for (int i = 0; i < MONTHS; i++)
	{
		gross[i] = 0;
	}
}

Sales::Sales(int yy, const double * gr, int n)
{
	year = yy;
	int lim = (n < MONTHS) ? n : MONTHS;
	int i;
	for (i = 0; i < lim; ++i)
	{
		gross[i] = gr[i];
	}
	for (; i < MONTHS; ++i)
	{
		gross[i] = 0;
	}
}

double Sales::operator[](int i) const
{
	if (i < 0 || i >= MONTHS)
	{
		throw bad_index(i);
	}
	return gross[i];
}

double & Sales::operator[](int i)
{
	if (i < 0 || i >= MONTHS)
	{
		throw bad_index(i);
	}
	return gross[i];
}

LabeledSales::nbad_index::nbad_index(const std::string & lb, int ix, const std::string & s) : Sales::bad_index(ix, s)
{
	lbl = lb;
}

LabeledSales::LabeledSales(const std::string & lb, int yy) : Sales(yy)
{
	label = lb;
}

LabeledSales::LabeledSales(const std::string & lb, int yy, const double * gr, int n) : Sales(yy, gr, n)
{
	label = lb;
}

double LabeledSales::operator[](int i) const
{
	if (i < 0 || i >= MONTHS)
	{
		throw nbad_index(Label(), i);
	}
	return Sales::operator[](i);
}

double & LabeledSales::operator[](int i)
{
	if (i < 0 || i >= MONTHS)
	{
		throw nbad_index(Label(), i);
	}
	return Sales::operator[](i);

}
#endif