C++ Primer Plus 第11章 课后编程练习 代码

最新推荐文章于 2024-05-14 15:27:08 发布
最新推荐文章于 2024-05-14 15:27:08 发布
阅读量184 收藏
点赞数
分类专栏： C++ Primer Plus 课后编程练习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40459977/article/details/107774166
版权 
第一题
// 1.头文件
#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();
        // inline function
        double xval() const { return x; }
        double yval() const { return y; }
        double magval() const { return mag; }
        double angval() const { return ang; }
        // set mode
        void polar_mode();
        void rect_mode();
        // 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 std::ostream &operator<<(std::ostream &os, const Vector &v);
    };
} // namespace VECTOR

#endif

//2.函数定义
#include "vector.h"
#include <cmath>
using std::atan;
using std::atan2;
using std::cos;
using std::cout;
using std::sin;
using std::sqrt;

namespace VECTOR
{
    const double Rad_to_Deg = 45.0 / atan(1.0); // 1弧度=57.295...°

    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 (mode == RECT)
        {
            x = n1;
            y = n2;
            set_ang();
            set_mag();
        }
        else if (mode == 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 (mode == RECT)
        {
            x = n1;
            y = n2;
            set_ang();
            set_mag();
        }
        else if (mode == 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);
    }

    // friends
    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 << ")";
        }
        else
        {
            os << "Vector object mode is invalid";
        }

        return os;
    }
} // namespace VECTOR

//3.主函数
#include "vector.h"
#include <cstdlib>
#include <ctime>
#include <fstream>
#include <iostream>

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("randwalk.txt", ios::out | ios::app);

    cout << "Enter target distance (q to quit): ";
    while (cin >> target)
    {
        cout << "Enter step length: ";
        if (!(cin >> dstep))
            break;
        cout << "Target Distance: " << target << ", Step Size: " << dstep << endl;
        fout << "Target Distance: " << target << ", Step Size: " << dstep << endl;
        int i = 0;
        cout << i << ": " << result << endl;
        fout << i << ": " << result << endl;

        while (result.magval() < target)
        {
            direction = rand() % 360;
            step.reset(dstep, direction, Vector::POL); //! 因为Vector类名称已经可用,所以这里可以直接使用
            result = result + step;
            steps++;
            i++;
            cout << i << ": " << result << endl;
            fout << i << ": " << result << endl;
        }
        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;

        fout << "After " << steps << " steps, the subject "
                                     "has the following location:\n";
        fout << result << endl;
        result.polar_mode();
        fout << " or\n"
             << result << 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;
    }

    return 0;
}

第二题
// 1.头文件
#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;
        double set_mag();
        double set_ang();

        double set_x();
        double set_y();

    public:
        Vector();
        Vector(double n1, double n2, Mode form = RECT);
        void reset(double n1, double n2, Mode form = RECT);
        ~Vector();
        // inline function
        double xval() const { return x; }
        double yval() const { return y; }

        //! 注意: 这里需要去掉const,为什么呢 ?
        //! 答: 这两个函数没有改变类对象啊!!
        double magval() { return set_mag(); }
        double angval() { return set_ang(); }

        // set mode
        void polar_mode();
        void rect_mode();
        // 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 std::ostream &operator<<(std::ostream &os, const Vector &v);
    };
} // namespace VECTOR

#endif

//2.函数定义
#include "vector.h"
#include <cmath>
using std::atan;
using std::atan2;
using std::cos;
using std::cout;
using std::sin;
using std::sqrt;

namespace VECTOR
{
    const double Rad_to_Deg = 45.0 / atan(1.0); // 1弧度=57.295...°

    double Vector::set_mag()
    {
        return sqrt(x * x + y * y);
    }

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

    double Vector::set_x()
    {
        return x * cos(y);
    }

    double Vector::set_y()
    {
        return x * sin(y);
    }

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

