***************************< 캠퍼스 C  강좌 >******************************
[제목] :
[코드] : campusc1-029 (초급)
[교재] : CAMPUS C (초급, Third edition)  [출판사 : 책과스승]
[알림] :이 파일은 "캠퍼스 C"에서 모든 분께 공개한 "초급 강좌"입니다.
        이 [알림]의 내용을 지우지 않는다면 누구에게나 임의로 복사해 줄 수
        있습니다. 그러나 이 강좌 내용에 대한 저작권은 "캠퍼스 C"에 있습니다.

[연락처] : 605-8662 (서울) ("캠퍼스 C", 도서출판 "책과 스승")
           천리안 : go campusc  
           나우콤 : go lcampc
           하이텔 ID : campusc
****************************<< 목 차 >>************************************
<1> 프로그램의 디자인
<2> 메뉴에 대하여
     1> 메뉴의 변천
     2> 우리가 쓸 메뉴
     3> 메뉴에 쓸 데이타를 살펴보자
     4> struct 가 기본이다
     5> address.c 에 사용한 스트락춰를 살펴보자
     6> 메뉴 데이타를 화면에 찍어보자
***********************************************************************
<1> 프로그램의 디자인
*********************************************************************** 
   이제부터 저는 조그만  "주소관리 프로그램"을 짜려고 합니다.  내용은 간
단한 것이지만 이런 프로그램은 거의 모든  프로그램의 기초가 되는것이기 때
문에 누구나 한번은 짜봐야 하는것입니다.  저는 여러분들이 원하시는 자료관
리 프로그램을  정확히 모르므로 저  나름대로 시작합니다. 이제  여러분들도
각자 자기가 필요한 프로그램을 구상하시고 같이 출발해야 합니다.
     이 주소관리  프로그램은 address.c 라는 소스화일로  만듭니다. 이것을
만들기전에 우리는 프로그램을 "디자인" 해야  하는데 "디자인"이라는 용어가
너무 거창하지요 ?  사실상 이정도는 우리  머리속에서 자동적으로 디자인 됩
니다.

(구상 1) 무슨 프로그램 짤래 ? 
        --> "주소관리 프로그램" 혹은 "성적 관리 프로그램"
이게 처음하는 구상입니다.

(구상 2) 주소관리 프로그램 을 왜 만들어 ?
        --> 수첩에다 일일이 적기귀찮고 또  사람이름 하나 찾으려면 시간이
        많이 걸리니까 컴퓨터에서 편하게 하자는 거지.

(구상 3) 그럼 실제로 어떤기능을 갖지 ?
       --> 처음에는   이름과 주소를 쳐넣어야 되니까  "입력"기능이 있어야
        하고 둘째     주소를 찾아봐야 하니까 "검색" 기능도 있어야지
        셋째    사람들 이사가면 주소가 바뀔테니 "수정" 기능도 있어야지

(구상 4) 그외 또 필요한 기능은 없을까 ?
      --> 조직에서 탈퇴한 사람이나 사망한 사람이 있으면 지워야 되니까
          "삭제" 기능도 있어야지
      --> 또 주소록 만들어서 사람들 나눠주려면 "프린트"도 해야지

이 정도까지 그야말로  상식적인 디자인 아니겠습니까 ? 이래서  저는 여기까
지를 프로그램으로 짰습니다. 개괄적인 프로그램의  기능과 흐름을 디자인 한
것이지요. 여러분에게 같이 보내드린 address.c  가 그것입니다. 그만 읽으시
고 그걸 컴파일해서 실행 시켜보세요.
***********************************************************************
<2> 메뉴 에 대하여
     1> 메뉴의 변천
     2> 우리가 쓸 메뉴
     3> 메뉴에 쓸 데이타를 살펴보자
     4> struct 가 기본이다
     5> address.c 에 사용한 스트락춰를 살펴보자
     6> 메뉴 데이타를 화면에 찍어보자
***********************************************************************
1> 메뉴의 변천
-----------------------------------------------------------------------
        옛날부터 메뉴  선택법은 변천사가 있습니다. 첫째로  가장 초보적이
고 원시적인 방법이  천리안이나 하이텔처럼 원하는 메뉴의  번호나 머리글자
를 입력하는 방법입니다.  이건 통신 프로그램에서는 아직까지 어쩔  수 없는
방법입니다. 그러나 PC 상에서 혼자 쓰는 프로그램은  거의 이 방법을 안쓰지
요.
        둘째는 우리가 하려는 막대 선택법  이라는 겁니다. 아시다시피 화살
