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

[연락처] : 605-8662 (서울) ("캠퍼스 C", 도서출판 "책과 스승")
           천리안 : go campusc  
           나우콤 : go lcampc
           하이텔 ID : campusc
****************************<< 목 차 >>************************************
<1> 비트 필드(bit-field) 구조체
        1> 비트 필드 구조체는 이렇게 생겼다.
        2> 비트 필드 구조체의 메모리 구조
        3> 선언하는 방법 및 주의 사항
        4> 사용법
        5> 적용 사례
<2> 유니온 (union)
        1> 형태및 선언법
        2> 메모리 구조
        3> 사용법
        4> 사용예
<3> 스트락춰,유니온, 비트 필드 스트락춰의 복합 표현
**************************< 내용 시작 >********************************
<1> 비트 필드(bit-field) 구조체
***********************************************************************
1> 비트 필드 구조체는 이렇게 생겼다.
-----------------------------------------------------------------------
        비트 필드  구조체란 말그대로 구조체이다. 그러나  다른점은 멤버의
크기가, 보통 취급하는  기본 단위인 char,int,long 따위가  아니고, 비트 단
위로 나뉘어져 있다는 것이다. 
        이제부터 우리는, 비트 필드  구조체를 사용하여, 마징가에게 실제로
무기를 장착 시켜주자. 다음과 같이 선언 한다.

struct robot {
                 unsigned int  m16     : 1; 
                 unsigned int  dagger  : 2;     <-- (요기)
                 unsigned int  missile : 3;
             } mazinga;

        위에 보다시피   비트의 크기를 " : 3" 따위로  ":" 기호와 "숫자"로
표시한다. 이  숫자들은 비트의 갯수를  의미한다. 즉 위의  (요기)의 의미는
dagger가 2개 있다는  얘기가 아니라, 2 비트 만큼  있다는 것이다.따라서 최
고로  4개 (2x2)  까지  단도를 가질  수  있다.  마찬가지로 missile은  8개
(2x2x2) 까지 가질 수 있고, m16 소총은 2자루 까지 가질 수 있다.
        따라서 위의 mazinga  라는 스트락춰는 전부 해서 6  비트 밖에 되지
않는 다. 이건 한 바이트 char  보다도 작다.그러나 비트 필드 스트락춰는 무
조건
        ------------------------
        2 바이트인 int 형을 기준
        ------------------------
으로 비트를 나누도록 되어 있다. 따라서  멤버의 데이타 타입도 2 바이트 형
인 int 나 unsigned int를 쓰도록  되있다. 위에서 전부 unsigned int 형으로
쓴걸 확인하고  우리는 앞으로 아무 생각없이  unsigned int 형을  쓰기로 하
자. 그리고 멤버이름  앞에 전부 unsigned int 라고 붙어  있으나 "하나의" 2
바이트 안에서 나누자는 뜻이지, 각자 2 바이트를 갖는다는 얘기가 아니다.
-----------------------------------------------------------------------
2> 비트 필드 구조체의 메모리 구조
-----------------------------------------------------------------------
        아래와 같은 비트 필드  스트락춰의 메모리 구조를 그리면   [253쪽]
그림과 같다.
struct robot {
                 unsigned int  m16     : 1; 
                 unsigned int  dagger  : 2;
                 unsigned int  missile : 3;
             } mazinga;

        비트 필드 스트락춰는 내부에서 선언된 순서대로 비트 0 부터  15 쪽
으로 메꾸어 나가는 것이다.   이건 무조건 2 바이트를 기준으로 하기 때문에
쓰다가 남아도 할 수 없다. 그림에서 x로 표시한 부분이 그것을 의미한다.
-----------------------------------------------------------------------
3> 선언하는 방법 및 주의 사항
-----------------------------------------------------------------------
        비트 필드 스트락춰는  선언하는 방법에는 몇가지 기억  해야 하는것
이 있다. 아래를 보자.

struct robot {
                 unsigned int  m16     : 1; 
                 unsigned int  dagger  : 2;
                 unsigned int          : 1;     <-- (요기)
                 unsigned int  missile : 3;
             } mazinga;

