C++ cout

cout은 cout << " C++ ";
이런식으로 출력문을 나타내는 객체이다
표준 출력 스트림을 나타내는 객체라고도 하며
콘솔에 텍스트를 출력하는데 주로 사용된다고 한다.

cout 객체는 C++의 표준 라이브러리에서 제공되며, iostream 헤더 파일에 정의되어 있다.

사용방법 : cout을 사용하여 텍스트를 출력하려면 <iostream> 헤더 파일을 포함하고, 다음과 같이 
<< 연산자를 사용하여 출력할 내용을 지정한다.

솔직히 cout이라고 왜 지정을했을까 이유를 찾아봤다.
왜 cout일까..

gpt에게 물어보니 cout이라는 이름은 C++ 표준 라이브러리에서 사용되는 약속된 이름이라고 한다
console output 의 줄임말이라고하니 왜 cout이라고 명칭을 지었는지 알겠다!
궁금증 해결@

그리고 cout과 같이 사용하는 << 과 endl; 이 있다
<< 연산자는 C++에서 출력 스트림에 데이터를 쓰는데 사용되는 연산자라고 한다.
이 연산자를 사용하여 데이터를 스트림에 "삽입" 하거나 출력하는 작업을 수행한다고 알려줬다.
C++의 입출력 라이브러리에서 데이터를 스트림으로 흘려보내는 역할이다 라니.
흠.. 그냥 cout을 사용할때 필수적이니 그렇게 알고있어야겠다.

endl은 말 그대로 끝나는지점이며, 개행 문자를 삽입하여 줄을 바꿔준다.
라고 알고있으면 될 것 같다.

**using namespace std;**는 C++ 프로그래밍에서 매우 흔하게 사용되는 문장 중 하나입니다. 이 문장은 C++ 표준 라이브러리의 모든 요소를 현재의 코드 범위에서 사용 가능하게 해주는 역할을 합니다. 아래에서 자세히 설명하겠습니다.

C++에서 **std**는 "Standard"의 줄임말로, C++ 표준 라이브러리에 정의된 다양한 기능과 객체들을 포함하는 네임스페이스(namespace)입니다. 이 표준 라이브러리는 문자열 처리, 입출력, 컨테이너(배열, 벡터, 리스트 등), 알고리즘 등 다양한 기능을 제공합니다.

그런데, C++에서는 네임스페이스를 사용하여 식별자(변수, 함수 등)가 충돌하는 것을 방지합니다. 예를 들어, 여러 라이브러리나 사용자 정의 코드에서 같은 이름의 함수나 변수를 사용하는 경우 충돌이 발생할 수 있습니다. 따라서 표준 라이브러리의 요소를 사용할 때, C++에서는 해당 요소들을 std 네임스페이스 안에 묶어두었습니다.

using namespace std; 문장은 이러한 std 네임스페이스를 현재의 코드 범위에 가져오는 역할을 합니다.

즉, 이 문장을 사용하면 **std::**를 붙이지 않고도 표준 라이브러리의 요소를 사용할 수 있습니다.

예를 들어, **std::cout**은 표준 출력 스트림을 나타내는데, **using namespace std;**를 사용하면 아래와 같이 간단하게 사용할 수 있습니다.

#include <iostream>int main() {
    cout << "Hello, World!" << endl;
    return 0;
}

하지만, 네임스페이스를 가져오는 것은 식별자 충돌을 피하기 위해 사용하는 좋은 방법이 아닐 수 있습니다. 특히 큰 프로젝트에서는 식별자 충돌 문제를 디버깅하기 어려울 수 있으므로, 좋은 프로그래밍 습관 중 하나는 using namespace std; 대신 필요한 표준 라이브러리 요소만 선택적으로 가져오는 것입니다. 예를 들어, **using std::cout;**와 같이 필요한 것만 네임스페이스에서 가져와 사용할 수 있습니다. 이렇게 하면 코드의 가독성을 높이고 충돌 가능성을 줄일 수 있습니다.

챗 gpt에게 물어봤지만 C++ 에서의 표준 라이브러리의 모든 요소를 현재의 코드 범위에서 사용 가능하게 해주는 역할이라고 한다.

std가 무슨뜻인지 몰랐지만 Standard라는 뜻이 있는것도 처음 알게됐다

다양한 기능과 객체들을 포함하는 네임스페이스(namespace) 라고 하는데 문자열 처리, 입출력, 컨테이너, 알고리즘 등 다양한 기능을 사용할 수 있다고 한다.

사실 using namespace std; 라는 문장을 std:: 를 사용하지않고 편한 사용을 위해서 그냥 그렇게 쓴다고만 알고 있었다.

대부분의 C++수업이나 강의들은 이런 것 들에 대한 자세한 정보를 알려주지 않는다. 필요없는지는 모르겠지만 나는 항상 이런게 왜 이렇게 사용되는지 너무 궁금했다.

처음 Java를 배웠을때도 나와 뜻이 잘 맞는 친구와 static과 new를 사용해서 객체를 생성했을떄의 차이점이 뭔지 너무 궁금해서 1~2시간 정도의 토론을 나누며 결국 답을 찾아냈다.

지금은 당연하게도 너무 쉬운 설명이다. 하지만 친구와 그렇게 코드에대해 자세하게 토론할 수 있는 친구가 있었던게 너무나 고마웠다.

하여튼 앞으로도 뭔가 알고싶은게 있다면 일일이 다 찾아보고 알아내고야 말겠다!

C++ 포인터

주소 연산자 & 주소 연산자 & 를 사용하면 변수에 할당된 메모리 주소를 확인할 수 있다.

#include <iostream>
using namespace std;

int main() {
int x = 5;
cout << x << '\\n';
cout << &x << '\\n';
return 0;
}

역참조 연산자 * 변수의 주소를 얻는 것 자체로는 그다지 유용하지 않다. 역참조 연산자 * 를 사용하면 특정주소에서 값에 접근할 수 있다.

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

int main() {
int x = 5;
printf("%d\\n", x);
cout << &x << '\\n'; 	//x변수의 메모리 주소 값
cout << *&x << '\\n';	//x 변수의 메모리 주소값에 할당되어있는 값
return 0;
}

포인터 (Pointer) 주소 연산자 7와 역참조 연산자 *와 함께 이제 포인터에 관해 이야기할 수 있다. 포인터는 어떠한 값을 저장하는 게 아닌 메모리 주소를 저장하는 변수다. 포인터(Pointer) 는 C++ 언어에서 가장 혼란스러운 부분 중 하나로 여겨지지만, 알고 보면 놀랍게도 간단하다.

포인터 선언 (Declaring a pointer) 포인터 변수는 일반 변수처럼 선언되며, 자료형과 변수 이름 사이에 *가 붙는다

