(C++기초플러스 6판 프로그래밍 연습 정답,솔루션) CHAPTER 14 C++ 코드의 재활용 p.1103~ 1번~5번

1번

//winec.h
#ifndef WINEC_H_
#define WINEC_H_
#include<iostream>
#include<string>
#include<valarray>

template<class T1,class T2>
class Pair
{
private:
	T1 year;
	T2 num;
public:
	T1 first() const { return year; }
	T2 second() const { return num; }
	Pair() {}
	Pair(const T1& y, const T2& n) :year(y),num(n){}
};

class Wine
{
private:
	typedef std::valarray<int> ArrayInt;
	typedef Pair<ArrayInt, ArrayInt> PairArray;
	PairArray p;
	std::string label;
	int year_n;
public:
	Wine(const char* l, int y, const int yr[], const int bot[]);
	Wine(const char* l, int y);
	void GetBottles();
	const std::string& Label() { return label; }
	int sum() const { return p.second().sum(); }
	void Show() const;
};

#endif

//winec.cpp
#include"winec.h"

Wine::Wine(const char* l, int y)
{
	label = l;
	year_n = y;
}

Wine::Wine(const char* l, int y, const int yr[], const int bot[])
	:label(l),year_n(y),p(ArrayInt(yr,y),ArrayInt(bot,y))
{
}


void Wine::GetBottles()
{
	ArrayInt y(year_n);
	ArrayInt n(year_n);
	std::cout << year_n << "년 간의 " << label << " 데이터를 입력하시오:\n";
	for (int i = 0; i < year_n; i++)
	{
		std::cout << "년도를 입력하시오: ";
		std::cin >> y[i];
		std::cout << "수량을 입력하시오: ";
		std::cin >> n[i];
	}
	p=Pair<ArrayInt,ArrayInt>(y, n);
}

void Wine::Show() const
{
	std::cout << "와인: " << label << '\n'
		<< "\t년도\t수량\n";
	for (int i = 0; i < year_n; i++)
	{
		std::cout << "\t" << p.first()[i] << "\t" << p.second()[i] << '\n';
	}
}


//pe14-1.cpp
#include"winec.h"
int main()
{
	using std::cin;
	using std::cout;
	using std::endl;

	cout << "와인 이름을 입력하시오: ";
	char lab[50];
	cin.getline(lab, 50);
	cout << "수확 년도 개수를 입력하시오: ";
	int yrs;
	cin >> yrs;

	Wine holding(lab, yrs);
	holding.GetBottles();
	holding.Show();

	const int YRS = 3;
	int y[YRS] = { 1993,1995,1998 };
	int b[YRS] = { 48,60,72 };
	Wine more("Gushing Grape Red", YRS, y, b);
	more.Show();
	cout << more.Label() << " 전체 수량"
		<< ": " << more.sum() << endl;
	cout << "프로그램 종료\n";
	return 0;
}

 

2번

//winec.h
#ifndef WINEC_H_
#define WINEC_H_
#include<iostream>
#include<string>
#include<valarray>

template<class T1,class T2>
class Pair
{
private:
	T1 year;
	T2 num;
public:
	T1 first() const { return year; }
	T2 second() const { return num; }
	Pair() {}
	Pair(const T1& y, const T2& n) :year(y),num(n){}
};

class Wine :private std::string,private Pair<std::valarray<int>,std::valarray<int>>
{
private:
	typedef std::valarray<int> ArrayInt;
	typedef Pair<ArrayInt, ArrayInt> PairArray;
	int year_n;
public:
	Wine(const char* l, int y, const int yr[], const int bot[]);
	Wine(const char* l, int y);
	void GetBottles();
	const std::string& Label() { return (const std::string &) *this; }
	int sum() const { return PairArray::second().sum(); }
	void Show() const;
};

#endif


//winec.cpp
#include"winec.h"

Wine::Wine(const char* l, int y) : std::string(l),year_n(y)
{
}

Wine::Wine(const char* l, int y, const int yr[], const int bot[])
	:std::string(l),year_n(y),PairArray(ArrayInt(yr,y),ArrayInt(bot,y))
{
}


