(C++기초플러스 6판 프로그래밍 연습 정답,솔루션) CHAPTER 12 클래스와 동적 메모리 대입 p.892~ 1번~6번

1번

//cow.h
#ifndef COW_H_
#define COW_H_
class Cow
{
private:
	char name[20];
	char* hobby;
	double weight;
public:
	Cow();
	Cow(const char* nm, const char* ho, double wt);
	Cow(const Cow& c);
	~Cow();
	Cow& operator=(const Cow& c);
	void ShowCow() const;
};
#endif

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

Cow::Cow()
{
	strcpy(name, "no name");
	hobby = new char[1];
	hobby[0] = '\0';
	weight = 0.0;
}
Cow::Cow(const char* nm, const char* ho, double wt)
{
	strncpy(name, nm, 19);
	name[19] = '\0';
	hobby = new char[strlen(ho) + 1];
	strcpy(hobby, ho);
	weight = wt;
}
Cow::Cow(const Cow& c)
{
	strcpy(name, c.name);
	delete[] hobby;
	hobby = new char[strlen(c.hobby) + 1];
	strcpy(hobby, c.hobby);
	weight = c.weight;
}
Cow::~Cow()
{ 
	delete[] hobby;
}
Cow& Cow::operator=(const Cow& c)
{
	if (this == &c)
		return *this;
	delete[]hobby;
	strcpy(name, c.name);
	hobby = new char[strlen(c.hobby) + 1];
	strcpy(hobby, c.hobby);
	weight = c.weight;
	return *this;
}
void Cow::ShowCow() const
{
	std::cout << "이름 : " << name << '\n'
		<< "취미 : " << hobby << '\n'
		<< "몸무게 : " << weight << '\n';
}

//usecow.cpp
#include"cow.h"

int main()
{
	Cow h("hong gil dong", "soccer", 72.4);
	Cow n;
	h.ShowCow();
	n.ShowCow();

	n = h;
	n.ShowCow();
}

 

 

2번

// string2.h -- 확대 개선된 String 클래스 정의

#ifndef STRING2_H_
#define STRING2_H_
#include <iostream>
using std::ostream;
using std::istream;

class String
{
private:
    char* str;             // 문자열을 지시하는 포인터
    int len;                // 문자열의 길이
    static int num_strings; // 객체의 수
    static const int CINLIM = 80;  // cin 입력 한계
public:
    // 생성자와 기타 메서드
    String(const char* s); // 생성자
    String();               // 디폴트 생성자
    String(const String&); // 복사 생성자
    ~String();              // 파괴자
    int length() const { return len; }
    void stringlow(); //프로그래밍 연습 2번
    void stringup(); //프로그래밍 연습 2번
    int has(char); //프로그래밍 연습 2번
    // 오버로딩 연산자 메서드
    String& operator=(const String&);
    String& operator=(const char*);
    char& operator[](int i);
    const char& operator[](int i) const;
    // 오버로딩 연산자 프렌드
    friend bool operator<(const String& st, const String& st2);
    friend bool operator>(const String& st1, const String& st2);
    friend bool operator==(const String& st, const String& st2);
    friend ostream& operator<<(ostream& os, const String& st);
    friend istream& operator>>(istream& is, String& st);
    friend String operator+(const String&,const String&); //프로그래밍 연습 2번
    // static 함수
    static int HowMany();
};
#endif

// string2.cpp -- String 클래스 메서드
#include <cstring>                 // 어떤 C++ 시스템에서는 string.h
#include "string2.h" // <iostream>을 포함한다
#include<cctype>

using std::cin;
using std::cout;

// static 클래스 멤버를 초기화한다

int String::num_strings = 0;

// static 메서드
int String::HowMany()
{
    return num_strings;
}

// 클래스 메서드
String::String(const char* s)     // C 스타일의 문자열로부터 String을 생성한다
{
    len = std::strlen(s);          // 문자열의 크기를 설정한다
    str = new char[len + 1];       // 기억 공간을 대입한다
    std::strcpy(str, s);           // 포인터를 초기화한다
    num_strings++;                 // 객체 카운트 설정
}