표 키로 메뉴를  선택하는 방법입니다. 이 내용 중에  팝업(pop-up)메뉴와 풀
다운(pull-down)메뉴라는 방법이 있습니다. 요즘은 이런  방법들을 잘 정리해
서 터보 C 메뉴같이 쓰는 법이  대중화 되있지요.
        세째는 그래픽을 이용하여 마우스로  메뉴선택하는 방법입니다. 물론
이것이 user interface측면에서는 더 진보된 방법입니다.
        네째는 아직 실용화 되었는지 잘 모르겠지만  말로 메뉴를 고르는 방
법이 아닐까 싶습니다.  예를 들면 "이야기" 하고 부르면  프로그램이 도는식
이지요. Star wars 같은 공상과학 영화에 가끔 나오지 않습니까 ?

        다섯째 이것도 역시  상상입니다만 나중엔 생각만 해도  컴퓨터를 돌
릴  수 있는  방법이 개발되지  않을까  기대해봅니다.이것도 역시  영화중에
"Fire fox"나 "Total  recall (?)" 같은 데서 어느정도 느껴볼  수 있지 않을
까 합니다.

        두말할 것도 없이 이렇게 메뉴  선택법이 바뀌는 기준은 "어떻게하면
"사용자가 쓰기 편할것인가 ?" 하는데 있습니다. 즉  "손하나 까딱 안하고 편
하게 컴퓨터를 쓸 수 있는 방법"을 찾자는데 있을것 입니다.

        사실상 메뉴를 선택하는 방법은 이런 방법  말고도 얼마든지 좋은 방
법이 있을 수 있겠지요.여러분들도 더 좋은 아이디어를 내 보세요.
-----------------------------------------------------------------------
2> 우리가 쓸 메뉴
-----------------------------------------------------------------------
        메뉴를 선택하는  방식을 디자인 하는것은 아주  중요합니다. 왜냐하
면 내용이  아무리 좋은 프로그램이라고  할지라도 쓰는 법이 복잡하면  일단
사람이 기피하는 경향이 많기 때문이지요.
        예를 든다면, 벤즈보다 더좋은 차가  있다고 하더라도 이걸 운전하는
방법이 아주 어려워서 한 1년쯤 배워야 한다고  합시다. 그러면 이 차는 사실
상 일반인한테 더이상 좋은차가 아닙니다.  마찬가지로 내용이 좋은 프로그램
이라도 사람이 일단 쓰기가 불편하다는 데야 더이상  할 말이 없는거지요. 이
런 문제를 "user interface"문제라고 합니다. 이건  심리학 이나 인간공학 같
은 다소 추상적인  학문이 도입되어야 할 문제라고 생각하고,  저 개인적으로
도 아주 관심이 많은 분야 입니다.
        그래서 저는 프로그램을  디자인 할때 한가지 기준이  있습니다. "사
람을 귀찮게 하지말라 ! 키 하나만 치면  나머지는 알아서 자동적으로 되게하
라" 이것이 저의 기본 생각 입니다.

        이런 면에서 따져보면 어떤 통신 회사의  운용 프로그램은 조금 문제
가 있는것 같더군요. 불필요한 키를 자꾸 치라고 하는 것이 있습니다.

        자꾸 이유없이 [ENTER]키를 치라고 하는것  이나 불필요한 확인 질문
같은 것 들은 사람을 귀찮게 할 뿐 더러 진행 속도를 느리게 하지요.
        컴퓨터에서는 아시다시피  실행 속도가 아주 중요합니다.  컴퓨터 강
좌에서 하루  날을잡아서 "속도"에 관한  정리를 한번 하겠습니다만,  속도를
따지자면 컴퓨터의 주변  장치 중에서 "사람의 키보드  입력속도"처럼 하염없
는 것도 없지요.  CPU의 입장에서 보면 사람이 입력하는 속도는  정말 대책이
안설 정도입니다.
        이렇게 느린, 사람의  데이터 입력을 자꾸 요구하는것은 안  좋은 일
이라는 것은 당연 하겠지요.

     우리가 쓸 address.c의  메뉴는 기본적으로 터보 C의 메뉴를  쓰는 방법