void Wine::GetBottles()
{
	ArrayInt y(year_n);
	ArrayInt n(year_n);
	std::cout << year_n << "년 간의 " << (const std::string &)*this << " 데이터를 입력하시오:\n";
	for (int i = 0; i < year_n; i++)
	{
		std::cout << "년도를 입력하시오: ";
		std::cin >> y[i];
		std::cout << "수량을 입력하시오: ";
		std::cin >> n[i];
	}
	(PairArray &)*this=PairArray(y, n);
}

void Wine::Show() const
{
	std::cout << "와인: " << (const std::string&) * this << '\n'
		<< "\t년도\t수량\n";
	for (int i = 0; i < year_n; i++)
	{
		std::cout << "\t" << PairArray::first()[i] << "\t" << PairArray::second()[i] << '\n';
	}
}

 

 

3번

//QueueTp.h
#ifndef QUEUETP_H_
#define QUEUETP_H_

template<class T>
class Queue
{
private:
    // 클래스 사용 범위의 정의들
        // Node는 이 클래스에 지역적인, 내포된 구조체 정의이다
    struct Node { T item; struct Node* next; };
    enum { Q_SIZE = 3 };
    // private 클래스 멤버들
    Node* front;       // Queue의 머리를 지시하는 포인터
    Node* rear;        // Queue의 꼬리를 지시하는 포인터
    int items;          // Queue에 있는 현재 항목 수
    const int qsize;    // Queue에 넣을 수 있는 최대 항목 수
    // public 복사를 방지하는 선점 정의
    Queue(const Queue& q) : qsize(0) { }
public:
    Queue(int qs = Q_SIZE); // qs 한계를 가진 큐를 생성한다
    ~Queue();
    bool isempty() const;
    bool isfull() const;
    int queuecount() const;
    bool enqueue(const T& item); // 항목을 꼬리에 추가한다
    bool dequeue(T& item);       // 머리에서 항목을 삭제한다
    Queue& operator=(const Queue& q) { return *this; }
};


template<class T>
Queue<T>::Queue(int qs) : qsize(qs)
{
    front = rear = NULL;    // 또는 nullptr
    items = 0;
}

template<class T>
Queue<T>::~Queue()
{
    Node* temp;
    while (front != NULL)   	// 큐가 아직 비어 있지 않으면
    {
        temp = front;       	// 머리 항목의 주소를 임시로 저장한다
        front = front->next;	// front를 그 다음 항목으로 다시 설정한다
        delete temp;        	// 이전의 머리 노드를 삭제한다
    }
}

template<class T>
bool Queue<T>::isempty() const
{
    return items == 0;
}

template<class T>
bool Queue<T>::isfull() const
{
    return items == qsize;
}

template<class T>
int Queue<T>::queuecount() const
{
    return items;
}

// 큐에 항목을 추가한다
template<class T>
bool Queue<T>::enqueue(const T& item)
{
    if (isfull())
        return false;
    Node* add = new Node;  // 노드를 생성한다
// 실패하면, new는 std::bad_alloc exception를 발생시킨다
    add->item = item;       // 큐가 비어 있으면
    add->next = NULL;       // 또는 nullptr;
    items++;
    if (front == NULL)      // 큐가 비어 있으면
        front = add;        // 항목을 머리에 넣는다
    else
        rear->next = add;   // 그렇지 않으면 꼬리에 넣는다
    rear = add;             // rear가 새 노드를 지시하게 만든다
    return true;
}

// 머리 항목을 item 변수에 넣고 큐에서 삭제한다
template<class T>
bool Queue<T>::dequeue(T& item)
{
    if (front == NULL)
        return false;
    item = front->item;     // 큐에 머리 항목을 item에 복사한다
    items--;
    Node* temp = front;    // 머리 항목의 위치를 임시로 저장한다
    front = front->next;    // front를 그 다음 항목으로 다시 설정한다
    delete temp;            // 이전의 머리 항목을 삭제한다
    if (items == 0)
        rear = NULL;
    return true;
}

#endif


// workermi.h  -- 다중 상속을 사용하는 노무 클래스들
#ifndef WORKERMI_H_
#define WORKERMI_H_

#include <string>

