C++ Primer Plus第五版 第11章 编程练习答案

最新推荐文章于 2019-09-09 20:13:40 发布
最新推荐文章于 2019-09-09 20:13:40 发布
阅读量533 收藏 1
点赞数
分类专栏： C++ Primer Plus 5 学习笔记 C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cx_12586/article/details/78587401
版权 
/*******************************************************************************************************************   
Author : Cui mingyang  
Blog : cx_12586  
Time : 2017/11/20 
From : C++ Primer Plus第五版第11章编程练习 第1题    
*******************************************************************************************************************/  
//头文件
#ifndef MODVECTOR_H_
#define MODVECTOR_H_
#include <iostream>
namespace VECTOR
{
	using std::ostream;
	class Vector
	{
	private:
		double x;          // horizontal value
		double y;          // vertical value
		char mode;         // 'r' = rectangular, 'p' = polar
		// private methods for setting values
		void set_mag();
		void set_ang();
		void set_x(double, double);
		void set_y(double, double);
	public:
		Vector();
		Vector(double n1, double n2, char form = 'r');
		void set(double n1, double n2, char form = 'r');
		~Vector();
		double xval() const {return x;}       // report x value
		double yval() const {return y;}       // report y value
		double magval() const;              // report magnitude
		double angval() const;              // report angle
		void polar_mode();                    // set mode to 'p'
		void rect_mode();                     // set mode to 'r'
		// operator overloading
		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 ostream & operator<<(ostream & os, const Vector & v);
	};

}   // end namespace VECTOR
#endif

//头文件对应的cpp文件
#include <cmath>
#include "vect.h"   // includes <iostream>
using std::sqrt;
using std::sin;
using std::cos;
using std::atan2;
using std::cout;

namespace VECTOR
{

	const double Rad_to_deg = 57.2957795130823;

	// private methods
	// calculates magnitude from x and y


	// set x from polar coordinate
	void Vector::set_x(double mag, double ang)
	{
		x = mag * cos(ang);
	}

	// set y from polar coordinate
	void Vector::set_y(double mag, double ang)
	{
		y = mag * sin(ang);
	}

	// public methods
	Vector::Vector()             // default constructor
	{
		x = y  = 0.0;
		mode = 'r';
	}

	// construct vector from rectangular coordinates if form is r
	// (the default) or else from polar coordinates if form is p
	Vector::Vector(double n1, double n2, char form)
	{
		mode = form;
		if (form == 'r')
		{
			x = n1;
			y = n2;
		}
		else if (form == 'p')
		{
			set_x(n1, n2 / Rad_to_deg);
			set_y(n1, n2 / Rad_to_deg);
		}
		else
		{
			cout << "Incorrect 3rd argument to Vector() -- ";
			cout << "vector set to 0\n";
			x = y = 0.0;
			mode = 'r';
		}
	}

	// set vector from rectangular coordinates if form is r (the
	// default) or else from polar coordinates if form is p
	void Vector:: set(double n1, double n2, char form)
	{
		mode = form;
		if (form == 'r')
		{
			x = n1;
			y = n2;
		}
		else if (form == 'p')
		{
			set_x(n1, n2 / Rad_to_deg);
			set_y(n1, n2 / Rad_to_deg);
		}
		else
		{
			cout << "Incorrect 3rd argument to Vector() -- ";
			cout << "vector set to 0\n";
			x = y = 0.0;
			mode = 'r';
		}
	}

	Vector::~Vector()    // destructor
	{
	}

	double Vector::magval() const            // report magnitude
	{
		return sqrt(x*x +y*y);
	}

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

	void Vector::polar_mode()    // set to polar mode
	{
		mode = 'p';
	}

	void Vector::rect_mode()     // set to rectangular mode
	{
		mode = 'r';
	}

	// operator overloading
	// add two Vectors
	Vector Vector::operator+(const Vector & b) const
	{
		return Vector(x + b.x, y + b.y);
	}

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

