c++ Primer Plus 第十一章 答案

最新推荐文章于 2022-09-16 09:50:43 发布
最新推荐文章于 2022-09-16 09:50:43 发布
阅读量222 收藏 1
点赞数
分类专栏： C++ Primer Plus 答案
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45791686/article/details/110388225
版权

第1题
头文件和函数定义和原文相同
vector.h

#ifndef VECTOR_H_
#define VECTOR_H_
#include <iostream>

namespace VECTOR
{
	class Vector
	{
	public:
		enum Mode { RECT, POL };

	private:
		double x;
		double y;
		double mag;
		double ang;
		Mode mode;
		void set_mag();
		void set_ang();
		void set_x();
		void set_y();

	public:
		Vector();
		Vector(double n1, double n2, Mode form = RECT);
		void reset(double n1, double n2, Mode form = RECT);
		~Vector();
		double xval() const { return x; }
		double yval() const { return y; }
		double magval() const { return mag; }
		double angval() const { return ang; }
		void polar_mode();
		void rect_mode();
		Vector operator+(const Vector& b) const;
		Vector operator-(const Vector& b) const;
		Vector operator-() const;
		Vector operator*(double n) const;

		//friends
		friend Vector operator*(double n, const Vector& a);
		friend std::ostream& operator<<(std::ostream& os, const Vector& v);
	};
}
#endif // !VECTOR_H_

vector.cpp

#include <cmath>
#include "vector.h"
using std::sqrt;
using std::sin;
using std::cos;
using std::atan;
using std::atan2;
using std::cout;

namespace VECTOR
{
	const double Rad_to_deg = 45.0 / atan(1.0);

	void Vector::set_mag()
	{
		mag = sqrt(x * x + y * y);
	}

	void Vector::set_ang()
	{
		if (x == 0.0 && y == 0.0)
		{
			ang = 0.0;
		}
		else
		{
			ang = atan2(y, x);
		}
	}

	void Vector::set_x()
	{
		x = mag * cos(ang);
	}

	void Vector::set_y()
	{
		y = mag * sin(ang);
	}

	Vector::Vector()
	{
		x = y = mag = ang = 0.0;
		mode = RECT;
	}

	Vector::Vector(double n1, double n2, Mode form)
	{
		mode = form;
		if (form == RECT)
		{
			x = n1;
			y = n2;
			set_mag();
			set_ang();
		}
		else if (form == POL)
		{
			mag = n1;
			ang = n2 / Rad_to_deg;
			set_x();
			set_y();
		}
		else
		{
			cout << "Incorrect 3rd argument to Vector(), vector set to 0\n";
			x = y = mag = ang = 0.0;
			mode = RECT;
		}
	}

	void Vector::reset(double n1, double n2, Mode form)
	{
		mode = form;
		if (form == RECT)
		{
			x = n1;
			y = n2;
			set_mag();
			set_ang();
		}
		else if (form == POL)
		{
			mag = n1;
			ang = n2 / Rad_to_deg;
			set_x();
			set_y();
		}
		else
		{
			cout << "Incorrect 3rd argument to Vector(), vector set to 0\n";
			x = y = mag = ang = 0.0;
			mode = RECT;
		}
	}

	Vector::~Vector()
	{
	}

	void Vector::polar_mode()
	{
		mode = POL;
	}

	void Vector::rect_mode()
	{
		mode = RECT;
	}

	Vector Vector::operator+(const Vector& b) const
	{
		return Vector(x + b.x, y + b.y);
	}

	Vector Vector::operator-(const Vector& b) const
	{
		return Vector(x - b.x, y - b.y);
	}

	Vector Vector::operator-() const
	{
		return Vector(-x, -y);
	}

	Vector Vector::operator*(double n) const
	{
		return Vector(n * x, n * y);
	}

	Vector operator*(double n, const Vector& a)
	{
		return a * n;
	}

	std::ostream& operator<<(std::ostream& os, const Vector& v)
	{
		if (v.mode == Vector::RECT)
		{
			os << "(x,y) = (" << v.x << ", " << v.y << ")";
		}
		else if (v.mode == Vector::POL)
		{
			os << "(m,a) = (" << v.mag << ", " << v.ang * Rad_to_deg << ")";
		}
		else
		{
			os << "Vector object mode is invalid";
		}
		return os;
	}
}

usevector.cpp

#include <cstdlib>
#include <ctime>
#include <fstream>
#include "vector.h"

