C++ Primer Plus （第六版）编程练习记录（chapter15 友元、异常和其他）

最新推荐文章于 2024-10-04 17:07:53 发布

零矩阵

最新推荐文章于 2024-10-04 17:07:53 发布

阅读量232

点赞数

分类专栏： C++编程文章标签： c++ 类 exception

本文链接：https://blog.csdn.net/px597/article/details/106501725

版权

C++编程专栏收录该内容

16 篇文章 0 订阅

订阅专栏

1．对Tv和Remote类做如下修改：
a．让它们互为友元；
b．在Remote类中添加一个状态变量成员，该成员描述遥控器是处于常规模式还是互动模式；
c．在Remote中添加一个显示模式的方法；
d．在Tv类中添加一个对Remote中新成员进行切换的方法，该方法应仅当TV处于打开状态时才能运行。
编写一个小程序来测试这些新特性。

//class.h
#ifndef CLASS_H_
#define CLASS_H_
#include <iostream>
#include <string>
using namespace std;

class Remote;
class Tv
{
public:
	friend class Remote;

	enum State { Off, On };
	enum { Minval, Maxval = 20 };
	enum { Antenna, Cable };
	enum { TV, DVD };

	Tv(int s = Off, int mc = 125) :state(s), volume(5),
		maxchannel(mc), channel(1), mode(Cable), input(TV) {};
	~Tv() {};

	void onoff() { state = ((state == On) ? Off : On); }
	bool ison()const { return state == On; }
	bool volup();
	bool voldown();
	void chanup();
	void chandown();
	void set_chan(int c);
	void set_mode() { mode = (mode == Antenna) ? Cable : Antenna; }
	void set_input() { input = (input == TV) ? DVD : TV; }
	void setting() const;
	void set_intMode(Remote& r);

private:
	int state;
	int volume;
	int maxchannel;
	int channel;
	int mode;
	int input;
};

class Remote
{
public:
	friend class Tv;

	enum { TV, DVD };
	enum { Routine, Interaction};// 常规模式和互动模式
	Remote(int m = TV, int intmode = Routine) :mode(m), intMode(intmode) {};
	~Remote() {};
	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_mode(Tv& t) { t.set_mode(); }
	void set_input(Tv& t) { t.set_input(); }
	void set_chan(Tv& t, int c) { t.set_chan(c); }
	void show_mode() { std::cout << "Interaction mode: " << (intMode == Routine ? "Routine" : "Interaction") << std::endl; }

private:
	int mode;
	int intMode;
};

#endif // !CLASS_H_

//class.cpp
#include"class.h"

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 > 0)
		channel--;
	else
		channel = maxchannel;
}

void Tv::set_chan(int c)
{
	if (c > 0 && c <= maxchannel)
		channel = c;
	else
		std::cout << "Wrong enter.\n";
}
void Tv::set_intMode(Remote& r)
{
	if (ison())
	{
		r.intMode = (r.intMode == Remote::Routine ? Remote::Interaction : Remote::Routine);
	}
	else
		cout << "The tv is off,please turn it in first.\n" << endl;
};

void Tv::setting() 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;
	}
}

//main.cpp
/* *************************************************
* 文件名：
* 创建人：px
* 创建时间：2020/6/3 
* 描述：
************************************************* */
#include<iostream>
#include<string>
#include"class.h"

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

	s42.set_intMode(grey);

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

	s42.set_intMode(grey);

	Tv s58(Tv::On);
	s58.set_mode();
	grey.set_chan(s58, 28);
	cout << "\n58\" settings:\n";
	s58.setting();
	grey.show_mode();
	s58.set_intMode(grey);
	// std::cin.get();
	return 0;
}

2．修改程序清单15.11，使两种异常类型都是从头文件提供的logic_error类派生出来的类。让每个what( )方法都报告函数名和问题的性质。异常对象不用存储错误的参数值，而只需支持what( )方法。

//class.h
#ifndef CLASS_H_
#define CLASS_H_
#include <iostream>
#include <exception>
using namespace std;

class bad_hmean:public exception
{
public:
	bad_hmean(double a = 0, double b = 0) :v1(a), v2(b) {};
	void msag();
	const char* what() { return "bad arguments to hmean()"; }
	~bad_hmean() {};

private:
	double v1;
	double v2;
};
class bad_gmean:public exception
{
public:
	double v1;
	double v2;

	bad_gmean(double a = 0, double b = 0) :v1(a), v2(b) {};
	~bad_gmean() {};
	const char* msag();
	const char* what() { return "bad arguments to gmean()"; }
};

inline void bad_hmean::msag()
{
	cout << "hmean( " << v1 << ", " << v2 << " ):"
		<< "invalid arguments: a = -b\n";
};
inline const char* bad_gmean::msag()
{
	return "gmean() arguments should be >= 0.\n";
};
#endif // !CLASS_H_

//main.cpp
/* *************************************************
* 文件名：
* 创建人：px
* 创建时间：2020/6/3 
* 描述：
************************************************* */
#include <iostream>
#include <cmath>
#include "class.h"

// function prototypes
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 {                  // start of try block
			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 <q to quit>: ";
		}// end of try block
		catch (bad_hmean& bg)    // start of catch block
		{
			bg.msag();
			cout << "Error message:\n" << bg.what() << endl;
			cout << "Try again.\n";
			cout << "Enter two numbers: ";
			continue;
		}
		catch (bad_gmean& hg)
		{
			cout << hg.what();
			cout << "Error message:\n" << hg.what();
			cout << "Sorry, you don't get to play any more.\n";
			break;
		} // end of catch block
	}
	cout << "Bye!\n";
	// cin.get();
	// cin.get();
	return 0;
}

