1. 문제 기술 필자는 첫번째 파일과 두번째 파일의 내용이 합쳐진 세번째 파일을 만들기를 요한다.

2. 설계 계획 사용자에게 각각의 파일의 이름을 입력 받아 3개의 파일을 생성하고, 첫번째와 두번째 파일에 원하는 입력을 받아 각각의 내용을 합쳐 세번째 파일에 출력한다.

3. 데이터 처리 과정 사용자에게 각각의 파일의 이름을 입력 받아 저장한다. 입력 받은 파일의 이름에 .txt를 붙여 파일생성을 하고, 첫번째 파일과 두번째 파일에 각각 사용자가 원하는 내용을 입력한다. 이후, 첫번째와 두번째 파일의 내용을 string 형태로 읽어 들여 세번째 파일에 출력한다.

4. 실행 결과 및 분석

   #include<iostream>
   #include<fstream>
   #include<string>
   using namespace std;
   

int main() { string alpha = ".txt"; string firstWords, secondWords;

string firstFileName, secondFileName, mergedFileName;
cout << "Please enter the first file name : ";
cin >> firstFileName;
cout << "Please write the words : ";
cin >> firstWords;
cout << "Please enter the second file name : ";
cin >> secondFileName;
cout << "Please write the words : ";
cin >> secondWords;
cout << "Please enter the merged file name : ";
cin >> mergedFileName;

ofstream fin1(firstFileName + alpha);
fin1 << firstWords << endl;

ofstream fin2(secondFileName + alpha);
fin2 << secondWords << endl;

fin1.close();
fin2.close();

ifstream fin3(firstFileName + alpha);
ifstream fin4(secondFileName + alpha);
ofstream fout(mergedFileName + alpha);

string line;
fin3 >> line;
fout << line;

fin4 >> line;
fout << line;

fin3.close();
fin4.close();
fout.close();

return 0;

} ```

1. 문제 기술 필자는 본문에 있는 관리자와 유저의 로그인 정보를 관리하는 시스템의 구현을 요한다.

2. 설계 계획 본문에 따라 각각의 클래스를 만들어 해당하는 멤버함수를 구현하고, 유저와 관리자에 해당하는 아이디와 비밀번호를 입력하였을 때 작동하는 메인을 설계한다.

3. 데이터 처리 과정 본문에 있는 Security헤더를 각각 User와 Administrator 헤더에 선언하여 Security.cpp에 선언한다. 이후 Security 클래스의 멤버함수에서 나온 리턴값에 따라 각각의 클래스의 Login 함수의 아규먼트로 입력하여 나온 결과값에 따라 로그인을 시킨다.

4. 실행 결과 및 분석

   <Security.h>
   

#pragma once #include #include using namespace std;

class Security { public: static int validate(string username, string password); };

int Security::validate(string username, string password) { if ((username == "abbott") && (password == "monday")) return 1; if ((username == "costello") && (password == "tuesday")) return 2; return 0; }

<Administrator.h>

#pragma once #include "Security.h"

class Administrator { public: bool Login(int num); };

bool Administrator::Login(int num) { if (num == 2) return true; else return false; }

<User.h>

#pragma once #include "Security.h"

class User { public: bool Login(int num); };

bool User::Login(int num) { if (num == 1) return true; else return false; }

<Security.cpp>

#include "Administrator.h" #include "User.h"

int main() { Security a; Administrator b; User c;

if (c.Login(a.validate("abbott", "monday")) == 1) cout << "Good morning, user" << endl;
if (b.Login(a.validate("costello", "tuesday")) == 1) cout << "Good morning, admin" << endl;
return 0;

}

```

1. 문제 기술 필자는 구독자의 구독리스트를 관리하는 프로그램의 구현을 요한다.

2. 설계 계획 클래스를 선언하여 오버로딩 생성자에 의해 사용자의 이름을 최초로 입력 받는다. 이후 사용자는 메뉴에서 리스트를 추가할 수 있는데 이때, 동적 할당을 이용해 받은 데이터만큼 새로운 string 방을 추가한다. 동시에 개수를 계산하여 채널 개수에 입력한다. 사용자는 이름과 리스트를 추가 및 리셋 시킬 수 있다.

3. 데이터 처리 과정 리스트를 생성 할 시 사용자로부터 이름을 입력 받고 해당 데이터를 임시변수에 저장한다. 기존에 리스트가 생성되어 있지 않다면 동적할당을 하여 새로운 리스트를 추가하고, 리스트가 생성되어 있다면 임시주솟값에 기존의 리스트주소를 저장하여 데이터를 보존하고 새롭게 동적할당을 하여 임시주솟값에 들어간 데이터와 새로운 데이터를 입력 받고 임시주솟값의 데이터를 해제한다.

4. 실행 결과 및 분석

   #include <iostream>
   #include <string>
   #include <stdlib.h>
   using namespace std;
   

class Subscriber { private: string name; int numChannels; string* channelList; public: Subscriber(); Subscriber(string); ~Subscriber(); void setName(); void setList(); void getInfo(); void reset(); };

Subscriber::Subscriber(){ cout << "Please write your name: "; cin >> this->name; this->numChannels = 0; this->channelList = NULL; }

Subscriber::Subscriber(string name) { this->name = name; this->numChannels = 0; this->channelList = NULL; }

Subscriber::~Subscriber() { delete[] this->channelList; }

void Subscriber::setName(){ cout << "Please write your name: "; cin >> this->name; }

void Subscriber::setList() { string channel; cout << "Mr(s). " << this->name << ", please write names of the channels. If you want to quit, press q." << endl; while (true) { cin >> channel; if (channel == "q") break; else { if (this->numChannels == 0) { this->channelList = new string[this->numChannels + 1]; } else if (this->numChannels > 0) { string* tmp = this->channelList; this->channelList = new string[this->numChannels + 1]; for (int i = 0; i < this->numChannels; i++) { this->channelList[i] = tmp[i]; } delete[] tmp; } this->channelList[this->numChannels] = channel; this->numChannels++; } } }

void Subscriber::getInfo() { cout << "The list Mr(s). " << this->name << " subcribes :" << endl; if (this->numChannels == 0) cout << "Nothing in your list." << endl; for (int i = 0; i < this->numChannels; i++) cout << channelList[i] << endl; cout << "please press any button. "; cin.get(); cin.get(); }

void Subscriber::reset() { this->name = ""; this->numChannels = 0; delete[] this->channelList; this->channelList = NULL; }

int main(){ int num; Subscriber a; while (1) { cout << "1. Show your information / 2. Change your name / 3. Add your list / 4. Reset your information / 5. Quit\nPress the number: "; cin >> num; switch (num) { case 1: { a.getInfo(); } break; case 2: { a.setName(); } break; case 3: { a.setList(); } break; case 4: { a.reset(); } break; case 5: return 0; default: cout << "Wrong number" << endl; } system("cls"); } }