int main()
{
	using namespace std;
	using VECTOR::Vector;
	srand(time(0));
	double direction;
	Vector step;
	Vector result(0.0, 0.0);
	unsigned long steps = 0;
	double target;
	double dstep;
	ofstream fout;
	fout.open("thewalk.txt");

	cout << "Enter target distance (q to quit): ";
	while (cin >> target)
	{
		cout << "Enter step length: ";
		if (!(cin >> dstep))
		{
			break;
		}

		fout << "Target Distance: " << target << ", Step Size: " << dstep << endl;

		while (result.magval() < target)
		{
			fout << steps << ": (x,y) = (" << result.xval() << ", " << result.yval() << ")\n";
			direction = rand() % 360;
			step.reset(dstep, direction, Vector::POL);
			result = result + step;
			steps++;
		}
		cout << "After " << steps << " steps, the subject has the following location:\n";
		fout << "After " << steps << " steps, the subject has the following location:\n";
		cout << result << endl;
		fout << result << endl;
		result.polar_mode();
		cout << " or\n" << result << endl;
		fout << " or\n" << result << endl;
		cout << "Average outward distance per step = " << result.magval() / steps << endl;
		fout << "Average outward distance per step = " << result.magval() / steps << endl;
		steps = 0;
		result.reset(0.0, 0.0);
		cout << "Enter target distance (q to quit): ";
	}
	cout << "Bye!\n";
	cin.clear();
	while (cin.get() != '\n')
	{
		continue;
	}
}

第2题
vector.h

#ifndef VECTOR_H_
#define VECTOR_H_
#include <iostream>

namespace VECTOR
{
	class Vector
	{
	public:
		enum Mode { RECT, POL };

	private:
		double x;
		double y;
		Mode mode;

		void set_x(double mag, double ang);
		void set_y(double mag, double ang);

	public:
		Vector();
		Vector(double n1, double n2, Mode form = RECT);
		void reset(double n1, double n2, Mode form = RECT);
		~Vector();
		double xval() const { return x; }
		double yval() const { return y; }
		double magval() const;
		double angval() const;
		void polar_mode();
		void rect_mode();

		Vector operator+(const Vector& b) const;
		Vector operator-(const Vector& b) const;
		Vector operator-() const;
		Vector operator*(double n) const;

		//friends
		friend Vector operator*(double n, const Vector& a);
		friend std::ostream& operator<<(std::ostream& os, const Vector& v);
	};
}

#endif // !VECTOR_H_

vector.cpp

#include <cmath>
#include "vector.h"
using std::sqrt;
using std::sin;
using std::cos;
using std::atan;
using std::atan2;
using std::cout;

namespace VECTOR
{
	const double Rad_to_deg = 45.0 / atan(1.0);

	void Vector::set_x(double mag, double ang)
	{
		x = mag * cos(ang);
	}

	void Vector::set_y(double mag, double ang)
	{
		y = mag * sin(ang);
	}

	Vector::Vector()
	{
		x = y = 0.0;
		mode = RECT;
	}

	Vector::Vector(double n1, double n2, Mode form)
	{
		mode = form;
		if (form == RECT)
		{
			x = n1;
			y = n2;
		}
		else if (form == POL)
		{
			double mag = n1;
			double ang = n2 / Rad_to_deg;
			set_x(mag, ang);
			set_y(mag, ang);
		}
		else
		{
			cout << "Incorrect 3rd argument to Vector(), vector set to 0\n";
			x = y = 0.0;
			mode = RECT;
		}
	}

	void Vector::reset(double n1, double n2, Mode form)
	{
		mode = form;
		if (form == RECT)
		{
			x = n1;
			y = n2;
		}
		else if (form == POL)
		{
			double mag = n1;
			double ang = n2 / Rad_to_deg;
			set_x(mag,ang);
			set_y(mag,ang);
		}
		else
		{
			cout << "Incorrect 3rd argument to Vector(), vector set to 0\n";
			x = y = 0.0;
			mode = RECT;
		}
	}

	Vector::~Vector()
	{
	}

	double Vector::magval() const
	{
		double mag;
		mag = sqrt(x * x + y * y);
		return mag;
	}

	double Vector::angval() const
	{
		double ang;
		if (x == 0.0 && y == 0.0)
		{
			ang = 0.0;
		}
		else
		{
			ang = atan2(y, x);
		}
		return ang;
	}

	void Vector::polar_mode()
	{
		mode = POL;
	}