과 비슷합니다. 크게 보면 아래와 같이 3 부분으로 되있습니다.
     1. 처음의 "메인 메뉴"처럼 필요한것을  "바둑판" 처럼 벌여놓고 선택하
는법
     2. 메인 메뉴 밑의 "주소 메뉴"처럼 "가로"로 쭉 나열 하는 방법
     3. 주소메뉴 밑의 "SEARCH 메뉴" 처럼 "세로"로 쭉 나열 하는 방법

      1번 의 "바둑판"처럼  벌려놓고 선택하는 방법은  "메인  메뉴"를 선택
할때 흔히 쓰는  방법이지요. 각 항목의 프로그램은 개별적으로  독립된 것들
이지요.  이 형태를  그래픽으로  처리한다면 "windows"의  메뉴선택  법이나
"pb" 같은 것이 되겠지요.

     2번의 가로로  나열하는 방법은 아래한글이나  터보 C에서 쓰는것을  알
수 있을 겁니다.

     3번은 특히 풀 다운(pull down)메뉴  라고  부르는 것이지요.풀 다운 메
뉴란말 그대로 메뉴를 "아래로 끌어 당긴다"는  것입니다 아래 한글이나 터보
C 에디터에서 보듯이, 화면 맨 위줄의 메뉴  하나를 선택하면 그에 딸린 부수
적인 메뉴들이 아래로 주루룩 생기는 형태를 말합니다.  이런것도 더 말을 안
해도 잘아시리라믿고...
     

      위의 3 가지  방법은 내용적으로 사실상 다를것이  아무것도 없습니다.
아래를 보면 확실히 이해 할 수 있을 겁니다
-----------------------------------------------------------------------
3> 메뉴에 쓸 데이타를 살펴보자
----------------------------------------------------------------------- 
  메뉴를 그릴때 내가  제일 처음 하고 싶은 일은 모니터의  좌표 (1,1) 에다
"주소록 관리" 라고 쓰는 것입니다. 그러면

-----------< 방법 1-1 >--------------
main()
{

      gotoxy(1,1);
      printf("주소록 관리");
}
이렇게 하면 됩니다. 그러면 이제 좌표 (20,1)에  "작업종료" 라고 항목 하나
를 더 추가해 보지요.
-----------< 방법 1-2 >--------------
main()
{

      gotoxy(1,1);
      printf("주소록 관리");

      gotoxy(20,1);
      printf("작업종료");
}

예 ! 어려울 것 없습니다. 그러면 이걸  외부변수를 써서 다시 똑같은 과정을
반복해봅시다.
-----------< 방법 2-1 >--------------
char *p = "주소록 관리";
int x = 1;
int y =1;

main()
{
      gotoxy(x,y);
      printf("%s",p);
}
첨가 합니다.
-----------< 방법 2 -2 >--------------
char *p;
int x;
int y;

main()
{
       x = 1;
       y = 1;
       p = "주소록 관리";
       gotoxy(x,y);
       printf("%s",p);

       x = 20;
       y = 1;
       p = "작업종료";
       gotoxy(x,y);
       printf("%s",p);
}
여기서는 변수 3개를 만들고 거기다 데이타를  넣고 printf()를 썼습니다. 읽
기에는 더 불편해진것 같지요 ?  이걸 struct로 다시 써 볼까요 ?
-----------< 방법 3-1 >--------------
struct menu {
              char *p = "주소록 관리";
              int x = 1;
              int y =1;
            } mm;

main()
{
      gotoxy(mm.x , mm.y);
      printf("%s",mm.p);
}
------------------------
여기서는 스트락춰 변수 mm 이란걸 등장 시켰습니다.  mm.x , mm.y 따위의 표
현법을 아시지요 ?  이제 또 첨가 합니다.
-----------< 방법 3-2 >--------------
struct menu {
              char *p;
              int x;
              int y;
            } mm[2] = { "주소록 관리",1,1,
                        "작업종료",20,1
                      };
main()
{
     gotoxy(mm[0].x , mm[0].y);
     printf("%s",mm[0].p);

     gotoxy(mm[1].x , mm[1].y);
     printf("%s",mm[1].p);
}
여기서는 스트락춰 변수 mm 이 배열이 뻍습니다. 즉 mm[2] 로 바뀌었습니다.
어떤가요 ?  읽기 점점 더 어려워 지는것  같지 않습니까  ? 그러나 그럼에도
불구하고 <방법 1> 보다는  <방법 2>가 더 잘 쓰는 방법이고,  <방법 2> 보다
는 <방법 3 > 이 더 노련한 방법입니다.