	// reverse sign of Vector
	Vector Vector::operator-() const
	{
		return Vector(-x, -y);
	}

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

	// friend methods
	// multiply n by Vector a
	Vector operator*(double n, const Vector & a)
	{
		return a * n;
	}

	// display rectangular coordinates if mode is r,
	// else display polar coordinates if mode is p
	ostream & operator<<(ostream & os, const Vector & v)
	{
		if (v.mode == 'r')
			os << "(x,y) = (" << v.x << ", " << v.y << ")";
		else if (v.mode == 'p')
		{
			os << "(m,a) = (" << v.magval() << ", "
				<< v.angval() * Rad_to_deg << ")";
		}
		else
			os << "Vector object mode is invalid";
		return os;
	}

}  // end namespace VECTOR

//main函数
#include <iostream>
#include <cstdlib>      // rand(), srand() prototypes
#include <ctime>        // time() prototype
#include "vect.h" 

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

	//记录实验的次数
	cout << "Please enter the number of test: ";
	int num;
	cin >> num;
	double sum,min_step,max_step,temp;
	sum=max_step=temp=0;
	min_step=100;
	int i=0;
	cout << "Enter target distance (q to quit): ";
	while (i< num && cin >> target )
	{
		cout << "Enter step length: ";
		if (!(cin >> dstep))
			break;

		while (result.magval() < target)
		{
			direction = rand() % 360;
			step.set(dstep, direction, 'p');
			result = result + step;
			steps++;
		}
		
		// 计算最大最小和平均步数
		temp = result.magval()/steps;
		sum += temp;
		if (temp < min_step)
			min_step = temp;
		else if (temp > max_step)
			max_step = temp;
		steps = 0;
		result.set(0.0, 0.0);
		cout << "Enter target distance (q to quit): ";
		//记录实验次数
		i++;
	}
	cout << "The max step is " << max_step << ", and the min step is " << min_step << ", the mean step is " << sum/num <<endl;
	cout << "Bye!\n";
	system("pause");
	return 0;
}


/*******************************************************************************************************************   
Author : Cui mingyang  
Blog : cx_12586  
Time : 2017/11/20 
From : C++ Primer Plus第五版第11章编程练习 第2题    
*******************************************************************************************************************/  
//头文件
#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 { return sqrt(x * x + y * y); }  
        double angval() const {  
            if (x == 0.0 && y == 0.0)  
                return 0.0;  
            else  
                return atan2(y, x);  
        }  
        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  
//头文件对应的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)  
        {  
            set_x(n1, n2);  
            set_y(n1, n2);  
        }  
        else  
        {  
            cout << "Incorrect 3rd argument to Vector() -- ";  
            cout << "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)  
        {  
            set_x(n1, n2);  
            set_y(n1, n2);  
        }  
        else  
        {  
            cout << "Incorrect 3rd argument to Vector() -- ";  
            cout << "vector set to 0\n";  
            x = y = 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.magval() << ", " << v.angval() * Rad_to_deg << ")";  
        else  
            os << "Vector object mode is invalid";  
        return os;  
    }  
}  
//main函数
#include <iostream>  
#include <cstdlib>  
#include <ctime>  
#include "vector.h"  
  
int main()  
{  
    srand(time(0));  
    double direction;  
    VECTOR::Vector step;  
    VECTOR::Vector result(0.0, 0.0);  
    unsigned long steps = 0;  
    double target;  
    double dstep;  
    std::cout << "Enter target distance (q to quit): ";  
    while (std::cin >> target)  
    {  
        std::cout << "Enter step length: ";  
        if (!(std::cin >> dstep))  
            break;  
        while (result.magval() < target)  
        {  
            direction = rand() % 360;  
            step.reset(dstep, direction, VECTOR::Vector::POL);  
            result = result + step;  
            steps++;  
        }  
        std::cout << "After " << steps << " steps, the subject has the following location:\n";  
        std::cout << result << std::endl;  
        result.polar_mode();  
        std::cout << " or\n" << result << std::endl;  
        std::cout << "Average outward distance per step = " << result.magval() / steps << std::endl;  
        steps = 0;  
        result.reset(0.0, 0.0);  
        std::cout << "Enter target distance (q to quit): ";  
    }  
    std::cout << "Bye!\n";  
    std::cin.clear();  
    while(std::cin.get() != '\n')  
        continue;  
	system("pause");
    return 0;  
}  