	void Vector::rect_mode()
	{
		mode = RECT;
	}

	Vector Vector::operator+(const Vector& b) const
	{
		return Vector(x + b.x, y + b.y);
	}

	Vector Vector::operator-(const Vector& b) const
	{
		return Vector(x - b.x, y - b.y);
	}

	Vector Vector::operator-() const
	{
		return Vector(-x, -y);
	}

	Vector Vector::operator*(double n) const
	{
		return Vector(n * x, n * y);
	}

	Vector operator*(double n, const Vector& a)
	{
		return a * n;
	}

	std::ostream& operator<<(std::ostream& os, const Vector& v)
	{
		if (v.mode == Vector::RECT)
		{
			os << "(x,y) = (" << v.x << ", " << v.y << ")";
		}
		else if (v.mode == Vector::POL)
		{
			os << "(m,a) = (" << v.magval() << ", " << v.angval() * Rad_to_deg << ")";
		}
		else
		{
			os << "Vector object mode is invalid";
		}
		return os;
	}
}

main.cpp

#include <cstdlib>
#include <ctime>
#include "vector.h"

int main()
{
	using namespace std;
	using VECTOR::Vector;
	srand(time(0));
	double direction;
	Vector step;
	Vector result(0.0, 0.0);
	unsigned long steps = 0;
	double target;
	double dstep;

	cout << "Enter target distance (q to quit): ";
	while (cin >> target)
	{
		cout << "Enter step length: ";
		if (!(cin >> dstep))
		{
			break;
		}

		while (result.magval() < target)
		{
			direction = rand() % 360;
			step.reset(dstep, direction, Vector::POL);
			result = result + step;
			steps++;
		}
		cout << "After " << steps << " steps, the subject has the following location:\n";
		cout << result << endl;
		result.polar_mode();
		cout << " or\n" << result << endl;
		cout << "Average outward distance per step = " << result.magval() / steps << endl;
		steps = 0;
		result.reset(0.0, 0.0);
		cout << "Enter target distance (q to quit): ";
	}
	cout << "Bye!\n";
	cin.clear();
	while (cin.get() != '\n')
	{
		continue;
	}
}

第3题
vector.h

#ifndef VECTOR_H_
#define VECTOR_H_
#include <iostream>

namespace VECTOR
{
	class Vector
	{
	public:
		enum Mode { RECT, POL };
	private:
		double x;
		double y;
		double mag;
		double ang;
		Mode mode;

		void set_mag();
		void set_ang();
		void set_x();
		void set_y();

	public:
		Vector();
		Vector(double n1, double n2, Mode form = RECT);
		void reset(double n1, double n2, Mode form = RECT);
		~Vector();

		double xval() const { return x; }
		double yval() const { return y; }
		double magval() const { return mag; }
		double angval() const { return ang; }
		void polar_mode();
		void rect_mode();

		Vector operator+(const Vector& b) const;
		Vector operator-(const Vector& b) const;
		Vector operator-() const;
		Vector operator*(double n) const;

		friend Vector operator*(double n, const Vector& a);
		friend std::ostream& operator<<(std::ostream& os, const Vector& v);
	};
}
#endif

vector.cpp

#include <cmath>
#include "vector.h"

using std::sqrt;
using std::sin;
using std::cos;
using std::atan;
using std::atan2;
using std::cout;

namespace VECTOR
{
	const double Rad_to_deg = 45.0 / atan(1.0);

	void Vector::set_mag()
	{
		mag = sqrt(x * x + y * y);
	}

	void Vector::set_ang()
	{
		if (x == 0.0 && y == 0.0)
			ang = 0.0;
		else
			ang = atan2(y, x);
	}

	void Vector::set_x()
	{
		x = mag * cos(ang);
	}

	void Vector::set_y()
	{
		y = mag * sin(ang);
	}

	Vector::Vector()
	{
		x = y = mag = ang = 0.0;
		mode = RECT;
	}

	Vector::Vector(double n1, double n2, Mode form)
	{
		mode = form;
		if (form == RECT)
		{
			x = n1;
			y = n2;
			set_mag();
			set_ang();
		}
		else if (form == POL)
		{
			mag = n1;
			ang = n2 / Rad_to_deg;
			set_x();
			set_y();
		}
		else
		{
			cout << "Incorrect 3rd argument to Vector() -- ";
			cout << "vector set to 0\n";
			x = y = mag = ang = 0.0;
			mode = RECT;
		}
	}