위의 <방법  1,2,3>을 보면, 어느경우나  아래와 같은 데이타들이 필요  합니
다.
        ----------------------------
         좌표(1,1) 과 "주소록 관리"
         좌표(20,1)과 "작업종료"
        ----------------------------
어떤 방법이 더  좋은가 하는 기준은 이 데이타들이 얼마나  일목요연하게 정
리되어
        -----------------------------------------------
        1. 한눈에 읽어 보기쉽고
        2. 따라서 고치기 쉽고
        3. 또 개념적으로 이해되기 쉬운 형태로 되있는가
        -----------------------------------------------
하는점 입니다. 따라서 간단히 얘기해서   "데이타가 정리되서 한곳에 모여져
있으면" 가장좋은 형태다. 라고 일단 생각하면 됩니다.  물론 이 말자체가 완
전히 옳다고  말하기는 곤란할지도 모르겠지만,  제가 이렇게 말하는  의도를
짐작하실 수는 있을  겁니다. 위에서 <방법 3>이 데이타를 가장  잘 모아놨다
는 것을 아시겠지요 ?
        이런 방법을 쓸 때의 장점은, 앞으로 데이타를  바꿀 일이 있으면 무
조건 "스트락춰 정의"  해논 곳으로만 가면 된다는 것이지요.  따라서 고치기
가 쉽지요.  이상하게 들리겠지만 우리는  프로그램을 탄탄하게 쌓아  나가는
방법보다는 "잘 허물고 잘 바꿀 수 있는 방법"을  더 염두에 둬야 합니다. 왜
냐하면 우리가 지금 하고 있는 일이 (언제든지  사양이 바뀔 수 있는) 부드러
운 "소프트웨어" 개발이기 때문입니다.
-----------------------------------------------------------------------
<4> struct 가 기본이다
----------------------------------------------------------------------- 
   이제 스트락춰를 사용한  <방법 3>을 다시 봅시다. 여러분들은  이제 이런
표현법에 익숙해야 합니다. 이 표현법이  스트락춰의 가장 복잡한 표현이니까
이것만 완전히 볼  줄 알면 스트락춰의 내용은 거의 안다고  할 수 있습니다.
다시써보면
-----------<스트락춰 표현법 1>--------------
struct menu {
              char *p;
              int x;
              int y;
            } mm[2] = { "주소록 관리",1,1,
                        "작업종료",20,1
                      };

여기서는 3가지 얘기를 한꺼번에 하고 있습니다.
1. "struct menu" 를 하나 만들겠는데 그 구성원은 다음과 같다.
         {    char *p;
              int x;
              int y;
         }
2. 그  스트락춰 구성원 형태태로  집(아파트)를 확보했다. 그 문패는  mm[0]
        과 mm[1] 이다. 
3. 그 확보한 집에 내용을 집어넣었는데(초기화) 그 값들이 다음과 같다.
            { "주소록 관리",1,1,
               "작업종료",20,1
            }
이와같이 한꺼번에 너무 많은 얘기를 하려니까 복잡하게  보일 수 밖에요. 그
래서 너무 어지러운 사람들을 위해서 조금 풀어 쓰기도 합니다. 즉
-----------<스트락춰 표현법 2>--------------
struct menu {
              char *p;
              int x;
              int y;
            };                     <-- 한번 쉬고 (세미콜론 ";"의 의미)

struct menu  mm[2] = { "주소록 관리",1,1,
                        "작업종료",20,1
                     };
------------------------------------------------
위에 표시 한대로 처음에는
         1. "struct menu 를 하나 만들겠다"
라고 선언을 하고 한번 쉬었습니다. 세미콜론  ";" 이 컴파일러에게는 쉼표와
마찬가지지요. 그러니까 사람도 쉬어야 합니다.  여러분도 의식하시는지 모르
겠는데 우리가 지금 C를 공부 하는것은 결국  우리도 C 컴파일러가 되자는 것
이니까요.
그리고 두번째 하는 얘기는 
         2.  그 스트락춰  형태태로  집(아파트)를 확보했다.문패는  mm[0],
                mm[1]
         3. 확보한  집에 내용을 집어  넣었는데(초기화) 그 값들이  다음과
                같다.
            { "주소록 관리",1,1,
               "작업종료",20,1
            }
 C 소스 프로그램에서 볼수 있는 형태는 이 두가지와,   또 하나 아래처럼 태