    Vector::Vector(double n1, double n2, Mode form)
    {
        mode = form;
        if (mode == RECT)
        {
            x = n1;
            y = n2;
        }
        else if (mode == POL)
        {
            x = n1 * cos(n2);
            y = n1 * sin(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 (mode == RECT)
        {
            x = n1;
            y = n2;
        }
        else if (mode == POL)
        {
            x = n1 * cos(n2);
            y = n1 * sin(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;
        x = set_mag(); //*此时因为只有x和y.所以暂时让x充当mag,y充当ang的角色
        y = set_ang();
    }

    void Vector::rect_mode()
    {
        if (mode == POL)
        {
            mode = RECT;
            x = set_x();
            y = set_y();
        }
    }

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

    // friends
    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.x << "," << v.y << ")";
        }
        else
        {
            os << "Vector object mode is invalid";
        }

        return os;
    }
} // namespace VECTOR

//3.主函数
#include "vector.h"
#include <cstdlib>
#include <ctime>
#include <iostream>

int main()
{
    using namespace std;
    // using namespace VECTOR;
    //!使用VECTOR名称空间的类Vector, --->使得类名称Vector可用
    //!同时该类中的public方法可用
    //!为什么调用方法的时候不用加Vector::而使用类中的POL就需要这个Vector::?
    //!答:因为调用方法是用的类对象调用方法,这个类对象已经表明了是Vector::,而单单一个变量POL并没有这种信息
    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); //! 因为Vector类名称已经可用,所以这里可以直接使用
            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;
    }

    return 0;
}

第3题
// 1.头文件
#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();
        // inline function
        double xval() const { return x; }
        double yval() const { return y; }
        double magval() const { return mag; }
        double angval() const { return ang; }
        // set mode
        void polar_mode();
        void rect_mode();
        // 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 std::ostream &operator<<(std::ostream &os, const Vector &v);
    };
} // namespace VECTOR

#endif

//2.函数定义
#include "vector.h"
#include <cmath>
using std::atan;
using std::atan2;
using std::cos;
using std::cout;
using std::sin;
using std::sqrt;

namespace VECTOR
{
    const double Rad_to_Deg = 45.0 / atan(1.0); // 1弧度=57.295...°

    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 (mode == RECT)
        {
            x = n1;
            y = n2;
            set_ang();
            set_mag();
        }
        else if (mode == 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 (mode == RECT)
        {
            x = n1;
            y = n2;
            set_ang();
            set_mag();
        }
        else if (mode == 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);
    }

    // friends
    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 << ")";
        }
        else
        {
            os << "Vector object mode is invalid";
        }

        return os;
    }
} // namespace VECTOR

//3.主函数
#include "vector.h"
#include <cstdlib>
#include <ctime>
#include <iostream>

int main()
{
    using namespace std;
    // using namespace VECTOR;
    //!使用VECTOR名称空间的类Vector, --->使得类名称Vector可用
    //!同时该类中的public方法可用
    //!为什么调用方法的时候不用加Vector::而使用类中的POL就需要这个Vector::?
    //!答:因为调用方法是用的类对象调用方法,这个类对象已经表明了是Vector::,而单单一个变量POL并没有这种信息
    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 << "How many test do you want? \n";
    int N;
    cin >> N;
    double arr_step[N];
    double min;
    double max;
    double average;
    int i = 0;
    cout << "Enter target distance: ";
    cin >> target;
    cout << "Enter step length: ";
    cin >> dstep;

    for (int j = 0; j < N; j++)
    {
        while (result.magval() < target)
        {
            direction = rand() % 360;
            step.reset(dstep, direction, Vector::POL); //! 因为Vector类名称已经可用,所以这里可以直接使用
            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;
        arr_step[i++] = steps;

        steps = 0;
        result.reset(0.0, 0.0);
    }
    // if (i < N)
    // {
    //     steps = 0;
    //     result.reset(0.0, 0.0);
    //     cout << "Enter target distance (q to quit): ";
    // }

    min = arr_step[0];
    max = arr_step[0];
    double total = arr_step[0];
    for (int j = 1; j < N; j++)
    {
        if (arr_step[j] < min)
        {
            min = arr_step[j];
        }
        if (arr_step[j] > max)
        {
            max = arr_step[j];
        }

        total += arr_step[j];
    }
    average = total / N;
    cout << "Max step = " << max << endl;
    cout << "Min step = " << min << endl;
    cout << "Ave step = " << average << endl;
    cout << "Bye !\n";
    cin.clear();
    while (cin.get() != '\n')
    {
        continue;
    }

    return 0;
}

第四题
//1.头文件
#ifndef TIME_H_
#define TIME_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);
    // 声明运算符重载函数,表明操作数是参数列表和调用对象

    friend Time operator+(const Time &t1, const Time &t2);
    friend Time operator-(const Time &t1, const Time &t2);
    friend Time operator*(const Time &t, double n);
    friend Time operator*(double n, const Time &t)
    {
        return t * n;
    }
    friend std::ostream &operator<<(std::ostream &os, const Time &t);
    void Show() const;
};