자료형 *포인터 이름;

int* iPtr;	//int형 포인터
double* dPtr;	//double형 포인터

int* iPtr2, *iPtr3;	//int형 두 개의 포인터 선언

여러 포인터 변수를 선언하는 경우 별표가 각 변수에 포함되어야 한다.

int* iPtr4, iPtr5 //iPtr4는 int에 대한 포인터지만 iPtr5는 단순한 int다.

일반 변수와 마찬가지로 포인터는 선언 시 초기화되지 않는다. 초기화되지 않은 값은 쓰레기다. int 포인터 라고 말하면 int형에 대한 포인터를 의미한다.

포인터에 값 할당 포인터는 메모리 주소만 저장하므로, 포인터에 값을 할당할 때 그 값은 주소여야 한다. 포인터로 하는 가장 흔한 작업은 다른 변수의 주소를 저장하는 것이다. 변수의 주소를 얻으려면 주소 연산자 & 를 사용한다. 포인터 = &변수;

int value = 5; int *ptr = &value; //변수값의 주소로 ptr 초기화

ptr은 값으로 value 변수 값의 주소를 가지고 있다. 그러므로 ptr은 value 변수를 가르키는 값이라고 할 수 있다.

#include <iostream>

int main()
{
int value = 5;
int *ptr = &value; // 변수 값의 주소로 ptr 초기화

std::cout << &value << '\\\\n'; // value 변수의 주소 출력
std::cout << ptr << '\\\\n';    // ptr 변수 값 출력

return 0;

}

// 0012FF7C // 0012FF7C

포인터 변수의 자료형은 가리키는 변수의 자료형과 같아야 한다.

int iValue = 5;
double dValue = 7.0;

int *iPtr = &iValue; // ok
double *dPtr = &dValue; // ok
iPtr = &dValue; // wrong -- int 포인터는 double 변수의 주소를 가리킬 수 없다.
dPtr = &iValue; // wrong -- double 포인터는 int 변수의 주소를 가리킬 수 없다.

다음 사항도 올바르지 않다.

int *ptr = 5;

포인터가 주소만 보유할 수 있고 정수 리터럴 5에는 메모리 주소가 없기 때문이다. 위 코드를 시도하면 컴파일러는 정수를 정수 포인터로 변환할 수 없으므로 오류가 발생한다.

C++에서는 포인터에 리터럴 메모리 주소를 직접 할당할 수 없다.

double *dPtr = 0x0012FF7C; // not okay (정수 리터럴을 할당하는 것으로 취급된다.)

주소 연산자 &는 피연산자의 주소를 리터럴로 반환하지 않는다. 대신 피연산자의 주소가 들어있는 포인터를 반환한다.

포인터는 여러 가지 경우에서 유용하다.

배열은 포인터를 사용하여 구현된다. 포인터는 배열을 반복할 때 사용할 수 있다. (배열 인덱스 대신 사용 가능) C++에서 동적으로 메모리를 할당할 수 있는 유일한 방법이다. (가장 흔한 사용 사례) 데이터를 복사하지 않고도 많은 양의 데이터를 함수에 전달할 수 있다. 함수를 매개 변수로 다른 함수에 전달하는 데 사용할 수 있다. 상속을 다룰 때 다형성을 달성하기 위해 사용한다. 하나의 구조체/클래스 포인터를 다른 구조체/클래스에 두어 체인을 형성하는 데 사용할 수 있다. 이는 연결리스트 및 트리와 같은 고급 자료구조에서 유용하다.

포인터는 내가 컴퓨터의 메모리에 보다 직접적으로 접근해서 이를 제어할 수 잇도록 해주는 도구. 비유하자면 기다란 집게이다.

변수에 입력된 값들은 메모리의 어딘가에 저장된다. 한정된 공간 안아세 변수나 함수들의 값들이 필요에따라 쓰이고 치워지고 하면서 프로그램이 돌아간다 프로그램을 짜다 보면 어느 변수에 지정한 값을 다른 여러곳에 써야 할 때가 있다.

c에서의 어느 함수에 '변수가 인자로 주어질 때는그 값이 복사되어서 , 즉 베껴 적어져서 넘어가게 된다. 복사가 된다는건 메모리의 값이 어딘가의 그 크기만큼 중복된 값이 차지한다. 그렇게 메모리를 낭비하지 않고 페이지 번호만 적어서 보내줄 수 있도록 하는게 포인터 이다.

메모리의 모든 칸에는 각각의 주소가 있다. 위치를 가르킨다는 말은 충분하지 않다. 시작하는 페이지와 줄을 줬으면 어디서 끝나는지도 알아야한다. 변수에 쓰이는 메모리는 어떤 자료형이냐에 따라 크기가 다르다. 정수는 1이든 100이든 천만자리수든 4바이트(32비트)를 차지한다. double도 1.0이란 값에도 8바이트를 차지한다 컴퓨터의 데이터는 수많은 0과 1, 즉 On, OFF로 나뉜다. 메모리의 칸 하나하나가 ON, OFF가 되어 2진수를 만든다

int num = 1;
int y = 100;
int* p1 = #

printf("p1 %d \\n", *p1); 	//일때는 1값이 나오고

p1++ 	//이렇게 포인터에 정수값을 더하면 자로형의 크기 곱하기 그 값만큼
//오른쪽으로 메모리의 값이 이동하게 된다.
//그러면 y값이 나와야 하지 않겠느냐 라고 생각하겠지만
//전혀 다른 값이 나와버린다
p1--	//다시 포인터의 값을 --해주면 원래대로 돌아온다.

int number[] = {1, 2, 3, 4, 5, 6, 7}
int* p2 = &numbers[0];

printf("p2 %d \\n", *p2); 	//일때는 배열의 1번째 즉 1의 값이 나온다.
p2++;		//포인터 값을 증가시키면
printf("p2 %d \\n", *p2); 	//일때는 배열의 2번째 즉 2의 값이 나온다.

포인터는 이런식으로 배열과 연계되어서 사용될 수 있다.

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <conio.h>
#include <windows.h>


typedef struct list
{
    int data;
    struct list* link;
}LIST;
                          //queue를 위한 구조체 선언
typedef struct queue
{
    LIST* front;
    LIST* rear;
}QUEUE;

//메뉴 정보 구조체
typedef struct _MENU {
   char drink[30];
   char price[30];
}MENU;

//고객 정보 구조체
typedef struct _customer {
   char name[30];
   char phone[30];
}CUSTOMER;

//번호표 구조체
typedef struct _ticket_number {
   char number[30];
   char name[30];
   char drink[30];
   char price[30];
}TICKET_NUMBER;