String::String()                   // 디폴트 생성자
{
    len = 4;
    str = new char[1];
    str[0] = '\0';                 // 디폴트 문자열
    num_strings++;
}

String::String(const String& st)
{
    num_strings++;             // static 맴버 갱신을 처리한다
    len = st.len;              // 같은 크기로 설정한다
    str = new char[len + 1];  // 기억 공간을 대입한다
    std::strcpy(str, st.str);  // 문자열을 새 위치에 복사한다
}

String::~String()                     // 꼭 필요한 파괴자
{
    --num_strings;                    // 필요하다
    delete[] str;                    // 필요하다
}

// 오버로드 연산자 메서드 

    // String을 String에 대입한다
String& String::operator=(const String& st)
{
    if (this == &st)
        return *this;
    delete[] str;
    len = st.len;
    str = new char[len + 1];
    std::strcpy(str, st.str);
    return *this;
}

// C 스타일의 문자열을 String에 대입한다
String& String::operator=(const char* s)
{
    delete[] str;
    len = std::strlen(s);
    str = new char[len + 1];
    std::strcpy(str, s);
    return *this;
}

// const가 아닌 String에 읽기-쓰기 개별 문자 접근
char& String::operator[](int i)
{
    return str[i];
}

// const String에 읽기 전용 개별 문자 접근
const char& String::operator[](int i) const
{
    return str[i];
}

// 오버로드 연산자 프렌드

bool operator<(const String& st1, const String& st2)
{
    return (std::strcmp(st1.str, st2.str) < 0);
}

bool operator>(const String& st1, const String& st2)
{
    return st1.str > st2.str;
}

bool operator==(const String& st1, const String& st2)
{
    return (std::strcmp(st1.str, st2.str) == 0);
}

ostream& operator<<(ostream& os, const String& st)
{
    os << st.str;
    return os;
}

istream& operator>>(istream& is, String& st)
{
    char temp[String::CINLIM];
    is.get(temp, String::CINLIM);

    if (is)
        st = temp;
    while (is && is.get() != '\n')
        continue;
    return is;
}

void String::stringlow() //프로그래밍 연습 2번
{
    for (int i = 0; i < len; i++)
            str[i] = tolower(str[i]);
}
void String::stringup() //프로그래밍 연습 2번
{
    for (int i = 0; i < len; i++)
            str[i] = toupper(str[i]);
}

String operator+(const String& s1, const String& s2)
{
    int slen = s1.len + s2.len + 1;
    char *temp = new char[slen];
    strcpy(temp, s1.str);
    strcat(temp, s2.str);
    String s(temp);
    return s;
}

int String::has(char a)
{
    int count = 0;
    for (int i = 0; i < len; i++)
        if (a == str[i])
            count++;
    return count;
}

//usestring2.cpp
#include<iostream>
#include"string2.h"
using namespace std;
int main()
{
	String s1(" and I am a C++ student.");
	String s2 = "영문 이름을 입력하십시오: ";
	String s3;
	cout << s2;
	cin >> s3;
	s2 = "My name is " + s3;
	cout << s2 << ".\n";
	s2 = s2 + s1;
	s2.stringup();
	cout << "다음 문자열에는\n" << s2 << "\n문자 'A'가 "
		<< s2.has('A') << "개 들어있습니다.\n";
	s1 = "red";
	String rgb[3] = { String(s1),String("green"),String("blue") };
	cout << "빛의 삼원색의 이름을 하나만 입력하십시오: ";
	String ans;
	bool success = false;
	while (cin >> ans)
	{
		ans.stringlow();
		for (int i = 0; i < 3; i++)
		{
			if (ans == rgb[i])
			{
				cout << "맞았습니다!\n";
				success = true;
				break;
			}
		}
		if (success)
			break;
		else
			cout << "다시 입력하십시오: ";
	}
	cout << "프로그램을 종료합니다.\n";
	return 0;
}

 

 

3번

// stock3.h -- 개정된 헤더 파일
#ifndef STOCK3_H_
#define STOCK3_H_
#include<iostream>
#include <cstring>

