25.07.31 학습개발일지 C++ Study5

<윤성우의 열혈 C++ 프로그래밍 책을 참고합니다>

과제 1.

1. '상속'의 이해

1) '상속' 이라는 용어의 의미, 뜻 설명

> 기존 클래스의 기능을 파생된 새 클래스에 물려주어 사용하는 것을 말함

2) '상속' 기능의 사용 목적

> 코드 재사용

> 다형성 구현(기초 클래스 포인터로 유도 클래스를 다루기 위함)

> 계층관계 구현

---

2. p.273~275

1) 클래스 다이어그램 그리기(p273)

(PermanentWorker)

>

2) 데이터적 성격을 가진 클래스

> 데이터적 성격을 가진 클래스는 기록의 보전을 목적으로 하는 클래스임

> 273p 예제를 참고하면, 사원의 이름과 사원의 급여처럼 데이터를 가지고 있는 클래스임을 확인할 수 있음

3) 기능적 성격을 가진 클래스

> 기능적 성격을 가진 클래스는 데이터 클래스를 기반으로 저장, 출력 등 기능을 목적으로 하는 클래스임

> 274p 예제를 참고하면,

기능적 성격을 가진 클래스의

멤버변수는 앞선 데이터 클래스를 객체로 생성해서 저장하는 수단이고

멤버함수는 데이터 클래스의 데이터를 저장, 출력을 담당하고 있음을 확인할 수 있음

---

3. p.275 / "7번 라인"의 객체 동적할당을 매개변수로 전달하는 문법 설명

handler.AddEmployee(new PermanentWorker("KIM", 1000));

void AddEmployee(PermanentWorker* emp){
	empList[empNum++] = emp;
}

> AddEmployee 함수의 매개변수는 PermanentWorker* emp로 PermanentWorker형 객체의 주소를 인자로 받음

PermanentWorker* emp = new PermanentWorker("KIM", 1000);

> 함수에 인자를 전달할 때 위와 같이 초기화가 진행되고,

> new 키워드로 런타임에 PermanentWorker 객체 크기만큼 메모리를 힙에 마련함

> PermanentWorker 생성자 호출로 초기화한다

> 이를 PermanentWorker형 포인터 emp에 저장함

---

4. p.276 / 앞선 내용들의 문제상황에 대해 설명

>

이전의 정의된 클래스에서 데이터와 기능을 확장하고자 하는 목적이 있는 상황이다

하지만 확장을 하기 위해서는 새로운 데이터 클래스를 정의해야 하고,

데이터 클래스에 적합한 기능을 기능 클래스에 추가하기 위해 새로운 멤버변수와 새로운 멤버함수가 추가되어야 한다.

결국 확장된 데이터와 기능 때문에 전체적으로 수정을 가해야 하는 것이 문제이다

---

과제 2.

1. p279~283

1) 상속 문법

Person // 기초(기반) 클래스
UnivStudent // 유도(파생) 클래스

class / 유도 클래스 이름 / : / 접근 제어 지시자 / 기초 클래스 이름
class Univ Student : public Person

2) 클래스 다이어 그램 그리기

(Person, UnivStudent)

3) UnivStudent 단독 클래스 구현 및 클래스 다이어그램 작성

#include <iostream>
#include <cstring>
using namespace std;

class UnivStudent
{
	private:
		int age; // 나이
		char name[50]; // 이름
		char major[50]; // 전공
	public:
		UnivStudent(char* myname, int myage, char* mymajor)
			: age(myage)
			{
				strcpy(name, myname);
				strcpy(major, mymajor);
			}
		void WhatYourName() const
		{
			cout << "My name is " << name << endl;
		}
		void HowOldAreYou() const
		{
			cout << "I am " << age << " years old." << endl;
		}
		void WhoAreYou() const
		{
			WhatYourName();
			HowOldAreYou();
			cout << "My major is " << major << endl << endl;
		}
};

4)

UnivStudent 클래스에 WhatYourName 함수와 HowOldAreYou 함수가 정의되어 있지 않음에도, 이 두 함수를 호출할 수 있는 이유

<원본 코드>

#include <iostream>
#include <cstring>
using namespace std;

class Person
{
private:
	char * name;
public:
	Person(char * myname)
	{
		name=new char[strlen(myname)+1];
		strcpy(name, myname);
	}
	~Person()
	{
		delete []name;
	}
	void WhatYourName() const
	{
		cout<<"My name is "<<name<<endl;
	}
};