//함수
QUEUE* Create_queue();
void Enqueue(QUEUE* pQ);
void Print(QUEUE* pQ);   //함수원형 선언
int Dequeue(QUEUE* pQ);
void Search(QUEUE* pQ);
int Que();

void new_add_menu();           //메뉴 추가 
void new_add_customer();      //고객 추가 
void new_add_ticker_number();      //번호표 추가 

int search_menu();            //메뉴 검색 
int search_customer();         //고객 검색 
int search_ticket_number();      //번호표 검색 

void edit_customer();         //고객 수정 
void edit_menu();            //메뉴 수정 

void del_customer();         //고객 삭제 
void del_menu();            //메뉴 삭제 

void view_menu();            //메뉴 전체 보기 
void view_customer();         //고객정보 전체 보기 
void view_ticket_number();      // 번호표 전체 보기 

int cross_search();       // 교차검색 

void end();                  //끝내기 

void input_menu();             //호출했을 ?? 정보를 전부 구조체에 담는 함수
void input_customer();
void input_ticket_number();

void SetTextColor(int background, int text) // UI
{
   SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), (background<<4) | text);
   //배경색인 background를 4비트 앞으로 보내고, text와 더하여 적용
}

//구조체 배열 전역변수 선언
MENU menu_info[200];
int menu_idx=0;        //메뉴 정보 카운팅

CUSTOMER customer_info[200];
int customer_idx=0;        //고객 정보 카운팅

TICKET_NUMBER ticket_number_info[200];
int ticket_number_idx=0;        //번호표 정보 카운팅


int main()  //메인화면
{
   int i, sel=1, idx;
   input_menu();
   input_customer();
   input_ticket_number();

   SetTextColor(15, 0); //15: 흰색, 0: 검은색

   while(sel!=16)
   {
      system("cls"); //화면지우기    
      printf("┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓\n");
      printf("┃                            ┃\n");
      printf("┃     카페 관리 프로그램     ┃\n"); 
      printf("┃                            ┃\n");
      printf("┃〓〓〓〓〓〓추가〓〓〓〓〓〓┃\n");
      printf("┃  1. 신규 메뉴 추가         ┃\n");
      printf("┃  2. 신규 고객 추가         ┃\n");
      printf("┃  3. 번호표 추가            ┃\n");
      printf("┃〓〓〓〓〓〓검색〓〓〓〓〓〓┃\n");
      printf("┃  4. 기존 메뉴 검색         ┃\n");
      printf("┃  5. 기존 고객 검색         ┃\n");
      printf("┃  6. 번호표 조회            ┃\n");
      printf("┃〓〓〓〓〓〓수정〓〓〓〓〓〓┃\n");
      printf("┃  7. 기존 고객 수정         ┃\n");
      printf("┃  8. 기존 메뉴 수정         ┃\n");
      printf("┃〓〓〓〓〓〓삭제〓〓〓〓〓〓┃\n");
      printf("┃  9. 기존 고객 삭제         ┃\n");
      printf("┃  10. 기존 메뉴 삭제        ┃\n");
      printf("┃〓〓〓〓〓전체보기〓〓〓〓〓┃\n");
      printf("┃  11. 메뉴 전체 보기        ┃\n");
      printf("┃  12. 고객 전체 보기        ┃\n");
      printf("┃  13. 번호표 전체 보기      ┃\n");
      printf("┃〓〓〓〓〓교차검색〓〓〓〓〓┃\n");
      printf("┃  14. 교차 검색             ┃\n");
      printf("┃〓〓〓〓〓대기열〓〓〓〓〓〓┃\n");
      printf("┃  15. 대기열 메뉴           ┃\n");
      printf("┃〓〓〓〓〓〓종료〓〓〓〓〓〓┃\n");
      printf("┃  16. 프로그램 종료         ┃\n");
      printf("┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛\n");
      printf("  원하는 메뉴를 선택하세요: ");

      scanf("%d", &sel) ;

switch(sel)
      {
      case 1:
         new_add_menu();
         break;
      case 2:
         new_add_customer();
         break;
      case 3:
         new_add_ticker_number();
         break;
      case 4:
         search_menu();
         break;
      case 5:
         search_customer();
         break;
      case 6:
         search_ticket_number();
         break;
      case 7:
         edit_customer();
         break;
      case 8:
         edit_menu();
         break;
      case 9:
         del_customer();
         break;
      case 10:
         del_menu();
         break;
      case 11:
         view_menu();
         break;
      case 12:
         view_customer();
         break;
      case 13:
         view_ticket_number();
         break;
      case 14:
        cross_search();
         break;
      case 15:
        Que();
         break;
      case 16:
         end();
         break;
      default:
         printf("\n잘못 선택하셨습니다.\n");
      }
      printf("\n작업을 완료하였습니다.\n새로운 메뉴를 선택하려면 Enter를 눌러주세요.\n");
      getch(); // 항목 입력 받기 대기 -> 엔터치면 새롭게 항복 선택 가능
   }
   return 0;
}

//고객 정보 파일에서 입력받기 
void input_customer()
 {
   FILE* c_fp = fopen("C:\\project\\Customer.txt", "r");
   char line[150];
   char* ptr;
   int word_cnt;

    //고객 정보 입력 
   while(fscanf(c_fp, "%s", line)>0)
   {
      word_cnt = 0;
      ptr = strtok(line,","); //","단위로 잘라내는 strtok함수  
      while(ptr!=NULL)
      {
         word_cnt++;
         switch(word_cnt)
         {
         case 1: //char name
            strcpy(customer_info[customer_idx].name, ptr);
            break;
         case 2: //char phone
            strcpy(customer_info[customer_idx].phone, ptr);
            break;
         }
         ptr=strtok(NULL,",");
      }
      customer_idx++;
   }
   fclose(c_fp); 
}
// 메뉴 정보 파일에서 입력 받기 
void input_menu()
 {
   FILE* fp = fopen("C:\\project\\Menu.txt", "r");
   char line[150];
   char* ptr;
   int word_cnt;

   //메뉴 정보 입력 
   while(fscanf(fp, "%s", line)>0)
   {
      word_cnt = 0;
      ptr = strtok(line,","); //","단위로 잘라내는 strtok 함수 
      while(ptr!=NULL)
      {
         word_cnt++;
         switch(word_cnt)
         {
         case 1: //char drink
            strcpy(menu_info[menu_idx].drink, ptr);
            break;
         case 2: //char price
            strcpy(menu_info[menu_idx].price, ptr);
            break;
         }
         ptr=strtok(NULL,",");
      }
      menu_idx++;
   }
   fclose(fp); 
}
//번호표 정보 파일에서 입력받기 
void input_ticket_number()
 {
   FILE* fp = fopen("C:\\project\\Ticket_number.txt", "r");
   char line[150];
   char* ptr;
   int word_cnt;
//   int count=0; //번호표 부여  (x)

   //정보 입력 
   while(fscanf(fp, "%s", line)>0)
   {
      word_cnt = 0;
      ptr = strtok(line,","); //","단위로 잘라내는 strtok 함수 
      while(ptr!=NULL)
      {
         word_cnt++;          
         switch(word_cnt)
         {
         case 1: //char number
            strcpy(ticket_number_info[ticket_number_idx].number, ptr);
            break;
         case 2: //char name
            strcpy(ticket_number_info[ticket_number_idx].name, ptr);
            break;
         case 3: //char drink
            strcpy(ticket_number_info[ticket_number_idx].drink, ptr);
            break;
         case 4: //char price
            strcpy(ticket_number_info[ticket_number_idx].price, ptr);
            break;
        }
         ptr=strtok(NULL,",");
      }
      ticket_number_idx++;
   }
   fclose(fp); 
}