그명을 생략하는 것이라고 얘기한 적 있습니다.
-----------<스트락춰 표현법 3>--------------
struct      {                            <--- 태그(tag)명 "menu" 생략
              char *p;
              int x;
              int y;
            } mm[2] = { "주소록 관리",1,1,
                        "작업종료",20,1
                      };
        이렇게 태그명을 생략하면 위의 <스트락춰  표현법 2>처럼 두 부분으
로 나눠쓰지  못합니다. 이유는 숙제로  내 드릴테니 생각해 보시고,  따라서
이 표현법은 그 스트락춰를 딱 한번만 쓸 경우 사용합니다.
      좌우간 위의 3 경우 어느것이든  우리는 스트락춰의 집(아파트)를 확보
하고 거기다 문패를 다는 일에 궁극적인 관심이 있는 겁니다.

      그럼 여기서 중요한 문제를 풀어 볼까요..이것을  모르면 진도를 더 나
갈 필요가 없습니다.
<문> 다음의 크기를 알아보세요.이 개념은 머리속에 확실히 있어야 합니다.

struct      {
                    char *p;
              int x;
              int y;
            } mm[2] = { "주소록 관리",1,1,
                        "작업종료",20,1
                      };
main()
{
        printf(" size = %d\n",sizeof(char));
        printf(" size = %d\n",sizeof(int));

        printf(" size = %d\n",sizeof(mm[0].x));
        printf(" size = %d\n",sizeof(mm[0].y));
        printf(" size = %d\n",sizeof(mm[0].p));

        printf(" size = %d\n",sizeof(mm));
        printf(" size = %d\n",sizeof(mm[0]));
        printf(" size = %d\n",sizeof(mm[1]));

        printf(" size = %x\n",mm);
        printf(" size = %x\n",&mm[0]);
        printf(" size = %x\n",&mm[0].p);

        printf(" size = %x\n",&mm[1]);
        printf(" size = %x\n",&mm[1].p);
}

<참고>  [229쪽] 스트락춰의 메모리 구조를 참조 하세요.

        여기서 100호라는 주소는 내 마음대로  적은것이지만 출발 위치는 그
림처럼 항상 왼쪽 끝으로 합니다. 위 문제를 풀어  보면 정확한 주소를 알 수
있지만 그 주소도  항상 똑같은건 아니고 컴파일러가 상황에 맞게  결정 합니
다. 그러므로 우리는  정확한 주소에 대해서 신경을 안써도 됩니다.  다만 이
웃집을 가려면 몇집을 뛰어야 하나, 크기는 얼마나  큰가에만 신경을 쓰면 됩
니다.

그리고  위 구조체가 의미 하는것은 다음과 같습니다.
    1.옆으로 6집이 붙었고 2층 짜리 아파트입니다.
    2.100호를 기준으로  옆으로 번지수가  하나씩 증가하고 2층이  되더라도
        연속적으로 증가합니다
    3.집앞에 문패가 p,x,y 라고 붙어 있는데 각자 2채씩 차지하고 있습니다
        따라서 103호의 경우도 102호와 함께   x의 집이지요. 그리고 보통의
        경우 동시에 이문들이 열리면서 데이타들이 드나듭니다.
    4.1층의 100호 앞에는 문패 mm[0] 이 하나더 붙어 있습니다.
      mm[0]은 스트락춰의 이름인데 이건 1층을 통째로 자기집으로 합니다.
      마찬가지로 2층의 mm[1]은 2층을 통째로 자기집으로 합니다.
    5.1층과  2층에 똑같은  문패  p,x,y 가  있지만  스트락춰 문패  mm[0],
        mm[1]이 틀리므로 서로 구별할 수 있습니다. 즉
      1층의 x에 1234를 넣고 싶으면  -->      mm[0].x = 1234;
      2층의 x에 1111을 넣고 싶으면  -->      mm[1].x = 1111;
     