double hmean(double a, double b)
{
	if (a == -b)
		throw bad_hmean();
	return 2.0 * a * b / (a + b);
}

double gmean(double a, double b)
{
	if (a < 0 || b < 0)
		throw bad_gmean();
	return std::sqrt(a * b);
}

3．这个练习与编程练习2相同，但异常类是从一个这样的基类派生而来的：它是从logic_error派生而来的，并存储两个参数值。异常类应该有一个这样的方法：报告这些值以及函数名。程序使用一个catch块来捕获基类异常，其中任何一种从该基类异常派生而来的异常都将导致循环结束。

//class.h
#ifndef CLASS_H_
#define CLASS_H_
#include <iostream>
#include <string>
#include <exception>
#include <stdexcept>
using namespace std;

class bad:public logic_error
{
public:
	bad(double a = 0, double b = 0, const string & str1 = "Error in bad.") :v1(a), v2(b), logic_error(str1) {};
	~bad() {};
	virtual void mesg();	//虚函数以便后面的基类指针所指向的对象能够调用自己所属的方法。
private:
	double v1;
	double v2;
};


class bad_hmean:public bad
{
public:
	bad_hmean( double a = 0, double b = 0, const string & s = "Error in hmean.") : bad(a,b,s) {};
	~bad_hmean() {};
	void mesg();
};
class bad_gmean:public bad
{
public:
	bad_gmean(double a = 0, double b = 0, const string& s = "Error in gmean.") :bad(a, b, s) {};
	~bad_gmean() {};
	void mesg();

};

inline void bad::mesg()
{
	cout << v1 << ", " << v2;
}
inline void bad_hmean::mesg()
{
	cout << what() << endl;
	cout << "hmean( ";
	bad::mesg();
	cout<< " ): " << "invalid arguments: a = -b.\n";
}
inline void bad_gmean::mesg()
{
	cout << what() << endl;
	cout << "gmean( ";
	bad::mesg();
	cout << " ): " << "should be >=0.\n";
}
#endif // !CLASS_H_

//main.cpp
/* *************************************************
* 文件名：
* 创建人：px
* 创建时间：2020/6/3 
* 描述：
************************************************* */
#include <iostream>
#include <cmath>
#include "class.h"

// function prototypes
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 {                  // start of try block
			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 <q to quit>: ";
		}// end of try block
		catch (bad& lg)    // start of catch block
		{
			lg.mesg();
			cout << "Sorry, you don't get to play any more.\n";
			break;
		}
	}
	cout << "Bye!\n";
	// cin.get();
	// cin.get();
	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);
}

4．程序清单15.16在每个try后面都使用两个catch块，以确保nbad_index异常导致方法label_val( )被调用。请修改该程序，在每个try块后面只使用一个catch块，并使用RTTI来确保合适时调用label_val( )。

//class.h
#ifndef CLASS_H_
#define CLASS_H_
#include <iostream>
#include <stdexcept>
#include <string>

class Sales
{
public:
	enum { MONTHS = 12 };   // could be a static const

	class bad_index : public std::logic_error
	{
	private:
		int bi;  // bad index value
	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; //LabeledSales bad index
	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;
};

#endif // !CLASS_H_

//class.cpp
#include"class.h"
using std::string;

Sales::bad_index::bad_index(int ix, const 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 > n and i < MONTHS
	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 string& lb, int ix,const string& s) : Sales::bad_index(ix, s)
{
	lbl = lb;
}

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

LabeledSales::LabeledSales(const 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);
}

//main.cpp
/* *************************************************
* 文件名：
* 创建人：px
* 创建时间：2020/6/3 
* 描述：
************************************************* */
#include <iostream>
#include "class.h"


int main()
{
	using namespace std;

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

	cout << "First try block:\n";
	try
	{
		int i;
		cout << "Year = " << sales1.Year() << endl;
		for (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 (logic_error& bad)//基类引用以捕获两种异常
	{
		if (Sales::bad_index * bd = dynamic_cast<Sales::bad_index*>(&bad))//bad_index错误
		{
			cout << bd->what();
			cout << "bad index: " << bd->bi_val() << endl;
		}
		else if (LabeledSales::nbad_index * bd = dynamic_cast<LabeledSales::nbad_index*>(&bad))
		{
			cout << bd->what();
			cout << "Company: " << bd->label_val() << endl;
			cout << "bad index: " << bd->bi_val() << endl;
		}
	}
	cout << "\nNext try block:\n";
	try
	{
		sales2[2] = 37.5;
		sales1[20] = 23345;
		cout << "End of try block 2.\n";
	}
	catch (logic_error& bad)//基类引用以捕获两种异常
	{
		if (Sales::bad_index * bd = dynamic_cast<Sales::bad_index*>(&bad))//bad_index错误
		{
			cout << bd->what();
			cout << "bad index: " << bd->bi_val() << endl;
		}
		else if(LabeledSales::nbad_index * bd = dynamic_cast<LabeledSales::nbad_index*>(&bad))
		{
			cout << bd->what();
			cout << "Company: " << bd->label_val() << endl;
			cout << "bad index: " << bd->bi_val() << endl;
		}
	}
	cout << "Done.\n";
	return 0;
}