위의 (요기) 처럼  필드의 이름이 생략 되면 자리 차지만  한다. 그리고 당연
히 여기에는 값을   넣거나 읽을수가 없다(이름이  없어서).  그림은 [253쪽]
아래와 같다.

        비트 필드  폭을 0으로 지정  할  수도 있다. 그럴바에야 쓰지를  말
지 뭐하러 쓰나 할지도   모르겠지만, 나름대로 의미가  있다. 선언과 메모리 
구조를 보자.

struct robot {
                 unsigned int  m16     : 1; 
                 unsigned int  dagger  : 2;
                 unsigned int          : 0;     <-- (요기)
                 unsigned int  missile : 3;
             } mazinga;
        [254쪽] 상단의 그림.
 

        즉 0 을 쓰면 그다음 선언된  비트 필드는 새로운 int 메모리에 쓰이
고 사용하던 int 는 안쓴다(x 한 부분)
        또 어떤 비트 필드가 int의 경계에  걸리면  그것도 역시 새로운 int
로 밀려 버린다. 

struct robot {
                 unsigned int  m16     : 1; 
                 unsigned int  dagger  : 14;
                 unsigned int  missile : 3;
             } mazinga;

선언된 대로 순서대로 나눠보면, 아래와 같고  이때 missile은 두 int의 경계
에 걸쳐 있다. [254쪽] 그림 참조.

-----------------------------------------------------------------------
4> 사용법
-----------------------------------------------------------------------
        비트 필드 스트락춰에 값을 대입  하는 방법은 보통 스트락춰의 그것
과 같다. 즉 아래와 같이 선언 되었을 때,

struct robot {
                 unsigned int  m16     : 1; 
                 unsigned int  dagger  : 2;
                 unsigned int  missile : 3;
             } mazinga;

main()
{
        mazinga.m16 = 1;        /* 총 한자루 */
        mazinga.dagger = 3;     /* 단도 3개 */
        mazinga.missile = 5;    /* 미사일 5 기 */
}

        여러분은  지금   이런  표현이 주는  편리함을   느낄 수 있어야 한
다.  현재 missile 에  5  기라는 의미로 5를 대입 했지만, 비트 필드 스트락
춰를 안 쓰면 바이트 단위로 따져서 00101000의 값이 되야한다. (나머지 모든
비트가 0인 경우)
이걸 16진법으로 쓰면 0x28이 된다. 이것이 현재 미사일 5기에 대한 값이라고
다시 한번 생각해보자. 도저히 이해하기 어려운 값이 되고만다는 것을 이해할
수 있을 것이다.

        값을 읽어 올 때도 마찬가지로 아래와 같은 표현을 쓴다.
main()
{
        printf("%x", mazinga.missile);
}
-----------------------------------------------------------------------
5> 적용 사례
-----------------------------------------------------------------------
        지금까지 다뤄온 비트  필드 스트락춰를 어디다 써먹을까  궁금해 하
는 사람이 있을 것이다. 그 기능은  응용하기에 따라 여러가지가 있겠지만 크
게 몇가지로 나눠보면 다음과 같이 생각해 볼 수가 있다.
        ------------------------------------------------
        1. 컴퓨터 내부 칩들의 레지스터를 프로그래밍 할때
        2. 데이타 베이스의 자료의 크기를 작게 할 때
        3. 기타 프로그램 작성시 필요한 경우
        ------------------------------------------------
        위에서 첫번째 경우는  나중에 중급 과정에서나 다룰  내용이 될것이
다. 간략하게 얘기를  해보면, 컴퓨터 내부에는 여러가지의  프로그램이 가능
한 칩들이 있다.  이런 칩들은 보통 수 바이트 정도의  작은 레지스터를 가지
고 잇는데, 보통  이런 레지스터들은 비트 단위로 의미를  가지고 있다. 마치
CPU  안의  flag  레지스터들과  같다.  따라서  이런  칩들은  비트  단위로
operation을 할 필요가  많으므로 당연히 비트 필드  스트락춰를 쓰게 될것이
다. 그러나 많은 경우는 어셈블러로 프로그램을  짜고 일부만 C 의 비트 필드
스트락춰를 이용하게 될것이다.
        세번째 경우를 먼저  얘기하면, 예를 들기가 어려울  정도로 많은 예