//1. 신규 메뉴 추가
void new_add_menu()
{
   FILE* fp = fopen("C:\\project\\Menu.txt", "a");
   
   system("cls");
    printf("┏━━━━━━━━━━━━━━━━━━━━━━━━━━┓\n");
    printf("┃                          ┃\n");
   printf("┃      신규 메뉴 추가      ┃\n");
   printf("┃                          ┃\n");
   printf("┗━━━━━━━━━━━━━━━━━━━━━━━━━━┛\n");   

   printf("\n"); 
   printf("메뉴 이름: ");
   scanf("%s", &menu_info[menu_idx].drink);
   printf("가격: ");
   scanf("%s", &menu_info[menu_idx].price);
   printf("신규 메뉴 추가 완료");



   fprintf(fp, "%s,%s\n", menu_info[menu_idx].drink, menu_info[menu_idx].price);
   menu_idx++;
   fclose(fp);
}

//2. 신규 고객 정보 추가 
void new_add_customer()
{
   FILE* c_fp = fopen("C:\\project\\Customer.txt", "a");
   
   system("cls");
    printf("┏━━━━━━━━━━━━━━━━━━━━━━━━━━┓\n");
    printf("┃                          ┃\n");
   printf("┃      신규 고객 추가      ┃\n");
   printf("┃                          ┃\n");
   printf("┗━━━━━━━━━━━━━━━━━━━━━━━━━━┛\n");   



   printf("\n");
   printf("고객 이름: ");
   scanf("%s", &customer_info[customer_idx].name);
   printf("고객 전화번호: ");
   scanf("%s", &customer_info[customer_idx].phone);
   printf("신규 고객 추가 완료");
   
   fprintf(c_fp, "\n%s,%s\n", customer_info[customer_idx].name, customer_info[customer_idx].phone);
   customer_idx++;
   fclose(c_fp);
}


//3. 신규 번호표 추가 
void new_add_ticker_number()
{
   FILE* fp = fopen("C:\\project\\Ticket_number.txt", "a");
   system("cls");
    printf("┏━━━━━━━━━━━━━━━━━━━━━━━━━━┓\n");
    printf("┃                          ┃\n");
   printf("┃     신규 번호표  추가    ┃\n");
   printf("┃                          ┃\n");
   printf("┗━━━━━━━━━━━━━━━━━━━━━━━━━━┛\n");   

   
   printf("\n");
   printf("번호: ");
   scanf("%s", &ticket_number_info[menu_idx].number);
   printf("이름: ");
   scanf("%s", &ticket_number_info[menu_idx].name);
   printf("음료: ");
   scanf("%s", &ticket_number_info[menu_idx].drink);
   printf("가격: ");
   scanf("%s", &ticket_number_info[menu_idx].price);

   fprintf(fp, "%s,%s,%s,%s\n", ticket_number_info[menu_idx].number, ticket_number_info[menu_idx].name, ticket_number_info[menu_idx].drink,ticket_number_info[menu_idx].price);
   ticket_number_idx++;
   fclose(fp);
}

//4. 메뉴 종류로 검색하기 
int search_menu()
{
   int i;
   char drink[30]; //여기에 입력할 이름 

   system("cls");
    printf("┏━━━━━━━━━━━━━━━━━━━━━━━━━━┓\n");
    printf("┃                          ┃\n");
   printf("┃        메뉴 검색         ┃\n");
   printf("┃                          ┃\n");
   printf("┗━━━━━━━━━━━━━━━━━━━━━━━━━━┛\n");   

   printf("\n음료 이름: ");
   scanf("%s", &drink);
   for(i=0; i<=menu_idx; i++) //menu 유요한 배열만큼 돌립니다. 
   {
      if(strcmp(drink, menu_info[i].drink)==0)
      { //strcmp함수 사용 -> 입력한 drink과 구조체 배열의 메뉴가 일치하면 0을 반환. 
            printf("음료: %s \n가격: %s\n", menu_info[i].drink, menu_info[i].price);
            return i;
      }
      
      else if(strcmp(drink, menu_info[i].drink)!=0 && i==menu_idx)
      {
            printf("============================\n");
             printf("찾으시는 정보가 없습니다.\n");
             printf("============================\n");
             return i;
      }
      
      else
      continue;
   }
}

//5. 이름으로 고객 정보 검색 
int search_customer()
{
   int i;
   char name[30];
   
      system("cls");
    printf("┏━━━━━━━━━━━━━━━━━━━━━━━━━━┓\n");
    printf("┃                          ┃\n");
   printf("┃        고객 검색         ┃\n");
   printf("┃                          ┃\n");
   printf("┗━━━━━━━━━━━━━━━━━━━━━━━━━━┛\n");   
   
   printf("\n이름: ");
   scanf("%s", &name);
   for(i=0; i<=customer_idx; i++) 
   {
      if(strcmp(name, customer_info[i].name)==0)
     {  //고객의 유무에 따라 반환하기 위한 형태
         printf("고객 이름: %s \n고객 전화번호: %s\n", customer_info[i].name, customer_info[i].phone);   
         return i;
       }
       
       else if(strcmp(name ,customer_info[i].name)!=0 && i==customer_idx)
       {
          printf("============================\n");
          printf("찾으시는 정보가 없습니다.\n");
          printf("============================\n");
      return i;   
     }
     
     else continue;
   }
}