class Worker   // 추상화 기초 클래스
{
private:
    std::string fullname;
    long id;
protected:
    virtual void Data() const;
    virtual void Get();
public:
    Worker() : fullname("no name"), id(0L) {}
    Worker(const std::string& s, long n)
        : fullname(s), id(n) {}
    virtual ~Worker() = 0; // 순수 가상 파괴자 함수
    virtual void Set() = 0;
    virtual void Show() const = 0;
};

class Waiter : virtual public Worker
{
private:
    int panache;
protected:
    void Data() const;
    void Get();
public:
    Waiter() : Worker(), panache(0) {}
    Waiter(const std::string& s, long n, int p = 0)
        : Worker(s, n), panache(p) {}
    Waiter(const Worker& wk, int p = 0)
        : Worker(wk), panache(p) {}
    void Set();
    void Show() const;
};

class Singer : virtual public Worker
{
protected:
    enum {
        other, alto, contralto, soprano,
        bass, baritone, tenor
    };
    enum { Vtypes = 7 };
    void Data() const;
    void Get();
private:
    static char* pv[Vtypes];    // 목소리 유형 문자열 대응 값
    int voice;
public:
    Singer() : Worker(), voice(other) {}
    Singer(const std::string& s, long n, int v = other)
        : Worker(s, n), voice(v) {}
    Singer(const Worker& wk, int v = other)
        : Worker(wk), voice(v) {}
    void Set();
    void Show() const;
};

// 다중 상속
class SingingWaiter : public Singer, public Waiter
{
protected:
    void Data() const;
    void Get();
public:
    SingingWaiter() {}
    SingingWaiter(const std::string& s, long n, int p = 0,
        int v = other)
        : Worker(s, n), Waiter(s, n, p), Singer(s, n, v) {}
    SingingWaiter(const Worker& wk, int p = 0, int v = other)
        : Worker(wk), Waiter(wk, p), Singer(wk, v) {}
    SingingWaiter(const Waiter& wt, int v = other)
        : Worker(wt), Waiter(wt), Singer(wt, v) {}
    SingingWaiter(const Singer& wt, int p = 0)
        : Worker(wt), Waiter(wt, p), Singer(wt) {}
    void Set();
    void Show() const;
};

#endif


// workermi.cpp -- 다중 상속을 사용하는 working 클래스 메서드들
#include "workermi.h"
#include <iostream>
using std::cout;
using std::cin;
using std::endl;

// Worker 메서드들
Worker::~Worker() { }

// protected 메서드들
void Worker::Data() const
{
    cout << "사원 이름: " << fullname << endl;
    cout << "사원 번호: " << id << endl;
}

void Worker::Get()
{
    getline(cin, fullname);
    cout << "사원 번호를 입력하십시오: ";
    cin >> id;
    while (cin.get() != '\n')
        continue;
}

// Waiter 메서드들
void Waiter::Set()
{
    cout << "웨이터의 이름을 입력하십시오: ";
    Worker::Get();
    Get();
}

void Waiter::Show() const
{
    cout << "직종: 웨이터\n";
    Worker::Data();
    Data();
}

// protected 메서드들
void Waiter::Data() const
{
    cout << "웨이터 등급: " << panache << endl;
}

void Waiter::Get()
{
    cout << "웨이터 등급을 입력하십시오: ";
    cin >> panache;
    while (cin.get() != '\n')
        continue;
}

// Singer 메서드들

char* Singer::pv[Singer::Vtypes] = { "other", "alto", "contralto",
            "soprano", "bass", "baritone", "tenor" };

void Singer::Set()
{
    cout << "가수의 이름을 입력하십시오: ";
    Worker::Get();
    Get();
}

void Singer::Show() const
{
    cout << "직종: 가수\n";
    Worker::Data();
    Data();
}

// protected 메서드들
void Singer::Data() const
{
    cout << "목소리 유형: " << pv[voice] << endl;
}

void Singer::Get()
{
    cout << "가수의 목소리 유형 번호를 입력하십시오:\n";
    int i;
    for (i = 0; i < Vtypes; i++)
    {
        cout << i << ": " << pv[i] << "   ";
        if (i % 4 == 3)
            cout << endl;
    }
    if (i % 4 != 0)
        cout << '\n';
    cin >> voice;
    while (cin.get() != '\n')
        continue;
}