/*******************************************************************************************************************   
Author : Cui mingyang  
Blog : cx_12586  
Time : 2017/11/20 
From : C++ Primer Plus第五版第11章编程练习 第3题    
*******************************************************************************************************************/  
//头文件
#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 { return sqrt(x * x + y * y); }  
        double angval() const {  
            if (x == 0.0 && y == 0.0)  
                return 0.0;  
            else  
                return atan2(y, x);  
        }  
        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  
//头文件对应的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)  
        {  
            set_x(n1, n2);  
            set_y(n1, n2);  
        }  
        else  
        {  
            cout << "Incorrect 3rd argument to Vector() -- ";  
            cout << "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)  
        {  
            set_x(n1, n2);  
            set_y(n1, n2);  
        }  
        else  
        {  
            cout << "Incorrect 3rd argument to Vector() -- ";  
            cout << "vector set to 0\n";  
            x = y = 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.magval() << ", " << v.angval() * Rad_to_deg << ")";  
        else  
            os << "Vector object mode is invalid";  
        return os;  
    }  
}  
  
//main函数
#include <iostream>  
#include <cstdlib>  
#include <ctime>  
#include "vector.h"  
  
int main()  
{  
    srand(time(0));  
    double direction;  
    VECTOR::Vector step;  
    VECTOR::Vector result(0.0, 0.0);  
    unsigned long steps = 0;  
    double target;  
    double dstep;  
    int N;  
    unsigned long max = 0;  
    unsigned long min = 999;  
    double avg = 0;  
    std::cout << "Enter N times to test: ";  
    std::cin >> N;  
    for (int i = 0; i < N; ++i)  
    {  
        std::cout << "Enter target distance (q to quit): ";  
        std::cin >> target;  
        std::cout << "Enter step length: ";  
        if (!(std::cin >> dstep))  
            break;  
        while (result.magval() < target)  
        {  
            direction = rand() % 360;  
            step.reset(dstep, direction, VECTOR::Vector::POL);  
            result = result + step;  
            steps++;  
        }  
        max = (max < steps) ? steps : max;  
        min = (min > steps) ? steps : min;  
        avg += steps;  
        result.polar_mode();  
        steps = 0;  
        result.reset(0.0, 0.0);  
    }  
    avg /= N;  
    std::cout << "max: " << max << std::endl << "min: " << min << std::endl << "average: " << avg << std::endl;  
    std::cout << "Bye!\n";  
    std::cin.clear();  
    while (std::cin.get() != '\n')  
        continue; 
	system("pause");
    return 0;  
}  

/*******************************************************************************************************************   
Author : Cui mingyang  
Blog : cx_12586  
Time : 2017/11/20 
From : C++ Primer Plus第五版第11章编程练习 第4题    
*******************************************************************************************************************/  
//头文件
#ifndef TIMER_H_  
#define TIMER_H_  

#include <iostream>  

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

#endif  
//头文件对应的cpp文件
#include "Timer.h"  

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

Timer::Timer(int h, int m)  
{  
	hours = h;  
	minutes = m;  
}  

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

void Timer::AddHr(int h)  
{  
	hours = (hours + h) % 24;  
}  

void Timer::Reset(int h, int m)  
{  
	hours = h;  
	minutes = m;  
}  

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

Timer operator-(const Timer &t1, const Timer &t2)  
{  
	Timer t;  
	t.minutes = (t1.hours * 60 + t1.minutes) - (t2.hours * 60 + t2.minutes);  
	t.hours = t.minutes / 60;  
	t.minutes %= 60;  
	return t;  
}  