//6. 번호표 조회 
int search_ticket_number()
{
   int i;
   char number[30];
   
      system("cls");
    printf("┏━━━━━━━━━━━━━━━━━━━━━━━━━━┓\n");
    printf("┃                          ┃\n");
   printf("┃       번호표 검색        ┃\n");
   printf("┃                          ┃\n");
   printf("┗━━━━━━━━━━━━━━━━━━━━━━━━━━┛\n");   

   
   printf("\n번호표: ");
   scanf("%s", &number);
   for(i=0; i<ticket_number_idx; i++) 
   {
      if(strcmp(number, ticket_number_info[i].number)==0)
     {  //고객의 유무에 따라 반환하기 위한 형태
      printf("번호: %s \n이름: %s \n음료: %s \n가격: %s \n", ticket_number_info[i].number, ticket_number_info[i].name,ticket_number_info[i].drink,ticket_number_info[i].price);
         return i;
        }
   }
   return -1;
}

//7. 고객 정보 수정 
 void edit_customer()
{
   int i, j, k;
   char name[20];
   char info[20];
   
      system("cls");
    printf("┏━━━━━━━━━━━━━━━━━━━━━━━━━━━┓\n");
    printf("┃                           ┃\n");
   printf("┃      고객 정보 수정       ┃\n");
   printf("┃                           ┃\n");
   printf("┗━━━━━━━━━━━━━━━━━━━━━━━━━━━┛\n");   


   
   printf("\n이름을 입력해주세요: "); 
   scanf("%s", name);
   printf("\n");

   for(i=0; i<customer_idx; i++)
   {
      if(strcmp(name, customer_info[i].name)==0)
      { 
         printf("이름: %s\n전화번호: %s\n", customer_info[i].name, customer_info[i].phone);
         printf("\n");
         printf("1.이름 2.전화번호\n");
         printf("번호를 선택하세요: ");
         scanf("%d", &j);
         if(j==1)
         {
            printf("수정할 이름: ");
            scanf("%s", customer_info[i].name); 
         } 
         else if(j==2)
         {
            printf("수정할 전화번호: ");
            scanf("%s", customer_info[i].name); 
         } 
         printf("\n");
      }
   }
}

//8. 메뉴 정보 수정 
 void edit_menu()
{
   int i, j, k;
   char drink[20];
   char info[20];
   
      system("cls");
    printf("┏━━━━━━━━━━━━━━━━━━━━━━━━━━┓\n");
    printf("┃                          ┃\n");
   printf("┃        메뉴 수정         ┃\n");
   printf("┃                          ┃\n");
   printf("┗━━━━━━━━━━━━━━━━━━━━━━━━━━┛\n");   

   
   printf("\n메뉴를 입력해주세요: "); 
   scanf("%s", drink);
   printf("\n");

   for(i=0; i<menu_idx; i++)
   {
      if(strcmp(drink, menu_info[i].drink)==0)
      {
         printf("음료: %s\n가격: %s\n", menu_info[i].drink, menu_info[i].price);
         printf("\n");
         printf("1.음료 2.가격\n");
         printf("번호를 선택하세요: ");
         scanf("%d", &j);
         if(j==1)
         {
            printf("수정할 음료: ");
            scanf("%s", menu_info[i].drink); 
         } 
         else if(j==2)
         {
            printf("수정할 가격: ");
            scanf("%s", menu_info[i].price); 
         } 
         printf("\n");
      }
   }
}

//9. 기존 고객 삭제 
void del_customer()
 {   
   FILE* fp = fopen("C:\\project\\Customer.txt", "r+");

    int i=0;
   char name[30];
   
      system("cls");
    printf("┏━━━━━━━━━━━━━━━━━━━━━━━━━━┓\n");
    printf("┃                          ┃\n");
   printf("┃        고객 삭제         ┃\n");
   printf("┃                          ┃\n");
   printf("┗━━━━━━━━━━━━━━━━━━━━━━━━━━┛\n");   

   
   printf("\n이름: ");
   scanf("%s", &name);   

    //입력된 이름으로 고객 정보 삭제 
    for(i=0; i<customer_idx; i++)
    {
        //삭제할 고객 정보 출력
        if(strcmp(name, customer_info[i].name)==0)
        {
           printf("\n삭제할 고객 이름\n이름: %s\n전화번호: %s\n",customer_info[i].name, customer_info[i].phone);
           //고객 정보 삭제 
           memset(&customer_info[i], 0x00, sizeof(CUSTOMER));
         fprintf(fp, "%s %s\n", customer_info[i].name, customer_info[i].phone);
         fclose(fp);
        }
    }
}

//10. 기존 메뉴 삭제 
void del_menu()
 {   
   FILE* fp = fopen("C:\\project\\Menu.txt", "r+");

    int i=0;
   char drink[30];
   
      system("cls");
    printf("┏━━━━━━━━━━━━━━━━━━━━━━━━━━┓\n");
    printf("┃                          ┃\n");
   printf("┃        메뉴 삭제         ┃\n");
   printf("┃                          ┃\n");
   printf("┗━━━━━━━━━━━━━━━━━━━━━━━━━━┛\n");   

   
   printf("\n메뉴 이름: ");
   scanf("%s", &drink);   

    //입력된 메뉴로 음료 정보 삭제 
    for(i=0; i<menu_idx; i++)
    {
        //삭제할 음료 정보 출력
        if(strcmp(drink, menu_info[i].drink)==0)
        {
           printf("\n삭제할 메뉴\n음료: %s\n가격: %s\n",menu_info[i].drink, menu_info[i].price);
           //음료 정보 삭제 
           memset(&menu_info[i], 0x00, sizeof(MENU));
         fprintf(fp, "%s %s\n", menu_info[i].drink, menu_info[i].price);
         fclose(fp);
        }
    }
}

//11. 메뉴 전체보기
void view_menu()
{
   int i;
   
      system("cls");
    printf("┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓\n");
    printf("┃                            ┃\n");
   printf("┃        메뉴 전체보기       ┃\n");
   printf("┃                            ┃\n");
   printf("┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛\n");   

   
   printf("\n          Menu                    Price \n");
   printf("------------------------------------------------\n");
   for(i=0; i<menu_idx; i++) //유효한 배열 불러오기 
   {
      printf("%15s%20s\n",menu_info[i].drink,menu_info[i].price);
   }
}

//12. 고객 전체보기  
void view_customer()
{
   int i;
   
         system("cls");
    printf("┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓\n");
    printf("┃                            ┃\n");
   printf("┃        고객 전체보기       ┃\n");
   printf("┃                            ┃\n");
   printf("┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛\n");   
   
   printf("\n          Name           Phone       \n");
   printf("---------------------------------------\n");
   for(i=0; i<customer_idx; i++)
   {
      printf("%15s%20s\n", customer_info[i].name, customer_info[i].phone);
   }
}