![](https://images.velog.io/images/hyeonu_chun/post/49d8bf00-5caa-40d7-b28a-c2f02b036ede/image.png)![](https://images.velog.io/images/hyeonu_chun/post/6e255c02-f5f3-4b17-89c7-efe9b6ddc447/image.png)![](https://images.velog.io/images/hyeonu_chun/post/df6342d7-e0e1-489e-85a8-0e725b5e705b/image.png)리스트를 구현하는 여러 방법이 있었지만 사용자가 얼마나 구독을 할지 모르는 상황에서 구독채널 개수의 한계를 없애기 위해서 링크드 리스트를 간략하게 나마 표현했다. Equal operator를 현 코드에는 구현하지 않았는데, c++에서 제공하는 오퍼레이터를 그대로 사용할 경우 얕은 복사가 되어 같은 주소를 가리키는 변수가 2개가 생기게 되어 원치 않은 데이터의 손실이 생길 수 있다. 따라서 새로운 동적할당을 하여 변수가 각각 다른 주솟값을 가리키게 하는 것이 바람직하다.

1. 문제 기술 필자는 음악리스트를 각 조건에 맞는 연산을 수행하여 정렬하기를 원한다.

2. 설계 계획 각 조건에 맞게 설계하기 위해서 string 배열타입의 음악리스트를 변수로 입력한다. 조건에 맞게끔 변수를 조정하여 정렬하기 쉬운 형태로 변경하고, 이후 알고리즘 헤더의 sort함수를 이용해 정렬한다.

3. 데이터 처리 과정 String 타입의 배열을 만들어 각각의 방에 음악 타이틀을 하나씩 넣어 변수로 입력한다. 사용자가 원하는 타이틀의 개수를 num이라는 변수에 저장해 타이틀을 추가해도 반자동적으로 타이틀의 개수를 체크한다. 우선적으로, 타이틀 앞의 무의미한 정보를 삭제하기 위해 ‘.’앞뒤의 글자를 제거한다. 타이틀 내의 타이틀과 뮤지션을 나뉘어 주는 대쉬 표시를 헷갈리게 하지 않기 위해 타이틀 내의 대쉬 표시를 공백으로 전환하고, 동시에 중복되는 공백표시를 제거해 하나의 공백으로 변경한다. 변경된 정보들을 가지고 제목정렬을 한 뒤 번호를 붙인다.

4. 실행 결과 및 분석

   #include <iostream>
   #include <string>
   #include <algorithm>
   

using namespace std;

bool comp(string s1, string s2) { return s1 < s2; }

int main() { string line[] = {"1. Adagio "Moon" - Ludwig Van Beethoven","15. Dutch Warblet - no author listed", "123. Ba- Be- - no author listed"}; const int num = sizeof(line) / sizeof(line[0]); for (int i = 0; i < num; i++) cout << line[i] << endl; cout << endl;

for (int i = 0; i < num; i++) {
    line[i].erase(0, line[i].find(".") + 2);
    bool a = false;
    int b = 0;
    for (int j = line[i].size() - 1; j >= 0; j--) {
        if (line[i].at(j) == '-' && !a) {
            a = true;
            b = j;
        }
        else if (line[i].at(j) == '-' && a) {
            line[i].at(j) = ' ';
        }
        if (j <= line[i].size() - 2 && j >= 1) {
            if (line[i].at(j) == ' ') {
                if (line[i].at(j - 1) == ' ' || line[i].at(j + 1) == ' ') line[i].erase(j, 1);
            }
        }
    }
}
sort(line, line + num, comp);
for (int i = 0; i < num; i++) cout << i + 1 << ". " << line[i] << endl;

}

 ![](https://images.velog.io/images/hyeonu_chun/post/f3b9acc8-307b-4f76-9c3f-787dfa60ae2b/image.png)                 
 조건에서 이해 가능한 조건을 우선적으로 실행하여 구현하였다. 제목정렬이 아닌 가수정렬로 바꿀 시 rfind 함수를 이용해 대쉬 표기를 찾아 가수와 제목의 위치를 바꾸고 sort 함수를 이용해 정렬하면 가수정렬도 가능하지만, 조건들에 있는 첫번째/두번째 이니셜과 이름의 위치 바꾸는 로직을 이해하지 못해 구현하지 않았다. 

1. 문제 기술 필자는 본문의 8.7을 응용하여 멤버변수의 교체와 그에 따른 멤버함수들을 변환 및 생성자 추가를 요한다.

2. 설계 계획 기본적인 틀은 다 설계가 되어있기에 문제에서 요구하듯, 기존 멤버변수를 삭제 시키고 배열과 사용중인 배열의 방의 사이즈를 나타내는 정수값을 변수로 둔다. 멤버변수를 초기화 시키는 디폴트 생성자, 오버로디드 생성자를 만들고 변수들이 변함에 따라 기존에 오버로딩 된 연산자의 정의를 바꾼다.

3. 데이터 처리 과정 CharPair type의 a, b, c를 생성하게 되면 arguments에 따라 각각 디폴트 생성자, 오버로디드 생성자들이 호출되어 객체 생성을 완료한다. 객체 생성이 정상적으로 완료되었는지 확인하기 위해 각 객체마다 멤버변수를 확인할 수 있는 멤버함수를 불러 클래스 내부의 멤버변수를 간접적으로 확인한다.

4. 실행 결과 및 분석

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

class CharPair { public: CharPair(); CharPair(int sz); CharPair(int sz, char array[]); char& operator[](int index); int returnSize() { return size; }

private: char array[100]; int size; };

CharPair::CharPair() { size = 10; for (int i = 0; i < 100; i++) this->array[i] = '#'; }

CharPair::CharPair(int sz) : size(sz) { for (int i = 0; i < 100; i++) this->array[i] = '#'; }

CharPair::CharPair(int sz, char array[]) : size(sz) { for (int i = 0; i < 100; i++) this->array[i] = array[i]; }

char& CharPair::operator[](int index) { int num = 0; for (int i = 0; i < this->size; i++) { if (index == i) { num = 1; return this->array[i]; } } if (num == 0) { cout << "Illegal index value. \n"; exit(1); } }

int main() { char array[] = { 'a', 'b', 'c', 'd' ,'e' }; CharPair a; CharPair b(1); CharPair c(5, array);

cout << "1. Size of a = " << a.returnSize() << ", a[2] = " << a[2] << endl;

cout << "2. Size of b = " << b.returnSize() << ", b[0] = " << b[0] << endl;

cout << "3. Size of c = " << c.returnSize() << ", c[4] = " << c[4] << endl;

return 0;

}

![](https://images.velog.io/images/hyeonu_chun/post/05361920-a55a-401e-bf4c-fe2451f44cba/image.png)
기존 Display 8.7의 코드에 멤버 변수의 변화에 따라 작성된 코드이다. 오버로딩 연산자에서 기존코드에선 단순하게 배열을 흉내 냈을 뿐이지만 이번 과제에선 직간접적으로 배열을 이용해 원하는 배열의 방을 뽑아내야 함과 동시에 예외처리를 해야 했다. 콘솔창에서 입력 받는 변수가 없어 단순변수를 이용해 예외처리를 진행하였다.

1. 문제 기술 필자는 복소수의 기초연산을 할 수 있는 프로그램의 설계를 요한다.

2. 설계 계획 클래스 내부에 문제에서 요하는 데이터 멤버와 멤버 함수를 작성하고 연산자 오버로딩을 통해 클래스와 클래스의 연산을 가능하게 만든다. 입출력의 형태도 오버로딩을 통해 형태에 따라 입력되고 출력되게 만든다.

3. 데이터 처리 과정 먼저 Complex class type의 (a, b), (c, d)를 파라메타로 가지는 객체를 생성한다. 이라는 객체를 생성한다. 따라서 Complex class의 오버로디드 생성자가 호출되어 데이터 멤버를 파라메타에 해당하는 객체 생성을 완료한다. 기존 main 함수에 입력되어 있는 연산문에 따라 Complex x와 y는 오버로디드 된 연산자 *를 호출하여 복소수의 곱셈연산을 수행하게 된다. 이후 출력 연산자를 호출하여 사용자가 원하는 출력의 형태로 출력하여 곱셈연산을 대조 비교한다.

4. 실행 결과 및 분석

   #include <iostream>
   using namespace std;
   

class Complex { private: double real; double imaginary; public: Complex(double real = 0, double imaginary = 0); Complex(double realpart); ~Complex() {} Complex operator+(const Complex &a) const; Complex operator-(const Complex &a) const; Complex operator-() const; Complex operator*(const Complex &a) const; Complex operator/ (const Complex & a) const; bool operator==(const Complex& a); bool operator!=(const Complex& a); friend ostream &operator<<(ostream &os, Complex &a); friend istream &operator>>(istream &is, Complex &a); double displayReal() { return real; } double displayImaginary() { return imaginary; } };

Complex::Complex(double real, double imaginary) { this->real = real; this->imaginary = imaginary; }

Complex::Complex(double realpart) { this->real = realpart; this->imaginary = 0; }

ostream &operator<<(ostream &os, Complex &a) { if (a.real != 0) os << a.real; if (a.imaginary != 0) { cout.setf(ios::showpos); os << a.imaginary << "i"; cout.unsetf(ios::showpos); } if (a.real == 0 && a.imaginary == 0) os << 0; return os; }

istream &operator>>(istream &is, Complex &a) { is >> a.real >> a.imaginary; return is; }

Complex Complex::operator+(const Complex& a) const { Complex temp(this->real + a.real, this->imaginary + a.imaginary); return temp; }

Complex Complex::operator-(const Complex& a) const { Complex temp(this->real - a.real, this->imaginary - a.imaginary); return temp; }

Complex Complex::operator-() const { Complex temp(-this->real, -this->imaginary); return temp; }

Complex Complex::operator*(const Complex& a) const { double x, y; x = this->real * a.real - this->imaginary * a.imaginary; y = this->real * a.imaginary + this->imaginary * a.real; Complex temp(x, y); return temp; }

Complex Complex::operator/ (const Complex& a) const { double x, y, z; z = a.real * a.real + a.imaginary * a.imaginary; x = (this->real * a.real + this->imaginary * a.imaginary) / z; y = (this->imaginary * a.real + this->real * a.imaginary) / z; Complex temp(x, y); return temp; }

bool Complex::operator==(const Complex& a) { if (this->real == a.real && this->imaginary == a.imaginary) { return true; } else return false; }

bool Complex::operator!=(const Complex& a) { if (this->real != a.real && this->imaginary != a.imaginary) { return true; } else return false; }

int main() { double a, b, c, d; cout << "Please enter four values to calculate : "; cin >> a >> b >> c >> d; Complex x(a,b), y(c,d); const Complex i(0, 1);

Complex z = x * y;

cout << x << " * " << y << " = " << z << " (=(" << a << "*" << c << " - " << b << "*" << d << ") + (" << a << "*" << d << " + " << b << "*" << c << "))" <<endl;

}

![](https://images.velog.io/images/hyeonu_chun/post/d9387182-510b-4e44-a8f5-8957fbace9bb/image.png)
문제가 요한대로 각 객체를 생성하여 곱셈 뿐만 아니라 다양한 형태의 연산을 시도하였을 때 정상적으로 작동하였다. 복소수 i와의 연산에서도 문제가 없었지만 오버로디드 연산자를 사용하여 객체 3개 이상의 연산을 할 시 문제가 발생 되었다. 입출력 연산의 경우 함수 호출 과정을 줄이기 위해 Friend 함수로 입력했지만 이 점은 피드백 과정 이후에 개선한 것으로 기존 연산자 함수들은 유지하였는데, 나머지 연산자 함수들도 개선을 통해 3개 이상의 피연산 계산이 가능하도록 해야 한다는 것을 인지하였다.

1. 문제 기술 필자는 일정 금액 이하의 각 자릿수 덧셈 연산만 하는 덧셈기의 구현을 요한다. 뿐만 아니라 일정 금액 초과 시 경고를 띄워 사용자에게 인지시키고 리셋이 가능하다.

2. 설계 계획 클래스 내부에 문제에서 요하는 데이터 멤버와 멤버 함수를 작성하고 금액의 합을 보여주는 멤버 함수를 추가한다. 생성자는 모두를 0으로 초기화하게 디폴트 생성자로 작성하고, 각 자리수의 덧셈 멤버 함수는 10을 초과할 시 해당 자릿수를 0으로 초기화하고 다음 자릿수를 하나 증가시키며 1000의 자리가 넘어갈 경우 오버플로우를 경고한다. 프로그램을 종료하지 않는 이상 리셋을 통해 덧셈기를 사용 가능하며 asdfor(ASDFOR)을 제외한 입력이나 1~9를 제외한 입력은 일체 예외 처리한다.

3. 데이터 처리 과정 먼저 Counter class type의 Counter이라는 객체를 생성한다. 따라서 Counter class의 디폴트 생성자가 호출되어 데이터 멤버를 초기화 시키고, 객체 생성을 완료한다. (이전의 입력을 고려해) 콘솔창을 리셋시키고 오버플로우를 검사한다. 덧셈기에 해당하는 기능을 나타내는 디스플레이를 출력하고, 사용자에게 해당 기능에 맞는 문자를 입력 받으면 기능을 수행한다. 자릿수 덧셈 시 추가로 숫자를 입력 받아 입력 받은 횟수만큼 해당 자릿수를 1씩 증가시킨다. 덧셈, 리셋 등의 기능을 수행한 뒤 무한루프문에 의해 기능은 0.5초의 딜레이를 가지고 다시금 수행 가능하게 되며 Q(q)를 입력 시 프로그램이 종료된다.

4. 실행 결과 및 분석

   #include <iostream>
   #include <windows.h>
   using namespace std;
   

class Counter { private: bool overflowflag; int units; int tens; int hundreds; int thousands;

public: Counter() :units(0), tens(0), hundreds(0), thousands(0), overflowflag(false) {} ~Counter() {}

bool overflow();

void reset();

void incr1();
void incr10();
void incr100();
void incr1000();

void displayMoney();

};

void Counter::reset() { this->overflowflag = false; this->units = this->tens = this->hundreds = this->thousands = 0; }

void Counter::displayMoney() { cout << "Total : $" << this->thousands << this->hundreds << "." << this->tens << this->units << endl; }

bool Counter::overflow() { return this->overflowflag; }

void Counter::incr1000() { if (this->thousands < 9) this->thousands++; else { this->thousands = 0; this->overflowflag = true; } }

void Counter::incr100() { if (this->hundreds < 9) this->hundreds++; else { this->hundreds = 0; this->incr1000(); } }

void Counter::incr10() { if (this->tens < 9) this->tens++; else { this->tens = 0; this->incr100(); } }

void Counter::incr1() { if (this->units < 9) this->units++; else { this->units = 0; this->incr10(); } }

int inputDigit();

int main() { int i; int digit; char key; Counter Counter;

while (true) {
    system("cls");
    if (Counter.overflow() == true) cout << "WARNING : Overflow has happened. Press r to reset." << endl;
    Counter.displayMoney();
    cout << "a - units\ns - tens\nd - hundreds\nf - thousands\no - check overflow\nr - reset\nQ - quit\nEnter a character : ";
    cin >> key;

    while(cin.get() != '\n') {
        key = 0;
    }

    switch (key) {
    case 'A':
    case 'a': {
        digit = inputDigit();
        for (i = 0; i < digit; i++) {
            Counter.incr1();
        }
    } break;
    case 'S':
    case 's': {
        digit = inputDigit();
        for (i = 0; i < digit; i++) {
            Counter.incr10();
        }
    } break;
    case 'D':
    case 'd': {
        digit = inputDigit();
        for (i = 0; i < digit; i++) {
            Counter.incr100();
        }
    } break;
    case 'F':
    case 'f': {
        digit = inputDigit();
        for (i = 0; i < digit; i++) {
            Counter.incr1000();
        }
    } break;
    case 'O':
    case 'o': {
        if (Counter.overflow() == true) {
            cout << "WARNING : Overflow has happened. Press r to reset." << endl;
        }
        else cout << "Overflow has not happended." << endl;
    } break;
    case 'R':
    case 'r': {
        cout << "Resetting..." << endl;
        Counter.reset();
    } break;
    case 'Q':
    case 'q': {
        cout << "Quitting..." << endl;;
        return 0;
    }
    default: {
        cout << "Please enter a CORRECT character." << endl;
        break;
    }
    }
    Sleep(500);
}

}

int inputDigit() { int digit; cout << "Enter a digit between 1 and 9 : "; cin >> digit; if (cin.get() != '\n') { cout << "Please enter a CORRECT number." << endl; cin.clear(); while (cin.get() != '\n') {} return 0; } if (cin.fail() == true) { cout << "Please enter a CORRECT number." << endl; cin.clear(); while (cin.get() != '\n') {} return 0; } if (0 > digit || digit > 9) { cout << "Please enter a CORRECT number." << endl; return 0; } else return digit; }

![](https://images.velog.io/images/hyeonu_chun/post/1f76b7fb-c423-4afc-8cae-0924c6fabd09/image.png)
덧셈기의 원리에 따라 각 자릿수에 해당하는 숫자를 받고 더해서 오버플로우가 발생하면 경고하고 리셋을 권하는 형태의 결과물이 완성되었다. 기능적인 측면에서 오버플로우가 발생할 시 어떤 기능을 입력하던 경고문이 지속되어 ‘o’ 기능의 필요성을 느끼지는 못했다(독해를 잘못했을 가능성이 크다). 기존 과제에서 예외처리를 시행하지 않았었지만, 이번 과제의 경우 연속적인 입력의 경우 하나라도 잘못된 입력이 들어가면 무한루프에 빠지거나 원치 않은 기능을 수행하게 되어 최대한 노력을 해보았지만 깔끔하게 처리하지 못했다는 문제가 있다.

1. 문제 기술 필자는 반지름을 오브젝트로 갖고 이 반지름을 제어하고 이를 통해 원의 넓이, 지름, 원주 그리고 반지름을 보여주는 함수들을 가진 클래스의 구현을 요한다.

2. 설계 계획 클래스 외에서 직접적으로 제어할 수 없는 데이터 멤버를 지정하고, 디폴트 생성자를 수동생성한다. 변수를 간접적으로 제어하기 위해 문제에서 요하는 각각의 기능을 가진 SetRadius, Calculate, ReturnRadius 함수를 만든다. 각각의 함수를 정의하고 메인함수 내에서 원하는 반지름을 double 형으로 받으면 그에 따라 반지름을 세팅하고 원의 넓이, 지름 그리고 원주를 계산하여 보여준다. 마지막으로 입력 받은 반지름을 보여준다.

3. 데이터 처리 과정 먼저 Circle class type의 Circle이라는 데이터 멤버를 선언한다. 따라서 Circle class의 디폴트 생성자가 호출되어 데이터 멤버를 초기화 시키고, 객체 생성을 완료한다. 다음으로 원하는 반지름을 입력 받기 위해 r이라는 변수를 선언하고, 입출력 함수를 통해 반지름을 입력 받는다. 클래스를 테스트하기 위해 입력 받은 반지름을 멤버 함수를 통해 전달하여 입력한다. 전달받은 반지름으로 원의 넓이, 지름 그리고 원주를 계산하고 출력한다. 입력 받은 반지름 값이 데이터 멤버에 입력되었는지 확인하는 리턴함수를 통해 출력한다. 마지막으로 소멸자를 통해 객체 소멸을 완료시킨다.

4. 실행 결과 및 분석

   #include <iostream>
   #include <math.h>
   #define PI 3.14
   using namespace std;
   

class Circle { private: double radius; public: Circle(); ~Circle() { /* cout << "Call Destructor..." << endl; */ } void SetRadius(double r); void Calculate(); double ReturnRadius(); };

Circle::Circle() { this->radius = 0; /* cout << "Call Constructor..." << end/; */ }

void Circle::SetRadius(double r) { this->radius = r; }

void Circle::Calculate() { cout << "The area of the circle is " << fixed << 2 * PI * pow(this->radius, 2) << endl; cout << "The diameter of the circle is " << 2 * this->radius << endl; cout << "The circumference of the circle is " << 2 * PI * this->radius << endl; }

double Circle::ReturnRadius() { return this->radius; }

int main() { Circle Circle; double r;

cout << "Please enter the radius you want to change. ";
cin >> r;

Circle.SetRadius(r);
Circle.Calculate();

cout << "The radius of the circle is " << Circle.ReturnRadius() << endl;

}

![](https://images.velog.io/images/hyeonu_chun/post/99e2be5e-33e0-4f9f-84aa-b08e50f550f8/image.png)
금일 날짜를 반지름으로써 입력하여 원의 넓이, 지름, 원주 그리고 반지름을 정상적으로 출력한다. 강제형변환 횟수를 줄이기 위해 데이터를 double 형으로 입력 받아 제곱 함수의 데이터 리턴값과의 계산에도 문제가 생기지 않았다. 본 클래스에는 This 포인터를 쓸 이유는 없었지만 개인적으로 쓰는 것이 입출력 되는 데이터들의 구분이 되어 사용하였다. 생성자의 개념이 미숙하여 생성자와 소멸자의 수행 위치를 확인하기 위한 테스트를 진행하였다.

1. 문제 기술

   필자는 메인 함수 내의 배열 데이터에서 중복되는 데이터를 삭제하여 나열하고, 동시에 의도적으로 사용되는 배열 내의 데이터 수를 계산하는 함수의 구현을 요한다.

2. 설계 계획

   함수를 구현하기 위해서 배열내의 각각의 데이터가 중복되지 않아야 한다. 첫번째 배열이 자신을 제외한 나머지 배열을 확인하며 같은 데이터가 있을 경우, 그 데이터의 뒤에서부터 배열을 한 칸 씩 앞으로 이동시킨다. 이와 동시에 Garbage 데이터로 인한 혼동을 막기 위해 마지막 번째 배열은 널문자로 초기화 시킨다. 마찬가지로 두번째 데이터 또한 첫번째 데이터와 자신을 제외한 나머지 데이터와 비교하며 중복되는 데이터를 삭제 및 이동시킨다. 같은 방법으로 함수에 입력 받는 사이즈 값에 따라 동작을 수행한다.

3. 데이터 처리 과정

   문제에 따라 deleteRepeats 함수는 입력 받는 데이터는 Character type의 배열과 배열내의 의도적으로 사용되는 배열의 개수이다. 즉, 매개변수들은 각각 Character pointer type과 int의 참조형이다. 입력 받은 배열은 함수 정의부에 따라 3중 For문에 의해 데이터를 비교, 삭제 및 이동시키고 정수 값에 중복되지 않은 데이터의 개수를 입력시킨다. 이후 deleteRepeats 함수에 의해 중복되지 않은 데이터와 개수가 출력되게 된다.

4. 실행 결과 및 분석

   #include<iostream>
   using namespace std;
   

void deleteRepeats(char *, int &);

int main() { char a[10]; a[0] = 'c'; a[1] = 'a'; a[2] = 'c'; a[3] = 'a'; int size = 4; deleteRepeats(a, size); }

void deleteRepeats(char *ch, int &size) {

for (int i = 0; i < size; i++) {
    for (int j = i + 1; j < size; j++) {
        if (ch[i] == ch[j]) {
            for (int k = j + 1; k < size; k++) {
                ch[k - 1] = ch[k];
            }
            size--;
            ch[size] = NULL;
            j--;
        }
    }
}
cout << ch[0] << ch[1] << ch[2] << ch[3] << size << endl;

}

``` 5. 소감 및 피드백

메인에서 입력되는 데이터에 따라 구동하는 함수이다. 결과적으로 3중 For문을 이용해 비교하며 데이터 삭제 및 이동을 위해 데이터를 하나하나 앞으로 옮기는 행위는 적은 데이터에서는 상관이 없으나 중복 횟수가 많고 배열의 길이가 길어질 시 연산의 횟수를 끊임없이 늘리는데 동조할 것이다. 동적 메모리 할당에 관해 공부하여 더욱 깔끔한 코드를 작성해야 함을 다시 끔 느꼈다.

#include <SoftwareSerial.h>
#include <Adafruit_NeoPixel.h>

SoftwareSerial mySerial(2, 3); // RX, TX
int BUTTON1 = 4;
int BUTTON2 = 5;
int BUTTON3 = 6;
int pot = A0;
int btnstate1;
int prevstate1 = 1;
int btnstate2;
int prevstate2 = 1;
int btnstate3;
int prevstate3 = 1;
int num1 = 0;
int num2 = 0;
int num3 = 0;
int lednum1 = 0;
int lednum2 = 0;
int lednum3 = 0;
int lednum4 = 0;
int lednum5 = 0;
int lednum6 = 0;
#define PIN 7
#define LEDNUM 3
Adafruit_NeoPixel strip = Adafruit_NeoPixel(LEDNUM, PIN, NEO_GRB + NEO_KHZ800);

void setup() {
  Serial.begin(9600);
  mySerial.begin(4800);
  int reading = analogRead(pot);
  int b = map(reading,0,1024,1,150);
    strip.begin();    
  strip.setPixelColor(0, b, 0, 0);
  strip.show();     
  delay(400);
  strip.setPixelColor(1, b, b, 0);
  strip.show();     
  delay(400);
  strip.setPixelColor(2, 0, b, 0);
  strip.show();     
  delay(400);
  int k = 0;
  while(k < 4)
  {
    strip.setPixelColor(0, b, 0, 0);
    strip.setPixelColor(1, b, b, 0);
    strip.setPixelColor(2, 0, b, 0);
    strip.show();
    delay(200);
  strip.setPixelColor(0, 0, 0, 0);
  strip.setPixelColor(1, 0, 0, 0);
  strip.setPixelColor(2, 0, 0, 0);
  strip.show();
  delay(200);
  k++;
  }
}

void loop() {
  int reading = analogRead(pot);
int b = map(reading,0,1024,1,150);

  if (Serial.available()) {
    char c = (char)Serial.read();
   if (c == 'm'){
         mySerial.print("m");
  strip.setPixelColor(2, b, 0, 0);
    strip.show();
  }
   if (c == 'n'){
         mySerial.print("n");
  strip.setPixelColor(2, 0, 0, 0);
    strip.show();
  }
   if (c == 'o'){
         mySerial.print("o");
  strip.setPixelColor(2, b, b, 0);
    strip.show();
  }
   if (c == 'p'){
         mySerial.print("p");
  strip.setPixelColor(2, 0, 0, 0);
    strip.show();
  }
   if (c == 'q'){
         mySerial.print("q");
  strip.setPixelColor(2, 0, b, 0);
    strip.show();
  }
   if (c == 'r'){
         mySerial.print("r");
  strip.setPixelColor(2, 0, 0, 0);
    strip.show();
  }
  }

    if (mySerial.available()) {
    char c = (char)mySerial.read();
   if (c == 'g'){
        Serial.print("g");
  strip.setPixelColor(0, b, 0, 0);
    strip.show();
  }
   if (c == 'h'){
        Serial.print("h");
  strip.setPixelColor(0, 0, 0, 0);
    strip.show();
  }
   if (c == 'i'){
        Serial.print("i");
  strip.setPixelColor(0, b, b, 0);
    strip.show();
  }
   if (c == 'j'){
        Serial.print("j");
  strip.setPixelColor(0, 0, 0, 0);
    strip.show();
  }
   if (c == 'k'){
        Serial.print("k");
  strip.setPixelColor(0, 0, b, 0);
    strip.show();
  }
   if (c == 'l'){
        Serial.print("l");
  strip.setPixelColor(0, 0, 0, 0);
    strip.show();
  }
  }


    btnstate1 = digitalRead(BUTTON1);
if(btnstate1 != prevstate1){
  if(btnstate1 ==1){
    if(num1 == 0){
      mySerial.print("a");
    Serial.print("a");
  strip.setPixelColor(1, b, 0, 0);
    strip.show();
        num1 ++;
  }
  else {
    mySerial.print("b");    
    Serial.print("b");
  strip.setPixelColor(1, 0, 0, 0);
    strip.show();
        num1 = 0;
  }
  }
  prevstate1 = btnstate1;
}

    btnstate2 = digitalRead(BUTTON2);
if(btnstate2 != prevstate2){
  if(btnstate2 ==1){
    if(num2 == 0){
      mySerial.print("c");
    Serial.print("c");
  strip.setPixelColor(1, b, b, 0);
    strip.show();
        num2 ++;
  }
  else {    
    mySerial.print("d");
    Serial.print("d");
  strip.setPixelColor(1, 0, 0, 0);
    strip.show();
        num2 = 0;
  }
  }
  prevstate2 = btnstate2;
}

btnstate3 = digitalRead(BUTTON3);
if(btnstate3 != prevstate3){
  if(btnstate3 ==1){
    if(num3 == 0){
      mySerial.print("e");
    Serial.print("e");
  strip.setPixelColor(1, 0, b, 0);
    strip.show();
        num3 ++;
  }
  else {    
    mySerial.print("f");
    Serial.print("f");
  strip.setPixelColor(1, 0, 0, 0);
    strip.show();
        num3 = 0;
  }
  }
  prevstate3 = btnstate3;
}
delay(10);
}

Slave part code (HardwareSerial)

#include <Adafruit_NeoPixel.h>

int BUTTON1 = 4;
int BUTTON2 = 5;
int BUTTON3 = 6;
int pot = A0;
int btnstate1;
int prevstate1 = 1;
int btnstate2;
int prevstate2 = 1;
int btnstate3;
int prevstate3 = 1;
int num1 = 0;
int num2 = 0;
int num3 = 0;
int lednum1 = 0;
int lednum2 = 0;
int lednum3 = 0;
int lednum4 = 0;
int lednum5 = 0;
int lednum6 = 0;

#define PIN 7
#define LEDNUM 3
Adafruit_NeoPixel strip = Adafruit_NeoPixel(LEDNUM, PIN, NEO_GRB + NEO_KHZ800);

void setup() {
  Serial.begin(9600);
  strip.begin();                           // 네오픽셀 제어시작
  strip.show();                            // 네오픽셀 초기화
  int reading = analogRead(pot);
  int b = map(reading,0,1024,1,150);
    strip.begin();    
  strip.setPixelColor(0, b, 0, 0);
  strip.show();     
  delay(400);
  strip.setPixelColor(1, b, b, 0);
  strip.show();     
  delay(400);
  strip.setPixelColor(2, 0, b, 0);
  strip.show();     
  delay(400);
  int k = 0;
  while(k < 4)
  {
    strip.setPixelColor(0, b, 0, 0);
    strip.setPixelColor(1, b, b, 0);
    strip.setPixelColor(2, 0, b, 0);
    strip.show();
    delay(200);
  strip.setPixelColor(0, 0, 0, 0);
  strip.setPixelColor(1, 0, 0, 0);
  strip.setPixelColor(2, 0, 0, 0);
  strip.show();
  delay(200);
  k++;
  }
}

void loop() {
int reading = analogRead(pot);
int b = map(reading,0,1024,1,150);

  if (Serial.available()) {
    char c = (char)Serial.read();
   if (c == 'a'){
  strip.setPixelColor(1, b, 0, 0);
    strip.show();
  }
   if (c == 'b'){
  strip.setPixelColor(1, 0, 0, 0);
    strip.show();
  }
   if (c == 'c'){
  strip.setPixelColor(1, b, b, 0);
    strip.show();
  }
   if (c == 'd'){
  strip.setPixelColor(1, 0, 0, 0);
    strip.show();
  }
   if (c == 'e'){
  strip.setPixelColor(1, 0, b, 0);
    strip.show();
  }
   if (c == 'f'){
  strip.setPixelColor(1, 0, 0, 0);
    strip.show();
  }
   if (c == 'g'){
  strip.setPixelColor(0, b, 0, 0);
    strip.show();
  }
   if (c == 'h'){
  strip.setPixelColor(0, 0, 0, 0);
    strip.show();
  }
   if (c == 'i'){
  strip.setPixelColor(0, b, b, 0);
    strip.show();
  }
   if (c == 'j'){
  strip.setPixelColor(0, 0, 0, 0);
    strip.show();
  }
   if (c == 'k'){
  strip.setPixelColor(0, 0, b, 0);
    strip.show();
  }
   if (c == 'l'){
  strip.setPixelColor(0, 0, 0, 0);
    strip.show();
  }
  }



    btnstate1 = digitalRead(BUTTON1);
if(btnstate1 != prevstate1){
  if(btnstate1 ==1){
    if(num1 == 0){
      Serial.print("m");
  strip.setPixelColor(2, b, 0, 0);
    strip.show();
        num1 ++;
  }
  else {
    Serial.print("n");    
  strip.setPixelColor(2, 0, 0, 0);
    strip.show();
        num1 = 0;
  }
  }
  prevstate1 = btnstate1;
}

    btnstate2 = digitalRead(BUTTON2);
if(btnstate2 != prevstate2){
  if(btnstate2 ==1){
    if(num2 == 0){
      Serial.print("o");
  strip.setPixelColor(2, b, b, 0);
    strip.show();
        num2 ++;
  }
  else {    
    Serial.print("p");
  strip.setPixelColor(2, 0, 0, 0);
    strip.show();
        num2 = 0;
  }
  }
  prevstate2 = btnstate2;
}

btnstate3 = digitalRead(BUTTON3);
if(btnstate3 != prevstate3){
  if(btnstate3 ==1){
    if(num3 == 0){
      Serial.print("q");
  strip.setPixelColor(2, 0, b, 0);
    strip.show();
        num3 ++;
  }
  else {    
    Serial.print("r");
  strip.setPixelColor(2, 0, 0, 0);
    strip.show();
        num3 = 0;
  }
  }
  prevstate3 = btnstate3;
}
delay(10);
}

Slave part code (SoftwareSerial)

#include <SoftwareSerial.h>
#include <Adafruit_NeoPixel.h>

SoftwareSerial mySerial(2, 3);
int BUTTON1 = 4;
int BUTTON2 = 5;
int BUTTON3 = 6;
int pot = A0;
int btnstate1;
int prevstate1 = 1;
int btnstate2;
int prevstate2 = 1;
int btnstate3;
int prevstate3 = 1;
int num1 = 0;
int num2 = 0;
int num3 = 0;
int lednum1 = 0;
int lednum2 = 0;
int lednum3 = 0;
int lednum4 = 0;
int lednum5 = 0;
int lednum6 = 0;

#define PIN 7
#define LEDNUM 3
Adafruit_NeoPixel strip = Adafruit_NeoPixel(LEDNUM, PIN, NEO_GRB + NEO_KHZ800);

void setup() {
  mySerial.begin(4800);
      strip.begin();                           // 네오픽셀 제어시작
  strip.show();                            // 네오픽셀 초기화
  int reading = analogRead(pot);
  int b = map(reading,0,1024,1,150);
    strip.begin();    
  strip.setPixelColor(0, b, 0, 0);
  strip.show();     
  delay(400);
  strip.setPixelColor(1, b, b, 0);
  strip.show();     
  delay(400);
  strip.setPixelColor(2, 0, b, 0);
  strip.show();     
  delay(400);
  int k = 0;
  while(k < 4)
  {
    strip.setPixelColor(0, b, 0, 0);
    strip.setPixelColor(1, b, b, 0);
    strip.setPixelColor(2, 0, b, 0);
    strip.show();
    delay(200);
  strip.setPixelColor(0, 0, 0, 0);
  strip.setPixelColor(1, 0, 0, 0);
  strip.setPixelColor(2, 0, 0, 0);
  strip.show();
  delay(200);
  k++;
  }
}

void loop() {
int reading = analogRead(pot);
int b = map(reading,0,1024,1,150);

  if (mySerial.available()) {
    char c = (char)mySerial.read();
   if (c == 'a'){
  strip.setPixelColor(1, b, 0, 0);
    strip.show();
  }
   if (c == 'b'){
  strip.setPixelColor(1, 0, 0, 0);
    strip.show();
  }
   if (c == 'c'){
  strip.setPixelColor(1, b, b, 0);
    strip.show();
  }
   if (c == 'd'){
  strip.setPixelColor(1, 0, 0, 0);
    strip.show();
  }
   if (c == 'e'){
  strip.setPixelColor(1, 0, b, 0);
    strip.show();
  }
   if (c == 'f'){
  strip.setPixelColor(1, 0, 0, 0);
    strip.show();
  }
   if (c == 'm'){
  strip.setPixelColor(2, b, 0, 0);
    strip.show();
  }
   if (c == 'n'){
  strip.setPixelColor(2, 0, 0, 0);
    strip.show();
  }
   if (c == 'o'){
  strip.setPixelColor(2, b, b, 0);
    strip.show();
  }
   if (c == 'p'){
  strip.setPixelColor(2, 0, 0, 0);
    strip.show();
  }
   if (c == 'q'){
  strip.setPixelColor(2, 0, b, 0);
    strip.show();
  }
   if (c == 'r'){
  strip.setPixelColor(2, 0, 0, 0);
    strip.show();
  }
  }

    btnstate1 = digitalRead(BUTTON1);
if(btnstate1 != prevstate1){
  if(btnstate1 ==1){
    if(num1 == 0){
      mySerial.print("g");
  strip.setPixelColor(0, b, 0, 0);
    strip.show();
        num1 ++;
  }
  else {
    mySerial.print("h");    
  strip.setPixelColor(0, 0, 0, 0);
    strip.show();
        num1 = 0;
  }
  }
  prevstate1 = btnstate1;
}

    btnstate2 = digitalRead(BUTTON2);
if(btnstate2 != prevstate2){
  if(btnstate2 ==1){
    if(num2 == 0){
      mySerial.print("i");
  strip.setPixelColor(0, b, b, 0);
    strip.show();
        num2 ++;
  }
  else {    
    mySerial.print("j");
  strip.setPixelColor(0, 0, 0, 0);
    strip.show();
        num2 = 0;
  }
  }
  prevstate2 = btnstate2;
}

btnstate3 = digitalRead(BUTTON3);
if(btnstate3 != prevstate3){
  if(btnstate3 ==1){
    if(num3 == 0){
      mySerial.print("k");
  strip.setPixelColor(0, 0, b, 0);
    strip.show();
        num3 ++;
  }
  else {    
    mySerial.print("l");
  strip.setPixelColor(0, 0, 0, 0);
    strip.show();
        num3 = 0;
  }
  }
  prevstate3 = btnstate3;
}
delay(10);
}

//TRIG, ECHO PIN 정의//

const int TRIG = 2;
const int ECHO = 3;                  

//평균 이동 필터의 Buffer Size 정의//

//변수 정의//
float duration;

void setup(){

  Serial.begin(9600);       //시리얼 통신 설정
  Serial.flush();         //시리얼 통신 후 다시 시리얼 통신을 시작할 때, 들어오거나 남아있던 값을 제거

  //핀 모드 설정

  pinMode(TRIG,OUTPUT);     
  pinMode(ECHO,INPUT);
  digitalWrite(TRIG,LOW);
}

void loop(){

  digitalWrite(TRIG, HIGH);
  delayMicroseconds(10);
  digitalWrite(TRIG, LOW);

  duration = pulseIn(ECHO, HIGH);

  Serial.println(duration);

  delay(1000);
}

Python code

# pip install pySerial
import serial

arduino = serial.Serial('COM8', 9600)

class Student():
    def __init__(self):
        self.z=2
        print("z init as :", self.z)

a = list()

duration = 0
distance = 0

cm_distance = 0
new_cm_distance = 0

pre_distance = 0

sum_of_buffer = 0

new_duration = 0

alpha = 0.3
beta = 0.01

cnt = 0
s = 1  # 0.1

cnt_hit = 0
h = 1  # 0.1

outCount = 0

human_sig = False

for i in range(10):

    duration = float(arduino.readline().decode()[:-1])
    cm_distance = ((duration * 340) / 10000) / 2
    a.append(cm_distance)

    if cm_distance > 280:
        cm_distance = 280
    elif cm_distance < 2:
        cm_distance = 2

    sum_of_buffer += a[i]

pre_distance = sum_of_buffer / len(a)

while 1:
    new_duration = float(arduino.readline().decode()[:-1])
    new_cm_distance = ((new_duration * 340) / 10000) / 2

    if new_cm_distance < 190:
        distance = alpha * pre_distance + (1-alpha) * new_cm_distance

    elif new_cm_distance < 280:
        distance = (1-alpha) * pre_distance + alpha * new_cm_distance
    else:
        distance = (1-beta) * pre_distance + beta * new_cm_distance

    if distance > 280:
        distance = 280
    elif distance < 2:
        distance = 2

    print("distance(cm) :", int(distance), end=' ')

    cnt += s

    times = 100000 - cnt * 930  # 300000 - cnt * 930

    print("Sample Number :", cnt, end=' ')

    if distance <= 150:
        cnt_hit += h

    print("Human Cnt_Number :", cnt_hit, end=' ')

    if cnt_hit < 16.10:
        if times <= 60000:  #120000
            # delay(120000) 고정된 2분
            cnt = 0
            # 시간을 뽑아 실시간 기록하거나 찾을 필요없이 현회차와 전회차 비교해서 오차 확인 가능
            cnt_hit = 0
            times = 0
            outCount += 1
    else:
        human_sig = True
        print("Human_Signal :", human_sig)
        # delay(times) 측정되는 3분 중에 남는 시간 + 2분
        human_sig = False
        cnt = 0
        # 시간을 뽑아 엑셀이든 txt파일 데이터가 실시간으로 밀리지 않는지 확인하지 위해서
        cnt_hit = 0
        times = 0
        outCount = 0

    pre_distance = distance
    print("outCount :", outCount)
    # outCount 18cycle일때 경고 메세지, 24cycle일땐 out
    # 가방이나 물건 올려놨을때 움직임 없을때 확인하는 로직 현회차와 전회차 비교해서 오차 확인 가능
    # 실시간 실내/실외 온도나 습도에 따른 파라메타 변화 적용 or not

20210707 Ver2.5

Arduino IDE code

const int ECHO1=13;        // mini_size 3
const int TRIG1=12;     // mini_size 2
const int ECHO2=9;         // mini_size 5
const int TRIG2=8;         // mini_size 4
const int ECHO3=3;         // mini_size 7
const int TRIG3=2;         // mini_size 6

#define SIZE 20         // Buffer of setting Moving average filter
#define DIST 280*58.8     // mini_size 50*58.8

int buffer1[SIZE];
int buffer2[SIZE];
int buffer3[SIZE];

const int maxdist = 280;    //mini_size 50
const int mindist = 2;        //mini_size 2
double kalman1(double U1);
double kalman2(double U2);
double kalman3(double U3);        

double tmp1 = 200;    //tmp_value for invalid, mini_size 32
double tmp2 = 200;    //tmp_value for invalid, mini_size 32
double tmp3 = 200;    //tmp_value for invalid, mini_size 32

long Cm1, Cm2, Cm3;
long duration1, duration2, duration3;

float sum1 = 0;
float sum2 = 0;
float sum3 = 0;
float distance1, distance2, distance3;

char ch;

double kalman1(double U1){
  static const double R1 = 40;
  static const double H1 = 1.00;
  static double Q1 = 10;
  static double P1 = 0;
  static double U_hat1 = 170;    // mini_size 20
  static double K1 = 0;
  K1 = P1*H1/(H1*P1*H1+R1);
  U_hat1 += + K1*(U1-H1*U_hat1);
  P1 = (1-K1*H1)*P1+Q1;
  return U_hat1;
}

double kalman2(double U2){
  static const double R2 = 40;
  static const double H2 = 1.00;
  static double Q2 = 10;
  static double P2 = 0;
  static double U_hat2 = 170;    // mini_size 20
  static double K2 = 0;
  K2 = P2*H2/(H2*P2*H2+R2);
  U_hat2 += + K2*(U2-H2*U_hat2);
  P2 = (1-K2*H2)*P2+Q2;
  return U_hat2;
}

double kalman3(double U3){
  static const double R3 = 40;
  static const double H3 = 1.00;
  static double Q3 = 10;
  static double P3 = 0;
  static double U_hat3 = 170;    // mini_size 20
  static double K3 = 0;
  K3 = P3*H3/(H3*P3*H3+R3);
  U_hat3 += + K3*(U3-H3*U_hat3);
  P3 = (1-K3*H3)*P3+Q3;
  return U_hat3;
}

void setup() {
  Serial.begin(9600);
  Serial.flush();
  pinMode(TRIG1,OUTPUT);
  pinMode(ECHO1,INPUT);
  digitalWrite(TRIG1,LOW);
  pinMode(TRIG2,OUTPUT);
  pinMode(ECHO2,INPUT);
  digitalWrite(TRIG2,LOW);
  pinMode(TRIG3,OUTPUT);
  pinMode(ECHO3,INPUT);
  digitalWrite(TRIG3,LOW);

  for(int i=0; i<=SIZE-1; i++)
  {
    digitalWrite(TRIG1,HIGH);
    delayMicroseconds(10);
    digitalWrite(TRIG1,LOW);
    duration1=pulseIn(ECHO1,HIGH);
    Cm1=duration1*0.034/2;
    if(Cm1>maxdist) Cm1=maxdist;
    else if(Cm1<mindist) Cm1=mindist;
    buffer1[i]=Cm1;
    sum1+=buffer1[i];
  }
  for(int i=0; i<=SIZE-1; i++)
  {
    digitalWrite(TRIG2,HIGH);
    delayMicroseconds(10);
    digitalWrite(TRIG2,LOW);
    duration2=pulseIn(ECHO2,HIGH);
    Cm2=duration2*0.034/2;
    if(Cm2>maxdist) Cm2=maxdist;
    else if(Cm2<mindist) Cm2=mindist;
    buffer2[i]=Cm2;
    sum2+=buffer2[i];
  }
  for(int i=0; i<=SIZE-1; i++)
  {
    digitalWrite(TRIG3,HIGH);
    delayMicroseconds(10);
    digitalWrite(TRIG3,LOW);
    duration3=pulseIn(ECHO3,HIGH);
    Cm3=duration3*0.034/2;
    if(Cm3>maxdist) Cm3=maxdist;
    else if(Cm3<mindist) Cm3=mindist;
    buffer3[i]=Cm3;
    sum3+=buffer3[i];
  }
  Serial.flush();
}

void loop() {
  if(Serial.available() >0){
    ch = Serial.read();
    if(ch == 'a') delay(1000);    // Break time
  }

  digitalWrite(TRIG1,HIGH);
  delayMicroseconds(10);
  digitalWrite(TRIG1,LOW);
  duration1=pulseIn(ECHO1,HIGH, DIST); // invaild value(280cm 이상) 1차 예외처리(timeout 조절)
  Cm1=duration1*0.034/2;

  if(Cm1==0) Cm1 = tmp1;  // 1차 예외처리 된 data 직전 typical data 사용
  else{
    if(Cm1>maxdist) Cm1=maxdist;  // extreme case 2차 예외처리(distance limiting)
    else if(Cm1<mindist) Cm1=mindist;
    tmp1 = Cm1;
  }

  sum1-=buffer1[0];
  for(int i=0; i<SIZE-1; i++)
  {
    buffer1[i]=buffer1[i+1];
  }
  buffer1[SIZE-1]=Cm1;
  sum1+=buffer1[SIZE-1];

  if(Cm1 > 150){    // mini_size 22
    distance1=sum1/SIZE;    // Moving average filtered distance 사용
  }
  else{
    distance1 = kalman1(Cm1);    // Kalman filtered distance 사용
  }

  delay(50);
  /////////////////////////////////////////////////////////////////////////////////////
  digitalWrite(TRIG2,HIGH);
  delayMicroseconds(10);
  digitalWrite(TRIG2,LOW);
  duration2=pulseIn(ECHO2,HIGH,DIST); // invaild value(280cm 이상) 1차 예외처리(timeout 조절)
  Cm2=duration2*0.034/2;

  if(Cm2==0) Cm2 = tmp2;  // 1차 예외처리 된 data 직전 typical data 사용
  else{
    if(Cm2>maxdist) Cm2=maxdist;  // extreme case 2차 예외처리(distance limiting)
    else if(Cm2<mindist) Cm2=mindist;
    tmp2 = Cm2;
  }

  sum2-=buffer2[0];
  for(int i=0; i<SIZE-1; i++)
  {
    buffer2[i]=buffer2[i+1];
  }
  buffer2[SIZE-1]=Cm2;
  sum2+=buffer2[SIZE-1];  

  if(Cm2 > 150){    // mini_size 22
    distance2=sum2/SIZE;    // Moving average filtered distance 사용
  }
  else{
    distance2 = kalman2(Cm2);    // Kalman filtered distance 사용
  }

  delay(50);
  ///////////////////////////////////////////////////////////////////////////////
  digitalWrite(TRIG3,HIGH);
  delayMicroseconds(10);
  digitalWrite(TRIG3,LOW);
  duration3=pulseIn(ECHO3,HIGH, DIST); // invaild value(280cm 이상) 1차 예외처리(timeout 조절)
  Cm3=duration3*0.034/2;

  if(Cm3==0) Cm3 = tmp3;  // 1차 예외처리 된 data 직전 typical data 사용
  else{
    if(Cm3>maxdist) Cm3=maxdist;  // extreme case 2차 예외처리(distance limiting)
    else if(Cm3<mindist) Cm3=mindist;
    tmp3 = Cm3;
  }

  sum3-=buffer3[0];
  for(int i=0; i<SIZE-1; i++)
  {
    buffer3[i]=buffer3[i+1];
  }
  buffer3[SIZE-1]=Cm3;
  sum3+=buffer3[SIZE-1];  

  if(Cm3 > 150){    // mini_size 22
    distance3=sum3/SIZE;    // Moving average filtered distance 사용
  }
  else{  // 3차 칼만필터 filtering 구간
    distance3 = kalman3(Cm3);    // Kalman filtered distance 사용
  }

  delay(50);

  //Serial.print(distance1); Serial.print(" "); Serial.println(Cm1);// Serial.print(" "); Serial.println(distance3);
  Serial.print(distance1); Serial.print(' '); Serial.print(distance2); Serial.print(' '); Serial.println(distance3);

  delay(50);
}

Python code (Server)

import serial
import time

select_comport = input('select port:')

arduino = serial.Serial(select_comport, 9600)

sample_cnt = 200
human_exist_dist = 150  # 22
yellow_card = 45
red_card = 60
sec = 1
line_list = list()
desk_list = list()
full_cycle_time = 60

with open("number_of_student.txt", "r") as f:
    line_tmp = f.readlines()
    max_desk_cnt = len(line_tmp)

cnt = max_desk_cnt * sample_cnt


class Desk:
    def __init__(self):
        self.distance = 0
        self.hit_cnt = 0
        self.out_cnt = 0
        self.flag = False
        self.stu_phone = ""

    def print_desk_info(self):
        print(self.stu_phone, "(Dist:", int(self.distance), "Hit:", self.hit_cnt, "Out:", self.out_cnt, end=')\t\t\t\t')


def read_distance():
    if arduino.readable():
        try:
            tmp_distance = arduino.readline().decode().split(' ')
            tmp_distance = [float(e) for e in tmp_distance]
            for m in range(max_desk_cnt - len(tmp_distance)):
                tmp_distance.append(0)
            return tmp_distance
        except ValueError:
            return [0]

# Initialize
for i in range(max_desk_cnt):
    desk_list.append(Desk())

first_time = time.time()  # real time checking

# Loop
while True:
    try:
        # 실시간으로 number_of_student value 들이 kiosk 에 의해 변했는지 확인
        with open("number_of_student.txt", "r") as f:
            line_list = f.readlines()
        for i in range(len(line_list)):
            temp = desk_list[i]
            temp.stu_phone = line_list[i][:-1]
            if temp.stu_phone == "0":  # 학생 번호가 있어야하는 위치에 0이 있으면 객체 데이터 초기화
                temp.flag = False
                temp.out_cnt = 0
                temp.hit_cnt = 0
            else:  # 학생 번호가 입장되었으면 flag value on (distance 에 따른 logic 실행)
                temp.flag = True

        dist_list = read_distance()  # 아두이노를 통해 들어온 데이터 1차 정제

        if len(dist_list) == max_desk_cnt:
            for i in range(max_desk_cnt):  # 각 센서의 데이터별로 처리 시작
                tmp_desk = desk_list[i]
                tmp_desk.distance = dist_list[i]

                cnt -= sec
                print(cnt, end=': ')
                if cnt == -sec:

                    cnt = max_desk_cnt * sample_cnt  # break time 이후 cnt 값 초기화
                    cycle_time = time.time() - first_time
                    print("BREAK")
                    if cycle_time < full_cycle_time:
                        time.sleep(full_cycle_time - cycle_time)
                    arduino.read_all()
                    with open("data_list.txt", "a") as f:  # cycle time 기록
                        f.write(str(cycle_time) + ";")
                        for j in desk_list:
                            f.write(str(j.hit_cnt) + ";")
                        f.write("\n")
                    for j in desk_list:  # break time 이후 cnt_hit 초기화
                        j.hit_cnt = 0
                    first_time = time.time()
                    break

                if tmp_desk.flag == True:  # flag 가 1일때, 즉 사람이 입장했을때 실행
                    if 0 < tmp_desk.distance <= human_exist_dist:  # 사람이 있다는 거리
                        tmp_desk.hit_cnt += sec
                    if cnt < max_desk_cnt:  # break 전 마지막 루프에서 cnt_hit 값에 따른 결과 처리
                        if tmp_desk.hit_cnt <= sample_cnt * 0.2:  # sensing time 의 20%, 사람이 일정이상 앉아 있지 않을 때
                            tmp_desk.out_cnt += 1
                            if tmp_desk.out_cnt == red_card:  # 퇴장 처리
                                with open("sign_list.txt", "a") as f:  # 퇴장 메세지 전송
                                    f.write(tmp_desk.stu_phone + "Red" + "\n")
                                with open("out_student.txt", "a") as f:  # kiosk 에게 퇴장한 사람 데이터 전송
                                    out_student_list = [str(i), "'", tmp_desk.stu_phone, "'", str(time.time()), "'",
                                                        str(time.strftime('%c', time.localtime(time.time()))), "\n"]
                                    f.writelines(out_student_list)
                                line_list[i] = "0\n"  # number_of_student 에서 받아들였던 데이터 수정
                                with open("number_of_student.txt", "w") as f:  # 수정된 number_of_student 데이터 전송
                                    for line in line_list:
                                        f.write(line)
                                tmp_desk.stu_phone = "0"  # 객체 데이터 수정
                                tmp_desk.flag = False
                                tmp_desk.out_cnt = 0
                                tmp_desk.hit_cnt = 0
                            elif tmp_desk.out_cnt == yellow_card:  # 경고 처리
                                with open("sign_list.txt", "a") as f:  # 경고 메세지 전송
                                    f.write(tmp_desk.stu_phone + "Yellow" + '\n')
                        else:   # 사람이 일정이상 앉아 있을 때
                            tmp_desk.out_cnt = 0
                tmp_desk.print_desk_info()
            print()
    except IOError:
        pass

Python code (Kiosk)

import os
import time
from openpyxl import load_workbook

data_list = list()

with open("number_of_student.txt", "r") as f:
    line_ori = f.readlines()
num_of_data = len(line_ori)


def read_data():
    with open("number_of_student.txt", "r") as p:
        line_ori_tmp = p.readlines()
    line_tmp = [line_ori_tmp[x][:-1] for x in range(num_of_data)]

    with open("out_student.txt", "r") as s:
        line_stu = s.readlines()
    if line_stu != "":
        for x in range(len(line_stu)):
            line_stu_tmp = line_stu[x].split("'")
            for data_tmp in data_list:
                if (data_tmp[0] == int(line_stu_tmp[0])) & (data_tmp[1] == line_stu_tmp[1]):
                    data_tmp[2] = int(-(float(line_stu_tmp[2]) - data_tmp[2]))
                    data_tmp.append(line_stu_tmp[3][:-1])
                    print(data_tmp)  # 엑셀에 프린트

                    wb_tmp = load_workbook('using_list.xlsx')
                    ws_tmp = wb_tmp['Sheet1']
                    ws_tmp.append(data_tmp)
                    wb_tmp.save('using_list.xlsx')

                    data_list.remove(data_tmp)
        with open("out_student.txt", "w") as s:
            s.write("")
    return line_tmp


while True:
    enter_or_exit = input("입장 / 퇴장 : ")
    line = read_data()
    if enter_or_exit == "입장":
        print("사용 가능한 좌석 : ")
        for i in range(num_of_data):
            if line[i] == '0':
                print(i+1, "번", end=" ")
        print()
        num_sit = input("입장할 좌석번호 / 나가기(0) : ")[:1]
        line = read_data()
        if num_sit.isnumeric() == 1:
            num_sit = int(num_sit) - 1
            if 0 <= num_sit < num_of_data:
                if line[num_sit] == '0':
                    num_student = input("사용자의 핸드폰 번호 : ")
                    line = read_data()
                    line[num_sit] = num_student
                    if (len(num_student) == 11) & (num_student.isnumeric() == 1) & (num_student[:2] == "01"):
                        data_list.append([num_sit, num_student, time.time(), time.strftime('%c', time.localtime(time.time()))])
                        with open("number_of_student.txt", "w") as f:
                            for j in range(num_of_data):
                                f.write(line[j]+'\n')
                        print("회원님의 자리는", num_sit + 1, "번 입니다.")
                    else:
                        print("잘못된 입력입니다.")
                else:
                    print("잘못된 좌석을 지정하였습니다.")
            else:
                print("잘못된 좌석을 지정하였습니다.")
        else:
            print("잘못된 좌석을 지정하였습니다.")
        print("메인화면으로 돌아갑니다.")
        input("아무버튼이나 눌러주세요.")
        os.system('cls')
    elif enter_or_exit == "퇴장":
        num_sit = input("퇴장할 좌석번호 / 나가기(0) : ")[:1]
        line = read_data()
        if num_sit.isnumeric() == 1:
            num_sit = int(num_sit) - 1
            if 0 <= num_sit < num_of_data:
                if line[num_sit] != '0':
                    num_student = input("사용자의 핸드폰 번호 : ")
                    if (len(num_student) == 11) & (num_student.isnumeric() == 1):
                        with open("number_of_student.txt", "r") as f:
                            line_ori = f.readlines()
                        line = [line_ori[x][:-1] for x in range(num_of_data)]
                        for data in data_list:
                            if (num_sit == data[0]) & (num_student == data[1]):
                                data[2] = int(time.time() - data[2])
                                # data[2] = data[2] // 60
                                data.append(time.strftime('%c', time.localtime(time.time())))
                                line_ori[num_sit] = "0\n"
                                with open("number_of_student.txt", "w") as f:
                                    for j in line_ori:
                                        f.write(j)
                                print(data)  # 엑셀에 프린트
                                wb = load_workbook('using_list.xlsx')
                                ws = wb['Sheet1']
                                ws.append(data)
                                wb.save('using_list.xlsx')
                                data_list.remove(data)
                                print(num_sit + 1, "번 자리가 퇴장처리 되었습니다. 이용해주셔서 감사합니다.")
                                break
                        else:
                            print("올바르지 않은 번호입니다.")
                    else:
                        print("잘못된 입력입니다.")
                else:
                    print("잘못된 좌석을 지정하였습니다.")
        else:
            print("잘못된 좌석을 지정하였습니다.")
        print("메인화면으로 돌아갑니다.")
        input("아무버튼이나 눌러주세요.")
        os.system('cls')
    else:
        print("잘못된 입력입니다.")
        print("메인화면으로 돌아갑니다.")
        input("아무버튼이나 눌러주세요.")
        os.system('cls')

Python code (Message)

import requests
import time

while 1:
    try:
        with open("sign_list.txt", "r") as f:
            signs = f.readlines()
            num_of_sign = len(signs)
        for i in range(num_of_sign):
            a = signs[i][:11] + " 고객님께 보내는 알림입니다.\n"
            if signs[i][11:-1] == "Yellow":
                b = "경고 알림: 15분 동안 자리를 비우셨습니다.\n25분 동안 자리를 비울시 퇴장 처리됩니다."
            else:
                b = "퇴장 알림: 25동안 자리를 비우셨습니다.\n좌석이 퇴장 처리됩니다."
            try:
                TARGET_URL = 'https://notify-api.line.me/api/notify'
                TOKEN = 'i8DYbNCp5k6B6m7QP4kfiLYzvJZNzQX27cMwd5E8Jo5'  # 발급받은 토큰
                headers = {'Authorization': 'Bearer ' + TOKEN}
                data = {'message': a+b}

                response = requests.post(TARGET_URL, headers=headers, data=data)
            except Exception as ex:
                print(ex)
        if num_of_sign != 0:
            with open("sign_list.txt", "w") as f:
                f.write("")
    except IOError:
        pass
    time.sleep(1)

1. 로그인 (1) 관리자 모드

    - 책 추가 (Input : 책 제목, 출판사, 종류)
    - 책 삭제 (Input : 책 제목)
    - 사용자들의 대출 리스트 (Output : 사용자 이름, 전공, 학번, 대출날짜)
    - 책 검색 (Input : 책 제목 / Output : 출판사, 종류, 코드, 대출여부)
    - 전체 책 목록 (Output : 책 제목, 출판사, 종류, 코드, 대출여부)

   (2) 사용자 모드

    - 책 대출 (Input : 책 제목, 코드)
    - 책 반납 (Input : 책 제목, 코드)
    - 나의 대출 리스트 (Output : 책 제목, 코드, 대출날짜)
    - 책 검색 (Input : 책 제목 / Output : 출판사, 종류, 코드, 대출여부)
    - 전체 책 목록 (Output : 책 제목, 출판사, 종류, 코드, 대출여부)

2. 사용자 추가

   • 사용자 입력 (Input : 이름, 전공, 학번)

3. 사용자 삭제

   • 사용자 삭제 (Input : 이름)

     //Rent.h
     #pragma once
     #include <string>
     #include <time.h>  
     #include <iostream>
     using namespace std;
     

struct Rent{ char BookKind; int BookCode; int Personid; int startDay; //int useDay; };

//Person.h #pragma once #include #include #define pMax 10 using namespace std;

class Person { private: int id; string major; string PersonName; public: Person(string PersonName = "아무개", int id = 0, string major = "noname"); int getId(); void setId(int id); string getMajor(); void setMajor(string major); string getPersonName(); void setPersonName(string PersonName); };

//Person.cpp #include "Person.h"

Person::Person(string PersonName, int id , string major ) : id(id), major(major), PersonName(PersonName) {};

int Person::getId() { return id; }

void Person::setId(int id) { this->id = id; }

string Person::getMajor() { return major; }

void Person::setMajor(string major) { this->major = major; }

string Person::getPersonName() { return PersonName; }

void Person::setPersonName(string PersonName) { this->PersonName = PersonName; }

//PersonManage.h #pragma once #include "Person.h" #include "RentBookList.h"

class PersonManage { private: Person *PersonArray[pMax]; public: int PersonCnt; PersonManage();

Person** getPersonArray();    
PersonManage & operator=(const PersonManage &r);    
Person* findPerson(int id);
bool addPerson(Person* ap);
bool deletePerson(string PersonName);    
// friend int RentBookList::getPersonId(Person &rp);

};

//PersonManage.cpp #include "PersonManage.h" #include using namespace std;

PersonManage::PersonManage() : PersonCnt(0) { PersonArray[pMax] = { NULL, }; };

Person** PersonManage::getPersonArray() { return PersonArray; }

PersonManage& PersonManage::operator=(const PersonManage &r) { if (this == &r) return *this; for (int i = 0; i < this->PersonCnt; i++) { delete this->getPersonArray()[i]; } this->PersonCnt = r.PersonCnt; return *this; }

Person* PersonManage::findPerson(int id) { for (int i = 0; i < PersonCnt; i++) { if (PersonArray[i]->getId() == id) return PersonArray[i]; } return NULL; }

bool PersonManage::addPerson(Person *ap) //등록 성공 - 1, 등록 실패 - 0 리턴 { if (PersonCnt > pMax) return false; else {
for (int i = 0; i < PersonCnt; i++) { if (PersonArray[i]->getId() == ap->getId()) { cout << "해당 학번은 이미 존재합니다." << endl; return false; } } PersonArray[PersonCnt] = new Person(ap->getPersonName(),ap->getId(), ap->getMajor()); PersonCnt++; return true; } }

bool PersonManage::deletePerson(string PersonName) // 삭제 성공 - true, 삭제 실패 - false 리턴 { int i; int j; int index = -1; char ch;

if (PersonCnt == 0)
    return false;

for (i = 0; i < PersonCnt; i++)
    if (PersonArray[i]->getPersonName() == PersonName)
        index = i;

if (index != -1) {
    i = index;
    cout << "정말 삭제하시겠습니까?(Y/N) : ";
    cin >> ch;
    if (ch == 'y' || ch == 'Y') {
        delete PersonArray[i];
        for (j = i; j < PersonCnt - 1; j++) {
            PersonArray[i] = PersonArray[i + 1];
        }
        PersonCnt--;
        return true;
    }
    else
        return false;
}
return false;

}

//Book.h #pragma once #include #include using namespace std;

class Book { private: string BookName; string CpyName; public: Book(); Book(string BookName, string CpyName);

string getBookName();
void setBookName(string BookName);
string getCpyName();
void setCpyName(string CpyName);

virtual void infoView() = 0;
virtual bool getflag() = 0;
virtual void setflag(bool num) = 0;

};

//Book.cpp #include #include using namespace std; #include "Book.h"

Book::Book() :BookName(""), CpyName("") {} Book::Book(string BookName, string CpyName) : BookName(BookName), CpyName(CpyName) {}

string Book::getBookName() { return BookName; } void Book::setBookName(string BookName) { this->BookName = BookName; } string Book::getCpyName() { return CpyName; } void Book::setCpyName(string CpyName) { this->CpyName = CpyName; }

//Novel.h #pragma once #include "Book.h"

class Novel : public Book { char BookKind; int BookCode; bool flag = false; public: static int NovelNum; Novel(); Novel(string BookName, string CpyName, char kind); char getBookKind(); void setBookKind(char kind); int getBookCode(); void setBookCode(int Code); void infoView(); void setflag(bool num); bool getflag(); };

//Novel.cpp #include #include using namespace std; #include "Novel.h"

int Novel::NovelNum = 1;

Novel::Novel() : Book("",""), BookKind(0) {} Novel::Novel(string BookName, string CpyName, char kind) : Book(BookName, CpyName), BookKind(kind) { BookCode = NovelNum; NovelNum++; } char Novel::getBookKind() { return BookKind; } void Novel::setBookKind(char kind) { BookKind = kind; } int Novel::getBookCode() { return BookCode; } void Novel::setBookCode(int Code) { BookCode = Code; }

void Novel::infoView() { cout << "책제목 : " << this->getBookName() << " " << "출판사 : " << this->getCpyName() << " " << "책종류 : 소설 " << " " << "책코드 : " << this->BookKind << this->BookCode; if (this->flag == true) cout << " (대출중...)"; cout << endl; }

void Novel::setflag(bool num) { this->flag = num; } bool Novel::getflag() { return flag; }

//Comic.h #pragma once #include "Book.h"

class Comic : public Book { char BookKind; int BookCode; bool flag = false; public: static int ComicNum; Comic(); Comic(string BookName, string CpyName, char kind); char getBookKind(); void setBookKind(char kind); int getBookCode(); void setBookCode(int Code); void infoView(); void setflag(bool num); bool getflag(); };

//Comic.cpp #include #include using namespace std; #include "Comic.h"

int Comic::ComicNum = 1;

Comic::Comic() : Book("", ""), BookKind(0) {} Comic::Comic(string BookName, string CpyName, char kind) : Book(BookName, CpyName), BookKind(kind) { BookCode = ComicNum; ComicNum++; } char Comic::getBookKind() { return BookKind; } void Comic::setBookKind(char kind) { BookKind = kind; } int Comic::getBookCode() { return BookCode; } void Comic::setBookCode(int Code) { BookCode = Code; } void Comic::infoView() { cout << "책제목 : " << this->getBookName() << " " << "출판사 : " << this->getCpyName() << " " << "책종류 : 만화 " << " " << "책코드 : " << this->BookKind << this->BookCode; if (this->flag == true) cout << " (대출중...)"; cout << endl; }

void Comic::setflag(bool num) { this->flag = num; } bool Comic::getflag() { return flag; }

//MajorBook.h #pragma once #include "Book.h"

class MajorBook : public Book { char BookKind; int BookCode; bool flag = false; public: static int MajorNum; MajorBook(); MajorBook(string BookName, string CpyName, char kind); char getBookKind(); void setBookKind(char kind); int getBookCode(); void setBookCode(int Code); void infoView(); void setflag(bool num); bool getflag(); };

//MajorBook.cpp #include #include using namespace std; #include "MajorBook.h"

int MajorBook::MajorNum = 1;

MajorBook::MajorBook() : Book("", ""), BookKind(0) {} MajorBook::MajorBook(string BookName, string CpyName, char kind) : Book(BookName, CpyName), BookKind(kind) { BookCode = MajorNum; MajorNum++; } char MajorBook::getBookKind() { return BookKind; } void MajorBook::setBookKind(char kind) { BookKind = kind; } int MajorBook::getBookCode() { return BookCode; } void MajorBook::setBookCode(int Code) { BookCode = Code; } void MajorBook::infoView() { cout << "책제목 : " << this->getBookName() << " " << "출판사 : " << this->getCpyName() << " " << "책종류 : 전공서적 " << " " << "책코드 : " << this->BookKind << this->BookCode; if (this->flag == true) cout << " (대출중...)"; cout << endl;

}

void MajorBook::setflag(bool num) { this->flag = num; } bool MajorBook::getflag() { return flag; }

//BookManage.h #pragma once #include "Book.h" #include "Novel.h" #include "MajorBook.h" #include "Comic.h" #include <stdlib.h> #include "RentBookList.h" #include using namespace std; #define bMax 10

class BookManage { private: Book* BookArray[bMax]; RentBookList List; public: int BookCnt; BookManage(); ~BookManage(); BookManage (const BookManage &r); Book** getBookArray(); BookManage & operator=(const BookManage &r); RentBookList &getRentBookList(); void printBook(); bool addBook(Book * ap); bool deleteBook(string BookName); Book *findBook(char BookKind, int BookCode); };

//BookManage.cpp #include #include "BookManage.h"

BookManage::BookManage() { for (int i = 0; i < bMax; i++) { this->BookArray[i] = NULL; } BookCnt = 0; } BookManage::~BookManage() { for (int i = 0; i < bMax; i++) { delete[] this->BookArray[i]; } }

BookManage::BookManage(const BookManage &r) { int i; this->BookCnt = r.BookCnt; for (i = 0; i < this->BookCnt; i++) { if (dynamic_cast<Novel >(r.BookArray[i]) != NULL) { this->BookArray[i] = new Novel((dynamic_cast<Novel >(r.BookArray[i]))); } else if (dynamic_cast<MajorBook *>(r.BookArray[i]) != NULL) { this->BookArray[i] = new MajorBook((dynamic_cast<MajorBook >(r.BookArray[i]))); } else if (dynamic_cast<Comic *>(r.BookArray[i]) != NULL) { this->BookArray[i] = new Comic((dynamic_cast<Comic *>(r.BookArray[i]))); } } }

Book** BookManage::getBookArray() { return this->BookArray; }

BookManage & BookManage::operator=(const BookManage &r) { int i;

if (this == &r) {
    return *this;
}

this->BookCnt = r.BookCnt;

for (i = 0; i < this->BookCnt; i++)
{
    delete this->BookArray[i];
}

for (i = 0; i < this->BookCnt; i++) {
    if (dynamic_cast<Novel *>(r.BookArray[i]) != NULL) {
        this->BookArray[i] = new Novel(*(dynamic_cast<Novel *>(r.BookArray[i])));
    }
    else if (dynamic_cast<MajorBook *>(r.BookArray[i]) != NULL) {
        this->BookArray[i] = new MajorBook(*(dynamic_cast<MajorBook *>(r.BookArray[i])));
    }
    else if (dynamic_cast<Comic *>(r.BookArray[i]) != NULL) {
        this->BookArray[i] = new Comic(*(dynamic_cast<Comic *>(r.BookArray[i])));
    }

}
return *this;

}

void BookManage::printBook() { for (int i = 0; i < this->BookCnt; i++) { this->BookArray[i]->infoView(); } }

bool BookManage::addBook(Book * ap) {
if (this->BookCnt < bMax) { this->BookArray[this->BookCnt] = ap; this->BookCnt++; return true; } return false; } bool BookManage::deleteBook(string BookName) { int i, res; char YorN;

res = -1;

for (int i = 0; i < this->BookCnt; i++) {
    if (this->BookArray[i]->getBookName() == BookName) {
        res = i;
    }
}

if (res == -1) {
    return false;
}

else {
    cout << "** 정말로 삭제하겠습니까?(y/n) : ";
    cin >> YorN;
    if (YorN == 'y' || YorN == 'Y') {
        delete this->BookArray[res];

        for (i = res; i < this->BookCnt - 1; i++) {
            this->BookArray[i] = this->BookArray[i + 1];
            if (i == this->BookCnt - 2)
                this->BookArray[BookCnt - 1] = NULL;
        }
        this->BookCnt--;
        return true;
    }
    else
        return false;

}

}

Book *BookManage::findBook(char BookKind, int BookCode) {

Novel *np;
Comic *cp;
MajorBook *mp;

//cout << BookCnt << endl;
for(int i=0;i<BookCnt;i++){

    if (dynamic_cast<Novel *>(BookArray[i]) != NULL) {
        np = dynamic_cast<Novel *>(BookArray[i]);
        //cout << np->getBookKind() << np->getBookCode() << endl;
        if ((np->getBookKind()== BookKind) &&(np->getBookCode() == BookCode)) {
            return BookArray[i];
        }
    }
    else if (dynamic_cast<MajorBook *>(BookArray[i]) != NULL) {
        mp = dynamic_cast<MajorBook *>(BookArray[i]);
        if ((mp->getBookKind() == BookKind) && (mp->getBookCode() == BookCode)) {
            return BookArray[i];
        }
    }
    else if (dynamic_cast<Comic *>(BookArray[i]) != NULL) {
        cp = dynamic_cast<Comic *>(BookArray[i]);
        if ((cp->getBookKind() == BookKind) && (cp->getBookCode() == BookCode)) {
            return BookArray[i];
        }
    }
}
return NULL;

}

RentBookList &BookManage::getRentBookList() { return this->List; }

//RentBookList.h #pragma once #include "Rent.h" #include "Person.h" #define bMax 10 class RentBookList { private: Rent * RentArray[bMax] = { NULL, }; public: RentBookList(); ~RentBookList(); Rent ** getRentArray(); // int getPersonId(Person &rp); };

//RentBookList.cpp #include "BookManage.h" #include "PersonManage.h" #include "Rent.h" #include "RentBookList.h"

RentBookList::RentBookList() {} RentBookList::~RentBookList() {} Rent ** RentBookList::getRentArray() { return RentArray; } //int RentBookList::getPersonId(Person &rp) //{ // return Personid; //}

//main.cpp #include using namespace std; #include #define MASTER 1111 // 관리자 아이디 #define bMax 10 #pragma warning (disable : 4996)

#include "BookManage.h" #include "PersonManage.h" #include "Book.h" #include "Person.h" #include "Novel.h" #include "MajorBook.h" #include "Comic.h" #include "RentBookList.h" #include

void PersonLogin(PersonManage &Pm, BookManage &Bm); // 관리자, 사용자 로그인

void masterMenu(PersonManage &Pm, BookManage &Bm); // 관리자 메뉴

void addbook(BookManage &Bm); // 책 추가

void deletebook(BookManage &Bm); // 책 삭제

void rentlist(PersonManage &Pm, BookManage &Bm); // 대출자 명단

void normalMenu(Person *p, BookManage &Bm); // 사용자 메뉴

void rentbook(int id, BookManage &Bm); // 책 대출

void returnbook(int id, BookManage &Bm); // 책 반납

void myrentlist(int id, BookManage &Bm); // 나의 대출 목록

void findbook(BookManage &Bm); // 단일 책 검색

void allbook(BookManage &Bm); // 책 목록 전체 보기

void PersonRegist(PersonManage &Pm); // 사용자 추가

void PersonDelete(PersonManage &Pm); // 사용자 삭제

int menu(const char **menuList, int menuCnt);

void displayTitle(const char *title);

int controlMenuSelect(const char *message, int menuCnt);

int inputInteger(const char *message);

void myFlush();

int main() { BookManage bmanage; PersonManage pmanage;

const char *menuList[] = { "로그인 ", "사용자 등록 ", "사용자 삭제 ", "종료 " };
int menuCnt = sizeof(menuList) / sizeof(menuList[0]);
int menuNum;

displayTitle("도서 관리 시스템 시작");
while (true)
{
    menuNum = menu(menuList, menuCnt);
    if (menuNum == menuCnt) { break; }
    switch (menuNum)
    {
    case 1: PersonLogin(pmanage, bmanage); break;
    case 2:    PersonRegist(pmanage); break;
    case 3:    PersonDelete(pmanage); break;
    }
}
displayTitle("도서 관리 시스템 종료");
return 0;

}

int menu(const char *menuList, int menuCnt) { int i; int menuNum = 0; / 입력된 메뉴 번호 저장 변수*/

cout << endl << "==================================" << endl;
for (i = 0; i < menuCnt; i++)
{
    cout << i + 1 << "." << menuList[i] << endl;
}
cout << "==================================" << endl;
while (menuNum<1 || menuNum>menuCnt)  /* 범위 내의 번호가 입력될 때 까지 반복*/
{
    menuNum = inputInteger("# 메뉴번호를 입력하세요 : ");

}
return menuNum;

}

void displayTitle(const char *title) { cout << endl << "------------------------------" << endl; cout << " " << title << endl; cout << "------------------------------" << endl; }

void PersonLogin(PersonManage &Pm, BookManage &Bm) { Person * p; int id;

displayTitle("로그인");
id = inputInteger("* 사용자 학번 : ");

if (id == MASTER) {
    cout << "로그인 되었습니다." << endl;
    masterMenu(Pm, Bm);
}
else {
    p = Pm.findPerson(id);
    if (p == NULL) {
        cout << "존재하지 않는 입력입니다." << endl;
        return;
    }
    cout << "로그인 되었습니다." << endl;
    normalMenu(p, Bm);
}

}

void masterMenu(PersonManage &Pm, BookManage &Bm) {

const char *menuList[] = { "책 추가 ", "책 삭제 ", "대출자 명단 ", "책 검색 ", "전체 목록 ", "종료 " };
int menuCnt = sizeof(menuList) / sizeof(menuList[0]);
int menuNum;

displayTitle("관리자 모드 실행");
while (true)
{
    menuNum = menu(menuList, menuCnt);
    if (menuNum == menuCnt) { break; }
    switch (menuNum)
    {
    case 1: addbook(Bm); break;
    case 2:    deletebook(Bm); break;
    case 3:    rentlist(Pm, Bm); break;
    case 4: findbook(Bm); break;
    case 5: allbook(Bm); break;
    }
}
displayTitle("관리자 모드 종료");

}

void addbook(BookManage &Bm) { string BookName; string CpyName; int num; Book *ap = NULL; bool res;

displayTitle("책 등록");

cout << "* 책 제목 : ";
cin >> BookName;
cout << "* 책 출판사 : ";
cin >> CpyName;
num = controlMenuSelect("* 책의 종류(1. 소설 / 2. 전공서적 / 3. 만화) : ", 3);

switch (num) {
case 1: ap = new Novel(BookName, CpyName, 'N'); break;
case 2: ap = new MajorBook(BookName, CpyName, 'M'); break;
case 3: ap = new Comic(BookName, CpyName, 'C'); break;
}

res = Bm.addBook(ap);
if (res)
{
    cout << BookName << " 등록을 완료하였습니다." << endl << endl;
}
else
{
    cout << "등록을 실패하였습니다." << endl << endl;
}

}

void deletebook(BookManage &Bm) { string BookName; bool res;

displayTitle("책 삭제");

cout << "* 책 제목 : ";
cin >> BookName;

res = Bm.deleteBook(BookName);
if (res)
{
    cout << BookName << "이 삭제되었습니다." << endl << endl;
}
else
{
    cout << "삭제를 실패하였습니다." << endl << endl;
}

}

void rentlist(PersonManage &Pm, BookManage &Bm) { displayTitle("대출자 명단");

Rent **list;
list = Bm.getRentBookList().getRentArray();

for (int i = 0;i< bMax;i++) {
    if (list[i] != NULL) {
        Person* a = Pm.findPerson(list[i]->Personid);
        Book * b = Bm.findBook(list[i]->BookKind, list[i]->BookCode);
        cout << "이름 : " << a->getPersonName() << ", 전공 : " << a->getMajor() << ", 학번 : " << a->getId() << " (" << b->getBookName() << " 대출날짜 : " << list[i]->startDay << "일)" << endl;
    }
}
cout << endl;

}

void normalMenu(Person *p, BookManage &Bm) {

const char *menuList[] = { "대출 ", "반납 ", "대출명단 ", "책검색 ","전체 목록 ","종료 " };
int menuCnt = sizeof(menuList) / sizeof(menuList[0]);
int menuNum;
int id = p->getId();

displayTitle("사용자 메뉴");
while (true)
{
    menuNum = menu(menuList, menuCnt);
    if (menuNum == menuCnt) { break; }
    switch (menuNum)
    {
    case 1: rentbook(id, Bm); break;
    case 2:    returnbook(id, Bm); break;
    case 3:    myrentlist(id, Bm); break;
    case 4: findbook(Bm); break;
    case 5: allbook(Bm); break;
    }
}
displayTitle("사용자 메뉴 종료");

}

void rentbook(int id, BookManage &Bm) { displayTitle("대출");

string bookname;

char ch;
int n;
Rent **list;
list = Bm.getRentBookList().getRentArray();

cout << "* 책 제목 : ";
cin >> bookname;
for (int i = 0; i < Bm.BookCnt;i++) {
    if (Bm.getBookArray()[i]->getBookName() == bookname) {
        cout << "* 책 코드 : ";
        cin >> ch >> n;

        Book * b = Bm.findBook(ch, n);

        if (b != NULL) {
            if (b->getBookName() != bookname) {
                cout << "대출이 불가능합니다." << endl;
                return;
            }
            for (int i = 0; i < Bm.BookCnt;i++) {
                if (list[i] != NULL) {
                    //cout << list[i]->BookKind << list[i]->BookCode << endl;
                    if (list[i]->BookKind == ch && list[i]->BookCode == n) {
                        cout << "대출이 불가능합니다." << endl;
                        return;
                    }
                }
            }
        }
        else {
            cout << "대출이 불가능합니다." << endl;
            return;
        }
        // 도서관에도 책이 있고, 대출도서명단에 책이 없을때, 즉, 대출 가능
        time_t day = time(NULL);
        for (int i = 0;i < Bm.BookCnt;i++) {
            if (list[i] == NULL) {
                time_t timer;
                struct tm *t;
                timer = time(NULL); // 현재 시각을 초 단위로 얻기
                t = localtime(&timer);
                list[i] = new Rent;
                list[i]->BookKind = ch;
                list[i]->BookCode = n;
                list[i]->Personid = id;
                list[i]->startDay = t->tm_mday;
                cout << "대출이 완료되었습니다." << endl;
                b->setflag(true);
                break;
            }
        }
        return;
    }
}
cout << "대출이 불가능합니다." << endl;

}

void returnbook(int id, BookManage &Bm) { displayTitle("반납");

string bookname;
char ch;
int n;
int num = 0;
Rent **list;
list = Bm.getRentBookList().getRentArray();

cout << "* 책 제목 : ";
cin >> bookname;

for (int i = 0; i < Bm.BookCnt;i++) {
    if (Bm.getBookArray()[i]->getBookName() == bookname) {
        cout << "* 책 코드 : ";
        cin >> ch >> n;

        Book * b = Bm.findBook(ch, n);

        if (b != NULL) {
            if (b->getBookName() != bookname) {
                cout << "반납이 불가능합니다." << endl;
                return;
            }
        }
        // rent 배열 한칸씩 앞으로 떙기는 작업
        for (int i = 0; i < Bm.BookCnt;i++) {
            if (list[i] != NULL) {
                if (list[i]->Personid == id) {
                    if (list[i]->BookKind == ch && list[i]->BookCode == n) {
                        // memset(list[i], 0, sizeof(Rent));
                        delete list[i];
                        for (i; i < Bm.BookCnt - 1; i++)
                        {
                            list[i] = list[i + 1];
                            if (i == Bm.BookCnt - 2)
                            {
                                // memset(list[i], 0, sizeof(Rent));
                                // delete list[Bm.BookCnt - 1];
                                list[Bm.BookCnt - 1] = NULL;
                            }
                        }
                        cout << "반납이 완료되었습니다." << endl;
                        b->setflag(false);
                        return;
                    }
                    else {
                        cout << "반납이 불가능합니다." << endl;
                        return;
                    }
                }
            }
        }
        cout << "반납이 불가능합니다." << endl;
        return;
    }
}

}

void myrentlist(int id, BookManage &Bm) { displayTitle("나의 대출 책 목록"); Book * b; Rent **list; list = Bm.getRentBookList().getRentArray(); for (int i = 0; i < Bm.BookCnt;i++) { if (list[i] != NULL) { //cout << list[i]->Personid << " " << id << endl; if (list[i]->Personid == id) { b = Bm.findBook(list[i]->BookKind, list[i]->BookCode); cout << "제목 : " << b->getBookName() << ", 코드 : " << list[i]->BookKind << list[i]->BookCode << " (대출 날짜 : " << list[i]->startDay << "일)" << endl; } } } }

void findbook(BookManage &Bm) { displayTitle("책 검색"); cout << "* 책제목을 입력하세요: "; char sBookName[50]; cin >> sBookName; for (int i = 0; i < Bm.BookCnt; i++) { if (Bm.getBookArray()[i]->getBookName() == sBookName) { Bm.getBookArray()[i]->infoView(); } } }

void allbook(BookManage &Bm) { displayTitle("전체 목록"); for (int i = 0; i < Bm.BookCnt; i++) { cout << i + 1 << ". "; Bm.getBookArray()[i]->infoView(); } }

int controlMenuSelect(const char *message, int menuCnt) { int menuNum;

while (true)
{
    menuNum = inputInteger(message);
    if (menuNum > 0 && menuNum <= menuCnt) { break; }
}
return menuNum;

}

void PersonRegist(PersonManage &Pm) { string personName; string major; int id; Person *ap = NULL; bool res;

displayTitle("사용자 등록하기");

cout << "* 사용자 이름 : ";
cin >> personName;
cout << "* 사용자 전공 : ";
cin >> major;
id = inputInteger("* 사용자 학번 : ");

ap = new Person(personName, id, major);

res = Pm.addPerson(ap);
if (res)
{
    cout << personName << "님의 등록을 완료하였습니다." << endl << endl;
}
else
{
    cout << "등록을 실패하였습니다." << endl << endl;
}

}

void PersonDelete(PersonManage &Pm) { string personName; bool res;

displayTitle("사용자 탈퇴하기");

cout << "* 사용자 이름 : ";
cin >> personName;

res = Pm.deletePerson(personName);
if (res)
{
    cout << personName << "님의 정보가 삭제되었습니다." << endl << endl;
}
else
{
    cout << "탈퇴를 실패하였습니다." << endl << endl;
}

}

int inputInteger(const char *message) { int number;

while (1) {
    cout << message;
    cin >> number;

    if (cin.get() == '\n') {
        return number;
    }

    myFlush();
}

}

void myFlush() { cin.clear(); while (cin.get() != '\n'); }

```

//Happy.h
#pragma once
#include <string>
using namespace std;

class Happy {
private:
    string name;
    int money;
    char *list[100] = { NULL, };
    int index;
public:
    Happy(string np = "", int money = 10000);
    Happy(Happy &r);
    ~Happy();
    Happy &operator=(Happy &r);
    void use(char *lp, int n);
    Happy &winner(Happy &r);
    void setName(string &name);
    string &getName();
    void setMoney(int money);
    int getMoney();
    char **getList();
    int getIndex();
};
//Happy.cpp
#include <iostream>
#include <string>
#include "Happy.h"
#pragma warning (disable : 4996)
using namespace std;

Happy::Happy(string np, int n) {
    this->name = np;
    this->money = n;
    this->index = 0;
}

Happy::Happy(Happy &r) {
    int i = 0;
    this->name = r.name;
    this->money = r.money;
    this->index = r.index;
    while (r.list[i] != NULL) {
        this->list[i] = new char[strlen(r.list[i]) + 1];
        strcpy(this->list[i], r.list[i]);
        i++;
    }
}

Happy::~Happy() {
    int i = 0;
    while (this->list[i] != NULL) {
        delete[] this->list[i];
        i++;
    }
}

Happy &Happy::operator=(Happy &r) {
    int i = 0;
    this->name = r.name;
    this->money = r.money;
    this->index = r.index;
    while (r.list[i] != NULL) {
        this->list[i] = new char[strlen(r.list[i]) + 1];
        strcpy(this->list[i], r.list[i]);
        i++;
    }
    return *this;
}

void Happy::use(char *lp, int n) {
    int i = 0;
    int len = strlen(lp) + 2;
    if (this->money >= n) {
        this->money -= n;
    }
    else cout << "잔액이 부족합니다." << endl;
    this->index++;
    while (1) {
        if (this->list[i] == NULL) {
            this->list[i] = new char[len];
            strcpy(this->list[i], lp);
            break;
        }
        else i++;
    }
}

Happy &Happy::winner(Happy &r) {
    if (this->money > r.money) {
        return *this;
    }
    else {//if (this->money < r.money) {
        return r;
    }
    //else return Happy();
}

void Happy::setName(string &name) {
    this->name = name;
}

string &Happy::getName() {
    return this->name;
}

void Happy::setMoney(int money) {
    this->money = money;
}

int Happy::getMoney() {
    return this->money;
}

char **Happy::getList() {
    return this->list;
}

int Happy::getIndex() {
    return this->index;
}
//HW16.cpp
#include <iostream>
#include "Happy.h"
#pragma warning (disable : 4996)
using namespace std;

int main() {
    Happy a("철이"), b("메텔"), w;
    char item[100];
    int price;

    cout << "철이가 돈을 씁니다..." << endl;
    while (1) {
        cout << "구입 내역 : ";
        cin >> item;
        if (strcmp(item, "끝") == 0)break;
        cout << "금액 입력 : ";
        cin >> price;
        a.use(item, price);
    }

    cout << "\n메텔이 돈을 씁니다..." << endl;
    while (1) {
        cout << "구입 내역 : ";
        cin >> item;
        if (strcmp(item, "끝") == 0)break;
        cout << "금액 입력 : ";
        cin >> price;
        b.use(item, price);
    }

    cout << "\n최종 승자는?" << endl;
    w = a.winner(b);
    cout << w.getName() << "이고 총 " << w.getIndex() << "건을 사용하고 남은 금액은 " << w.getMoney() << "원 입니다." << endl;

    int i = 0;
    cout << "사용 내역 : ";
    while (w.getList()[i]) {
        cout << w.getList()[i] << " ";
        i++;
    }
    return 0;
}

#include <iostream>
using namespace std;

class Time {
private:
    int hour;
    int min;
    double time;
    static int mode;
    enum { integer, real };
public:
    Time();
    Time(int, int);
    Time(double);
    Time(const Time &tr);
    Time plus(const Time &tr);
    void setHour(int);
    int getHour();
    void setMin(int);
    int getMin();
    int getMode();
    friend ostream &operator<<(ostream &os, const Time &br);
    static void mode_change();
};

int Time::mode = integer;

Time::Time() {
    this->hour = 0;
    this->min = 0;
    this->time = 0.0;
}

Time::Time(int hour,int min) {
    this->hour = hour;
    this->min = min;
    this->time = hour + double(min) / 60;
}

Time::Time(double time) {
    this->hour = int(time);
    this->min = int((time - int(time)) * 60);
    this->time = time;
}

Time::Time(const Time &tr) {
    this->hour = tr.hour;
    this->min = tr.min;
    this->time = tr.time;
}

Time Time::plus(const Time &tr){
    int sum = this->min + tr.min;
    this->hour += tr.hour;
    if (sum >= 60) {
        this->hour++;
        this->min = sum - 60
;
    }
    this->time = this->hour + double(this->min) / 60;
    return *this;
}

void Time::setHour(int hour) {
    this->hour = hour;
}

int Time::getHour() {
    return this->hour;
}

void Time::setMin(int min) {
    this->min = min;
}

int Time::getMin() {
    return this->min;
}

int Time::getMode() {
    return this->mode;
}

void Time::mode_change() {
    mode = (mode + real) % 2;
}

ostream &operator<<(ostream &os, Time &br);

int main() {
    Time a(3, 21);
    Time b(2.7);
    cout << "기본 출력 형태(시간, 분)..." << endl;
    cout << a << endl;
    cout << b << endl;
    Time::mode_change();
    cout << "출력모드를 바꾼 후..." << endl;
    cout << a << endl;
    cout << b << endl;
    return 0;
}

ostream &operator<<(ostream &os, Time &br) {
    double time = br.getHour() + double(br.getMin()) / 60;
    if (br.getMode() == 0) {
        os << br.getHour() << "시간 " << br.getMin() << "분";
    }
    else {
        os << time << "시간";
    }
    return os;
}

HW14

#include <iostream>
#include <cstring>
#pragma warning (disable : 4996)
using namespace std;

class MyString {
private:
    char *str;
    int len;
public:
    MyString();
    MyString(const char*cp);
    MyString(const MyString &br);
    ~MyString();
    MyString &operator=(const MyString &br);
    MyString operator+(const MyString &br);
    bool operator>(const MyString &br);
    friend ostream &operator<<(ostream &os, MyString &br);
    friend istream &operator>>(istream &is, MyString &br);
    void setStr(const char *cp);
    char *getStr() const;
    int getLen() const;
};

ostream &operator<<(ostream &os, MyString &br);
istream &operator>>(istream &is, MyString &br);

MyString::MyString() {
    this->str = new char[strlen("") + 1];
    strcpy(this->str, ""); // this->str = ""; string 영역(상수영역)의 null string을 가리킴
    this->len = 0;
}

MyString::MyString(const char *cp) {
    this->len = strlen(cp);
    this->str = new char[this->len + 1];
    strcpy(this->str, cp);
}

MyString::MyString(const MyString &br) {
    this->len = br.len;
    this->str = new char[this->len + 1];
    strcpy(this->str, br.str);
}

MyString::~MyString() {
    delete[] this->str;
}

MyString &MyString::operator=(const MyString &br) {
    if (this == &br) { // **** 나 - 나 방지코드
        return *this;
    }
    delete[] this->str;
    this->len = br.len;
    this->str = new char[this->len + 1];
    strcpy(this->str, br.str);
    return *this;
}

MyString MyString::operator+(const MyString &br) {
    char temp[100] = "";
    strcpy(temp, this->str);
    strcat(temp, br.str);
    return MyString(temp);
    //char *cp;
    //cp = new char[this->len + br.len + 1];
    //strcpy(cp, this->str);
    //strcat(cp, br.str);
    //MyString temp(cp);
    //delete[] cp;
    //return temp;
}

bool MyString::operator>(const MyString &br) {
    //return (this->len > br.len); // 길이 비교
    return strcmp(this->str, br.str); // 스펠링 비교
}

void MyString::setStr(const char *cp) {
    if (this->str == cp) { // 본인의 문자열로 초기화시키려 할때
        return;
    }
    this->len = strlen(cp);
    delete[] this->str;
    this->str = new char[this->len + 1];
    strcpy(this->str, cp);
}

char *MyString::getStr() const{
    return this->str;
}

int MyString::getLen() const{
    return this->len;
}

int main() {
    MyString ary[5];
    MyString res;
    cout << "5개의 과일이름 입력 : ";
    for (int i = 0;i < 5;i++) {
        cin >> ary[i];
    }
    cout << "첫번째와 두번째 중 긴 과일 이름 : ";
    if (ary[0] > ary[1]) {
        cout << ary[0] << endl;
    }
    else {
        cout << ary[1] << endl;
    }
    res = ary[0] + ary[1] + ary[2] + ary[3] + ary[4];
    cout << "모든 문자열 출력 : " << res << endl;
    cout << "배열내의 문자열 출력..." << endl;
    for (int i = 0;i < 5;i++) {
        cout << ary[i] << endl;
    }
    for (int i = 0;i < 5;i++) {
        ary[i].setStr("abc");
        cout << ary[i].getStr();
        cout << ary[i].getLen();
    }
    return 0;
}

ostream &operator<<(ostream &os, MyString &br) {
    os << br.str << "(" << br.len << ")" << endl;
    return os;
}

istream &operator>>(istream &is, MyString &br) { // *****
    char temp[5000];
    is >> temp;
    delete[] br.str;
    br.len = strlen(temp);
    br.str = new char[br.len + 1];
    strcpy(br.str, temp);
    return is;
}

//int main() {
//    char temp[1000];
//    char str1[20] = "apple ";
//    char str2[20] = "pie";
//
//    strcpy(temp, str1); // temp : "apple "
//    strcat(temp, str2); // temp의 \0 자리에서부터 str2를 붙임
//    cout << temp << "" << str1 << "" << str2 << endl;
//
//    char temp2[1000] = "";
//    strcat(temp2, str1); // temp : "apple "
//    strcat(temp2, str2); // temp의 \0 자리에서부터 str2를 붙임
//    cout << temp2 << "" << str1 << "" << str2 << endl;
//}

#include <iostream>
#include <cstring>
#pragma warning (disable : 4996)
using namespace std;

// Fitness.h
class Fitness {
private:
    int num;
    char *name;
    double weight;
    double height;
public:
    // 생성자
    Fitness();
    Fitness(int num, const char *name, double weight, double height);
    Fitness(Fitness &r);
    ~Fitness();
    // 연산자
    Fitness &operator=(Fitness &r);
    bool operator==(Fitness &r);
    // setter, getter
    void setNum(int num);
    int getNum();
    void setName(const char *name);
    char *getName();
    void setWeight(double weight);
    double getWeight();
    void setHeight(double height);
    double getHeight();
    // 기타멤버함수
    double bmi();
};

// Fitness.cpp
Fitness::Fitness() {
    this->num = 0;
    this->name = new char[1];
    strcpy(this->name, "");
    this->weight = 0;
    this->height = 0;
}

Fitness::Fitness(int num, const char *name, double weight, double height) {
    if (this->name != NULL) {
        if (name != NULL) {
            this->name = new char[strlen(name) + 1];
            strcpy(this->name, name);
        }
    }
    else return;
    this->num = num;
    this->weight = weight;
    this->height = height;
}

Fitness::Fitness(Fitness &r) {
    if (name != NULL) {
        this->name = new char[strlen(r.name) + 1];
        strcpy(this->name, r.name);
    }
    else return;
    this->num = r.num;
    this->weight = r.weight;
    this->height = r.height;
}

Fitness::~Fitness() {
    if (name != NULL) {
        strcpy(this->name, "");
        delete[] this->name;
    }
    else return;
    this->num = 0;
    this->weight = 0;
    this->height = 0;
    //cout << "소멸 성공" << endl;
}

Fitness &Fitness::operator=(Fitness &r) {
    if (*this == r) return *this;
    strcpy(this->name, "");
    delete[] this->name;
    this->name = new char[strlen(r.name) + 1];
    strcpy(this->name, r.name);
    this->num = r.num;
    this->weight = r.weight;
    this->height = r.height;
    return *this;
}

bool Fitness::operator==(Fitness &r) {
    if (this->num == r.num) {
        return 1;
    }
    if (r.name != NULL) {
        if (strcmp(this->name, r.name) == 0) {
            return 1;
        }
    }
    return 0;
}

void Fitness::setNum(int num) {
    this->num = num;
}

int Fitness::getNum() {
    return this->num;
}

void Fitness::setName(const char *name) {
    if (this->name != NULL) {
        if (name != NULL) {
            strcpy(this->name, "");
            delete[] this->name;
            this->name = new char[strlen(name) + 1];
            strcpy(this->name, name);
        }
    }
}

char *Fitness::getName() {
    return this->name;
}

void Fitness::setWeight(double weight) {
    this->weight = weight;
}

double Fitness::getWeight() {
    return this->weight;
}

void Fitness::setHeight(double height) {
    this->height = height;
}

double Fitness::getHeight() {
    return this->height;
}

double Fitness::bmi() {
    return this->weight / (this->height * this->height) * 10000;
}

// main.cpp
int menu(const char **menuList, int menuCnt);
void memInput(Fitness **br, int &memNum, int &memCnt, int &dataCnt);
void memPrint(Fitness **br, int memCnt);
void memFind(Fitness **br, int memCnt);
void memDelete(Fitness **br, int &memNum, int &memCnt, int &dataCnt);
void memBmi(Fitness **br, int &memCnt);
void myflush();

int main() {
    const char *menuList[] = { "회원등록", "회원전체보기", "회원정보검색", "회원탈퇴" , "특별관리회원","종료" };
    int menuCnt, menuNum, memNum = 1, memCnt = 0, dataCnt = 0;

    Fitness *fary[100] = { 0, };

    menuCnt = sizeof(menuList) / sizeof(menuList[0]);

    while(1)
    {
        menuNum = menu(menuList, menuCnt);
        if (menuNum == menuCnt)
        {
            break;
        }
        switch (menuNum)
        {
        case 1: memInput(fary, memNum, memCnt, dataCnt); cout << endl; break;
        case 2: memPrint(fary, memCnt); cout << endl;  break;
        case 3: memFind(fary, memCnt); cout << endl;  break;
        case 4: memDelete(fary, memNum, memCnt, dataCnt); cout << endl; break;
        case 5: memBmi(fary, memCnt); cout << endl; break;
        }
    }
    for (int i = 0;i < dataCnt;i++) {
        delete[] fary[i];
    }
    return 0;
}

int menu(const char **menuList, int menuCnt)
{
    int menuNum = 0;
    for (int i = 0; i < menuCnt; i++)
    {
        cout << i + 1 << "." << menuList[i] << " / ";
    }
    cout << "\b\b \n";
    while (menuNum<1 || menuNum>menuCnt)
    {
        cout << "# 메뉴번호를 입력하세요 : ";
        cin >> menuNum;
        while (cin.fail()) {
            cin.clear();
            myflush();
            cout << "* 잘못된 메뉴번호 입니다." << endl << "# 메뉴번호를 입력하세요 : ";
            cin >> menuNum;
        }
        myflush();
    }
    return menuNum;
}

void memInput(Fitness **br, int &memNum, int &memCnt, int &dataCnt) {
    double weight, height;
    char temp[30];
    cout << "\n* 회원 입력 메뉴" << endl;
    while (1) {
        cout << "\n회원 성명(종료) : ";
        cin.getline(temp, sizeof(temp));
        if (strcmp(temp, "종료") == 0) break;
        if (br[memCnt] == NULL) {
            br[memCnt] = new Fitness[1];
            br[memCnt]->setNum(memNum);
            dataCnt++;
        }
        cout << "회원 번호 : " << br[memCnt]->getNum() << "번" << endl;
        br[memCnt]->setName(temp);
        cout << "회원 몸무게(kg) : ";
        cin >> weight;
        cout << "회원 키(cm) : ";
        cin >> height;
        myflush();
        br[memCnt]->setWeight(weight);
        br[memCnt]->setHeight(height);
        memCnt++;
        memNum = memCnt + 1;
    }
}

void memPrint(Fitness **br, int memCnt) {
    cout << "\n* 회원 전체 보기" << endl << endl;
    for (int i = 0;i < memCnt;i++) {
        cout << br[i]->getNum() << "번 - " << br[i]->getName() << "님, 키(cm) : " << br[i]->getHeight() << ", 몸무게(kg) : " << br[i]->getWeight() << endl;
    }
}

void memFind(Fitness **br, int memCnt) {
    int num = 0;
    char temp[30];
    cout << "\n* 회원 정보 검색 메뉴" << endl << "\n회원 성명 : ";
    cin >> temp;
    for (int i = 0;i < memCnt;i++) {
        if (strcmp(br[i]->getName(), temp) == 0) {
            cout << br[i]->getNum() << "번 - " << br[i]->getName() << "님, 키(cm) : " << br[i]->getHeight() << ", 몸무게(kg) : " << br[i]->getWeight() << endl;
            num++;
        }
    }
    if (num == 0) cout << "* 등록되지 않은 회원입니다." << endl;
}

void memDelete(Fitness **br, int &memNum, int &memCnt, int &dataCnt) {
    int num;
    char temp[10];
    cout << "\n* 회원 탈퇴 메뉴" << endl;
    while (1) {
        cout << "\n회원 번호(종료) : ";
        cin >> num;
        while (cin.fail()) {
            cin.clear();
            cin.getline(temp, sizeof(temp));
            if (strcmp(temp, "종료") == 0) return;
            else {
                cout << "* 잘못된 회원번호 입니다." << endl << endl << "회원 번호 : ";
                cin >> num;
            }
        }
        myflush();
        if (num <= dataCnt) {
            int cnt = 0;
            for (int i = 0;i < memCnt;i++) {
                if (br[i]->getNum() == num) {
                    cnt++;
                    cout << br[i]->getNum() << "번 - " << br[i]->getName() << "님, 키(cm) : " << br[i]->getHeight() << ", 몸무게(kg) : " << br[i]->getWeight() << endl;
                    cout << "* 삭제하시겠습니까?(네/아니오) : ";
                    cin.getline(temp, sizeof(temp));
                    if (strcmp(temp, "네") == 0) {
                        int num = br[i]->getNum();
                        cout << "삭제가 완료되었습니다." << endl;
                        *br[i] = *br[memCnt - 1];
                        br[memCnt - 1]->setNum(num);
                        //delete[] br[memCnt - 1];
                        memCnt--;
                    }
                    else {
                        cout << "삭제가 취소되었습니다." << endl;
                        break;
                    }
                }
            }
            if (cnt == 0)cout << "* 잘못된 회원번호 입니다." << endl;;
        }
        else {
            cout << "* 잘못된 회원번호 입니다." << endl;
        }
    }
}

void memBmi(Fitness **br, int &memCnt) {
    cout << "\n* 특별 관리 회원 명단\n";
    for (int i = 0;i < memCnt;i++) {
        int bmi = int(br[i]->bmi());
        if (bmi >= 25) {
            if (bmi < 30) { cout << br[i]->getNum() << "번 - " << br[i]->getName() << "님의 BMI : " << bmi << " (과체중)" << endl; }
            else if (bmi < 40) { cout << br[i]->getNum() << "번 - " << br[i]->getName() << "님의 BMI : " << bmi << " (비만)" << endl; }
            else { cout << br[i]->getNum() << "번 - " << br[i]->getName() << "님의 BMI : " << bmi << " (과도비만)" << endl; }
        }
    }
}

void myflush() {
    while (cin.get() != '\n');
}

#include <iostream>
#include <cstring>
#pragma warning (disable : 4996)
using namespace std;

class Time {
private:
    int hour;
    int min;
public:
    Time();
    Time(int, int);
    Time(double);
    Time(const Time &tr);
    Time plus(const Time &tr);
    void setHour(int);
    int getHour() const;
    void setMin(int);
    int getMin() const;
};

Time::Time(){
    this->hour = 0;
    this->min = 0;
}

Time::Time(int hour, int min) {
    this->hour = hour;
    this->min = min;
}

Time::Time(double time) {
    this->hour = int(time);
    this->min = int((time - double(this->hour)) * 60);
}

Time::Time(const Time &tr) {
    this->hour = tr.hour;
    this->min = tr.min;
}

Time Time::plus(const Time &tr) {
    this->hour += tr.getHour();
    this->min += tr.getMin();
    if (this->min >= 60) {
        this->hour += this->min / 60;
        this->min %= 60;
    }
    return *this;
}

void Time::setHour(int hour) {
    this->hour = hour;
}

void Time::setMin(int min) {
    this->min = min;
}

int Time::getHour() const{
    return this->hour;
}

int Time::getMin() const{
    return this->min;
}

int main() {
    Time a(3, 20), b;
    cout << a.getHour() << "시간" << a.getMin() << "분" << endl;
    b.setHour(4);
    b.setMin(42);
    cout << b.getHour() << "시간" << b.getMin() << "분" << endl;
    Time res = a.plus(b);
    cout << "두 시간을 더하면 : " << res.getHour() << "시간" << res.getMin() << "분" << endl;
    return 0;
}

HW12

#include <iostream>
#include <cstring>
#pragma warning (disable : 4996)
using namespace std;

class Save {
private:
    char name[20];
    int capital;
    int profit;
    int tax;
    int tot;
    static double ratio;
public:
    static double tax_ratio;
    Save(const char *np = "아무개", int n = 0);
    ~Save() {};
    void calculate();
    static void set_ratio(double r);
    char *getName() const;
    int getCap() const;
    int getPro() const;
    int getTax() const;
    int getTot() const;
    double getRat() const;
    double getTaxRat() const;
};

double Save::ratio = 0.2;
double Save::tax_ratio = 0.1;

Save::Save(const char *np, int n) {
    if (np != NULL) {
        strcpy(this->name, np);
    }
    this->capital = n;
}

void Save::calculate() {
    this->profit = int(this->capital * this->ratio);
    this->tax = int(this->profit * this->tax_ratio);
    this->tot = int(this->capital + this->profit - this->tax);
}

void Save::set_ratio(double r){
    Save::ratio = r;
}

char* Save::getName() const {
    cout << "이름 : ";
    return (char*)(this->name);
}

int Save::getCap() const {
    cout << endl << "원금 : ";
    return this->capital;
}

int Save::getPro() const {
    cout << endl << "이자소득 : ";
    return this->profit;
}

int Save::getTax() const {
    cout << endl << "세금 : ";
    return this->tax;
}

int Save::getTot() const {
    cout << endl << "총금액 : ";
    return this->tot;
}

double Save::getRat() const {
    cout << endl << "이율 : ";
    return this->ratio;
}

double Save::getTaxRat() const {
    cout << endl << "세율 : ";
    return this->tax_ratio;
}

int main() {
    Save a("철이", 1000000), b("메텔", 2000000);
    a.calculate();
    cout << a.getName();
    cout << a.getCap();
    cout << a.getPro(); 
    cout << a.getTax();
    cout << a.getTot();
    cout << a.getRat();
    cout << a.getTaxRat() << endl << endl;
    Save::tax_ratio = 0.15;
    Save::set_ratio(0.25);
    b.calculate();
    cout << b.getName();
    cout << b.getCap();
    cout << b.getPro();
    cout << b.getTax();
    cout << b.getTot();
    cout << b.getRat();
    cout << b.getTaxRat() << endl << endl;
    return 0;
}

//Robot.h
#pragma once

class Robot {
private:
    char *name;
    int energy;
    void errPrn();
public:
    Robot();
    ~Robot();
    Robot(const char *name, int energy = 0);
    Robot(Robot &r);
    void go();
    void back();
    void turn();
    void jump();
    void charge(int e);
    char *getName();
    void setName(const char *);
    int getEnergy();
    void setEnergy(int);
};
//Robot.cpp
#include <iostream>
#include "Robot.h"
using namespace std;
#pragma warning (disable : 4996)

void Robot::errPrn() {
    cout << "에너지 부족!" << endl;
}

Robot::Robot() {
    this->name = new char[1];
    strcpy(this->name, "");
    this->energy = 0;
}

Robot::~Robot() {
    delete[] this->name;
}

Robot::Robot(const char *name, int energy) {
    this->name = new char[strlen(name) + 1];
    strcpy(this->name, name);
    this->energy = energy;
}

Robot::Robot(Robot &r) {
    this->name = new char[strlen(r.name) + 1];
    strcpy(this->name, r.name);
    this->energy = r.energy;
}

// 전진 메세지 출력
void Robot::go() {
    if (this->energy < 10) {
        this->errPrn();
    }
    else {
        cout << this->name << "전진..." << endl << endl;
        this->energy -= 10;
    }
}

// 후진 메세지 출력
void Robot::back() {
    if (this->energy < 20) {
        this->errPrn();
    }
    else {
        cout << this->name << "후진..." << endl << endl;
        this->energy -= 20;
    }
}

// 턴 메세지 출력
void Robot::turn() {
    if (this->energy < 30) {
        this->errPrn();
    }
    else {
        cout << this->name << "턴..." << endl << endl;
        this->energy -= 30;
    }
}

// 점프 메세지 출력
void Robot::jump() {
    if (this->energy < 40) {
        this->errPrn();
    }
    else {
        cout << this->name << "점프..." << endl << endl;
        this->energy -= 40;
    }
}

void Robot::charge(int e) {
    if (e < 0) {
        return;
    }
    else {
        this->energy += e;
    }
}

char *Robot::getName() {
    return this->name;
}

void Robot::setName(const char *name) {
    if (this->name != NULL) {
        delete[] this->name;
    }
    this->name = new char[strlen(name) + 1];
    strcpy(this->name, name);
}

int Robot::getEnergy() {
    return this->energy;
}

void Robot::setEnergy(int e) {
    if (e < 0) {
        return;
    }
    else {
        this->energy = e;
    }
}
//HW11.cpp
#include<iostream>
#include<cstring>
#include "Robot.h"
using namespace std;
#pragma warning (disable : 4996)

//int main()
//{
//    Robot r1;
//    Robot r2("하랑이");
//    Robot r3("댕댕이", 100);
//    Robot r4(r2);
//
//    cout << r1.getName() << " " << r2.getEnergy() << endl;
//    cout << r2.getName() << " " << r2.getEnergy() << endl;
//    cout << r3.getName() << " " << r3.getEnergy() << endl;
//    cout << r4.getName() << " " << r4.getEnergy() << endl;
//
//    r2.setName("로보트태권브이");
//    r2.setEnergy(250);
//    r2.setEnergy(-50);
//    cout << r2.getName() << " " << r2.getEnergy() << endl;
//
//    r3.go();
//    r3.back();
//    r3.turn();
//    r3.jump();
//    r3.charge(120);
//    cout << r3.getName() << " " << r3.getEnergy() << endl;
//
//    return 0;
//}

void input(Robot *rp, int rCnt);
void work(Robot *rp, int rCnt);
void output(Robot *rp, int rCnt);
void myflush();

int main() {

    Robot *rp;
    int rCnt;
    cout << "구입할 로봇 대수를 입력하시오 : ";
    cin >> rCnt;
    rp = new Robot[rCnt];
    input(rp, rCnt);
    work(rp, rCnt);
    output(rp, rCnt);
    return 0;
}

void input(Robot *rp, int rCnt) {
    char name[30];
    int energy;
    for (int i = 0; i < rCnt;i++) {
        cout << endl << i + 1 << "번 로봇명을 입력하시오 : ";
        cin >> name;
        (rp + i)->setName(name);
        cout << name << "의 에너지 양을 입력하시오 : ";
        cin >> energy;
        (rp + i)->setEnergy(energy);
    }
}

void work(Robot *rp, int rCnt) {
    myflush();
    while (1) {
        char name[30];
        int num, energy;
        cout << endl << "# 로봇명 선택(";
        for (int i = 0; i < rCnt;i++) {
            cout << (rp + i)->getName() << ", ";
        }
        cout << "\b\b) : ";
        cin.getline(name, sizeof(name));
        if (strcmp(name, "") == 0) return;
        for (int i = 0; i < rCnt;i++) {
            //cout << name << (rp + i)->getName() << strcmp(name, (rp + i)->getName()) << endl;
            if (strcmp(name, (rp + i)->getName()) == 0) {
                cout << "# 할일 선택(1.전진/2.후진/3.회전/4.점프/5.충전) : ";
                cin >> num;
                switch (num) {
                case 1: (rp + i)->go(); break;
                case 2: (rp + i)->back(); break;
                case 3: (rp + i)->turn(); break;
                case 4: (rp + i)->jump(); break;
                case 5: {
                    cout << "# 충전할 에너지양 입력 : ";
                    cin >> energy;
                    (rp + i)->charge(energy); break;
                }
                default: break;
                }
                myflush();
                break;
            }
            else {
                if (i == rCnt - 1) {
                    cout << "올바르지 못한 로봇명입니다!" << endl;
                }
            }
        }
    }
}

void output(Robot *rp, int rCnt) {
    cout << endl;
    for (int i = 0; i < rCnt; i++) {
        cout << i + 1 << ". " << (rp + i)->getName() << " : " << (rp + i)->getEnergy() << endl;
    }
}

void myflush() {
    while (cin.get() != '\n');
}

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <string.h>
#pragma warning (disable : 4996)

int random(int);
void myflush();

void praGame(void);
void figGame(void);

void printBin(int**, int);
void printBin_2(int **, int **, int N);

void compareData(int**, int);
void compareData_2(int **, int **, int);

void makeRanBin(int**, int);
void dataClear(int**, int);
int whoWin(int **, int **, int);
int winBin(int**, int);
void inputInt(const char *, int *, int, int);

int main() {
    srand(unsigned int(time(NULL)));
    int menu;
    while (1) {
        printf("1. 연습게임(개인 연습용)\n2. 대전게임(컴퓨터와 대전용)\n3. 종료\n\n");
        inputInt("# 메뉴선택 : ", &menu, 1, 3);
        switch (menu) {
        case 1: praGame(); getchar(); break;
        case 2: figGame(); getchar(); break;
        case 3: return 0;
        }
    }
    return 0;
}

// practice game
void praGame(void) {
    int N;
    printf("연습용 빙고게임을 시작합니다.\n\n");
    inputInt("# 빙고판의 가로, 세로 크기를 입력해주세요(양수값 입력) : ", &N, 2, 10);

    int **bin = (int**)calloc(N, sizeof(int*));
    for (int i = 0; i < N;i++) {
        bin[i] = (int*)calloc(N, sizeof(int));
    }

    makeRanBin(bin, N);
    printBin(bin, N);

    compareData(bin, N);

    dataClear(bin, N);
    printf("\n");
}

// fight game
void figGame(void) {
    int N;
    printf("컴퓨터 대전 빙고게임을 시작합니다.\n\n");
    inputInt("# 빙고판의 가로, 세로 크기를 입력해주세요(양수값 입력) : ", &N, 2, 10);
    printf("\n사용자 빙고게임판 내용을 생성중입니다.\n");
    printf("컴퓨터 빙고게임판 내용을 생성중입니다.\n\n");

    int **uBin = (int**)calloc(N, sizeof(int*));
    int **cBin = (int**)calloc(N, sizeof(int*));
    for (int i = 0; i < N;i++) {
        uBin[i] = (int*)calloc(N, sizeof(int));
    }
    for (int i = 0; i < N;i++) {
        cBin[i] = (int*)calloc(N, sizeof(int));
    }

    makeRanBin(uBin, N);
    makeRanBin(cBin, N);
    printBin_2(uBin, cBin, N);

    compareData_2(uBin, cBin, N);

    dataClear(uBin, N);
    dataClear(cBin, N);
    printf("\n");
}

// compare data - practice game
void compareData(int **bin, int N) {
    int cData;
    for (int i = 0; i < N*N;i++) {
        inputInt("\n# 지울 숫자 입력(1~%d) : ", &cData, 1, N*N);
        for (int j = 0; j < N;j++) {
            for (int k = 0;k < N;k++) {
                if (bin[j][k] == cData) {
                    bin[j][k] = -cData;
                    printBin(bin, N);
                    if (winBin(bin, N) == 1) { 
                        printf("\n# 아무 키나 치면 주 메뉴로 돌아갑니다.");
                        return; 
                    }
                    break;
                }
                else if (bin[j][k] == -cData) {
                    printf("* 이미 지워진 숫자 입니다. 다시 입력하세요.\n");
                    i--;
                }
            }
        }
    }
}

// compare data - fight game
void compareData_2(int **ubin,int **cbin, int N) {
    int cData, num = 0;
    for (int i = 0; i < N*N;i++) {
        if (i % 2 == 0) {
            inputInt("\n# 지울 숫자 입력(1~%d) : ", &cData, 1, N*N);
            for (int j = 0; j < N;j++) {
                for (int k = 0;k < N;k++) {
                    if (ubin[j][k] == -cData || cbin[j][k] == -cData) {
                        num = 1;
                        break;
                    }
                    if (ubin[j][k] == cData) ubin[j][k] = -cData;
                    if (cbin[j][k] == cData) cbin[j][k] = -cData;
                }
            }
            if (num == 1) {
                printf("* 이미 지워진 숫자 입니다. 다시 입력하세요.\n");
                i--;
                num = 0;
            }
            else {
                printBin_2(ubin, cbin, N);
                cData = whoWin(ubin, cbin, N);
                if (cData == 1) return;
            }
        }
        else {
            while (1) {
                int num = 0;
                cData = random(N*N) + 1;
                for (int i = 0; i < N;i++) {
                    for (int j = 0;j < N;j++) {
                        if (ubin[i][j] == -cData) num++;
                    }
                }
                if (num == 0)break;
            }
            printf("\n# 컴퓨터가 선택한 숫자는 (%d)입니다.\n", cData);
            for (int j = 0; j < N;j++) {
                for (int k = 0;k < N;k++) {
                    if (ubin[j][k] == cData) ubin[j][k] = -cData;
                    if (cbin[j][k] == cData) cbin[j][k] = -cData;
                }
            }
            printBin_2(ubin, cbin, N);
            cData = whoWin(ubin, cbin, N);
            if (cData == 1) return;
        }
    }
}

// who win : compare bingo that succes 'Bingo' first
int whoWin(int **ubin, int **cbin, int N) {
    int unum = 0, cnum = 0;
    if ((unum = winBin(ubin, N)) > 0 || (cnum = winBin(cbin, N)) > 0) {
        if (unum > cnum) printf("\n# 사용자 승!");
        else if (unum < cnum) printf("\n# 컴퓨터 승!");
        else printf("\n# 사용자, 컴퓨터 !");
        printf("\n# 아무 키나 치면 주 메뉴로 돌아갑니다.");
        return 1;
    }
    return 0;
}

// win bingo : count 'Bingo' line
int winBin(int **bin, int N) {
    int sum = 0;
    int val[4] = { 0, };
    for (int i = 0; i < N;i++) {
        val[0] = val[1] = 0;
        for (int j = 0;j < N;j++) {
            if (bin[i][j] < 0) val[0]++;
            if (bin[j][i] < 0) val[1]++;
            if (i == j) {
                if (bin[i][j] < 0) val[2]++;
            }
            if (i == N - j - 1) {
                if (bin[i][j] < 0) val[3]++;
            }
        }
        for (int k = 0;k < 4;k++) {
            if (val[k] == N) sum++;
        }
    }
    if (sum >= N) return 1;
    return 0;
}

// print practice game bingo
void printBin(int **bin, int N) {
    printf("\n|");
    for (int i = 0; i < N;i++) {
        for (int j = 0;j < N;j++) {
            if (bin[i][j] < 0) printf("    X");
            else printf("%5d", bin[i][j]);
        }
        printf("  |\n|");
    }
    printf("\b ");
}

// print fight game bingo
void printBin_2(int **ubin, int **cbin, int N) {

    printf("[user]\t\t\t\t[couputer]\n|");
    for (int i = 0; i < N;i++) {
        for (int j = 0;j < N;j++) {
            if (ubin[i][j] < 0) printf("    X");
            else printf("%5d", ubin[i][j]);
        }
        printf("  |\t|");
        for (int k = 0;k < N;k++) {
            if (cbin[i][k] < 0) printf("    X");
            else printf("%5d", cbin[i][k]);
        }
        printf("  |\n|");
    }
    printf("\b ");
}

// make random bingo : put random number in bingo 
void makeRanBin(int**bin, int N)
{
    int temp;
    int *cBin = (int*)calloc(N*N, sizeof(int));
    for (int i = 0; i < N*N;i++) {
            cBin[i] = i + 1;
    }
    for (int i = 0; i < N*N;i++) {
        int *num1 = cBin + random(N*N);
        int *num2 = cBin + random(N*N);
        temp = *num1; *num1 = *num2; *num2 = temp;
    }
    for (int i = 0; i < N;i++) {
        for (int j = 0; j < N;j++) {
            bin[i][j] = cBin[i*N + j];
        }
    }
    memset(cBin, 0, N*N);
    free(cBin);
}

// input integer : put integer that user select in data and do exception handling
void inputInt(const char *msg, int *p, int min, int max) {
    while (1) {
        printf(msg, max);
        scanf("%d", p);
        if (getchar() == '\n') {
            if (*p >= min && *p <= max) return;
            else printf("* 올바르지 못한 숫자입니다.\n");
        }
        else {
            printf("* 올바르지 못한 숫자입니다.\n");
            myflush();
        }
    }
}

// data clear
void dataClear(int **bin, int N) {
    for (int i = 0; i < N;i++) {
        memset(bin[i], 0, N);
        free(bin[i]);
    }
    memset(bin, 0, N);
    free(bin);
}

// make radom integer
int random(int num) {
    int res;
    res = rand() % num;
    return res;
}

// myflush
void myflush() {
    while (getchar() != '\n');
}

#include <iostream>
#include <time.h>
#pragma warning (disable : 4996)
using namespace std;

struct Goods {
    char item[50];
    int price;
    int year;
    int mon;
    int day;
    int discount;
};

void input(Goods &s);
void selling_price(Goods &s);
void prn(const Goods &s);
int tot_days(int y, int m, int d);
int leap_check(int year);
int errorCheck(int *num);

int main() {

    struct Goods s;
    input(s);
    selling_price(s);
    if (s.discount == -1) return -1;
    prn(s);
    return 0;
}

void selling_price(Goods &s) {
    time_t timer;
    struct tm *cur;
    timer = time(NULL);
    cur = localtime(&timer);

    int cur_year = cur->tm_year + 1900; //현재 해
    int cur_mon = cur->tm_mon + 1; // 현재 달
    int cur_day = cur->tm_mday; // 현재 날짜

    int res = tot_days(s.year, s.mon, s.day) - tot_days(cur_year, cur_mon, cur_day);

    if (res > 10) {
        s.discount = 0;
    }
    else {
        if (res < 0) {
            cout << "유통기한이 지났습니다!" << endl;
            s.discount = -1;
        }
        else if (res >= 0 && res <= 3) {
            s.price /= 2;
            s.discount = 50;
        }
        else if (res >= 4 && res <= 10) {
            s.price = s.price - (s.price / 5);
            s.discount = 20;
        }
    }
    return;
}

void input(Goods &s) {
    int res;
    cout << "품목 입력 : ";
    cin >> s.item;
    cout << "정가 입력 : ";
    cin >> s.price;
    while (1) {
        cout << "유통기한 입력 : ";
        cin >> s.year >> s.mon >> s.day;
        int num[3] = { s.year,s.mon,s.day };
        res = errorCheck(num);
        if (res == 1) break;
        cout << "올바르지 못한 날짜입니다" << endl;
    }
    return;
}

void prn(const Goods &s) {


    cout << "품목 : " << s.item << endl;
    cout << "판매가 : " << s.price << endl;
    cout << "유통기한 : " << s.year << "년 " << s.mon << "월 " << s.day << "일 " << endl;
    cout << "할인율 : " << s.discount << "%" << endl;
    return;
}

int leap_check(int num) {
    if (num % 4 != 0) {
        return 0;
    }
    else {
        if (num % 100 != 0) {
            return 1;
        }
        else {
            if (num % 400 == 0) {
                return 1;
            }
            else {
                return 0;
            }
        }
    }
}

int tot_days(int y, int m, int d) {
    int sum = 0;
    int month[12] = { 31,28,31,30,31,30,31,31,30,31,30,31 };
    for (int i = 1900; i < y; i++) {
        if (leap_check(i) == 1) {
            sum += 366;
        }
        else {
            sum += 365;
        }
    }
    if (leap_check(y) == 1) {
        if (m <= 2) {
            for (int i = 0; i < (m - 1); i++) {
                sum += month[i];
            }
            sum += d;
        }
        else {
            for (int i = 0; i < (m - 1);i++) {
                sum += month[i];
            }
            sum += d + 1;
        }
    }
    else {
        for (int i = 0;i < (m - 1);i++) {
            sum += month[i];
        }
        sum += d;
    }
    return sum;
}

int errorCheck(int *num) {
    int month[12] = { 31,28,31,30,31,30,31,31,30,31,30,31 };
    if (num[1] >= 1 && num[1] <= 12) {
        if (leap_check(num[0]) == 1) {
            if (num[1] == 2) {
                if (num[2] >= 1 && num[2] <= 29) return 1;
            }
            else {
                if (num[2] >= 1 && num[2] <= month[num[1] - 1]) return 1;
            }
        }
        else {
            if (num[2] >= 1 && num[2] <= month[num[1] - 1]) return 1;
        }
    }
    return 0;
}

#include <iostream>
using namespace std;

struct Savings {
    int w500;
    int w100;
    int w50;
    int w10;
};

void init(Savings &s);
void input(int &unit, int &cnt);
void save(Savings &s, int unit, int cnt);
int total(Savings &s);
void my_flush();

int main() {
    struct Savings s;
    int unit, cnt, sum;
    while (1) {
        init(s);
        while (1) {
            input(unit, cnt);
            if (unit == -1) break;
            save(s, unit, cnt);
        }
        cout << "총 저금액 : " << total(s) << endl << endl;
    }
    return 0;
}

void init(Savings &s) {
    s.w500 = 0;
    s.w100 = 0;
    s.w50 = 0;
    s.w10 = 0;
}

void input(int &unit, int &cnt) {
    while (1) {
        cout << "동전의 금액 : ";
        cin >> unit;
        if (cin.fail()) {
            my_flush();
            unit = -1;
            return;
        }
        switch (unit) {
        case 10:;
        case 50:;
        case 100:;
        case 500: {
            cout << "동전의 개수 : ";
            cin >> cnt;
            return;

        }
        default: break;
        }
    }

}

void save(Savings &s, int unit, int cnt) {
    switch (unit) {
    case 10: s.w10 += cnt; break;
    case 50: s.w50 += cnt; break;
    case 100: s.w100 += cnt; break;
    case 500: s.w500 += cnt; break;
    }
}

int total(Savings &s) {
    int sum = 0;
    sum += 10 * s.w10;
    sum += 50 * s.w50;
    sum += 100 * s.w100;
    sum += 500 * s.w500;
    return sum;
}

void my_flush() {
    cin.clear();
    while (cin.get() != '\n');
}

HW8

#include <iostream>
using namespace std;

void swap_ptr(const char* &, const char* &);

int main() {
    const char *ap = "apple";
    const char *bp = "banana";

    cout << "바꾸기 전의 문자열 : " << ap << " " << bp << endl;
    swap_ptr(ap, bp);
    cout << "바꾼 후의 문자열 : " << ap << " " << bp << endl;

    return 0;
}

void swap_ptr(const char* &ap, const char* &bp) {
    char *tp;
    //tp = new char[len + 1];
    //strcpy(tp,)
    tp = (char*)ap;
    ap = (char*)bp;
    bp = tp;
}