	void Vector::reset(double n1, double n2, Mode form)
	{
		mode = form;
		if (form == RECT)
		{
			x = n1;
			y = n2;
			set_mag();
			set_ang();
		}
		else if (form == POL)
		{
			mag = n1;
			ang = n2 / Rad_to_deg;
			set_x();
			set_y();
		}
		else
		{
			cout << "Incorrect 3rd argument to Vector() -- ";
			cout << "vector set to 0\n";
			x = y = mag = ang = 0.0;
			mode = RECT;
		}
	}

	Vector::~Vector()
	{
	}

	void Vector::polar_mode()
	{
		mode = POL;
	}

	void Vector::rect_mode()
	{
		mode = RECT;
	}

	Vector Vector::operator+(const Vector& b) const
	{
		return Vector(x + b.x, y + b.y);
	}

	Vector Vector::operator-(const Vector& b) const
	{
		return Vector(x - b.x, y - b.y);
	}

	Vector Vector::operator-() const
	{
		return Vector(-x, -y);
	}

	Vector Vector::operator*(double n) const
	{
		return Vector(n * x, n * y);
	}

	Vector operator*(double n, const Vector& a)
	{
		return a * n;
	}

	std::ostream& operator<<(std::ostream& os, const Vector& v)
	{
		if (v.mode == Vector::RECT)
			os << "(x,y) = (" << v.x << ", " << v.y << ")";
		else if (v.mode == Vector::POL)
		{
			os << "(m,a) = (" << v.mag << ", " << v.ang * Rad_to_deg << ")";
		}
		else
			os << "Vector object mode is invalid";
		return os;
	}
}

main.cpp

#include <iostream>
#include <cstdlib>
#include <ctime>
#include "vector.h"

int main()
{
	using namespace std;
	using VECTOR::Vector;
	srand(time(0));
	double direction;
	Vector step;
	Vector result(0.0, 0.0);
	unsigned long steps = 0;
	double target;
	double dstep;
	int times;

	cout << "How many times do you want: ";
	cin >> times;
	int* steps_n = new int[times];
	for (int i = 0; i < times; i++)
	{
		cout << "Enter #" << i + 1 << " target distance: ";
		while (!(cin >> target))
		{
			cout << "Enter #" << i + 1 << " target distance: ";
			cin.clear();
			while (cin.get() != '\n')
			{
				continue;
			}
		}
		cout << "Enter #" << i + 1 << " step length: ";
		while (!(cin >> dstep))
		{
			cout << "Enter #" << i + 1 << " step length: ";
			cin.clear();
			while (cin.get() != '\n')
			{
				continue;
			}
		}

		while (result.magval() < target)
		{
			direction = rand() % 360;
			step.reset(dstep, direction, Vector::POL);
			result = result + step;
			steps++;
		}
		steps_n[i] = steps;

		steps = 0;
		result.reset(0.0, 0.0);
	}

	int maxsteps = steps_n[0];
	int minsteps = steps_n[0];
	int sumsteps = 0, avesteps;

	for (int i = 0; i < times; i++)
	{
		maxsteps = maxsteps > steps_n[i] ? maxsteps : steps_n[i];
		minsteps = minsteps < steps_n[i] ? minsteps : steps_n[i];
		sumsteps += steps_n[i];
		cout << "#" << i + 1 << " steps = " << steps_n[i] << endl;
	}
	avesteps = sumsteps / times;

	delete[] steps_n;
	
	cout << "Max steps = " << maxsteps << endl;
	cout << "Min steps = " << minsteps << endl;
	cout << "Average steps = " << avesteps << endl;
}

第4题
mytime.h

#ifndef MYTIME_H_
#define MYTIME_H_
#include <iostream>

class Time
{
private:
	int hours;
	int minutes;

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*(double n) const;

	friend Time operator+(const Time& t1, const Time& t2);
	friend Time operator-(const Time& t1, const Time& t2);
	friend Time operator*(double n, const Time& t);
	friend std::ostream& operator<<(std::ostream& os, const Time& t);
};
#endif // !MYTIME_H_

mytime.cpp

#include "mytime.h"

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

Time::Time(int h, int m)
{
	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, int m)
{
	hours = h;
	minutes = m;
}

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

Time operator-(const Time& t1, const Time& t2)
{
	Time diff;
	int t1m, t2m;
	t1m = t1.hours * 60 + t1.minutes;
	t2m = t2.hours * 60 + t2.minutes;
	diff.minutes = (t1m - t2m) % 60;
	diff.hours = (t1m - t2m) / 60;
	return diff;
}

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

