(C++기초플러스 6판 프로그래밍 연습 정답,솔루션) CHAPTER 11 클래스의 활용 p.787~ 1번~7번

1번

// randwalk.cpp -- Vector 클래스를 사용한다
// vect.cpp 파일과 함께 컴파일한다
#include <iostream>
#include<fstream>
#include <cstdlib>      // rand(), srand()의 원형
#include <ctime>        // time()의 원형
#include "vect.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 write_randwalk;
    write_randwalk.open("randwalk.txt");
    if (!write_randwalk.is_open())
        exit(EXIT_FAILURE);

    cout << "목표 거리를 입력하십시오(끝내려면 q): ";
    while (cin >> target)
    {
        cout << "보폭을 입력하십시오: ";
        if (!(cin >> dstep))
            break;
        write_randwalk << "목표 거리: " << target << ", 보폭: " << dstep<<endl;
        while (result.magval() < target)
        {
            direction = rand() % 360;
            step.reset(dstep, direction, Vector::POL);
            result = result + step;
            write_randwalk << steps << ": (x,y) = " << result << endl;
            steps++;
        }
        write_randwalk << steps << " 걸음을 걸은 후 술고래의 현재 위치:\n";
        write_randwalk << result << endl;
        result.polar_mode();
        write_randwalk << " 또는\n" << result << endl;
        write_randwalk << "걸음당 기둥에서 벗어난 평균 거리 = "
            << result.magval() / steps << endl;
        steps = 0;
        result.reset(0.0, 0.0);
        cout << "목표 거리를 입력하십시오(끝내려면 q): ";
    }
    cout << "프로그램을 종료합니다.\n";
    cin.clear();
    while (cin.get() != '\n')
        continue;
    write_randwalk.close();
    return 0;
}

 

2번

// vect.cpp -- Vector 클래스를 위한 메서드
#include <cmath>
#include "vect.h"   // <iostream>을 포함한다
using std::sqrt;
using std::sin;
using std::cos;
using std::atan;
using std::atan2;
using std::cout;

namespace VECTOR
{
    // 1 라디안 내의 각도를 계산하여라(1 라디안에 대한 degree 값을 계산)
    const double Rad_to_deg = 45.0 / atan(1.0);
    // 반드시 약 57.2957795130823 값이 되어야 함

    // private 메서드들
    // x값과 y값으로 크기를 계산한다
    double Vector::magval() const  // 크기를 보고한다
    {
        return sqrt(x * x + y * y);
    }
    double Vector::angval() const   // 각도를 보고한다
    {
        if (x == 0.0 && y == 0.0)
            return 0;
        else
            return atan2(y, x);
    }

    // 극 좌표를 사용하여 x를 설정한다
    void Vector::set_x(double mag,double ang)
    {
        x = mag * cos(ang);
    }

    // 극 좌표를 사용하여 y를 설정한다
    void Vector::set_y(double mag,double ang)
    {
        y = mag * sin(ang);
    }

    // public 메서드들
    Vector::Vector()             // 디폴트 생성자
    {
        x = y = 0.0;
        mode = RECT;
    }

    // form이 r이면 직각 좌표로부터 벡터를 구성한다
    // form이 p이면 극 좌표로부터 벡터를 구성한다
    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 / Rad_to_deg);
            set_y(n1, n2 / Rad_to_deg);
        }
        else
        {
            cout << "Vector()에 전달된 제3의 매개변수가 잘못되었다.\n";
            cout << "그래서 벡터를 0으로 설정하였다.\n";
            x = y = 0.0;
            mode = RECT;
        }
    }

    // form이 RECT이면 직각 좌표로부터 벡터를 구성한다(디폴트)
    // form이 POL이면 극 좌표로부터 벡터를 구성한다
    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 / Rad_to_deg);
            set_y(n1, n2 / Rad_to_deg);
        }
        else
        {
            cout << "Vector()에 전달된 제3의 매개변수가 잘못되었다.\n";
            cout << "그래서 벡터를 0으로 설정하였다.\n";
            x = y = 0.0;
            mode = RECT;
        }
    }

    Vector::~Vector()    // 파괴자
    {
    }

    void Vector::polar_mode()    // 극 좌표 모드로 설정한다
    {
        mode = POL;
    }

    void Vector::rect_mode()     // 직각 좌표 모드로 설정한다
    {
        mode = RECT;
    }

    // 연산자 오버로딩
    // 두 Vector 객체를 더한다
    Vector Vector::operator+(const Vector& b) const
    {
        return Vector(x + b.x, y + b.y);
    }

    // Vector 객체 a에서 Vector 객체 b를 뺀다
    Vector Vector::operator-(const Vector& b) const
    {
        return Vector(x - b.x, y - b.y);
    }

    // Vector 객체의 부호를 바꾼다
    Vector Vector::operator-() const
    {
        return Vector(-x, -y);
    }

    // Vector 객체에 n을 곱한다
    Vector Vector::operator*(double n) const
    {
        return Vector(n * x, n * y);
    }

    // 프렌드 메서드들
    // n에 Vector 객체 a를 곱한다
    Vector operator*(double n, const Vector& a)
    {
        return a * n;
    }

    // mode가 RECT이면 직각 좌표를 출력한다
    // mode가 POL이면 극 좌표를 출력한다
    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 객체의 모드 지정이 틀렸습니다.\n";
        return os;
    }

}  // namespace VECTOR의 끝