가 있을것이다. 그중에서도  약방의 감초처럼 많이 쓰이는  예는 한글을 취급
하는 프로그램을 짤  때이다.  [550쪽]의 한글 조합형 코드를 보자.  아마 비
트 필드 스트락춰를 배운사람 이라면 누구나 이런  코드를 보면 당장 비트 필
드 스트락춰를 떠올릴 것이다. 한글 코드도 마침  2 바이트로 구성 되니 정말
안성 맞춤 아닌가 ?
        두번째 경우는 지금  단계에서도 충분히 다뤄 볼  만한 것이다. 지난
번 가족들의 신상명세를  찍는 프로그램을 짜 보셨는지  모르겠는데, 그런 데
이타 베이스의 자료를 처리할 때 비트  필드 스트락춰를 이용하면, 돈과 시간
을 엄청나게 절약을 할 수가 있다.
        예를 들면, 우리가 지금 내무부에서  사용하는 대한민국 국민의 신상
명세 데이타 베이스를 구축한다고 치자. 보통 스트락춰의 구조를 이용하자.

struct citizen {
                char    *name;
                char    sex;                    /* 성별  */
                char    left_hand_use;          /* 왼손 잡이 */
                } citizen;

        실제적인 스트락춰의 구조가 어떻게  되있는지는 모르겠으나, 위와같
이   되  있다고   치자.  그러면   한사람의   자료를  저장하기   위해서는
sizeof(citizen) 만큼(12 바이트)의 용량이 필요하다.
        위에서 성별은,  보통 프로그램에서는  실제적으로 'm',  'f' 따위로
male과 female 을 구별한다. 즉 2  가지 경우를 표시하는 것이다.
        역시 왼손잡이를 구별하는  변수도 기껏 해야 ,  왼손잡이, 오른손잡
이, 양손잡이, 이 3 가지면 충분할 것이다.
        보통, 친구 신상명세 데이타 베이스를  만들때는 위와 같이 하는것이
더 일반적이지만, 지금처럼 대한민국 국민의  데이타베이스를 구축할 때는 얘
기가 다르다. 짐작 하시겠지만, 위의  스트락춰 구조에서 데이타를 한 바이트
만 작게 하면, 한국인이 4천만명 이라고  쳤을 때 4천만 바이트(대충 40메가)
를 절약 할 수 있는것이다. 예를  들어 하드 디스크나, 테입에 담을때 용량이
훨씬 작아 질수 있고, 검색 속도등도 더 빨라질 것이다.

그렇게 쓸려면 아래처럼 비트 필드 스트락춰를 써야 하는 것이다.

struct sub {
                unsigned        sex  :  1 ;               /*  성별    */
 

                unsigned        left_hand_use : 2 ;     /* 왼손 잡이 */
        };
struct citizen {
                char    *name;
                struct sub sub;
                } citizen;

물론 쓰기에는 다소  불편해 졌지만, 하나를 얻으면 하나를  잃는법, 어쩔 수
없는 노릇이다.
        요즘에는 메모리와 하드  디스크의 값이 많이 싸져서  옛날처럼 프로
그램의 크기를 줄일려고  노력하지 않는것 같다. 프로그램  개발 생산성 측면
을 따지면 프로그램의 크기가 약간  커져도 상관은없지만, 예나 지금이나, 똑
같은 기능을 하는 프로그램을 짜는데  남들보다 프로그램이 크다면, 자기능력
이 부실하다는 걸  보여 주는것이다. 그건 곧 자기의 머리가  정리 되있지 않
다는 뜻이기도 하다. 혼자 장난으로  짜는 프로그램이야 아무 상관없지만, 남
들과 공동으로 프로그램을  개발할 때는 문제는 심각해진다.  같이 망하는 수
가 있는것이다.
        프로그램을 간결 명료 하게 짜려면  몇가지 측면에서 고려를 해 봐야
한다.
        첫째는 지금 위에서도  보았듯이, "데이타 구조"를 잘  잡아야 한다.
이것이 갖는 중요성을 느끼시는지 모르겠다.  언젠가 잡지에서, LOTUS를 개발
한 사람인가(?)가 한말 이 기억난다.  자기는 프로그램을 짤때 데이타 구조를
구상하는 시간이 가장 즐겁다고 했다. 그리고  시간을 아주 많이 할애 한다고
했다.
        이게 건축으로 치면 도면에 설계도를  그리는 작업과 유사하다. 땅파