class Stock
{
private:
    char * company;
    int shares;
    double share_val;
    double total_val;
    void set_tot() { total_val = shares * share_val; }
public:
    Stock();        // 디폴트 생성자
    Stock(const char * co, long n = 0, double pr = 0.0);
    ~Stock();       // 아무 일도 하지 않는 파괴자
    void buy(long num, double price);
    void sell(long num, double price);
    void update(double price);
    friend std::ostream& operator<<(std::ostream& os, const Stock& c);
    const Stock& topval(const Stock& s) const;
};

#endif

// stock3.cpp -- 개정판
#include "stock3.h"

// 생성자들
Stock::Stock()        // 디폴트 생성자
{
    strcpy(company, "no name");
    shares = 0;
    share_val = 0.0;
    total_val = 0.0;
}

Stock::Stock(const char* co, long n, double pr)
{
    company = new char[strlen(co) + 1];
    strcpy(company, co);

    if (n < 0)
    {
        std::cout << "주식 수는 음수가 될 수 없으므로, "
            << company << " shares를 0으로 설정합니다.\n";
        shares = 0;
    }
    else
        shares = n;
    share_val = pr;
    set_tot();
}

// 클래스 파괴자
Stock::~Stock()        // 말 없는 클래스 파괴자
{
    delete[] company;
}

// 다른 메서드들
void Stock::buy(long num, double price)
{
    if (num < 0)
    {
        std::cout << "매입 주식 수는 음수가 될 수 없으므로, "
            << "거래가 취소되었습니다.\n";
    }
    else
    {
        shares += num;
        share_val = price;
        set_tot();
    }
}

void Stock::sell(long num, double price)
{
    using std::cout;
    if (num < 0)
    {
        cout << "매도 주식 수는 음수가 될 수 없으므로, "
            << "거래가 취소되었습니다.\n";
    }
    else if (num > shares)
    {
        cout << "보유 주식보다 많은 주식을 매도할 수 없으므로, "
            << "거래가 취소되었습니다.\n";
    }
    else
    {
        shares -= num;
        share_val = price;
        set_tot();
    }
}

void Stock::update(double price)
{
    share_val = price;
    set_tot();
}

std::ostream& operator<<(std::ostream& os, const Stock& c)
{
    using std::ios_base;
    // 포맷을 #.###에 세팅한다
    ios_base::fmtflags orig =
        os.setf(ios_base::fixed, ios_base::floatfield);
    std::streamsize prec = os.precision(3);

    os << "회사명: " << c.company
        << "  주식 수: " << c.shares << '\n';
    os << "  주가: $" << c.share_val;
    // 포맷을 #.##에 세팅한다
    os.precision(2);
    os << "  주식 총 가치: $" << c.total_val << '\n';

    // 원본 포맷을 저장한다
    os.setf(orig, ios_base::floatfield);
    os.precision(prec);

    return os;
}



const Stock& Stock::topval(const Stock& s) const
{
    if (s.total_val > total_val)
        return s;
    else
        return *this;
}

// usestok3.cpp -- Stock 클래스를 사용한다
// stock3.cpp와 함께 컴파일한다

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

const int STKS = 4;
int main()
{
    // 초기화된 객체들의 배열을 생성한다
    Stock stocks[STKS] = {
        Stock("NanoSmart", 12, 20.0),
        Stock("Boffo Objects", 200, 2.0),
        Stock("Monolithic Obelisks", 130, 3.25),
        Stock("Fleep Enterprises", 60, 6.5)
    };

    std::cout << "보유 주식 리스트:\n";
    int st;
    for (st = 0; st < STKS; st++)
        std::cout << stocks[st];
    // 첫 번째 원소에 포인터 지정
    const Stock* top = &stocks[0];
    for (st = 1; st < STKS; st++)
        top = &top->topval(stocks[st]);
    // 가장 가치 있는 주식의 최고치
    std::cout << "\n최고 가치의 주식:\n";
    std::cout << *top;
    return 0;
}

 

 

4번

//stack1.h
#ifndef STACK1_H_
#define STACK1_H_
typedef unsigned long Item;