Time operator*(double n, const Time& t)
{
	Time result;
	result.minutes = t.hours * n * 60 + t.minutes * n;
	result.hours = result.minutes / 60;
	result.minutes = result.minutes % 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 "mytime.h"

int main()
{
	using std::cout;
	using std::endl;
	Time a(3, 35);
	Time b(2, 31);

	cout << "a : " << a << endl;
	cout << "b : " << b << endl;
	cout << "a + b : " << a + b << endl;
	cout << "a - b : " << a - b << endl;
	cout << "a * 2 : " << a * 2 << endl;
	cout << "2 * a: " << 2 * a << endl;
}

第5题
stonewt.h

#ifndef STONEWT_H_
#define STONEWT_H_
#include <iostream>

class Stonewt
{
public:
	enum Mode { STONE, PDS_INT, PDS_DOUBLE };

private:
	enum { Lbs_per_stn = 14 };
	int stone;
	double pds_left;
	double pounds;
	Mode mode;

public:
	Stonewt();
	Stonewt(double lbs, Mode m = STONE);
	Stonewt(int stn, double lbs, Mode m = STONE);
	~Stonewt();
	void stone_mode();
	void pds_int_mode();
	void pds_double_mode();
	Stonewt operator*(double n) const;  //st*double

	friend Stonewt operator+(const Stonewt& st1, const Stonewt& st2);  //st1+st2
	friend Stonewt operator-(const Stonewt& st1, const Stonewt& st2);  //st1-st2
	friend Stonewt operator*(double n, const Stonewt& st);  //double*st
	friend std::ostream& operator<<(std::ostream& os, const Stonewt& st);
};
#endif // !STONEWT_H_

stonewt.cpp

#include "stonewt.h"

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

Stonewt::Stonewt(double lbs, Mode m)
{
	stone = (int)lbs / Lbs_per_stn;
	pds_left = (int)lbs % Lbs_per_stn + lbs - (int)lbs;
	pounds = lbs;
	mode = m;
}

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

Stonewt::~Stonewt() {};

void Stonewt::stone_mode()
{
	mode = STONE;
}

void Stonewt::pds_int_mode()
{
	mode = PDS_INT;
}

void Stonewt::pds_double_mode()
{
	mode = PDS_DOUBLE;
}

Stonewt Stonewt::operator*(double n) const  //st*double
{
	return Stonewt(pounds * n);
}

Stonewt operator+(const Stonewt& st1, const Stonewt& st2)  //st1+st2
{
	return Stonewt(st1.pounds + st2.pounds);
}

Stonewt operator-(const Stonewt& st1, const Stonewt& st2)  //st1-st2
{
	return Stonewt(st1.pounds - st2.pounds);
}

Stonewt operator*(double n, const Stonewt& st)  //double*st
{
	//return Stonewt(st.pounds * n);
	return st * n;
}

std::ostream& operator<<(std::ostream& os, const Stonewt& st)
{
	if (st.mode == Stonewt::Mode::STONE)
	{
		os << st.stone << " stone, " << st.pds_left << " pounds\n";
	}
	else if (st.mode == Stonewt::Mode::PDS_DOUBLE)
	{
		os << st.pounds << " pounds\n";
	}
	else if (st.mode == Stonewt::Mode::PDS_INT)
	{
		os << (int)st.pounds << " pounds\n";
	}
	else
	{
		std::cout << "Unknown Mode.\n";
	}
	return os;
}

main.cpp

#include "stonewt.h"
using std::cout;

int main()
{
	Stonewt s1(275);
	Stonewt s2(285.7);
	Stonewt s3(21, 8);
	Stonewt sa = s1 + s2;
	Stonewt sb = s1 + s3;
	Stonewt sc = 2 * s1;
	Stonewt sd = s1 * 2;
	Stonewt se = s2 - s1;

	cout << "Stone Mode:\n";
	cout << "S1 stone: " << s1;
	cout << "S2 stone: " << s2;
	cout << "S3 stone: " << s3;
	cout << "S1 + S2 stone: " << sa;
	cout << "S1 + S3 stone: " << sb;
	cout << "2 * S1 stone: " << sc;
	cout << "S1 *2 stone: " << sd;
	cout << "S2 - S1 stone: " << se;
	s1.pds_double_mode();
	s2.pds_double_mode();
	s3.pds_double_mode();
	sa.pds_double_mode();
	sb.pds_double_mode();
	sc.pds_double_mode();
	sd.pds_double_mode();
	se.pds_double_mode();
	cout << "Pounds-double Mode:\n";
	cout << "S1 pounds(double): " << s1;
	cout << "S2 pounds(double): " << s2;
	cout << "S3 pounds(double): " << s3;
	cout << "S1 + S2 pounds(double): " << sa;
	cout << "S1 + S3 pounds(double): " << sb;
	cout << "2 * S1 pounds(double): " << sc;
	cout << "S1 * 2 pounds(double): " << sd;
	cout << "S2 - S1 pounds(double): " << se;
	s1.pds_int_mode();
	s2.pds_int_mode();
	s3.pds_int_mode();
	sa.pds_int_mode();
	sb.pds_int_mode();
	sc.pds_int_mode();
	sd.pds_int_mode();
	se.pds_int_mode();
	cout << "Pounds-int Mode:\n";
	cout << "S1 pounds(int): " << s1;
	cout << "S2 pounds(int): " << s2;
	cout << "S3 pounds(int): " << s3;
	cout << "S1 + S2 pounds(int): " << sa;
	cout << "S1 + S3 pounds(int): " << sb;
	cout << "2 * S1 pounds(int): " << sc;
	cout << "S1 * 2 pounds(int): " << sd;
	cout << "S2 - S1 pounds(int): " << se;
}

第6题
stonewt.h

#ifndef STONEWT_H_
#define STONEWT_H_

class Stonewt
{
private:
	enum { Lbs_per_stn = 14 };
	int stone;
	double pds_left;
	double pounds;

public:
	Stonewt();
	Stonewt(double lbs);
	Stonewt(int stn, double lbs);
	~Stonewt();
	void show_lbs() const;
	void show_stn() const;

	bool operator<(const Stonewt& st) const;
	bool operator<=(const Stonewt& st) const;
	bool operator>(const Stonewt& st) const;
	bool operator>=(const Stonewt& st) const;
	bool operator==(const Stonewt& st) const;
	bool operator!=(const Stonewt& st) const;
};
#endif // !STONEWT_H_

stonewt.cpp

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

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

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 = (double)stn * Lbs_per_stn + lbs;
}