//13. 번호표 전체보기  
void view_ticket_number()
{
   int i;
   
         system("cls");
    printf("┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓\n");
    printf("┃                              ┃\n");
   printf("┃        번호표 전체보기       ┃\n");
   printf("┃                              ┃\n");
   printf("┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛\n");   
   printf("\n          번호           이름           음료           가격\n");
   printf("-------------------------------------------------------------\n");
   for(i=0; i<ticket_number_idx; i++)
   {
      printf("%12s%15s%18s%15s\n", ticket_number_info[i].number, ticket_number_info[i].name,ticket_number_info[i].drink,ticket_number_info[i].price);
   }
}


//14. 메뉴 종류, 고객 종류 검색하기 
int cross_search()
{
   int i,j;
   char drink[30]; //여기에 입력할 이름 
   char name[30];

   system("cls");
    printf("┏━━━━━━━━━━━━━━━━━━━━━━━━━━┓\n");
    printf("┃                          ┃\n");
   printf("┃        교차 검색         ┃\n");
   printf("┃                          ┃\n");
   printf("┗━━━━━━━━━━━━━━━━━━━━━━━━━━┛\n");   

   printf("\n메뉴 이름: ");
   scanf("%s", &drink);
   for(i=0; i<menu_idx++; i++) //menu 유요한 배열만큼 돌립니다. 
   {
      if(strcmp(drink, menu_info[i].drink)==0){ //strcmp함수 사용 -> 입력한 drink과 구조체 배열의 메뉴가 일치하면 0을 반환. 
            printf("음료: %s \n가격: %s\n", menu_info[i].drink, menu_info[i].price); 
            break;
      }
       else{
          printf("============================\n");
          printf("  찾으시는 정보가 없습니다. \n");
          printf("============================\n");
          break; 
     }
 }
   
   printf("\n고객 이름: ");
   scanf("%s", &name);
   for(j=0; j<customer_idx; j++) 
   {
      if(strcmp(name, customer_info[j].name)==0){  //고객의 유무에 따라 반환하기 위한 형태
      printf("고객 이름: %s \n고객 전화번호: %s\n", customer_info[j].name, customer_info[j].phone);   
    
  }
          else{
          printf("============================\n");
          printf("  찾으시는 정보가 없습니다. \n");
          printf("============================\n");
      return j;   
     }
     return -1;
   }
}

// 15번 
int Que()
{
    QUEUE* Q;
    int item, val;
    system("cls");
    while(1)
    {
    	printf("\n\n\n     ┏━━━━━━━━━━━━━━━━━━━━┓\n");
    	printf("     ┃                    ┃    \n"); 
        printf("     ┃    *** MeNu ***    ┃\n");
        printf("     ┃   1) 번호표 생성   ┃\n");
        printf("     ┃   2) 번호표 입력   ┃\n");
        printf("     ┃   3) 번호표 삭제   ┃\n");
        printf("     ┃   4) 대기열        ┃\n");
        printf("     ┃   5) Exit          ┃\n");
        printf("     ┃                    ┃\n"); 
        printf("     ┃                    ┃    \n"); 
        printf("     ┗━━━━━━━━━━━━━━━━━━━━┛\n");
        printf("     SELECT : ");
        scanf("%d", &val);
        switch(val)
        {
        case 1 : Q = Create_queue(); break;
        case 2 :  Enqueue(Q); break;
        case 3 :  item = Dequeue(Q);
                  printf("\t 맨 앞 번호표가 삭제되었습니다.\n \t삭제된 번호표 = %d\n", item);
                  break;
        case 4 : Print(Q); break;
        case 5 : exit(1);
        }
    }
}

/* 큐를 초기화 하는 함수(front와 rear를 생성한다.) */
QUEUE* Create_queue()
{
	system("cls");
    QUEUE* Q;
    Q = (QUEUE*)malloc(sizeof(QUEUE));
    Q->front = NULL;
    Q->rear = NULL;
    return Q;
}

/* 큐에서 데이터를 입력하는 함수 */
void Enqueue(QUEUE* pQ)
{
	system("cls");
    LIST* newNode, *temp;
    int val;
    printf("\t 번호표를 입력해 주세요. : ");
    scanf("%d", &val);

    newNode = (LIST*)malloc(sizeof(LIST));
    newNode->data = val;
    newNode->link = NULL;

    if(pQ->rear == NULL)
    {
        pQ->rear = newNode;
        pQ->front = newNode;
    }
    else
    {
        temp = pQ->rear;
        while(temp->link != NULL)
            temp = temp->link;
        temp->link = newNode;
    }
}

/* 큐에서 데이터를 삭제하는 함수 */
int Dequeue(QUEUE* pQ)
{
	system("cls");
    LIST* temp;
    int item;
   
    if(pQ->front == NULL)
    {
        printf("\n\t 현재 대기열이 없습니다.\n");
        exit(1);
    }
    else
    {
        temp = pQ->front;//삭제할 데이터
        item = temp->data;
        pQ->front = pQ->front->link;//front를 앞으로 증가시킴
        if(pQ->front == NULL)//삭제할 노드가 한개일 경우
        {
            pQ->rear = NULL;
        }
        free(temp);
    }
    return item;
}

/* 큐에 있는 데이터를 출력하는 함수 */
void Print(QUEUE* pQ)
{
	system("cls");
    LIST* temp;
    temp = pQ->front;
    printf("\n\t*** 대기열 ***\n\t");
    while(temp != NULL)
    {
        printf("%d번 ", temp->data);
        temp = temp->link;
    }
    printf("\n");
}



//16. 프로그램 종료
void end()
{
   printf("\n프로그램을 종료합니다\n");
   exit(1);
}

#include <iostream>  	//선언부 컴파일에 접근을해서 선언파트에 있는 걸 처리해서 사용 
using namespace std;    //std라는 소속을 알려줄 필요가 다음부터 없는것 등록을 했을경우 ex( std::cout 

void swap();			//함수 선언문	 