// vect.h -- 모든 상태와 <<를 사용하는, Vector 클래스
#ifndef VECTOR_H_
#define VECTOR_H_
#include <iostream>
namespace VECTOR
{
    class Vector
    {
    public:
        enum Mode { RECT, POL };
        // 직사각형을 위해서는 RECT를, Polar modes를 위해서는 POL을 사용한다
    private:
        double x;          // 수평 성분
        double y;          // 수직 성분
        Mode mode;         // POL을 위해서 RECT를 (RECT 또는 POL)
    // 값들을 설정하는 private 메서드들
        void set_x(double,double);
        void set_y(double,double);
    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; }       // x값을 보고한다
        double yval() const { return y; }       // y값을 보고한다
        double magval() const;  // 크기를 보고한다
        double angval() const;   // 각도를 보고한다
        void polar_mode();                    // 모드를 'p'로 설정한다
        void rect_mode();                     // 모드를 'r'로 설정한다
    // 연산자 오버로딩
        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);
    };

}   						// namespace VECTOR의 끝
#endif

 

3번

// randwalk.cpp -- Vector 클래스를 사용한다
// vect.cpp 파일과 함께 컴파일한다
#include <iostream>
#include <cstdlib>      // rand(), srand()의 원형
#include <ctime> // time()의 원형
#include<new>
#include "vect.h"
int main()
{
    using namespace std;
    using VECTOR::Vector;
    srand(time(0));     // 난수 발생기에 씨를 뿌린다
    double direction;
    Vector step;
    Vector result(0.0, 0.0);
    unsigned long n, max, min;
    double average;
    double target;
    double dstep;
    cout << "목표 거리를 입력하십시오(끝내려면 q): ";
    while (cin >> target)
    {
        cout << "보폭을 입력하십시오: ";
        if (!(cin >> dstep))
            break;
        cout << "시도할 횟수를 입력하십시오: ";
        cin >> n;
        unsigned long *steps = new unsigned long[n];
        for (int i = 0; i < n; i++)
        {
            steps[i] = 0;
        }
        for (int i = 0; i < n; i++)
        {
            while (result.magval() < target)
            {
                direction = rand() % 360;
                step.reset(dstep, direction, Vector::POL);
                result = result + step;
                steps[i]++;
            }
            result.reset(0.0, 0.0);
        }
        average = max = min = steps[0];
        for (int i = 1; i < n; i++)
        {
            if (max < steps[i])
                max = steps[i];
            if (min > steps[i])
                min = steps[i];
            average += steps[i];
        }
        cout << "최고 걸음 수 : " << max << endl
            << "최저 걸음 수 : " << min << endl
            << "평균 걸음 수 : " << average / n << endl;
        delete[] steps;
        cout << "목표 거리를 입력하십시오(끝내려면 q): ";
    }
    cout << "프로그램을 종료합니다.\n";
    cin.clear();
    while (cin.get() != '\n')
        continue;
    return 0;
}

 

 

4번

// mytime3.h -- 프렌드를 사용하는 Time 클래스
#ifndef MYTIME3_H_
#define MYTIME3_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& t,const Time& i);
    friend Time operator-(const Time& t,const Time& i);
    friend Time operator*(const Time& t, double mult) { return mult * t; }
    friend Time operator*(double mult,const Time & t);
    friend std::ostream& operator<<(std::ostream& os, const Time& t);

};
#endif


// mytime3.cpp  -- Time 클래스의 메서드 구현
#include "mytime3.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& t,const Time& i)
{
    Time sum;
    sum.minutes = i.minutes + t.minutes;
    sum.hours = i.hours + t.hours + sum.minutes / 60;
    sum.minutes %= 60;
    return sum;
}