class UnivStudent : public Person
{
private:
	char * major;
public:
	UnivStudent(char * myname, char * mymajor)
		:Person(myname)
	{
		major=new char[strlen(mymajor)+1];
		strcpy(major, mymajor);
	}
	~UnivStudent()
	{
		delete []major;
	}
	void WhoAreYou() const
	{
		WhatYourName();
		cout<<"My major is "<<major<<endl<<endl;
	}
};

int main(void)
{
	UnivStudent st1("Kim", "Mathmatics");
	st1.WhoAreYou();

	UnivStudent st2("Hong", "Physics");
	st2.WhoAreYou();
	return 0;
};

>

UnivStudent 클래스는 Person 함수로부터 상속받는 클래스이므로

Person에 정의되어 있는 위의 두 함수가 UnivStudent 클래스의 멤버가 되었기 때문에

별도로 정의되어 있지 않아도 두 함수를 호출할 수 있다

---

2. p281~290

상속에서 기반 클래스와, 파생 클래스의

생성자 실행 구조와 실행 순서에 기반한 객체 생성 과정 설명

>

유도 클래스에서 생성자를 실행하기 위해서는

먼저 기초 클래스의 생성자를 호출한 후

유도 클래스의 생성자를 호출하여 멤버변수를 초기화하는 방식으로 객체를 생성한다

#include <iostream>
using namespace std;

class Base{ // 기초 클래스
	public:
		Base() { cout << "기초 클래스 생성자 호출 !" << endl; }
};

class Derived : public Base{ // 유도 클래스
	public:
		Derived() : Base() {
			cout << "유도 클래스 생성자 호출 !" << endl;
		}
};

int main() {
	Derived d; // 유도 클래스 객체 생성
	return 0;
}

---

3. p284

상속 구조에서 정보은닉, 접근 제어 구조 설명

> 상속 관계에서도 유도 클래스로는 기초 클래스의 private 멤버에 직접 접근할 수 없다

> 상속 당시에는 접근제어지시자를 선택할 수 있는데

이들의 역할은 선언한 접근 제어지시자보다 더 넓은 접근 제어지시자 모두를

선언했던 접근 제어지시자와 같게 만드는 기능이 있다

(예를 들어 유도 클래스를 private 선언하여 상속한 경우 기초 클래스의 public, protected와 같이 더 넓은 범위의 접근 제어지시자 모두를 private로 바꾸어 상속하게 된다)

---

4. p.285

상속 하는 클래스와, 상속 받는 클래스를 지칭하는 용어 중 본인에게 맞는 용어 하나 선택

> 기초 클래스 / 유도 클래스

---

5. p.291~293

소멸자 실행 과정과 순서에 대한 논리적 설명

>

유도 클래스 객체를 생성할 때에는 먼저 기초 클래스 생성자가 실행되어 초기화되고 이후 유도 클래스 생성자를 실행되어 초기화하는 반면

소멸할 때에는 먼저 유도 클래스의 소멸자가 실행되어 소멸하고 이후 기초 클래스 소멸자가 실행되어 소멸한다

#include <iostream>
using namespace std;

class Base{ // 기초 클래스
	public:
		Base() { cout << "기초 클래스 생성자 호출 !" << endl; }
		~Base() { cout << "기초 클래스 소멸자 호출 !" << endl; }
};

class Derived : public Base{ // 유도 클래스
	public:
		Derived() : Base() {
			cout << "유도 클래스 생성자 호출 !" << endl;
		}
		~Derived() { cout << "유도 클래스 소멸자 호출 !" << endl; }
};

int main() {
	Derived d; // 유도 클래스 객체 생성
	return 0;
}

---

6. p.295

문제1

#include <iostream>
using namespace std;

class Car
{
	private:
		int gasolineGauge;
	public:
		Car() : gasolineGauge(100) // Car 생성자(추가사항)
		{
			cout<<"Car 생성자 호출 !"<<endl;
		}
		int GetGasGauge()
		{
			return gasolineGauge;
		}
};

class HybridCar : public Car{
	private:
		int electricGauge;
	public:
		HybridCar() : Car(), electricGauge(50) // HybridCar 생성자(추가사항)
		{
			cout<<"HybridCar 생성자 호출 !"<<endl;
		}
		int GetElectricGauge()
		{
			return electricGauge;
		}
};