Stonewt::~Stonewt() {};

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

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

bool Stonewt::operator<(const Stonewt& st) const
{
	return pounds < st.pounds;
}

bool Stonewt::operator<=(const Stonewt& st) const
{
	return pounds <= st.pounds;
}

bool Stonewt::operator>(const Stonewt& st) const
{
	return pounds > st.pounds;
}

bool Stonewt::operator>=(const Stonewt& st) const
{
	return pounds >= st.pounds;
}

bool Stonewt::operator==(const Stonewt& st) const
{
	return pounds == st.pounds;
}

bool Stonewt::operator!=(const Stonewt& st) const
{
	return pounds != st.pounds;
}

main.cpp

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

int main()
{
	using std::cout;
	using std::endl;

	Stonewt st[6] = { 175,28.5,{26,7} };
	for (int i = 3; i < 6; i++)
	{
		double pounds;
		cout << "Enter #" << i + 1 << " value(pounds): ";
		std::cin >> pounds;
		st[i] = pounds;
	}

	Stonewt maxst = st[0], minst = st[0];
	Stonewt sttemp(11, 0);
	int n = 0;
	for (int i = 0; i < 6; i++)
	{
		maxst = maxst > st[i] ? maxst : st[i];
		minst = minst < st[i] ? minst : st[i];
		st[i].show_stn();
		if (st[i]>=sttemp)
		{
			n++;
		}
	}
	cout << "Min = ";
	minst.show_stn();
	cout << "Max = ";
	maxst.show_stn();
	cout << "There are " << n << " bigger than 11 stone.\n";
}

第7题
complex0.h

#ifndef COMPLEX0_H_
#define COMPLEX0_H_
#include <iostream>

class Complex0
{
private:
	double real_num;
	double imaginary_num;

public:
	Complex0();
	Complex0(double real, double imaginary);
	~Complex0();
	Complex0 operator+(const Complex0& c) const;
	Complex0 operator-(const Complex0& c) const;
	Complex0 operator*(const Complex0& c) const;
	Complex0 operator*(double n) const;
	Complex0 operator~() const;