고 벽돌 쌓는  일도 중요하지만, 설계도 작성에는 비할  바가 아니다. 그래서
어떤 건물을 지은 사람이란, 항상 설계자를   말하는 것이지, 현장 소장을 말
하는게 아니다.
        두번째는 알고리즘의 작성이다. 이것도 역시  데이타 구조와 함께 중
요한 과정이다.  보통 데이타 구조를 잡는  과정과 연계가 되어  구상해 나간
다. 이 부분도 거의 예술과 같은  창작 과정에 속하는 부분이다. 자기의 능력
이 여지없이 드러나는 부분이기도 하다.
        세번째는 코딩(coding)과정이다.  이건 건축에서  벽돌 쌓는  과정에
해당한다. 정해진 알고리즘대로 각 기능을  수행하도록 C 언어를 사용하여 프
로그램을 "쳐 넣는 단순한 과정" 이다.  그런데 여기서도 문제는 왕왕 발생한
다. 똑같은 설계도로 집을 지어도 어떤 건물은 부실한 것과 같다.

        이 단순한 과정에서도  그 프로그래머가 어느 정도  수준의 사람인지
금새 알아 볼 수 있다. 이 부분은  비록 프로그램 작성 측면에 있어서, 그 중
요성은 덜하지만, 작성된  소스 코드를 통하여 자기의  수준을 적나나하게 보
여 주는  과정이므로 간결 명확하게  짜도록 노력해야 한다.  경험에 의하면,
역시 알고리즘을 잘  구상하는 사람들이 코딩도 잘 하는것 같다.  그건 곧 그
사람의 생각이  확실하게 정리되 있어야  표현도 간결 명확하게  표현 된다는
얘기다. 억지로 표현만 잘 한다는 것은 불가능한 일일 것이다.
        지금 C 를 배우는 사람중에는  "프로그램을 짜는" 일이란,"모니터 앞
에 앉아서 키보드를 두드리는 일"이 라고  생각 하는 사람이 많을 것이다. 물
론 간단한 프로그램이야 별 상관 없을  것이지만, 그건, 위에 설명한 바와 같
이, 일종의 단순 막노동에 해당하는 일 이라는 걸 알아야 한다.
         "프로그램을 짠다"는 것에 대한 mind 를 새롭게 하시길 바란다.
***********************************************************************
<2> 유니온 (union)
        1> 형태및 선언법
        2> 메모리 구조
        3> 사용법
        4> 사용예
***********************************************************************
1> 형태및 선언법
-----------------------------------------------------------------------
        유니온 이란  형태상 스트락춰와 똑같다.  다만 아래와  같이 struct
대신 union이라고 쓰면 될 뿐이다.

union   robot {
                 long  head;
                 int   body;
                 char  arms[2];
             } mazinga;

        내용적으로는 약간 다른데,"유니온" 이란  단어가 의미 하듯이 "하나
로 합쳐진 메모리 구조"를 갖는다.
-----------------------------------------------------------------------
2> 메모리 구조
-----------------------------------------------------------------------
        메모리 구조는 [257쪽]에  잘 나타 나 있다. 첫  그림을 보면 문패가
100 번지에 다  붙어 있는 것을 볼  수 있다. 이제는 긴 설명이  없어도 이런
그림을 익숙하게 보시리라고 믿는다.
        유니온(union) 이란 이처럼,  각 멤버 들을 "한곳에"  몰아 넣는것이
다. 이 때 크기는 당연히
        --------------------------------------------------
        가장 큰 멤버의 집을 확보하고 나머지는 전부 100 번지
        부터 메워 넣는다
        ---------------------------------------------------

위 구조에서는 long 타입인 head 가 가장  크므로 4 바이트를 잡아 주고 나머
지들이 그안에 들어가 있는 것이다.
        따라서 아래와 같은 질문의 답은 똑같다.

main()
{
        printf("%x", &mazinga);
        printf("%x", &mazinga.head);
        printf("%x", &mazinga.body);
        printf("%x", &mazinga.arms[0]);
}

<문제> 다음의 답은 무엇인가 ?

main()
{
        printf("%x", sizeof(mazinga));
        printf("%x", sizeof(mazinga.head));
        printf("%x", sizeof(mazinga.body));
        printf("%x", sizeof(mazinga.arms[0]));
}
 