class HybridWaterCar : public HybridCar
{
	private:
		int waterGauge;
	public:
		HybridWaterCar() : HybridCar(), waterGauge(30) // HybridWaterCar 생성자(추가사항)
		{
			cout<<"HybridWaterCar 생성자 호출 !"<<endl;
		}
		void ShowCurrentGauge()
		{
			cout<<"잔여가솔린: "<<GetGasGauge()<<endl;
			cout<<"잔여전기량: "<<GetElectricGauge()<<endl;
			cout<<"잔여수소량: "<<waterGauge<<endl;
		}
};

// main 함수(추가사항)
int main(void)
{
	HybridWaterCar myCar; // HybridWaterCar 객체 생성
	myCar.ShowCurrentGauge(); // 현재 게이지 출력
	return 0;
}

---

문제2

#include<iostream>
#include <cstring>
using namespace std;

class MyFriendInfo{
	private:
		char* name;
		int age;
	public:
		MyFriendInfo(char* myName, int myAge) : age(myAge) // 생성자(추가사항)
			{
				name = new char[strlen(myName)+1]; // 동적 메모리 할당
				strcpy(name, myName);
				cout<<"MyFriendInfo() 생성자 호출 !"<<endl;
			}
		void ShowMyFriendInfo()
		{
			cout<<"이름 : "<<name<<endl;
			cout<<"나이 : "<<age<<endl;
		}
		~MyFriendInfo() // 소멸자(추가사항)
		{
			delete[] name; // 동적 메모리 해제
			cout<<"MyFriendInfo() 소멸자 호출 !"<<endl;
		}
};

class MyFriendDetailInfo : public MyFriendInfo
{
	private:
		char* addr;
		char* phone;
	public:
		MyFriendDetailInfo(char* myName, int myAge, char* myAddr, char* myPhone) // 생성자(추가사항)
			: MyFriendInfo(myName, myAge) // 기초 클래스 생성자 호출
			{
				addr = new char[strlen(myAddr)+1];
				phone = new char[strlen(myPhone)+1];
				strcpy(addr, myAddr);
				strcpy(phone, myPhone);
				cout<<"MyFriendDetailInfo() 생성자 호출 !"<<endl;
			}
		void ShowMyFriendDetailInfo()
		{
			ShowMyFriendInfo();
			cout<<"주소 : "<<addr<<endl;
			cout<<"전화 : "<<phone<<endl;
		}
		~MyFriendDetailInfo() // 소멸자(추가사항)
		{
			delete[] addr; // 동적 메모리 해제
			delete[] phone; // 동적 메모리 해제
			cout<<"MyFriendDetailInfo() 소멸자 호출 !"<<endl;
		}
};

int main(void)
{
	MyFriendDetailInfo myFriend(name, 25, addr, phone);
	myFriend.ShowMyFriendDetailInfo();
	return 0;
}

---

과제 3.

1. p.297

protected 정보은닉 접근 제어자의 상속 구조간 멤버 접근 범위 설명

> protected가 선언되면

외부에서 멤버에서 접근하는데 제약을 갖는다는 점에서 private와 공통점을 가진다

상속관계인 경우에만 유도 클래스에서 protected 멤버변수에 접근이 가능하다는 점에서 private와 차이점을 가진다

> 상속 문법시 접근제어지시자를 protected로 설정하게 되면 protected 보다 넓은 접근 범위를 가진 모든 지시자를 protected로 바꿔서 상속하게 되는데 public 밖에 없으므로 public이 아닌 멤버들을 protected로 바꾸어 상속한다

---

과제 4.

1.

- 예제의 computer, notebook, tabletnotebook 상속 구조인 클래스 간의 간단한 클래스 다이어그램 그리기

- notebook, tabletnotebook 클래스가 상속 구조가 없다고 가정하고, 단독 클래스 형태로 다이어그램 그리기

<상속 구조가 없는 경우의 클래스 정의>

#include <iostream>
#include <cstring>
using namespace std;

class NotebookComp{
	private:
		int Battery;
		char owner[50];
	public:
		NotebookComp(char* name, int initChag)
			: Battery(initChag)
			{
				strcpy(owner, name);
			}
		void Calculate()
		{
			cout<<"요청 내용을 계산합니다."<<endl;
		}
		void charging() {Battery += 5;}
		void UseBattery() {Battery -= 1;}
		void MovingCal()
		{
			if(GetBatteryInfo()<1)
			{
				cout<<"충전이 필요합니다."<<endl;
				return;
			}
			cout<<"이동하면서 ";
			Calculate();
			UseBattery();
		}
		int GetBatteryInfo() const {return Battery;}
};