Time operator-(const Time& t,const Time& i)
{
    Time diff;
    int tot1, tot2;
    tot1 = t.minutes + 60 * t.hours;
    tot2 = i.minutes + 60 * i.hours;
    diff.minutes = (tot2 - tot1) % 60;
    diff.hours = (tot2 - tot1) / 60;
    return diff;
}

Time operator*(double mult,const Time &t)
{
    Time result;
    long totalminutes = t.hours * mult * 60 + t.minutes * mult;
    result.hours = totalminutes / 60;
    result.minutes = totalminutes % 60;
    return result;
}

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

 

 

5번

// stonewt.h -- Stonewt 클래스 정의
#ifndef STONEWT_H_
#define STONEWT_H_
class Stonewt
{
public:
    enum MODE { STONE, POUNDS, PDS_LEFT };
private:
    enum { Lbs_per_stn = 14 };      // 스톤당 파운드 수
    int stone;                    // 정수부(스톤)
    double pds_left;              // 소수부(파운드)
    double pounds;                // 파운드로 나타낸 전체 무게
    MODE mode;
public:
    void set_mode(MODE form);
    Stonewt(double lbs,MODE form = STONE);
    Stonewt(int stn, double lbs,MODE form = STONE); // stone, lbs를 위한 생성자
    Stonewt();                    // 디폴트 생성자
    ~Stonewt();
    Stonewt operator+(const Stonewt& s) const;
    Stonewt operator-(const Stonewt& s) const;
    Stonewt operator*(const Stonewt& s) const;
    friend std::ostream& operator<<(std::ostream& os, const Stonewt& s);
};
#endif


// stonewt.cpp -- Stonewt 클래스의 메서드
#include <iostream>
using std::cout;
#include "stonewt.h"



// double형 값으로 Stonewt 객체를 생성한다
Stonewt::Stonewt(double lbs,MODE form)
{
    stone = int(lbs) / Lbs_per_stn;    // 정수 나눗셈
    pds_left = int(lbs) % Lbs_per_stn + lbs - int(lbs);
    pounds = lbs;
    mode = form;
}

// int형 값과 double형 값으로 Stonewt 객체를 생성한다
Stonewt::Stonewt(int stn, double lbs,MODE form)
{
    stone = stn;
    pds_left = lbs;
    pounds = stn * Lbs_per_stn + lbs;
    mode = form;
}

Stonewt::Stonewt()          // 디폴트 생성자, 무게 = 0
{
    stone = pounds = pds_left = 0;
    mode = STONE;
}

Stonewt::~Stonewt()         // 파괴자
{
}


void Stonewt::set_mode(MODE form)
{
    mode = form;
}
Stonewt Stonewt::operator+(const Stonewt& s) const
{
    return Stonewt(pounds + s.pounds,mode);
}
Stonewt Stonewt::operator-(const Stonewt& s) const
{
    return Stonewt(pounds - s.pounds,mode);
}
Stonewt Stonewt::operator*(const Stonewt& s) const
{
    return Stonewt(pounds * s.pounds,mode);
}



std::ostream& operator<<(std::ostream& os, const Stonewt& s)
{
    if (s.mode == Stonewt::STONE)
        os << s.stone << "스톤, " << s.pds_left << "파운드";
    else if (s.mode == Stonewt::POUNDS)
        os << (int)s.pounds << "파운드";
    else
        os << s.pounds << "파운드";
    return os;
}


// stone.cpp -- 사용자 정의 데이터형 변환
// stonewt.cpp와 함께 컴파일한다
#include <iostream>
using std::cout;
using std::endl;
#include "stonewt.h"
int main()
{
    Stonewt s1(325.4,Stonewt::PDS_LEFT);
    Stonewt s2(24, 8, Stonewt::STONE);
    Stonewt s3(223.56, Stonewt::POUNDS);

    cout << s1 << ";    " << s2 << ";   " << s3 << endl;

    s1.set_mode(Stonewt::STONE);
    s2.set_mode(Stonewt::STONE);
    s3.set_mode(Stonewt::STONE);

    cout << s1 << ";    " << s2 << ";   " << s3 << endl;

    Stonewt result;
    result = s1 + s2;
    cout << result << endl;
    cout << s1 - s2 << endl;
    cout << s1 * s3 << endl;

    return 0;
}

 

 

6번

// stonewt.h -- Stonewt 클래스 정의
#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);          // double형 파운드를 위한 생성자
    Stonewt(int stn, double lbs); // stone, lbs를 위한 생성자
    Stonewt();                    // 디폴트 생성자
    ~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.cpp -- Stonewt 클래스의 메서드
#include <iostream>
using std::cout;
#include "stonewt.h"