// SingingWaiter 메서드들
void SingingWaiter::Data() const
{
    Singer::Data();
    Waiter::Data();
}

void SingingWaiter::Get()
{
    Waiter::Get();
    Singer::Get();
}

void SingingWaiter::Set()
{
    cout << "가수 겸 웨이터의 이름을 입력하십시오: ";
    Worker::Get();
    Get();
}

void SingingWaiter::Show() const
{
    cout << "직종: 가수 겸 웨이터\n";
    Worker::Data();
    Data();
}


// pe14-3.cpp -- 다중 상속
// workermi.cpp와 함께 컴파일한다
#include <iostream>
#include <cstring>
#include "workermi.h"
#include"QueueTp.h"
const int SIZE = 2;

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

    Queue<Worker*> *lolas[SIZE];
    Worker* temp=nullptr;
    char ch;
    cout << "큐를 추가하려면 A, 큐를 처리하려면 P,\n 종료하려면 Q를 입력하십시오.\n";
    while (cin >> ch && std::toupper(ch) != 'Q')
    {
        while (cin.get() != '\n')
            continue;
        switch (ch)
        {
        case 'A':
        case 'a':
            int ct;
            for (ct = 0; ct < SIZE; ct++)
            {
                lolas[ct] = new Queue<Worker*>;
                cout << ct + 1 << "번째 queue를 전부 추가\n";
                for (int i = 0; i < 3; i++)
                {
                    char choice;
                    cout << "직종을 입력하십시오:\n"
                        << "w: 웨이터  s: 가수  "
                        << "t: 가수 겸 웨이터  q: 종료\n";
                    cin >> choice;
                    while (strchr("wstq", choice) == NULL)
                    {
                        cout << "w, s, t, q 중에서 하나를 선택하십시오: ";
                        cin >> choice;
                    }
                    if (choice == 'q')
                        break;
                    switch (choice)
                    {
                    case 'w':
                        temp = new Waiter;
                        break;
                    case 's':
                        temp = new Singer;
                        break;
                    case 't':
                        temp = new SingingWaiter;
                        break;
                    }
                    cin.get();
                    temp->Set();
                    lolas[ct]->enqueue(temp); //ct가 0 일때 lolas[0]안에 있는 첫번째 q가 temp로 초기화
                    cout << "----------------------------\n";
                    temp->Show();
                    cout << "가 추가됨\n----------------------------\n";
                }
            }//큐가 가득찰때 까지 진행
            break;
        case 'P':
        case 'p':
            for (ct = 0; ct < SIZE; ct++)
            {
                cout << ct + 1 << "번째의 모든 큐 제거\n";
                for (int i = 0; i < 3; i++)
                {
                    lolas[ct]->dequeue(temp);
                    cout << "----------------------------\n";
                    temp->Show();
                    cout << "가 제거됨\n----------------------------\n";
                }
            }
            break;
        }
        cout << "큐를 추가하려면 A, 큐를 처리하려면 P,\n 종료하려면 Q를 입력하십시오.\n";
    }
    delete temp;
    cout << "프로그램을 종료합니다.\n";
    return 0;
}

 

 

4번

//person.h
#ifndef PERSON_H_
#define PERSON_H_
#include<iostream>
#include<string>
#include<time.h>
#include<stdlib.h>
class Person
{
private:
	std::string pname;
	std::string lname;
protected:
	virtual void Get();
	virtual void Data() const;
public:
	Person(const std::string p,const std::string l) :pname(p),lname(l){}
	Person() : pname("none"),lname("none") {}
	virtual ~Person() = 0;
	virtual void Set() = 0;
	virtual void Show() const=0;
};

class Gunslinger : virtual public Person
{
private:
	double g_time;
	int notch;
protected:
	void Get();
	void Data() const;
public:
	Gunslinger(const std::string p,const std::string l,double g = 0,int n = 0)
		:Person(p,l),g_time(g),notch(n) {}
	Gunslinger() : Person(),g_time(0),notch(0) {}
	Gunslinger(const Person& p, double g, int n)
		:Person(p), g_time(g), notch(n) {}
	double Draw() const{ return g_time; }
	void Show() const;
	void Set();
};