#endif


//2.函数定义
#include "mytime.h"
#include <iostream>
// using std::ostream;
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;
}

// 在调用该运算符函数时,有两种方式直接调用运算符成员函数operator+;
// 或者是使用运算符形式: + ,运算符左边为调用对象,右边是参数传递的对象
Time operator+(const Time &t1, const Time &t2)
{
    Time temp;
    temp.minutes = (t1.minutes + t2.minutes) % 60;
    temp.hours = (t1.minutes + t2.minutes) / 60 + t1.hours + t2.hours;

    return temp;
}

Time operator-(const Time &t1, const Time &t2)
{
    Time temp;
    int tot1, tot2;
    tot1 = t1.hours * 60 + t1.minutes;
    tot2 = t2.hours * 60 + t2.minutes;
    temp.minutes = (tot1 - tot2) % 60;
    temp.hours = (tot1 - tot2) / 60;

    return temp;
}

Time operator*(const Time &t, double n)
{
    Time result;
    long total_minutes = (t.minutes + t.minutes * 60) * n;
    result.minutes = total_minutes % 60;
    result.hours = total_minutes / 60;

    return result;
}

void Time::Show() const
{
    std::cout << hours << " hours, " << minutes << " minutes";
}

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

    return os;
}


//3.主函数
#include "mytime.h"

int main()
{
    using std::cout;
    using std::endl;
    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;
}

第5题
//1.头文件
#ifndef STONE_H_
#define STONE_H_
#include <iostream>

class Stone
{
private:
    static const int Lbs_per_stn = 14;
    enum Mode
    {
        form_st, //英石格式
        form_ip, //整数磅格式
        form_dp  //浮点磅格式
    };
    Mode mode;
    // 英石格式
    int stone;
    double pds_left;
    // 浮点格式的磅
    double pounds;
    // 整数格式的磅
    int Ipound;
    void SetOthers();

public:
    Stone(double lbs);          // 单位为磅例如 35.3磅
    Stone(int stn, double lbs); // 单位为英石和磅例如 4英石 3.4磅
    Stone();
    ~Stone();

    // 重载运算符 <<
    friend std::ostream &operator<<(std::ostream &os, Stone &st);
    // 重载 + - *
    Stone operator+(const Stone &st) const;
    Stone operator-(const Stone &st) const;
    Stone operator*(double n) const;

    friend Stone operator*(double n, const Stone &st)
    {
        return st * n;
    }

    void set_form_st() { mode = form_st; }
    void set_form_ip() { mode = form_ip; }
    void set_form_dp() { mode = form_dp; }
};

#endif

//2.函数定义
#include <iostream>
using std::cout;
#include "stone.h"

Stone::Stone(double lbs)
{
    mode = form_dp;
    pounds = lbs; //浮点格式的磅

    stone = int(lbs) / Lbs_per_stn; //英石格式的磅
    pds_left = int(lbs) % Lbs_per_stn + lbs - int(lbs);

    Ipound = int(pounds + 0.5); //整数格式的磅
}

Stone::Stone(int stn, double lbs)
{
    mode = form_st;
    stone = stn; //英石格式的磅
    pds_left = lbs;

    pounds = stn * Lbs_per_stn + lbs; //浮点格式的磅

    Ipound = int(pounds + 0.5); //整数格式的磅
}

Stone::Stone()
{
    mode = form_dp;
    Ipound = pounds = stone = pds_left = 0;
}

Stone::~Stone()
{
}

std::ostream &operator<<(std::ostream &os, Stone &st)
{
    if (st.mode == Stone::form_st)
    {
        os << "Form_st: " << st.stone << " stone, " << st.pds_left << " pounds.\n";
    }
    else if (st.mode == Stone::form_dp)
    {
        os << "Form_dp: " << st.pounds << " pounds.\n";
    }
    else
    {
        os << "Form_ip: " << st.Ipound << " pounds.\n";
    }

    return os;
}

Stone Stone::operator+(const Stone &st) const
{
    Stone temp;
    temp.pounds = pounds + st.pounds;
    temp.SetOthers();

    return temp;
}

Stone Stone::operator-(const Stone &st) const
{
    Stone temp;
    temp.pounds = pounds - st.pounds;
    temp.SetOthers();

    return temp;
}

Stone Stone::operator*(double n) const
{
    Stone temp;
    temp.pounds = n * pounds;
    temp.SetOthers();

    return temp;
}