// double형 값으로 Stonewt 객체를 생성한다
Stonewt::Stonewt(double lbs)
{
    stone = int(lbs) / Lbs_per_stn;    // 정수 나눗셈
    pds_left = int(lbs) % Lbs_per_stn + lbs - int(lbs);
    pounds = lbs;
}

// int형 값과 double형 값으로 Stonewt 객체를 생성한다
Stonewt::Stonewt(int stn, double lbs)
{
    stone = stn;
    pds_left = lbs;
    pounds = stn * Lbs_per_stn + lbs;
}

Stonewt::Stonewt()          // 디폴트 생성자, 무게 = 0
{
    stone = pounds = pds_left = 0;
}

Stonewt::~Stonewt()         // 파괴자
{
}

// 무게를 스톤과 파운드의 조합 형식으로 출력한다
void Stonewt::show_stn() const
{
    cout << stone << "스톤, " << pds_left << "파운드\n";
}

// 무게를 파운드 형식으로 출력한다
void Stonewt::show_lbs() const
{
    cout << 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);
}


// stone.cpp -- 사용자 정의 데이터형 변환
// stonewt.cpp와 함께 컴파일한다
#include <iostream>
using std::cout;
using std::endl;
#include "stonewt.h"
int main()
{
    Stonewt ar[6] = { 30,24.6,34.2 };
    double var;
    for (int i = 3; i < 6; i++)
    {
        std::cin >> var;
        ar[i] = var;
    }
    Stonewt max, min, compare(11,0.0);
    max = min = ar[0];
    int count = 0;
    if (ar[0] >= compare)
        count++;
    for (int i = 1; i < 6; i++)
    {
        if (max < ar[i])
            max = ar[i];
        if (min > ar[i])
            min = ar[i];
        if (ar[i] >= compare)
            count++;
    }
    cout << "가장 큰 원소 : ";
    max.show_lbs();
    cout << "가장 작은 원소 : ";
    min.show_lbs();
    cout << "11스톤보다 크거나 같은 원소의 개수 : " << count << "\n";
    return 0;
}

 

 

7번

//complex0.h
#ifndef COMPLEX0_H_
#define COMPLEX0_H_
class complex {
private:
	double real_val;
	double imagin_val;
public:
	complex(double rval, double ival);
	complex();
	complex operator+(complex& t) const;
	complex operator-(complex& t) const;
	complex operator*(complex& t) const;
	complex operator~();
	friend complex operator*(double m,const complex& t);
	friend std::ostream& operator<<(std::ostream& os, const complex& t);
	friend std::istream& operator>>(std::istream& os, complex& t);
};
#endif

//complex0.cpp
#include<iostream>
#include"complex0.h"

complex::complex(double rval, double ival)
{
	real_val = rval;
	imagin_val = ival;
}
complex::complex()
{
	real_val = imagin_val = 0.0;
}

complex complex::operator+(complex& t) const
{
	return complex(real_val + t.real_val, imagin_val + t.imagin_val);
}
complex complex::operator-(complex& t) const
{
	return complex(real_val - t.real_val, imagin_val - t.imagin_val);
}
complex complex::operator*(complex& t) const
{
	return complex(real_val * t.real_val - imagin_val * t.imagin_val, real_val * t.imagin_val + t.real_val * imagin_val);
}
complex complex::operator~()
{
	return complex(real_val, -imagin_val);
}
complex operator*(double m, const complex& t)
{
	return complex(m * t.real_val, m * t.imagin_val);
}
std::ostream& operator<<(std::ostream& os, const complex& t)
{
	os << "(" << t.real_val << "," << t.imagin_val << "i)";
	return os;
}
std::istream& operator>>(std::istream& os, complex& t)
{
	std::cout << "실수부: ";
	os >> t.real_val;
	std::cout << "허수부: ";
	os >> t.imagin_val;
	return os;
}


//usecmplx.cpp
#include<iostream>
using namespace std;
#include"complex0.h"
int main()
{
	complex a(3.0, 4.0);
	complex c;
	cout << "하나의 복소수를 입력하십시오(끝내려면 q):\n";
	while (cin >> c)
	{
		cout << "c = " << c << endl;
		cout << "공액복소수 = " << ~c << endl;
		cout << "a = " << a << endl;
		cout << "a + c = " << a + c << endl;
		cout << "a - c = " << a - c << endl;
		cout << "a * c = " << a * c << endl;
		cout << "2 * c = " << 2 * c << endl;
		cout << "하나의 복소수를 입력하십시오(끝내려면 q)\n";
	}
	cout << "프로그램을 종료합니다.\n";
	return 0;
}