class Stack
{
private:
	enum{MAX=10}; //클래스용 상수
	Item* pitems; //스택 항목들을 저장
	int size; //스택에 들어 있는 원소의 수
	int top; //스택의 꼭대기 항목을 나타낸다
public:
	Stack(int n = MAX); //n개의 원소를 가진 스택을 생성
	Stack(const Stack& st);
	~Stack();
	bool isempty() const;
	bool isfull() const;
	//push() 는 스택이 가득 차 있으면 false를 아니면 true를 리턴
	bool push(const Item& item); // 스택에 항목을 추가
	//pop()은 스택이 비어있으면 false를, 아니면 true를 리턴한다
	bool pop(Item& item); //꼭대기 항목을 꺼내 item에 넣는다
	Stack& operator=(const Stack& st);
};
#endif

//stack1.cpp
#include "stack1.h"
Stack::Stack(int n)
{
	pitems = new Item[n];
	size = n;
	top = 0;
}
Stack::Stack(const Stack& st)
{
	delete[]pitems;
	pitems = new Item[st.size];
	for (int i = 0; i < st.size; i++)
		pitems[i] = st.pitems[i];
	size = st.size;
	top = st.top;
}
Stack::~Stack()
{
	delete[]pitems;
}
bool Stack::isempty() const
{
	return top == 0;
}
bool Stack::isfull() const
{
	return top == size;
}
bool Stack::push(const Item& item)
{
	if (top < size)
	{
		pitems[top++] = item;
		return true;
	}
	else
		return false;
}
bool Stack::pop(Item& item)
{
	if (top > 0)
	{
		item = pitems[--top];
		return true;
	}
	else
		return false;
}
Stack& Stack::operator=(const Stack& st)
{
	if (this == &st)
		return *this;

	delete[]pitems;
	pitems = new Item[st.size];
	for (int i = 0; i < st.size; i++)
		pitems[i] = st.pitems[i];
	size = st.size;
	top = st.top;
	return *this;
}


//usestack1.h
#include<iostream>
#include<cctype>
#include"stack1.h"

int main()
{
    using namespace std;
    Stack st; // 비어 있는 스택을 생성한다
    Stack st2;
    char ch;
    unsigned long po;
    cout << "주문서를 추가하려면 A, 주문서를 처리하려면 P,\n"
        << "종료하려면 Q를 입력하십시오.\n";
    while (cin >> ch && toupper(ch) != 'Q')
    {
        while (cin.get() != '\n')
            continue;
        if (!isalpha(ch))
        {
            cout << '\a';
            continue;
        }
        switch (ch)
        {
        case 'A':
        case 'a': cout << "추가할 주문서의 번호를 입력하십시오: ";
            cin >> po;
            if (st.isfull())
                cout << "스택이 가득 차 있습니다.\n";
            else
                st.push(po);
            break;
        case 'P':
        case 'p': if (st.isempty())
            cout << "스택이 비어 있습니다.\n";
                else {
            st.pop(po);
            cout << "#" << po << "주문서를 처리했습니다.\n";
        }
                break;
        }
        cout << "주문서를 추가하려면 A, 주문서를 처리하려면 P,\n"
            << "종료하려면 Q를 입력하십시오.\n";
    }

    st2 = st;
    for (int i = 0; i < 10; i++)
    {
        if (st.isempty())
            cout << "스택이 비어 있습니다.\n";
        else {
            st.pop(po);
            cout << "#" << po << "주문서를 처리했습니다.\n";
        }
    }

    return 0;
}

 

 

5번

// bank2.cpp -- Queue 인터페이스를 사용한다
// queue.cpp와 함께 컴파일한다
#include <iostream>
#include <cstdlib> // rand()와 srand()를 사용하기 위해
#include <ctime>   // time()을 사용하기 위해
#include "queue.h"
const int MIN_PER_HR = 60;

bool newcustomer(double x); // 새 고객이 도착했는가?