class PokerPlayer :virtual public Person
{
protected:
	void Data() const;
public:
	PokerPlayer(const std::string p, const std::string l)
		:Person(p, l) {}
	PokerPlayer(const Person &p)
		:Person(p) {}
	PokerPlayer():Person(){}
	int Draw() const { return (rand() % 52) + 1; }
	void Show() const;
	void Set();
};

class BadDude : public Gunslinger,public PokerPlayer
{
protected:
	virtual void Get();
	virtual void Data() const;
public:
	BadDude() {}
	BadDude(const std::string p,const std::string l,double g=0,int n=0) 
		: Person(p,l),Gunslinger(p,l,g,n) {}
	BadDude(const Person &p,double g=0,int n=0)
		:Person(p),Gunslinger(p,g,n) {}
	BadDude(const Gunslinger &g)
		:Person(g),Gunslinger(g) {}
	double gdraw() const { return Gunslinger::Draw(); }
	int cdraw() const { return PokerPlayer::Draw(); }
	void Set();
	void Show() const;
};

#endif


//person.cpp
#include"person.h"
#include<iostream>
using std::cin;
using std::cout;
using std::endl;
Person::~Person() {}

void Person::Get()
{
	cout << "성 입력: ";
	getline(cin, lname);
	cout << "이름 입력 : ";
	getline(cin, pname);
}

void Person::Data() const
{
	cout << "이름 : " << pname << ", " << lname << endl;
}

void Gunslinger::Set()
{
	cout << "총잡이의 이름 입력:\n";
	Person::Get();
	Get();
}

void Gunslinger::Show() const
{
	cout << "직업 : 총잡이\n";
	Person::Data();
	Data();
}

void Gunslinger::Data() const
{
	cout << "권총을 빼내는 데 걸리는 시간 : " << Draw() << endl;
	cout << "권총에 새겨진 금수 : " << notch << endl;
}

void Gunslinger::Get()
{
	cout << "권총을 빼내는 데 걸리는 시간 입력 : ";
	cin >> g_time;
	cout << "권총에 새겨진 금수 입력 : ";
	cin >> notch;
	while (cin.get() != '\n')
		continue;
}

void PokerPlayer::Set()
{
	cout << "PokerPlayer의 이름 입력: \n";
	PokerPlayer::Get();
}

void PokerPlayer::Show() const
{
	cout << "직업 : PokerPlayer\n";
	Person::Data();
	Data();
}

void PokerPlayer::Data() const
{
	cout << "다음에 꺼낼 카드 값 : " << Draw() << endl;
}

void BadDude::Data() const
{
	Gunslinger::Data();
	PokerPlayer::Data();
}

void BadDude::Get()
{
	Gunslinger::Get();
}

void BadDude::Set()
{
	cout << "총잡이 겸 Pokerplayer의 이름 입력:\n";
	Person::Get();
	Get();
}

void BadDude::Show() const
{
	cout << "직업 : 총잡이, PokerPlayer\n";
	Person::Data();
	Data();
}


//pe14-4.cpp
#include <iostream>
#include <cstring>
#include "person.h"
const int SIZE = 5;

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

    Person* lolas[SIZE];

    int ct;
    for (ct = 0; ct < SIZE; ct++)
    {
        char choice;
        cout << "직종을 입력하십시오:\n"
            << "g: 총잡이  p: Pokerplayer  "
            << "b: 총잡이 겸 Pokerplayer  q: 종료\n";
        cin >> choice;
        while (strchr("gpbq", choice) == NULL)
        {
            cout << "g, p, b, q 중에서 하나를 선택하십시오: ";
            cin >> choice;
        }
        if (choice == 'q')
            break;
        switch (choice)
        {
        case 'g':   lolas[ct] = new Gunslinger;
            break;
        case 'p':   lolas[ct] = new PokerPlayer;
            break;
        case 'b':   lolas[ct] = new BadDude;
            break;
        }
        cin.get();
        lolas[ct]->Set();
    }

    cout << "\n사원 현황은 다음과 같습니다:\n";
    int i;
    for (i = 0; i < ct; i++)
    {
        cout << endl;
        lolas[i]->Show();
    }
    for (i = 0; i < ct; i++)
        delete lolas[i];
    cout << "프로그램을 종료합니다.\n";
    return 0;
}

 

 