	friend Complex0 operator* (double n, const Complex0& c);
	friend std::istream& operator>>(std::istream& is, Complex0& c);
	friend std::ostream& operator<<(std::ostream& os, const Complex0& c);
};

#endif // !COMPLEX0_H_=

complex0.cpp

#include "complex0.h"

Complex0::Complex0()
{
	real_num = imaginary_num = 0.0;
}

Complex0::Complex0(double real, double imaginary)
{
	real_num = real;
	imaginary_num = imaginary;
}

Complex0::~Complex0() {}

Complex0 Complex0::operator+(const Complex0& c) const
{
	return Complex0(real_num + c.real_num, imaginary_num + c.imaginary_num);
}

Complex0 Complex0::operator-(const Complex0& c) const
{
	return Complex0(real_num - c.real_num, imaginary_num - c.imaginary_num);
}

Complex0 Complex0::operator*(const Complex0& c) const
{
	return Complex0(real_num * c.real_num - imaginary_num * c.imaginary_num, real_num * c.imaginary_num + imaginary_num * c.real_num);
}

Complex0 Complex0::operator*(double n) const
{
	return Complex0(n * real_num, n * imaginary_num);
}

Complex0 Complex0::operator~() const
{
	return Complex0(real_num, -imaginary_num);
}

Complex0 operator*(double n, const Complex0& c)
{
	return c * n;
}

std::istream& operator>>(std::istream& is, Complex0& c)
{
	std::cout << "real: ";
	is >> c.real_num;
	std::cout << "imaginary: ";
	is >> c.imaginary_num;
	return is;
}

std::ostream& operator<<(std::ostream& os, const Complex0& c)
{
	os << "(" << c.real_num << ", " << c.imaginary_num << "i)";
	return os;
}

main.cpp

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