int main()				// 몸체부, 메인 함수 // int 를 쓰는이유는 비정상적인 오류를 제외 시키는것
					//void를 써도 상관없지만 오류가 날수도있고 계속 컴퓨터가 값을 기다린다
{
	int arr[5];				//배열 arr[]를 메모리값의 크기가 5인 배열 선언 
	int temp = 0;			// temp라는 변수가 가르키는 주소 값에 메모리안에 0을 선언 0으로 초기화 

	cout << "=====input=====" <<endl; 								//출력문 
	for(int i=0; i<5; i++){								//조건식이 트루일때만 실행 그리고 문장을 갔다가 증감식을가고 다시 조건식으로 0~4까지 1++
		cout << i+1 << "번째 숫자 : "; 					//i는 0부터니까 i+1부터 시작 출력문 
		cin >> arr[i];									//0부터 4까지 arr[i]에 값 입력 
	}	
	cout << "============data============" <<endl; 				//출력문 
	cout << "현재 들어간 숫자 : ";								//출력문	 
	for(int i=0; i<5; i++){								//조건식이 트루일때만 실행 그리고 문장을 갔다가 증감식을가고 다시 조건식으로 0~4까지 1++ 
		cout << arr[i] << " "; 							//arr[] 배열값에 뭐가 들어가있는지 출력 
	}
	cout << endl;				//줄 바꿈 
	
	cout << "============swap============" << endl;			//출력문, 줄바꿈 
		for(int j=0; j<2; j++){		//0~1까지 1씩 증가//조건식이 트루일때만 실행 그리고 문장을 갔다가 증감식을가고 다시 조건식
				for(int i=j; i<4-j; i++){		//j부터 4-j까지 1씩 증가 //조건식이 트루일때만 실행 그리고 문장을 갔다가 증감식을가고 다시 조건식
					if(arr[i] > arr[i+1]){		//arr[i]가 a[i+1]보다 클때 실행
					swap(arr[i], arr[i+1]);				//swap 함수사용 
					}
					cout << j+1 << "-"<<i+1<< "번째 정렬 : ";			// for문이 2개이기때문에  j+1 - i+1 로 출력문을 써준다 
						for(int q=0; q<5; q++){					//조건식이 트루일때만 실행 그리고 문장을 갔다가 증감식을가고 다시 조건식으로0~5 1++ 
						cout << arr[q] << " "; 					//arr[q] 출력 
				}
								cout <<endl;				//줄바꿈 
			}
			cout << endl;
				for(int c=3; c>=j+1; c--){			//조건식이 트루일때만 실행 그리고 문장을 갔다가 증감식을가고 다시 조건식으로 3부터 j+1까지 1-- 
					if(arr[c] < arr[c-1]){				//arr[c] 가 arr[c-1] 이라면 조건문 실행 
					swap(arr[c], arr[c-1]);				// arr[c]와 arr[c-1]을 swap 함수로 값을 보냄 
				}
				cout << j+1 <<"-" << c+1<< "번째 정렬 : ";		//for문이 2개이기 때문에 j+1 - c+1로 값을 설정 (출력문) 
						for(int z=0; z<5; z++){				//조건식이 트루일때만 실행 그리고 문장을 갔다가 증감식을가고 다시 조건식으로 0~5까지 1++ 
						cout << arr[z] << " "; 				//arr[] 배열값 출력 
			}
						cout << endl;				//줄 바꿈 
		}
		cout << endl;
					
	}
}
void swap(int x, int y){		//함수 선언문 
	int temp;				// temp 변수 선언 
	
	temp = x;			//temp, x 값 교환		 
	x = y;				//x, y 값 교환 
	y = temp;			//y, temp 값 교환 
}

#include <iostream>  	//선언부 컴파일에 접근을해서 선언파트에 있는 걸 처리해서 사용 
using namespace std;    //std라는 소속을 알려줄 필요가 다음부터 없는것 등록을 했을경우 ex( std::cout 

void swap();			//함수 선언문	 

int main()				// 몸체부, 메인 함수 // int 를 쓰는이유는 비정상적인 오류를 제외 시키는것
					//void를 써도 상관없지만 오류가 날수도있고 계속 컴퓨터가 값을 기다린다
{
	int arr[5];				//배열 arr[]를 메모리값의 크기가 5인 배열 선언 
	int temp = 0;			// temp라는 변수가 가르키는 주소 값에 메모리안에 0을 선언 0으로 초기화 

	cout << "=====input=====" <<endl; 								//출력문 
	for(int i=0; i<5; i++){								//조건식이 트루일때만 실행 그리고 문장을 갔다가 증감식을가고 다시 조건식으로 0~4까지 1++
		cout << i+1 << "번째 숫자 : "; 					//i는 0부터니까 i+1부터 시작 출력문 
		cin >> arr[i];									//0부터 4까지 arr[i]에 값 입력 
	}	
	cout << "============data============" <<endl; 				//출력문 
	cout << "현재 들어간 숫자 : ";								//출력문	 
	for(int i=0; i<5; i++){								//조건식이 트루일때만 실행 그리고 문장을 갔다가 증감식을가고 다시 조건식으로 0~4까지 1++ 
		cout << arr[i] << " "; 							//arr[] 배열값에 뭐가 들어가있는지 출력 
	}
	cout << endl;				//줄 바꿈 
	
	cout << "============swap============" << endl;			//출력문, 줄바꿈 
		for(int j=0; j<5; j++){		//0~4까지 1씩 증가//조건식이 트루일때만 실행 그리고 문장을 갔다가 증감식을가고 다시 조건식
				for(int i=j; i>=1; i--){		//0~2까지 1씩 증가 //조건식이 트루일때만 실행 그리고 문장을 갔다가 증감식을가고 다시 조건식
					if(arr[i] > arr[i-1]){		//arr[i]가 a[i+1]보다 클때 실행
					swap(arr[i], arr[i-1]);				//swap 함수사용 
					}
					cout << "정렬 : ";			// for문이 2개이기때문에  j+1 - i+1 로 출력문을 써준다 
						for(int q=0; q<5; q++){					//조건식이 트루일때만 실행 그리고 문장을 갔다가 증감식을가고 다시 조건식으로0~5 1++ 
						cout << arr[q] << " "; 					//arr[q] 출력 
				}
								cout <<endl;				//줄바꿈 
			}
	}
}

void swap(int x, int y){		//함수 선언문 
	int temp;				// temp 변수 선언 
	
	temp = x;			//temp, x 값 교환		 
	x = y;				//x, y 값 교환 
	y = temp;			//y, temp 값 교환 
}

#include <iostream>				//C++을 구동하기 위한 헤더 파일 선언
using namespace std;			//std::의 접두어를 생략한다.