5번

//emp.h

#include<iostream>
#include<string>

class abstr_emp
{
private:
	std::string fname; //abstr_emp의 퍼스트 네임
	std::string lname; //abstr_emp의 라스트 네임
	std::string job; //abstr_emp의 직무
public:
	abstr_emp();
	abstr_emp(const std::string& fn, const std::string& ln, const std::string& j);
	virtual void ShowAll() const; //모든 데이터를 보여준다.
	virtual void SetAll(); //사용자에게 값들을 입력하라고 요구한다.
	friend std::ostream& operator<<(std::ostream& os, const abstr_emp& e);
	//퍼스트 네임과 라스트 네임을 디스플레이 한다.
	virtual ~abstr_emp() = 0;
};

class employee :public abstr_emp
{
public:
	employee();
	employee(const std::string& fn, const std::string& ln, const std::string& j);
	virtual void ShowAll() const;
	virtual void SetAll();
};

class manager :virtual public abstr_emp
{
private:
	int inchargeof;
protected:
	int InChargeOf() const { return inchargeof; }//출력
	int& InChargeOf() { return inchargeof; }//입력
public:
	manager();
	manager(const std::string& fn, const std::string& ln, const std::string& j, int ico = 0);
	manager(const abstr_emp& e, int ico);
	manager(const manager& m);
	virtual void ShowAll() const;
	virtual void SetAll();
};

class fink :virtual public abstr_emp
{
private:
	std::string reportsto;
protected:
	const std::string ReportsTo() const { return reportsto; }
	std::string& ReportsTo() { return reportsto; }
public:
	fink();
	fink(const std::string& fn, const std::string& ln, const std::string& j, const std::string& rpo);
	fink(const abstr_emp& e, const std::string& rpo);
	fink(const fink& e);
	virtual void ShowAll() const;
	virtual void SetAll();
};

class highfink :public manager, public fink
{
public:
	highfink();
	highfink(const std::string& fn, const std::string& ln, const std::string& j, const std::string& rpo, int ico);
	highfink(const abstr_emp& e, const std::string& rpo, int ico);
	highfink(const fink& f, int ico);
	highfink(const manager& m, const std::string& rpo);
	highfink(const highfink& h);
	virtual void ShowAll() const;
	virtual void SetAll();
};

//emp.cpp
#include"emp.h"
using std::cout;
using std::endl;
using std::cin;
abstr_emp::abstr_emp() :fname("none"), lname("none"), job("none")
{

}


abstr_emp::abstr_emp(const std::string& fn, const std::string& ln, const std::string& j)
	:fname(fn),lname(ln),job(j) {}

void abstr_emp::ShowAll() const //모든 데이터를 보여준다.
{
	cout <<"이름 : " <<fname << ", " << lname << endl;
	cout << "직업 : " << job << endl;
}
void abstr_emp::SetAll() //사용자에게 값들을 입력하라고 요구한다.
{
	cout << "퍼스트 네임 입력 : "; getline(cin,fname);
	cout << "라스트 네임 입력 : "; getline(cin, lname);
	cout << "직업 입력 : "; getline(cin, job);
}
std::ostream& operator<<(std::ostream& os, const abstr_emp& e)
//퍼스트 네임과 라스트 네임을 디스플레이 한다.
{
	os << e.fname << ", " << e.lname << endl;
	return os;
}

abstr_emp::~abstr_emp() {}

employee::employee() :abstr_emp() {}
employee::employee(const std::string& fn, const std::string& ln, const std::string& j)
	:abstr_emp(fn,ln,j) {}
void employee::ShowAll() const
{
	abstr_emp::ShowAll();
}

void employee::SetAll()
{
	abstr_emp::SetAll();
}

manager::manager() :abstr_emp(),inchargeof(0){}
manager::manager(const std::string& fn, const std::string& ln, const std::string& j, int ico)
	:abstr_emp(fn,ln,j),inchargeof(ico) {}
manager::manager(const abstr_emp& e, int ico)
	:abstr_emp(e),inchargeof(ico) {}