이런 문제를  이해하는데는 [257쪽]의 그림만  있으면 별로 어려울 것이 없을
것이다.따라서  지금 이 유니온 구조와  그림을 암기 하는게 필요하다.
        그 아래에 나오는 그림은 유니온의 배열에  관한 것인데, 더 이상 설
명없이 이해 하리라고 믿고 넘어 가기로 하겠다.
-----------------------------------------------------------------------
3> 사용법
-----------------------------------------------------------------------
        값을 대입 하거나 읽어오는 법도 스트락춰의 그것과 동일하다.즉
main()
{
        mazinga.head = 0x1234L;
        mazinga.body = 0x123;
        mazinga.arms[0] = 'a';

        printf("%x", mazinga.head);
        printf("%x", mazinga.body);
        printf("%x", mazinga.arms[0]);
}

        그러나 여기서 유의 할 것이 있다.  위와 같이 값을 줄줄이 대입하면
[257쪽]의 그림에서  보듯이 "엎어  쓰는 부분"이  항상 생긴다는 얘기다. 같
은 메모리 번지를  쓰고 있는 부분은 당연한 결과다.

<문제> 다음의 결과는 어떻게 될까 ?

main()
{
        mazinga.head = 0x12345678L;
        mazinga.body = 0x0101;

        printf("%x", mazinga.head);
}
-----------------------------------------------------------------------
4> 사용예
-----------------------------------------------------------------------
        유니온을 사용하는 경우는  주로 이렇다. 예를 들면  가족의 신상 명
세를 만들려고 할 때, 다음과 같이 스트락춰 구조를 잡았다고 치자.
struct family {
                char    *name;
                long    birthday;

        } family[12];

        이 집은 식구가 12명 이나 된다.  그런데 이중에는 이미 돌아가신 할
머니의 명단도 들어 있다고 치자. 제사날을 표시해 두고 싶어서 이다.
        이런 경우  위의 스트락춰 형식을  그대로 이용할 수  있을 것이라는
생각을 할것이다.  다만 문제가 되는것은  birthday 라는  변수명에 돌아가신
날을 적어 두어야 한다는 것이다. 그렇치  않으면 아래처럼 사망일 변수를 하
나 더 만들어야 한다.
struct family {
                char    *name;
                long    birthday;
                long    returnday;

        } family[12];

        이렇게 구조를 잡기도  이상 하다는 것을 알것이다.  살아 있는 사람
들에게는 이 난들이  전혀 필요 없기 때문이다.  내무부에서 한국인의 신상명
세를 이렇게 짜면  장관을 당장 파면 시켜야 된다. 이유는  메모리와 하드 디
스크를 낭비한 죄다.  이런 경우 지금 얘기한 유니온을 아래와  같이 쓰면 된
다.
union day_kind {
                long    birthday;
                long    returnday;
                };
struct family {
                char    *name;
                union day_kind  day_of;
        } family[12];

이렇게 해 놓으면 구별이 가능해 진다.즉
main()
{
        family[0].name = "김 막내";
        family[0].day_of.birthday = 0x880808;   /* 88년 8월 8일생 */

        family[1].name = "홍 할머니";
        family[1].day_of.returnday = 0x930303; * 93년 3월 3일 사망일 */
}

유니온을 쓰고 있기  때문에 데이타가 들어가는 자리는  결국 똑같다. 그러나
이름만 달리 쓰고 있다는 것을 알것이다.
        여기서 문제가 생길  소지도 있는데, 이 날짜가  생일을 의미하는지,
사망일을 의미하는지는, 입력되 있는 데이타만  봐서는 도저히 알 길이 없다.
자기 가족이 아닌 다음에야 할머니가  살아계시는지 돌아 가셨는지 알길이 없
는것이다. 그걸 구별하는 것은 전적으로
        --------------------
        프로그래머 책임이다
        --------------------
따라서 만일 프로그래머 마저 그걸 구별하는  방법을 갖고 있지 않다면 그 프
로그램은 버려야 한다.   그래서 보통은 다음과 같은 식별 멤버를 둔다.

union day_kind {
                long    birthday;
                long    returnday;
                };
struct family {
                char    *name;
                char    dead;
                union day_kind  day_of;
        } family[12];

자료 입력에서도 이 사실을 첨가해야 한다.