Timer operator*(const Timer &t, double n)  
{  
	Timer Temp;  
	Temp.minutes = t.hours * 60 * n + t.minutes * n;  
	Temp.hours = Temp.minutes / 60;  
	Temp.minutes %= 60;  
	return Temp;  
}  

Timer operator*(double n, const Timer &t)  
{  
	return operator*(t, n);  
}  

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

//main函数
#include "Timer.h"  
#include <iostream>  
int main()  
{  
	Timer t1(12, 53);  
	Timer t2(14, 00);  
	std::cout << t1 + t2 << std::endl;  
	system("pause");
	return 0;  
}  

/*******************************************************************************************************************   
Author : Cui mingyang  
Blog : cx_12586  
Time : 2017/11/20 
From : C++ Primer Plus第五版第11章编程练习 第5题    
*******************************************************************************************************************/  
//头文件
#ifndef STONEWT_H_  
#define STONEWT_H_  

#include <iostream>  

enum Mode { POUNDS, STONE };  

class Stonewt {  
private:  
	static const int Lbs_per_stn = 14;  
	Mode mode;  
	int stone;  
	double pds_left;  
	double pounds;  
public:  
	Stonewt(double lbs);  
	Stonewt(int stn, double lbs);  
	Stonewt();  
	~Stonewt() {};  

	void SetMode(Mode form);  
	friend Stonewt operator+(const Stonewt &s1, const Stonewt &s2);  
	friend Stonewt operator-(const Stonewt &s1, const Stonewt &s2);  
	friend Stonewt operator*(const Stonewt &s1, const Stonewt &s2);  
	friend std::ostream &operator<<(std::ostream &os, const Stonewt &s);  
};  

#endif  
//头文件对应的cpp文件
#include "stonewt.h"  

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

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

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

void Stonewt::SetMode(Mode form)  
{  
	mode = form;  
}  

Stonewt operator+(const Stonewt &s1, const Stonewt &s2)  
{  
	Stonewt s;  
	if (s1.mode == POUNDS)  
	{  
		s.pounds = s1.pounds + s2.pounds;  
		s.SetMode(POUNDS);  
	}  
	else  
	{  
		s.stone = s1.stone + s2.stone;  
		s.SetMode(STONE);  
	}  
	return s;  
}  

Stonewt operator-(const Stonewt &s1, const Stonewt &s2)  
{  
	Stonewt s;  
	if (s1.mode == POUNDS)  
	{  
		s.pounds = s1.pounds - s2.pounds;  
		s.SetMode(POUNDS);  
	}  
	else  
	{  
		s.stone = s1.stone - s2.stone;  
		s.SetMode(STONE);  
	}  
	return s;  
}  

Stonewt operator*(const Stonewt &s1, const Stonewt &s2)  
{  
	Stonewt s;  
	if (s1.mode == POUNDS)  
	{  
		s.pounds = s1.pounds * s2.pounds;  
		s.SetMode(POUNDS);  
	}  
	else  
	{  
		s.stone = s1.stone * s2.stone;  
		s.SetMode(STONE);  
	}  
	return s;  
}  
std::ostream &operator<<(std::ostream &os, const Stonewt &s)  
{  
	if (s.mode == POUNDS)  
		os << s.pounds;  
	else  
		os << s.stone;  
	return os;  
}  

//main函数
#include "stonewt.h"  

int main()  
{  
	Stonewt s1(10);  
	Stonewt s2(10);  

	std::cout << s1 << std::endl;  
	std::cout << s2 << std::endl;  

	std::cout << s1 + s2 << std::endl;  
	std::cout << s1 - s2 << std::endl;  
	std::cout << s1 * s2 << std::endl;  
	system("pause");
	return 0;  
}  

/*******************************************************************************************************************   
Author : Cui mingyang  
Blog : cx_12586  
Time : 2017/11/20 
From : C++ Primer Plus第五版第11章编程练习 第6题    
*******************************************************************************************************************/  
//头文件
#ifndef STONEWT_H_  
#define STONEWT_H_  