void Stone::SetOthers()
{
    stone = int(pounds) / Lbs_per_stn; //英石格式的磅
    pds_left = int(pounds) % Lbs_per_stn + pounds - int(pounds);
    Ipound = int(pounds + 0.5);
}
//3.主函数
#include "stone.h"

int main()
{
    using std::cout;
    Stone obj1;
    obj1 = Stone(278.6);
    Stone obj2(10, 4.5);
    cout << "obj1 :\n"
         << obj1;
    cout << "obj2 :\n"
         << obj2;

    Stone obj3 = obj1 + obj2;
    obj3.set_form_ip();
    cout << "obj1 + obj2 :\n"
         << obj3;
    obj3 = obj1 - obj2;
    obj3.set_form_st();
    cout << "obj1 - obj2 :\n"
         << obj3;
    obj3 = obj1 * 3;
    cout << "obj1 * 3 :\n"
         << obj3;
    obj3 = 3 * obj2;
    cout << "3 * obj2 :\n"
         << obj3;

    return 0;
}


第六题
//1.头文件
#ifndef STONE_H_
#define STONE_H_

class Stone
{
private:
    // static const int Lbs_per_stn = 14;
    enum
    {
        Lbs_per_stn = 14
    };
    int stone;
    double pds_left;
    double pounds;

public:
    Stone(double lbs);          // 单位为磅例如 35.3磅
    Stone(int stn, double lbs); // 单位为英石和磅例如 4英石 3.4磅
    Stone();
    ~Stone();

    void show_lbs() const;
    void show_stn() const;

    bool operator>(const Stone &st);
    bool operator<(const Stone &st);
    bool operator>=(const Stone &st);
    bool operator<=(const Stone &st);
    bool operator==(const Stone &st);
    bool operator!=(const Stone &st);
};

#endif
//2.函数定义
#include <iostream>
using std::cout;
#include "stone.h"

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

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

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

Stone::~Stone()
{
}

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

bool Stone::operator>(const Stone &st)
{
    if (pounds > st.pounds)
    {
        return true;
    }
    else
    {
        return false;
    }
}
bool Stone::operator<(const Stone &st)
{
    if (pounds < st.pounds)
    {
        return true;
    }
    else
    {
        return false;
    }
}
bool Stone::operator>=(const Stone &st)
{
    if (pounds >= st.pounds)
    {
        return true;
    }
    else
    {
        return false;
    }
}
bool Stone::operator<=(const Stone &st)
{
    if (pounds <= st.pounds)
    {
        return true;
    }
    else
    {
        return false;
    }
}
bool Stone::operator==(const Stone &st)
{
    if (pounds == st.pounds)
    {
        return true;
    }
    else
    {
        return false;
    }
}
bool Stone::operator!=(const Stone &st)
{
    if (pounds != st.pounds)
    {
        return true;
    }
    else
    {
        return false;
    }
}

//3.主函数
#include "stone.h"
#include <iostream>
int main()
{
    using std::cin;
    using std::cout;
    Stone arr_stone[6] = {
        Stone(78.9),
        Stone(7, 8.9),
        Stone(10, 0.0)};
    {
        int i = 3;
        cout << "Please enter the " << i + 1 << "th object's weight:(in pounds)\n";
        double temp;
        while (i < 6 && cin >> temp)
        {
            arr_stone[i] = Stone(temp);
            i++;
            if (i < 6)
            {
                cout << "Please enter the " << i + 1 << "th object's weight:(in pounds)\n";
            }
        }
    }

    int min = 0;
    int max = 0;
    int num = 0;
    Stone comp = Stone(11, 0.0);
    if (arr_stone[0] >= comp)
    {
        num++;
    }

    for (int i = 1; i < 6; i++)
    {
        if (arr_stone[i] < arr_stone[min])
        {
            min = i;
        }
        if (arr_stone[i] > arr_stone[max])
        {
            max = i;
        }
        if (arr_stone[i] >= comp)
        {
            num++;
        }
    }

    cout << "In the array:\n"
         << "The max is NO." << max << " (0~5).\n"
         << "==>";
    arr_stone[max].show_lbs();
    cout << "The min is NO." << min << " (0~5).\n"
         << "==>";
    arr_stone[min].show_lbs();
    cout << "And " << num << " objects are bigger than 11 stones.\n";

    return 0;
}

第七题
//1.头文件
#ifndef COMPLEX0_H_
#define COMPLEX0_H_
#include <iostream>