int main()
{
    using std::cin;
    using std::cout;
    using std::endl;
    using std::ios_base;
    // 필요한 여러 가지를 준비한다
    std::srand(std::time(0));    //  rand()의 무작위 초기화

    cout << "사례 연구: 히서 은행의 ATM\n";
    cout << "큐의 최대 길이를 입력하십시오: ";
    int qs;
    cin >> qs;

    cout << "시뮬레이션 시간 수를 입력하십시오: ";
    int hours;              // 시뮬레이션 시간 수
    cin >> hours;
    // 시뮬레이션은 1분에 1주기를 실행한다
    long cyclelimit = MIN_PER_HR * hours; // 시뮬레이션 주기 수

    double perhour;         //  시간당 평균 고객 수
    double min_per_cust;    //  평균 고객 도착 간격(분 단위)

    Item temp;              //  새 고객 데이터
    long turnaways;     //  큐가 가득 차서 발길을 돌린 고객 수
    long customers;     //  큐에 줄을 선 고객 수
    long served;        //  시뮬레이션에서 거래를 처리한 고객 수
    long sum_line;      //  큐의 누적 길이
    int wait_time;      //  ATM이 빌 때까지 대기하는 시간
    long line_wait;     //  고객들이 줄을 서서 대기한 누적 시간
    double line_wait_aver = 0;

    for (perhour = 1; line_wait_aver < 1; perhour++)
    {
        Queue line(qs);         // line 큐에는 최대 qs명까지 대기할 수 있다
        turnaways = 0;
        customers = 0;
        served = 0;
        sum_line = 0;
        wait_time = 0;
        line_wait = 0;
        line_wait_aver = 0;
        min_per_cust = MIN_PER_HR / perhour;
        for (int cycle = 0; cycle < cyclelimit; cycle++)
        {
            if (newcustomer(min_per_cust))  // 새 고객이 도착했다
            {
                if (line.isfull())
                    turnaways++;
                else
                {
                    customers++;
                    temp.set(cycle);    // cycle이 도착 시간이 된다
                    line.enqueue(temp); // 큐에 새 고객을 추가한다
                }
            }
            if (wait_time <= 0 && !line.isempty())
            {
                line.dequeue(temp);      // 다음 고객을 받는다
                wait_time = temp.ptime(); // wait_time을 설정한다
                line_wait += cycle - temp.when();
                served++;
            }
            if (wait_time > 0)
                wait_time--;
            sum_line += line.queuecount();
        }
        line_wait_aver = (double)line_wait / served;
        // 시뮬레이션 결과를 출력한다
        if (customers > 0)
        {
            cout << "perhour = " << perhour << '\n';
            cout << " 큐에 줄을 선 고객 수: " << customers << endl;
            cout << " 거래를 처리한 고객 수: " << served << endl;
            cout << " 발길을 돌린 고객 수: " << turnaways << endl;
            cout << "          평균 큐의 길이: ";
            cout.precision(2);
            cout.setf(ios_base::fixed, ios_base::floatfield);
            cout.setf(ios_base::showpoint);
            cout << (double)sum_line / cyclelimit << endl;
            cout << "       평균 대기 시간: "
                << (double)line_wait_aver << "분\n\n";
        }
        else
            cout << "고객이 한 명도 없습니다!\n";
    }
    cout << "시간당 평균 고객 수가 " << perhour-1 << "이상이 되면 평균 대기시간이 1분을 넘는다.\n";
    return 0;
}

//  x는 고객 간의 평균 시간 간격이다(분 단위)
//  이 시간 내에 고객이 도착하면 리턴값은 true이다
bool newcustomer(double x)
{
    return (std::rand() * x / RAND_MAX < 1);
}

 

 

6번

// bank3.cpp -- Queue 인터페이스를 사용한다
// queue.cpp와 함께 컴파일한다
#include <iostream>
#include <cstdlib> // rand()와 srand()를 사용하기 위해
#include <ctime>   // time()을 사용하기 위해
#include "queue.h"
const int MIN_PER_HR = 60;
Item temp;              //  새 고객 데이터
struct information
{
    long customers;     //  큐에 줄을 선 고객 수
    long served;        //  시뮬레이션에서 거래를 처리한 고객 수
    long sum_line;      //  큐의 누적 길이
    int wait_time;      //  ATM이 빌 때까지 대기하는 시간
    long line_wait;     //  고객들이 줄을 서서 대기한 누적 시간
};

bool newcustomer(double x); // 새 고객이 도착했는가?
void choose_line(Queue& line, information& info, int cycle, int ne);