class Stonewt {  
private:  
	enum{Lbs_per_stn = 14};  
	int stone;  
	double pds_left;  
	double pounds;  
public:  
	Stonewt(double lbs);  
	Stonewt(int stn, double lbs);  
	Stonewt();  
	~Stonewt();  
	void show_lbs() const;  
	void show_stn() const;  
	friend bool operator>(Stonewt &s1, Stonewt &s2);  
	friend bool operator<(Stonewt &s1, Stonewt &s2);  
	friend bool operator>=(Stonewt &s1, Stonewt &s2);  
	friend bool operator<=(Stonewt &s1, Stonewt &s2);  
	friend bool operator==(Stonewt &s1, Stonewt &s2);  
	friend bool operator!=(Stonewt &s1, Stonewt &s2);  
};  

#endif  
//头文件对应的cpp文件
#include "stonewt.h"  
#include <iostream>  

Stonewt::Stonewt(double lbs)  
{  
	stone = (int)lbs / Lbs_per_stn;  
	pds_left = (int)lbs % Lbs_per_stn;  
	pounds = lbs;  
}  

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

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

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 operator>(Stonewt &s1, Stonewt &s2)  
{  
	return s1.pounds > s2.pounds ? true : false;  
}  

bool operator<(Stonewt &s1, Stonewt &s2)  
{  
	return s1.pounds < s2.pounds ? true : false;  
}  

bool operator>=(Stonewt &s1, Stonewt &s2)  
{  
	return s1.pounds >= s2.pounds ? true : false;  
}  

bool operator<=(Stonewt &s1, Stonewt &s2)  
{  
	return s1.pounds <= s2.pounds ? true : false;  
}  

bool operator==(Stonewt &s1, Stonewt &s2)  
{  
	return s1.pounds == s2.pounds ? true : false;  
}  

bool operator!=(Stonewt &s1, Stonewt &s2)  
{  
	return s1.pounds != s2.pounds ? true : false;  
}  
//main函数
#include "stonewt.h"  
#include <iostream>  

int main()  
{  
	Stonewt s[6] = {(10), (20), (30) };  
	for (int i = 3; i < 6; ++i)  
	{  
		double t;  
		std::cin >> t;  
		s[i] = Stonewt(t);  
	}  
	Stonewt min(999), max(-1), st11(11);  
	int num = 0;  
	for (int i = 0; i < 6; ++i)  
	{  
		min = min > s[i] ? s[i] : min;  
		max = max < s[i] ? s[i] : max;  
		if (s[i] >= st11)  
			num++;  
	}  

	std::cout << "min: ";  
	min.show_stn();  
	std::cout << "max: ";  
	max.show_stn();  
	std::cout << ">=11: ";  
	std::cout << num;  

	system("pause");  
	return 0;  
}  



/*******************************************************************************************************************   
Author : Cui mingyang  
Blog : cx_12586  
Time : 2017/11/20 
From : C++ Primer Plus第五版第11章编程练习 第7题    
*******************************************************************************************************************/  
//头文件
#ifndef Complex_H_
#define Complex_H_
using namespace std;
class Complex
{
private:
	double real;
	double imag;
public:
	//构造函数和析构函数
	Complex();
	Complex(double x,double y);
	~Complex();
	
	//操作符重载
	Complex operator +(const Complex & c);
	Complex operator -(const Complex & c);
	Complex operator ~()const;
	Complex operator *(const Complex & c);

	friend Complex square(const Complex & z);
	friend Complex operator*(double n, const Complex & w);
	//输入输出操作符重载
	friend ostream & operator << (ostream & os, const Complex & c);
	friend istream & operator >> (istream & is, Complex & c);
};
#endif
//头文件对应的cpp文件
#include <iostream>
#include <complex>
#include "complex0.h"
using namespace std;