class Complex0
{
private:
    double real;
    double ima;

public:
    Complex0();
    Complex0(double x, double y);
    ~Complex0();

    //ÖŘÔŘÔËËăˇű
    Complex0 operator+(const Complex0 &co) const;
    Complex0 operator-(const Complex0 &co) const;
    Complex0 operator*(const Complex0 &co) const;

    Complex0 operator*(double x) const;
    friend Complex0 operator*(double x, const Complex0 &co);

    Complex0 operator~() const;

    friend std::ostream &operator<<(std::ostream &os, const Complex0 &co);
    friend bool operator>>(std::istream &is, Complex0 &co);
};

#endif


//2.函数定义
#include "complex0.h"
#include <cstdlib>

Complex0::Complex0()
{
    real = 0.0;
    ima = 0.0;
}
Complex0::Complex0(double x, double y)
{
    real = x;
    ima = y;
}
Complex0::~Complex0()
{
}
//ÖŘÔŘÔËËăˇű
Complex0 Complex0::operator+(const Complex0 &co) const
{
    Complex0 temp;
    temp.real = real + co.real;
    temp.ima = ima + co.ima;
    return temp;
}
Complex0 Complex0::operator-(const Complex0 &co) const
{
    Complex0 temp;
    temp.real = real - co.real;
    temp.ima = ima - co.ima;
    return temp;
}
Complex0 Complex0::operator*(const Complex0 &co) const
{
    Complex0 temp;
    temp.real = real * co.real - ima * co.ima;
    temp.ima = real * co.ima - ima * co.real;
    return temp;
}
Complex0 Complex0::operator*(double x) const
{
    Complex0 temp;
    temp.real = x * real;
    temp.ima = x * ima;
    return temp;
}
Complex0 operator*(double x, const Complex0 &co)
{
    return co * x;
}
Complex0 Complex0::operator~() const
{
    Complex0 temp;
    temp.real = real;
    temp.ima = -ima;
    return temp;
}
std::ostream &operator<<(std::ostream &os, const Complex0 &co)
{
    os << "(" << co.real << " , " << co.ima << "i)";
    return os;
}

bool operator>>(std::istream &is, Complex0 &co)
{
    int ret = false;

    std::cout << "real: ";
    char str1[20];
    // char *str1;
    is.getline(str1, 20);

    if (str1[0] == 'q')
    {
        ret = false;
    }
    else
    {
        co.real = strtod(str1, NULL);
        std::cout << "imaginary: ";
        char str2[20];
        // char *str2;
        is.getline(str2, 20);

        if (str2[0] == 'q')
        {
            ret = false;
        }
        else
        {
            co.ima = strtod(str2, NULL);
            ret = true;
        }
    }

    return ret;
}