이와같은 스트락춰의 구조를 우리는 기본으로 사용합니다
-----------------------------------------------------------------------
5> address.c 에 사용한 스트락춰를 살펴봅시다
-----------------------------------------------------------------------
아래에 메인 메뉴 그리기에 사용된 실제 스트락춰의 구조를 실었습니다.
구조는 위 아파트 그림과 똑같지만 층수가 무지무지 높아졌지요.
--------------< 스트락춰 사용법 1 >------------------------
#define MENU_UP  1
struct            {
                    char *name;
                    int  x,y;
                   } menu[] = { "주소록 관리", 1, MENU_UP,
                                "[ ....... ]", 18,MENU_UP,
                                "[ ....... ]", 35,MENU_UP,
                                "[ ....... ]", 52,MENU_UP,
                                " 작업 종료 ", 69,MENU_UP,
                                "[ ....... ]", 1, MENU_UP + 1,
                                "[ ....... ]", 18,MENU_UP + 1,
                                "[ ....... ]", 35,MENU_UP + 1,
                                "[ ....... ]", 52,MENU_UP + 1,
                                "[ ....... ]", 69,MENU_UP + 1,
                                "[ ....... ]", 1, MENU_UP + 2,
                                "[ ....... ]", 18,MENU_UP + 2,
                                "[ ....... ]", 35,MENU_UP + 2,
                                "[ ....... ]", 52,MENU_UP + 2,
                                "[ ....... ]", 69,MENU_UP + 2,
                             };
<문> 전부 몇층인가요 ?
<문> 위스트락춰의 배열  menu[] 는 menu[4]  따위와 같이  크기를 명시 하지
않았습니다. 몇이 생략된 것입니까 ?

다음은 부메뉴(sub menu)의 구조 입니다. 역시 다를 것이 하나도 없습니다.
이건 두번에 나눠서 표현 했습니다.
----------------------------------------------------------------------
#define SEARCH_Y   4

struct  juso_menu  {
                        char *name;
                        int  x,y;
                   };

struct  juso_menu  addr_menu[] = {  "[ Input   ]", 1, 1,
                                    "[ Search  ]", 18,1,
                                    "[ Change. ]", 35,1,
                                    "[ Delete. ]", 52,1,
                                    "[  EXIT   ]", 69,1,
                                 };
struct  juso_menu search_menu[] = {  "[ Name    ]", 18,SEARCH_Y,
                                     "[ Phone # ]", 18,SEARCH_Y + 1,
                                     "[ Address ]", 18,SEARCH_Y + 2,
                                     "[ Age     ]", 18,SEARCH_Y + 3,
                                     "[ EXIT    ]", 18,SEARCH_Y + 4,
                                  };

이제 형태적으로 우리가 사용할 메뉴의 스트락춰 구조를 아셨을 겁니다.
-----------------------------------------------------------------------
6> 메뉴 데이타를 화면에 찍어보자
----------------------------------------------------------------------- 
   이제 메뉴를 화면에 직접 찍어 봅시다. 그 루틴은 다음과 같습니다.
/*==================< sub routine >================*/
draw_main_menu()
{
         int i;

         for(i=0; i < sizeof(menu)/sizeof(menu[0]); i++) { <-- <보기 1>
                   gotoxy(menu[i].x,menu[i].y);            <-- <보기 2>
                   puts(menu[i].name);                     <-- <보기 3> 
         }
}
        이 루틴을 이해하기 위해서는 물론 여태까지  우리가 봐온 메뉴 데이
타의 스트락춰 구조를 이해해야 합니다. 이 for  문을 다 돌면 원하는 메뉴는
전부 화면에 찍히겠지요.
        먼저 <보기  1> 에서  "sizeof(menu)/sizeof(menu[0])" 가  의미하는
크기를 아시겠지요. 이렇게  해놓으면 찍을 메뉴 항목이 몇개  이든간에 알아
서 찍으므로 편리한 방법입니다.
        <보기 2>에서는   gotoxy(1,3) 따위  같이 숫자를 직접 쓰는것  보다
표현은 어려워 졌지만 for문을 쓸수있으니까 루틴이 간단해 졌지요.
        <보기 3> 에서는 진짜 메뉴 내용을  화면에 찍습니다. 내용이 어려울
것은 없을겁니다.

<숙제> address.c 중의 draw_address_menu()함수를 읽어보고 위의
       draw_main_menu()와 어떻게 틀린지 비교하세요
<숙제> address.c에서 메뉴를 자기가 원하는 이름과 좌표로 바꾸세요
<숙제> address.c에서 막대를 반전시키는 알고리즘을 읽고 이해 하세요
===========================< 마치는 글 >============================
수고 하셨습니다.
address.c 소스 파일을 같이 보냅니다.
====================================================================