//构造函数和析构函数
Complex::Complex()
{
	real = imag =0;
}
Complex::Complex(double x,double y)
{
	real = x;
	imag = y;
}
Complex::~Complex()
{

}
//操作符重载
Complex Complex::operator +(const Complex & c)
{
	return Complex(real+c.real, imag+c.imag);
}

Complex Complex::operator -(const Complex & c)
{
	return Complex(real-c.real, imag-c.imag);
}

Complex Complex::operator ~()const
{
	return Complex(real, -imag);
}

Complex Complex::operator *(const Complex & c)
{
	return Complex(real*c.real-imag*c.imag, real*c.imag+imag*c.real);
}


Complex square (const Complex & z)
{
	Complex sq;
	sq.real = z.real * z.real - z.imag * z.imag;
	sq.imag = 2.0 * z.real * z.imag;
	return sq;
}

Complex operator*(double n, const Complex & w)
{
	return Complex(n*w.real,n*w.imag);
}

//输入输出操作符重载
ostream & operator << (ostream & os, const Complex & c)
{
	os << "(" << c.real << ", " << c.imag << "i)" <<endl;
	return os;
}
istream & operator >> (istream & is, Complex & c)
{
	cout << "real: ";
	if (is >> c.real)
	{
		cout << "imaginary: ";
		is >> c.imag;
	}
	return is;

}

//main函数
#include <iostream>
#include "complex0.h"
int main()
{
	Complex a(3.0,4.0);
	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 <<'\n';
		cout << "a + c is " << a+c <<'\n';
		cout << "a - c is " << a-c <<'\n';
		cout << "a * c is " << a*c <<'\n';
		cout << "2 * c is " << 2.0*c <<'\n';
	}
	cout << "Done\n";
	system("pause");
	return 0;

}