int main()
{
    using std::cin;
    using std::cout;
    using std::endl;
    using std::ios_base;
    // 필요한 여러 가지를 준비한다
    std::srand(std::time(0));    //  rand()의 무작위 초기화

    cout << "사례 연구: 히서 은행의 ATM\n";
    cout << "큐의 최대 길이를 입력하십시오: ";
    int qs;
    cin >> qs;

    cout << "시뮬레이션 시간 수를 입력하십시오: ";
    int hours;              // 시뮬레이션 시간 수
    cin >> hours;
    // 시뮬레이션은 1분에 1주기를 실행한다
    long cyclelimit = MIN_PER_HR * hours; // 시뮬레이션 주기 수

    double perhour;         //  시간당 평균 고객 수
    double line_wait_aver = 0;
    double min_per_cust;    //  평균 고객 도착 간격(분 단위)
    int newcust;
    long turnaways;     //  큐가 가득 차서 발길을 돌린 고객 수

    for (perhour = 1; line_wait_aver < 1; perhour++)
    {
        Queue line(qs);         // line 큐에는 최대 qs명까지 대기할 수 있다
        Queue line2(qs);

        information info = {};
        information info2 = {};
        min_per_cust = MIN_PER_HR / perhour;
        for (int cycle = 0; cycle < cyclelimit; cycle++)
        {
            if (newcustomer(min_per_cust))  // 새 고객이 도착했다
            {
                if (line.isfull()&&line2.isfull())
                    turnaways++;
                else
                {
                    temp.set(cycle);
                    if (line.queuecount() < line2.queuecount())
                    {
                        choose_line(line, info, cycle, 1);
                        choose_line(line2, info2, cycle, 0);
                    }
                    else
                    {
                        choose_line(line, info, cycle, 0);
                        choose_line(line2, info2, cycle, 1);
                    }
                }
            }
            else
            {
                choose_line(line, info, cycle, 0);
                choose_line(line2, info2, cycle, 0);
            }
        }
        line_wait_aver = (double)((info.line_wait + info2.line_wait)/2)
            / (info.served + info2.served);
        // 시뮬레이션 결과를 출력한다
        if (info.customers+info2.customers > 0)
        {
            cout << "perhour = " << (int)perhour << '\n';
            cout << " 큐에 줄을 선 고객 수: " << info.customers + info2.customers << endl;
            cout << " 거래를 처리한 고객 수: " << info.served + info2.served << endl;
            cout << " 발길을 돌린 고객 수: " << turnaways << endl;
            cout << "          평균 큐의 길이: ";
            cout.precision(2);
            cout.setf(ios_base::fixed, ios_base::floatfield);
            cout.setf(ios_base::showpoint);
            cout << ((double)info.sum_line / cyclelimit +
                (double)info2.sum_line / cyclelimit) / 2 << endl;
            cout << "       평균 대기 시간: "
                << (double)line_wait_aver << "분\n\n";
        }
        else
            cout << "고객이 한 명도 없습니다!\n";
    }
    cout << "시간당 평균 고객 수가 " << perhour - 1
        << "이상이 되면 평균 대기시간이 1분을 넘는다.\n";
    return 0;
}

//  x는 고객 간의 평균 시간 간격이다(분 단위)
//  이 시간 내에 고객이 도착하면 리턴값은 true이다
bool newcustomer(double x)
{
    return (std::rand() * x / RAND_MAX < 1);
}

void choose_line(Queue& line, information& info, int cycle, int ne)
{
    if (ne == 1)  // 새 고객이 도착했다
    {
    
        {
            info.customers++;
            line.enqueue(temp); // 큐에 새 고객을 추가한다
        }
    }
    if (info.wait_time <= 0 && !line.isempty())
    {
        line.dequeue(temp);      // 다음 고객을 받는다
        info.wait_time = temp.ptime(); // wait_time을 설정한다
        info.line_wait += cycle - temp.when();
        if (cycle < temp.when())
        {
            std::cout << cycle << " " << temp.when()<<'\n';
        }

        info.served++;
    }
    if (info.wait_time > 0)
        info.wait_time--;
    info.sum_line += line.queuecount();
}