int main()
{
	Complex0 a(3.0, 4.0);
	Complex0 c;
	cout << "Enter a complex number (q to quit):\n";
	while (cin >> c)
	{
		cout << "c is " << c << endl;
		cout << "complex conjugate is " << ~c << endl;
		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 << "Enter a complex number (q to quit):\n";
	}
	cout << "Done!\n";
}
硕大菜鸟
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++ Primer Plus 第6版 中文版课后代码习题答案
03-10
《C++ Primer Plus 第6版 中文版》是一本深入浅出的C++学习书籍，其课后代码习题答案是学习过程中不可或缺的部分。这本书旨在帮助读者从零基础开始掌握C++编程语言，通过实例和习题来巩固理论知识，提升编程技能。...
C++ Primer Plus习题及答案-第十一章
jianmo的博客
10-13 781
C++ Primer Plus习题及答案-第十一章 习题选自：C++ Primer Plus(第六版) 内容仅供参考，如有错误，欢迎指正 !
【C++ Primer Plus】第11章 使用类
chaiky的博客
09-16 895
运算符重载。 友元函数。 重载
c++primer plus第十一章答案
lmylikefx的博客
07-12 318
这是主程序代码：main1.....main2..等表示第一题....第二题等代码主函数，每一小题通过main函数调用测试。#include #include"ston11_4.h" using namespace std; /* void main1() { vector step; vector result(0.0,0.0); unsigned long steps=0; double ta
C++primer plus 第十一章习题答案
weixin_44808331的博客
07-06 485
第一题： // An highlighted block Stonewt operator*(double mult); Stonewt Stonewt::operator*(double mult) { return Stonewt(mult * pounds); } 第二题： 成员函数是类定义的一部分，通过特定的对象来调用。成员函数可以隐式访问调用对象的成员，而无需使用成员运算符。友元函数...
C++ pprimer plus 第六版 第十一章 编程练习答案
菜鸡harry的博客
08-11 2036
第十一章 编程练习答案 1. //头文件，同11-13不用修改 #ifndef VECTOR_H_ #define VECTOR_H_ #include &lt;iostream&gt; namespace VECTOR { class Vector { public: enum Mode {RECT, POL}; //RECT指平面坐标，PO...
C++ Primer Plus 编程练习源码工程 第11章
09-14
在本压缩包文件中，我们聚焦于"C++ Primer Plus"这本书的第11章编程练习。这是一份由用户LeonardoLiuwenbo在学习过程中编写的源代码工程，旨在帮助读者深入理解和应用C++语言。第11章通常涵盖C++中的高级主题，可能...
C++ Primer Plus 编程练习源码工程 第15章
12-25
《C++ Primer Plus 编程练习源码工程 第15章》是针对C++初学者的一个宝贵资源，它包含了作者LeonardoLiuwenbo在学习《C++ Primer Plus》这本经典教材时所做的编程练习。这个章节聚焦于C++语言的深入特性，旨在通过...
C++ primer plus课后编程练习题答案
04-22
第十一章继续深入讲解了类和对象的使用，包括类的多态、类的继承、类的组合等，提供了相关的编程练习题和答案，帮助读者掌握类和对象的高级使用技巧。第十六章和第十七章讲解了高级主题，包括模板、异常处理、输入/...
c++primer plus第七章到第十三章习题源码
03-12
《C++ Primer Plus》是C++编程领域里一本经典的教程，涵盖了从基础语法到高级特性的广泛内容。从第七章到第十三章，这涵盖了类（classes）、对象（objects）、继承（inheritance）、多态（polymorphism）、模板...
新标准C++程序设计教材11-20章课后题答案
11-14
C++新标准C++程序设计—郭炜答案,答案非常齐全。
C++ Primer Plus（第六版）编程练习答案 第11章 使用类
清水河C罗——Leonardo-Liu
09-14 5061
本章所有编程练习的工程源码可在此处下载（点击此链接下载），供大家参考交流！   1. 修改程序清单11.5，使之将一系列连续的随机漫步者位置写入到文件中。对于每个位置，用步号进行标示。另外，让该程序将初始条件（目标距离和步长）以及结果小结写入到该文件中。该文件的内容与下面类似： （……代码省略……） 本题要求将随机漫步者的位置写入到文件中，这些内容刚好和程序清单11.13,11.14,11...
c++ Primer Plus（第六版）第十一章，编程练习之路
Robot_x的博客
01-14 2518
c++ Primer Plus（第六版）第十一章，个人学习记录，成长中
c++ primer plus第十一章习题答案
yuchendu的分享地
12-30 1043
第一题 // vect.h -- Vector class with <<, mode state #ifndef VECTOR_H_ #define VECTOR_H_ #include #include using std::sqrt; using std::atan2; using std::cos; using std::sin; namespace VECTOR { cla
C++ Primer Plus第六版 第十一章 编程练习答案
蒟蒻升级中...Orz
09-26 3338
//第一题 //windows下\r\n在txt中是换行...被坑了= = //vector.h #ifndef VECTOR_H_ #define VECTOR_H_ #include namespace VECTOR { class Vector { public: enum Mode { RECT, POL }; private: double x; double y
C++ primer plus 第六版 第十一章 复习题
菜鸡harry的博客
08-10 1058
第十一章 复习题 1. Stonewt Stonewt::operator*(double n) const { Stonewt result; double total = stn * Lbs_per_stn * n +lbs * n; result.stn = total / Lbs_per_stn; result.lbs = total % Lbs...
C Primer Plus 第十一章 课后答案
asdgyy的博客
10-03 9149
目录   复习题 1.下面字符串的声明有什么问题？ 2.下面的程序会打印什么 3.下面的程序会打印什么 4.下面的程序会打印什么 5.下面的练习涉及字符串、循环、指针和递增指针。首先，假设定义了下面的函数： 考虑下面的函数调用： x = pr("Ho Ho Ho!"); a.将打印什么？ b.x是什么类型？ c.x的值是什么？ d.表达式*--pc是什么意思？与--*pc有...
[C++ Primer Plus]第十一章
Yang
07-27 202
1.重载运算符，需要使用运算符函数 operator[color=red]op[/color](arg-list) op必须是有效的c++运算符 2. class_t a, b, c; c = a + b; //等价于c = a.operator+(b) a是调用的对象，b是作为参数传递的对象 3.重载限制 1）重载后的运算符必须至少有一个操作数是用户定义的类型 2）使用运算符不能...
C PRIMER PLUS第六版 第十一章编程练习
o707191418的博客
08-08 4156
1. #include &lt;stdio.h&gt; #define SIZE 40 void s_gets(char str[], int n); int main(void) { int i; int num; char st [SIZE]; printf("Enter a number for the length of the string:");...
C++ Primer Plus Sixth Edition
最新发布
03-09
"C++ Primer Plus Sixth Edition 是一本英文的第六版C++编程教程，由Stephen Prata撰写。这本书是Developer's Library系列的一部分，该系列专为编程专业人士提供关键的参考资料和教程，涵盖他们日常工作中使用的编程...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值