莫失_莫忘
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++ Primer Plus（第六版）编程练习答案 第11章 使用类
清水河C罗——Leonardo-Liu
09-14 5081
本章所有编程练习的工程源码可在此处下载（点击此链接下载），供大家参考交流！   1. 修改程序清单11.5，使之将一系列连续的随机漫步者位置写入到文件中。对于每个位置，用步号进行标示。另外，让该程序将初始条件（目标距离和步长）以及结果小结写入到该文件中。该文件的内容与下面类似： （……代码省略……） 本题要求将随机漫步者的位置写入到文件中，这些内容刚好和程序清单11.13,11.14,11...
50道C/C++编程练习题 复习必备(11-20)
qq_40575024的博客
06-22 5228
C/C++编程练习题 （11-20）11. 求 e=1 + 1/1! + 1/2! + 1/3! + ...12. 求PI值，PI/4 = 1 - 1/3 + 1/5 - 1/7 + ...13. 求PI值，PI/2 = 1 + 1/3 + 1/3*2/5 + 1/3*2/5*3/7 + ...14. 输入20个数，统计其中正数、负数和零的个数。15. 输入若干个整数，计算其中的奇数之和与偶数之和，假设输入0表示结束。16. 写一函数，计算x的y次方（假设x、y都为正整数） 使用C/C++两种语言完成50道
C Primer Plus (第五版)中文版——第 11 章 字符串和字符串函数
Mr__Gold的博客
11-19 237
11.1  字符串表示和字符串 I/O 11.1  在程序中定义字符串 一、字符串常量 字符串常量（string constant）又称字符串文字（string literal），是指位于一对双引号中的任何字符。字符串常量属于静态存储类。 可以用 #define 来定义字符串常量，也可以直接作为函数 printf() 或 puts() 的参数。 #define HMG "Hello,M...
c++基础编程练习11
zhangshan415的专栏
09-16 720
/* 11: 第11题 下列程序定义了n×n的二维数组，并在主函数中自动赋值。 请编写函数 fun(int a[][n]), 该函数的功能是：使数组左下半三角元素中的值全部置成0。 */ #include using namespace std ; const int n = 4 ; const int m = 4 ; void fun_right_down(int a[][n
C++编程练习——2014/3/11
MISAD
03-12 687
1
C++ Primer Plus第六版 第十一章 编程练习答案
蒟蒻升级中...Orz
09-26 3344
//第一题 //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 第五版》编程练习答案
11-21
### C++ Primer Plus 第五版编程练习答案解析 #### 知识点概述 本文将针对《C++ Primer Plus 第五版》中部分编程练习的答案进行详细的解析与解释，旨在帮助读者更好地理解C++语言的基本概念及其应用。所选示例涵盖...
C++ Primer Plus 编程练习源码工程 第11章
09-14
C++ Primer Plus 编程练习源码工程 第11章 ，这是本人自己学习书籍时写的编程练习的源码工程，供大家参考交流。
《C Primer Plus》第十一章编程练习11-12 萌新！
Alex_mercer_boy的博客
08-06 704
萌新报道！ 本人算是个小白，目前学到《C Primer Plus》第十二章。 准备开始发些博客，既是展现自己的渣渣实力，也是结交IT界的大牛们，嘿嘿！ 编译环境：VS 2017 Community 运行平台：Win 10 ×64 好了，话不多说，上题目： /* 11-12 ---编写一个程序，读取输入，直至读到 EOF ，报告读入的单词数， 大写字母数，小写字母数，标点字符数和数字...
c++ Primer Plus（第六版）第十一章，编程练习之路
Robot_x的博客
01-14 2526
c++ Primer Plus（第六版）第十一章，个人学习记录，成长中
记录——《C Primer Plus （第五版）》第十一章编程练习第5-12题
zgscsed的博客
12-18 2665
5.编写一个函数is_within()，它接受两个参数，一个是字符，另一个是字符串指针。其功能是如果字符在字符串中，就返回一个非0值（真）；如果字符不在字符串中，就返回0值（假）。在一个使用循环语句为这个函数提供输入的完整程序中进行测试。# include <stdio.h>int is_within(char ch, char * string); void clear();// 清除每次输入
C++ pprimer plus 第六版 第十一章 编程练习答案
菜鸡harry的博客
08-11 2062
第十一章 编程练习答案 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 第十一章习题答案
weixin_44808331的博客
07-06 490
第一题： // An highlighted block Stonewt operator*(double mult); Stonewt Stonewt::operator*(double mult) { return Stonewt(mult * pounds); } 第二题： 成员函数是类定义的一部分，通过特定的对象来调用。成员函数可以隐式访问调用对象的成员，而无需使用成员运算符。友元函数...
C ++ Primer Plus 第六版 第十一章编程练习答案
Fire_Sky_Ho的博客
07-28 1513
1.修改程序清单11.5，使之将一系列连续的随机漫步者位置写入到文件中。对于每个位置，用步号进行标志。另外，让该程序将初始条件（目标距离和步长）以及结果小结写入到该文件中。该文件的内容与下面类似： Target Distance: 100, Step Size: 20 0: (x,y) = (0, 0) 1: (x,y) = (-11.4715, 16.383)
c++程序设计基础（第五版）（上） 习题与解答
热门推荐
bueke的博客
09-09 11万+
习题与解答 C++程序设计基础（第5版）（上） 习题与解答 第1章练习题 同步练习1.1 一、选择题 1．一个最简单的C++程序，可以只有一个（ ）。 （A）库函数 （B）自定义函数 （C）main函数 （D）空函数 2．函数名是（ ），用于识别和调用函数。 （A）关键字 （B）标识符 （C）常数 （D）语句 3．用C++语言编写的源程序要成为目标程序必须要经过（ ）...
1
14658
08-14 664
1
C++ Primer Plus第五版 第六章 编程练习答案
cx_12586的博客
10-20 2080
C++ Primer Plus第五版 第六章 编程练习答案
C++ Primer Plus 第六版：第二至第六章编程练习答案解析
“C++ Primer Plus（第六版）第二至第六章课后编程练习答案” 在C++编程中，练习和理解各种概念是至关重要的。以下是对提供的编程练习的详细解释和知识点总结： **第二章：开始学习C++** 1. **输入/输出流**：在...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值