main()
{
        family[0].name = "김 막내";
        family[0].dead = 'n';                   /* No */
        family[0].day_of.birthday = 0x880808;   /* 88년 8월 8일생 */

        family[1].name = "홍 할머니";
        family[1].dead = 'y';                   /* Yes */
        family[1].day_of.returnday = 0x930303;  /* 93년 3월 3일 사망 */
}

<숙제> 가족의 신상 명세를 만드는데, 여자  가족은 전부 화장을 한다고 치고
1주일에 화장 하는  횟수, 남자들은 면도하는 횟수를 나타낼  수 있는 유니온
을 잡고 적용하라.
***********************************************************************
<3> 스트락춰,유니온, 비트 필드 스트락춰의 복합 표현
***********************************************************************
        위에도 잠깐  나왔지만, 스트락춰, 유니온, 비트  필드 스트락춰들은
자주 복합적으로 쓰인다.  아래같은 경우는 거의 쓰이지  않지만 문제를 어렵
게 하기위해 일부러  복잡하게 만들어 보았다. 하지만  기본적인 내용을 이해
하고 있는  사람이라면 이런 유치한 표현은  쉽게 이해 할 수  있을 것이라고
믿는다.

#include        <stdio.h>
#include        <stdlib.h>

struct robot {
                char    *name;
                union spec {
                                unsigned        kg;
                                struct gun {
                                                unsigned m16    : 2;
                                                unsigned m60    : 1;
                                                unsigned        : 0;
                                                unsigned missile : 2;
                                } arms[2];
                } spec;
                struct robot *next;
             } mazinga;

<문제> mazinga의 크기는 ? (sizeof 사용)
<문제> spec 의 크기는 ?
<문제> arms[0]의 크기는 ?
<문제> struct robot의 크기는 ?
<문제> union spec 의 크기는 ?
<문제> struct gun 의 크기는 ?
<문제> m16에 2 를 대입하라;
<문제> kg에 105 를 대입하라;
<문제> *name에 여러분의 영문 이름(예 : "honggildong")을 대입해보세요.

<문제> 위에 대입한 값을 전부 찍어서 제대로 들어 갔는지 확인해 보세요.

다음과 같이 로보트를 10개 더 만들었다.
struct robot fighter[10];
<문제> 이 로보트들로 한방향 비상 연락망을 짜보세요.(위의 스트락춰 이용)
<문제> dos.h 에는 다음과 같이 실제 union의 사용예가 잘 나와 있습니다.

struct WORDREGS {                  
        unsigned int    ax, bx, cx, dx, si, di, cflag, flags;
};

struct BYTEREGS {
        unsigned char   al, ah, bl, bh, cl, ch, dl, dh;
};

union   REGS    {
        struct  WORDREGS x;
        struct  BYTEREGS h;
};

문1> sizeof( struct WORDREGS) 의 크기는 얼마인가요 ?
문2> sizeof( struct BYTEREGS) 의 크기는 얼마인가요 ?
문3> sizeof( union REGS) 의 크기는 얼마인가요 ?

<참고> 위에서

struct WORDREGS {                  
        unsigned int    ax, bx, cx, dx, si, di, cflag, flags;
};
        여기에 나오는 이름  ax, bx, cx,... 따위는  CPU안의 "레지스터" 이
름들 입니다. [20쪽]의 그림을   확인해 보시고 이 변수명들의 의미를 이해하
세요.
        "struct WORDREGS" 에서 WORDREGS 란  "WORD REGISTERS (워드 레지스
터들)" 이란 의미의 준말인데, 여기서 WORD란  2 바이트 크기를 의미 합니다.
[20쪽] 그림에서 ax 가 2  바이트를 차지하고 있는 것이 보이지요 ?
2 바이트이기 때문에 unsigned int 라고 선언한 것을 이해 하시겠지요 ?

        마찬가지로 "struct  BYTEREGS" 에서  BYTEREGS 란  "BYTE REGISTERS
(바이트 레지스터들)" 이란  의미의 준말인데, BYTE  가  한 바이트라는 사실
은 이미 아실테고 따라서 "unsigned char"  타입으로 선언한 걸 이해 해야 합
니다.
************************< 끝 마치며 >**********************************
위의 숙제를 충실히 해보세요. 수고 하셨습니다
***********************************************************************