class TableNotebook{
	private:
		int Battery;
		char owner[50];
		char regstPenModel[50];
	public:
		TableNotebook(char* name, int initChag, char* pen)
			: Battery(initChag)
			{
				strcpy(owner, name);
				strcpy(regstPenModel, pen);
			}
		void Write(char* penInfo){
			if(GetBatteryInfo()<1)
			{
				cout<<"충전이 필요합니다."<<endl;
				return;
			}
			if(strcmp(regstPenModel, penInfo) != 0)
			{
				cout<<"등록된 펜이 아닙니다."<<endl;
				return;
			}
			cout<<"필기 내용을 처리합니다."<<endl;
			UseBattery();
		}
		void Calculate()
		{
			cout<<"요청 내용을 계산합니다."<<endl;
		}
		void charging() {Battery += 5;}
		void UseBattery() {Battery -= 1;}
		void MovingCal()
		{
			if(GetBatteryInfo()<1)
			{
				cout<<"충전이 필요합니다."<<endl;
				return;
			}
			cout<<"이동하면서 ";
			Calculate();
			UseBattery();
		}
		int GetBatteryInfo() const {return Battery;}
};

int main(void){
	NotebookComp nc("이수종", 5);
	TableNotebook tn("정수영", 5, "ISE-241-242");
	nc.MovingCal();
	tn.Write("ISE-241-242");
	return 0;
}

---

 

2. p.307~390

- 각각의 예제의 gun, police 클래스간의 간단한 클래스 다이어그램

- is-a, has-a 관계 차이 설명

> is a(~이다)는 상속관계를 뜻한다.

A1 is a A 의 의미는 "A1은 일종의 A 이다" 를 말함.

A1은 A의 종류라는 것을 의미함.

> has a(~을 소유하다)는 포함관계를 뜻한다.

A has a B 의 의미는 A가 B를 소유한다.

B는 A의 구성요소일 뿐 A의 종류는 아니란 것을 의미함.

---

3.

문제1.

#include<iostream>
using namespace std;

class Rectangle // 기초 클래스(직사각형)
{
	private :
		int width, height, area; 
	public :
		Rectangle(int w, int h) : width(w), height(h)
		{
			area = width * height;
			cout << "직사각형 생성자 호출 !" << endl;
		}
		void ShowAreaInfo()
		{
			cout << "면적 : " << area << endl;
		}
};
class Square : public Rectangle{ // 유도 클래스(정사각형)
	public :
		Square(int len) : Rectangle(len, len) // 기초 클래스의 생성자를 호출하여 초기화
		{
			cout << "정사각형 생성자 호출 !" << endl;
		}
};


int main(void){
	Rectangle rec(4, 3);
	rec.ShowAreaInfo();

	Square sqr(7);
	sqr.ShowAreaInfo();
	return 0;
}

---

문제2.

#include<iostream>
#include <cstring>
using namespace std;

class Book{
	private:
		char* title; // 책 제목
		char* isbn; // 국제표준도서번호
		int price; // 책 가격
	public:
		Book(char* t, char* i, int p) : price(p){
			title = new char[strlen(t)+1];
			strcpy(title, t);
			isbn = new char[strlen(i)+1];
			strcpy(isbn, i);
			cout << "Book 클래스 생성자 호출 !" << endl;
		}
		void ShowBookInfo(){
			cout << "제목: " << title << endl;
			cout << "ISBN: " << isbn << endl;
			cout << "가격: " << price << endl;
		}
		~Book(){
			delete[] title;
			delete[] isbn;
			cout << "Book 클래스 소멸자 호출 !" << endl;
		}
};
class Ebook : public Book{
	private:
		char* DRMKey; // 보안 키
	public:
		Ebook(char* t, char* i, int p, char* key) : Book(t, i, p)
			{
				DRMKey = new char[strlen(key)+1];
				strcpy(DRMKey, key);
				cout << "Ebook 클래스 생성자 호출 !" << endl;
			}
		void ShowEbookInfo(){
			ShowBookInfo();
			cout << "보안 키: " << DRMKey << endl;
		}
		~Ebook(){
			delete[] DRMKey;
			cout << "Ebook 클래스 소멸자 호출 !" << endl;
		}
		
};

int main(void){
	Book book("좋은 C++", "555-12345-890-0", 20000);
	book.ShowBookInfo();
	cout << endl;
	Ebook ebook("좋은 C++ ebook", "555-12345-890-1", 10000, "fdx9w0i8kiw");
	ebook.ShowEbookInfo();\
	return 0;
}

---

4. 프로젝트 05 단계, 클래스 간 간단한 클래스 다이어그램