manager::manager(const manager& m)
	: abstr_emp(m) {
	inchargeof = m.inchargeof;
}

void manager::ShowAll() const
{
	abstr_emp::ShowAll();
	cout << "inchargeof : " << inchargeof << endl;
}

void manager::SetAll()
{
	abstr_emp::SetAll();
	cout << "inchargeof 입력 : "; cin >> inchargeof;
	while (cin.get() != '\n')
		continue;
}

fink::fink() : abstr_emp(),reportsto("none"){}
fink::fink(const std::string& fn, const std::string& ln, const std::string& j, const std::string& rpo)
	:abstr_emp(fn,ln,j),reportsto(rpo) {}
fink::fink(const abstr_emp& e, const std::string& rpo)
	:abstr_emp(e),reportsto(rpo) {}
fink::fink(const fink& e)
	:abstr_emp(e){}
void fink::ShowAll() const
{
	abstr_emp::ShowAll();
	cout << "reportsto : " << reportsto << endl;
}
void fink::SetAll()
{
	abstr_emp::SetAll();
	cout << "reportsto 입력 : "; cin >> reportsto;
	while (cin.get() != '\n')
		continue;
}

highfink::highfink() : abstr_emp(),manager(),fink() {}
highfink::highfink(const std::string& fn, const std::string& ln, const std::string& j, const std::string& rpo, int ico)
	:abstr_emp(fn,ln,j),manager(fn,ln,j,ico),fink(fn,ln,j,rpo) {}
highfink::highfink(const abstr_emp& e, const std::string& rpo, int ico)
	:abstr_emp(e),manager(e,ico),fink(e,rpo) {}
highfink::highfink(const fink& f, int ico)
	:abstr_emp(f),manager(f,ico),fink(f) {}
highfink::highfink(const manager& m, const std::string& rpo)
	:abstr_emp(m),manager(m),fink(m,rpo){}
highfink::highfink(const highfink& h)
	:abstr_emp(h),manager(h),fink(h) {}
void highfink::ShowAll() const
{
	abstr_emp::ShowAll();
	cout << "inchargeof : " << manager::InChargeOf() << endl;
	cout << "reportsto : " << fink::ReportsTo() << endl;
}
void highfink::SetAll()
{
	abstr_emp::SetAll();
	cout << "inchargeof 입력 : "; cin >> manager::InChargeOf();
	cin.get();
	cout << "reportsto 입력 : "; getline(cin, fink::ReportsTo());
}







//pe14-5.cpp
#include<iostream>
using namespace std;
#include "emp.h"
int main(void)
{
	employee em("Trip", "Harris", "Thumper");
	cout << em << endl;
	em.ShowAll();

	manager ma("Amorphia", "Spindragon", "Nuancer", 5);
	cout << ma << endl;
	ma.ShowAll();

	fink fi("Matt", "Oggs", "Oiler", "Juno Barr");
	cout << fi << endl;
	fi.ShowAll();
	highfink hf(ma, "Curly Kew");
	hf.ShowAll();
	cout << "다음 출력을 위해 아무 키나 누르십시오:\n";
	cin.get();
	highfink hf2;
	hf2.SetAll();

	cout << "abstr_emp * 포인터의 사용:\n";
	abstr_emp* tri[4] = { &em,&fi,&hf,&hf2 };
	for (int i = 0; i < 4; i++)
		tri[i]->ShowAll();

	return 0;
}

/*대입 연산자를 정의하지 않은 이유
abstr_emp * 은 클래스의 대입이 아닌 포인터의 대입이므로 필요없다.
ShowAll()과 SetAll은 클래스마다 정의가 다르므로 가상
abstr_emp를 가상 기초 클래스로 선언하지 않으면 highfink에서 manager와 fink에 의해 abstr_emp 클래스를 중복으로 가지게됨.
highfink 클래스의 데이터 부분은 manager와 fink가 가지고있다.
operator<<()가 한가지 버전만 필요한 이유는 , 퍼스트네임과 라스트네임만 출력하고, 프렌드 함수이기 때문
프로그램 끝 부분 코드를 다음으로 대체하면 ... 대입 연산자가 없다고 나올것이다. */