//3.主函数
#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 << '\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 * c << '\n';

        cout << "Enter a complex number (q to quit :)\n";
    }
    cout << "Done!\n";
    return 0;
}
咖啡与乌龙
关注
专栏目录
C++ Primer Plus 第六版 所有章节课后编程练习答案
xiaojimmychen的专栏
11-01 8万+
C++ Primer Plus 第六版 所有章节课后编程练习答案
C++ primer plus 课后习题答案
03-30
这个文件是我买的资料。我看过，和C++ primer plus 这本书的课后习题非常吻合。
第十一章 编程练习 （C++ Primer Plus）
一个有梦想，有追求，有抱负的人
06-28 446
1.修改程序清单11.5，使之将一系列连续的随机漫步者位置写入到文件中。对于每个位置，用步号进行标示。另外，让该程序将初始条件（目标距离和步长）以及结果小结写入到该文件中。该文件的内容与下面类似： Target Distance: 100, Step Size: 20 0:(x,y)=(0,0) 1:(x,y)=(-11.4715,16.383) 2:(x,y)=(-8.68807,-3.4223...
c++ primer plus 第六版 课后习题源代码
weixin_33724046的博客
06-24 2385
c++primer第六版 课后编程练习的源代码，从第七章到第16章，基本全，网盘下载地址为 http://pan.baidu.com/s/1ntolFKH 转载于:https://www.cnblogs.com/KyleRuan/p/4317831.html...
C++ Primer plus 第二章课后编程练习
weixin_41284599的博客
02-27 350
第二章课后编程练习 18 //第二章课后编程练习1 #include &lt;iostream&gt; using namespace std; int main() { cout &lt;&lt; "my name is : " &lt;&lt; "wang ming\n"; cout &lt;&lt; "my address: " &lt;&lt; &quot
C++ primer plus 第五章编程练习
weixin_52190646的博客
05-14 447
6．完成编程练习5，但这一次使用一个二维数组来存储输入—3年中每个月的销售量。算多少年后，Cleo的投资价值才能超过Daphne的投资价值，并显示此时。请编写一个程序，输入全。的盈利是105美元的5%—即5.25美元，依此类推。商（存储在字符数组或string对象中的字符串）、生产年份（整数）。例如，如果用户输入的是2和9，则程序将指出2～9之间所有。示，并将输入的数据储存在一个int数组中。9．编写一个满足前一个练习中描述的程序，但使用string对象而不。年中每个月的销售量（图书数量，而不是销售额）。
C++ Primer Plus 第6版 中文版课后代码习题答案
03-10
《C++ Primer Plus 第6版 中文版》是一本深入浅出的C++学习书籍，其课后代码习题答案是学习过程中不可或缺的部分。这本书旨在帮助读者从零基础开始掌握C++编程语言，通过实例和习题来巩固理论知识，提升编程技能。...
C++ primer plus课后编程练习题答案
04-22
第十一章继续深入讲解了类和对象的使用，包括类的多态、类的继承、类的组合等，提供了相关的编程练习题和答案，帮助读者掌握类和对象的高级使用技巧。第十六章和第十七章讲解了高级主题，包括模板、异常处理、输入/...
c++primerplus(第六版)课后编程练习答案.pdf
05-20
以上就是从《C++ Primer Plus（第六版）》第二章和第三章的课后编程练习答案中提取的一些重要知识点。通过这些示例，我们可以了解到C++的基本语法、函数定义与调用、数据类型以及如何处理用户输入和输出等核心概念。
C++primer plus 第十一章习题答案
weixin_44808331的博客
07-06 498
第一题： // An highlighted block Stonewt operator*(double mult); Stonewt Stonewt::operator*(double mult) { return Stonewt(mult * pounds); } 第二题： 成员函数是类定义的一部分，通过特定的对象来调用。成员函数可以隐式访问调用对象的成员，而无需使用成员运算符。友元函数...
C++ Primer Plus（第六版）编程练习答案 第11章 使用类
清水河C罗——Leonardo-Liu
09-14 5113
本章所有编程练习的工程源码可在此处下载（点击此链接下载），供大家参考交流！   1. 修改程序清单11.5，使之将一系列连续的随机漫步者位置写入到文件中。对于每个位置，用步号进行标示。另外，让该程序将初始条件（目标距离和步长）以及结果小结写入到该文件中。该文件的内容与下面类似： （……代码省略……） 本题要求将随机漫步者的位置写入到文件中，这些内容刚好和程序清单11.13,11.14,11...
机器人路径优化：基于强化学习Q-learning算法的移动机器人路径优化MATLAB
10-04
机器人路径优化：基于强化学习Q-learning算法的移动机器人路径优化MATLAB
基于Java、Kotlin和C++的多语言支持的WidgetCase自定义控件通用库设计源码
10-04
本项目是一款支持Java、Kotlin和C++的多语言自定义控件通用库，包含176个文件，涵盖43个PNG图片、41个Java源文件、40个XML布局文件、21个Kotlin源文件、4个Gradle配置文件及其他相关文件。库提供详尽的API文档，支持持续集成与维护，旨在提供便捷、高效的自定义控件开发体验。
基于树莓派的HarmonyOS系统移植与开发设计源码
10-04
本项目为基于树莓派的HarmonyOS系统移植与开发设计源码，包含116个文件，涵盖20个头文件、19个Markdown文档、16个C语言源文件、7个PNG图片文件、7个PDF文件、4个二进制文件、4个ELF文件、4个gn文件、3个HCS文件，以及使用C、Shell和Python等多种编程语言编写。该源码旨在实现HarmonyOS系统在树莓派平台上的移植与应用开发。
毕设项目springboot校友社交系统 答辩用的 PPT
最新发布
10-04
【毕设项目】springboot校友社交系统 答辩用的 PPT
全国大学生电子设计大赛项目合集全国电赛优秀作品STM32项目(ST大赛三等奖作品)超声波自拍神器
10-04
全国大学生电子设计大赛项目合集全国电赛优秀作品STM32项目(ST大赛三等奖作品)超声波自拍神器
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

咖啡与乌龙

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值