class BASE1{						//기본 클래스 sel,count,arr[],mid 멤버 변수와 Set(), tam2() 멤버 함수를 지님 //디폴트 생성자도 자동생성 
	int arr[6];						//전역 정수형 배열로 arr[6] 선언 
	int mid, sel, count=0;			//전역 정수형 변수 mid, sel, count 선언 
	int left = 1, right = 5; 		// left, right 초기화
	public:							//어디서든지 사용가능 
		void set(int a){			//Set int 인자를 1개 받는 생성자 
			sel = a;				//sel이라는 변수가 가르키는 주소 값에 메모리안에 a을 선언 a로 초기화 // 받은 인자값을 sel에 선언 
		}
		void tam2(){				//이분탐색 생성자 
			for(int i=1;i<6;i++){arr[i]=i;} 	//배열값을 추가해주는 for문 	
			
			for(int i=0; i<5; i++){			//조건식이 트루일때만 실행 그리고 문장을 갔다가 증감식을가고 다시 조건식으로 0~4까지 1++ 
      		mid = (left+right)/2; 			// mid값 갱신 새로 돌아갈때마다 
      		if(arr[mid] == sel){			//arr[mid]와 sel 값이 같다면 조건식 실행 
      			count++;					//count 값 증가 
      			cout << count <<"번째 비교 "<< endl;		//비교 횟수 출력문 
		  		cout << mid << "값과" << sel << "값이 같습니다." << endl;	//비교값 출력문 
		  		break;						//값이 같다면 for문 탈출 
	 		 }
	  		else if(arr[mid] > sel){		//arr[mid]가 sel보다 크다면 
	  			count++;					//count 값 증가	 
      			cout << count <<"번째 비교 "<< endl;		//비교 횟수 출력문 
				cout << mid << "값과" << sel << "값이 같지 않습니다.." << endl;		//비교값 출력문 
				right = mid;				//왼쪽값이 크면 미드를 왼쪽으로 당겨준다 
	  		}
	  		else if(arr[mid] < sel){		//arr[mid]가 sel보다 작다면 
	  			count++;					//count값 증가 
      			cout << count <<"번째 비교 "<< endl;		//비교 횟수 출력문 
				cout << mid << "값과" << sel << "값이 같지 않습니다.." << endl;		//비교값 출력문 
				left = mid+1;				//만약 나눴을때 4.5라면 정수는 항상 4가 나오기 때문에 비교값이 5일때를 대비해서 만들어준 값 
			  }
  		}	
	}
};
int main(){					// 몸체부, 메인 함수 // int 를 쓰는이유는 비정상적인 오류를 제외 시키는것
							//void를 써도 상관없지만 오류가 날수도있고 계속 컴퓨터가 값을 기다린다
    int sel;				//정수형 변수 sel 선언  
    
  	cout << "찾을 값을 입력해 주세요: ";		//출력문 
  	cin >> sel; 								//sel 입력문	
  	
	BASE1 B;								//클래스의 객체 생성 객체 이름은 B 
	B.set(sel);								//클래스에 접근 (sel)인자값 보내기 
	B.tam2();								//클래스의 멤버에 접근 B.tam() 사용 

}

#include <iostream>  	//선언부 컴파일에 접근을해서 선언파트에 있는 걸 처리해서 사용 
using namespace std;    //std라는 소속을 알려줄 필요가 다음부터 없는것 등록을 했을경우 ex( std::cout 

int main()				// 몸체부, 메인 함수 // int 를 쓰는이유는 비정상적인 오류를 제외 시키는것
						//void를 써도 상관없지만 오류가 날수도있고 계속 컴퓨터가 값을 기다린다
{
   int a[5]={1,4,3,2,5};											//arr 이라는 배열이 가르키는 주소 메모리 값을 5로 선언과 동시에 1,4,3,2,5로 초기화 
   int temp=0; 														//temp라는 변수가 가르키는 주소 값에 메모리안에 0을 선언 0으로 초기화 
   int data=0;														//data 이라는 변수가 가르키는 주소 값에 메모리안에 0을 선언 0으로 초기화 
   cout << "============data============" <<endl; 					//데이터값 출력문, 줄바꿈  

   for(int i=0; i<5; i++) 											//0 ~ 4까지 1++ 조건식이 트루일때만 실행 그리고 문장을 갔다가 증감식을가고 다시 조건식
   {
   	  cout<< i+1 << "번째 배열 값: ";		 						// i+1 번째 배열값 출력문 
      cout<<a[i]<<endl; 											// a[i] 배열 값 출력문, 줄바꿈 
   }
    cout<<endl;														//줄바꿈 
  cout << "============swap============" << endl;					//솔트 시작 출력문, 줄바꿈 
  for (int i=0; i<4; i++)											//0 ~ 4까지 1++ 조건식이 트루일때만 실행 그리고 문장을 갔다가 증감식을가고 다시 조건식
   {
      if (a[i] < a[i+1])											//a[i] 배열 값이 a[i+1]보다 작다면 if조건문 실행 
      {
         temp = a[i+1];												//temp 배열 값에 주소가 가르키는 메모리 값에 a[i+1] 대입 
         a[i+1] = a[i];												//a[i+1] 배열 값에 주소가 가르키는 메모리 값에 a[i] 대입
         a[i] = temp;												//a[i] 배열 값에 주소가 가르키는 메모리 값에 temp 대입    솔트문 

         for(int j=0; j<5; j++)										//0 ~ 4까지 1++ 조건식이 트루일때만 실행 그리고 문장을 갔다가 증감식을가고 다시 조건식
         {
            cout<<a[j]<<" ";										//a[j] 배열값 출력문 
         }
            cout << endl;					 						//줄바꿈 
      }
   }
   
   for(int i=4;i>0;i--){											//4 ~ 1까지 1-- 조건식이 트루일때만 실행 그리고 문장을 갔다가 증감식을가고 다시 조건식
      if(a[i]>a[i-1]){												//a[i] 배열 값이 a[a+i]보다 크다면 if조건문 실행 
         temp=a[i];													//temp 배열 값에 주소가 가르키는 메모리 값에 a[i] 대입 
         break;														//for문 탈출 
      }
   }
   for(int i=3;i>0;i--){											//3 ~ 1까지 1-- 조건식이 트루일때만 실행 그리고 문장을 갔다가 증감식을가고 다시 조건식
      if(temp>=a[i]){												//temp 값이 a[i]보다 크거나 같다면 if조건문 실행 
         a[i]=a[i-1];												//a[i] 배열 값에 주소가 가르키는 메모리 값에 a[i-1] 대입
      } 
   }
   for(int i=0;i<5;i++){											//0~4까지 1++ 조건식이 트루일때만 실행 그리고 문장을 갔다가 증감식을가고 다시 조건식
      if(data<a[i]) {												//data 값이 a[i]보다 작다면 if조건문 실행 
         data=a[i];													//data 값에 주소가 가르키는 메모리 값에 a[i] 대입
      }
   }
   if((a[0]==a[1])&&(temp>data))									//a[0]값과 a[1]값이 같으면서 temp값이 data보다 커야 if조건문 실행 
      {
        a[0]=temp;													//a[0] 배열 값에 주소가 가르키는 메모리 값에 temp대입
    }
   cout<<endl<<"최종 배열 값:";										//최종 배열 값 출력문 

   for(int i=0;i<5;i++) 											//0~4까지 1++ 조건식이 트루일때만 실행 그리고 문장을 갔다가 증감식을가고 다시 조건식
   {
      cout<<" "<<a[i]; 												//a[i] 배열값 출력 
   }  
   return 0; 														//리턴값 0 
}