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

[연락처] : 605-8662 (서울) ("캠퍼스 C", 도서출판 "책과 스승")
           천리안 : go campusc  
           나우콤 : go lcampc
           하이텔 ID : campusc
****************************<< 목 차 >>************************************
<1> 구조체 (Struct) 의 기본 에 대하여..
        1> 시작전에 필요한 말들..
        2> 구조체는  (머리 + 몸통 + 꼬리) 로 이루어져 있다.
        3> 구조체의 각 부분이 의미 하는것
        4> 구조체를 쓰는 이유 ?
        5> 구조체 선언하는법 4가지 (실제 사용 3가지)
        6> typedef으로 struct의 표현을 간단하게 하자
        7> 구조체를 "새로운 타입"의 관점에서 보자
        8> 구조체 변수의 초기화
        9> 구조체의 메모리 구조
        10> 구조체의 멤버 참조법
        11> 구조체의 크기에 관하여
        12> 구조체의 주소에 관하여
        13> 숙제
**************************< 내용 시작 >********************************
1> 시작전에 필요한 말들..
-----------------------------------------------------------------------
        우리는 이제부터 구조체에 대해서 알아 보려고  한다. C 에서 구조체
는  포인터  만큼이나  중요한 내용이고, 또 본격적으로  프로그램을 짜기 위
해서는 이 구조체를 "기본적"으로 이용해야 한다.

        구조체는 이른바 "복합적인 데이타 타입"이다.  쉽게 얘기해서 , "기
본적인 데이타 타입"인   char, int, long 따위가 껌, 사탕,  과자 같은 것이
라면, 구조체는 이것들을 "과자 종합 선물"로 포장하여  상자에 담은 것과 유
사하다.

        이렇게 담아 놓으면, 사탕을 먹기 위해 상자  뚜껑을 열고 사탕을 찾
아야 하는 불편함이  있다. 게다가 상자안에 또 작은 상자가  있다면 성질 급
한 사람들은 열이 좀 날지도 모르겠다.
        그러나 이렇게 포장을  해 놓음으로서 우리는 과자들을  간편하게 정
리, 운반, 보관  할 수가 있다. 시내에 다니는 과자회사  차들이 하늘높이 과
자상자를 싣고 다니는 모습과  골재차 들이  모래를 실어 나르는 모습을 상상
해 보라. 어느정도 구조체의 필요성을 느낄 수 있을것이다.

        구조체는 이와 같이, 우리가 태어 나면서 부터  익숙해져 왔던  조직
에 관한 얘기를  하는것인데, 항상 그래왔듯이 "문제"는 이 내용을  "C 말"로
표현해야 한다는데 있다.  우리는 또다시, 우리가 잘아는 한국말을  놔두고 C
말로 이해를 하는 작업을 해야 한다.
        이제부터 이런 작업을  약간 쉽게 하기 위하여, 몇가지  유명한 로보
트 이름을 알려 드리겠다.
1. mazinga :
이 로보트는  머리, 몸통, 두팔, 두  다리로 구성됨. 각 부분은  해체 되서도
잘싸우고, (사람형태로) 결합해서도  잘 싸움. 이 이름은 앞으로  "보통 스트
락춰"를 대표하는 이름으로 쓰일것임

2. robocop :
이 영화는 1,2,3  까지 나왔음, 배열 스트락춰 robocop[3]의   형태로 쓰일것
임.

3. asura   : 역시 옛날에  나온 만화영화 "요괴 인간"에서  나오는 귀신같은
악당 로보트(?) 임. 원래 이름은 "아수라  백작"으로 왼쪽은 남자고 오른쪽은
여자임. 이것은   항상 우리를 괴롭히는  포인터 스트락춰   *asura의 형태로
쓰일것임.

-----------------------------------------------------------------------
2> 구조체는  (머리 + 몸통 + 꼬리) 로 이루어져 있다.
-----------------------------------------------------------------------
구조체는 다음과 같이 생겼다.
struct robot {                          <-- (tag 명)
                 int  head;             <-- (member)
                 int  body;                     //
                 char arms;                     //
                 long legs;                     //
             }   mazinga;               <-- (변수명)

이 형태는 다음과 같이 3 부분으로 구분될 수 있다.

1. 머리(대표명) (struct robot 부분)
-------------------------------------
        1) struct 는 예약어로서 항상 선두에 온다.
        2) struct 뒤에 따라오는 robot을 일반적으로  "tag 명" 이라고 부른
          다.
           즉 이 스트락춰  의 태그명은 robot 다. 물론 내 맘대로 짓는다
        3) struct robot  은 헌병(겜뻬이)처럼 항상 같이 붙어  다니지 따로
          떨어져  다닐 수 없다. 따라서 우리는 struct만  봤다하면 항상 뒤
           따라 오는 태그명을 찾아야  한다. (태그명을 생략 할  수도 있지
          만...)
        4) 머리 부분은  구조체의 몸통을 대표하는 이름이다. 즉  우리가 어
           떤 사람의 이름을 들으면 그  사람의 모든것을 알 수 있는것과 같
           다.

           예)  임청하  -->  그 여자 정말 멋...      (x,틀린 표현)
                struct 임청하   -->  그래 그 여자 멋있어  (o,맞는 표현)

2.몸통  (블럭 {} 사이의 변수명들 )
----------------------------------
        1) 이 부분은 우리가 잘아는, 보통 타입의 변수명들이다.
        2) 이 변수명들을 우리는  "member"라고 부른다.  즉 이 구조체의 구
          성원이란 뜻이다.
        3)  이 몸통의  멤버로  다른 스트락춰의  변수명을  쓸 수  있다.즉
          nesting(중첩)이 가능하다.( 상자 안에 또 상자)

3. 꼬리  ( mazinga 변수)
-----------------------
        1) 이름이 이상하게 꼬리가 뻍지만,  사실은 가장 "중요한" 부분으로
           몸통의 멤버들을 묶어서 "구조화" 시키는 새로운 "변수명"이다.
        2) 우리가 변수명을 맘대로 짓듯이 이  새로운 타입의 변수명도 맘대
           로 지을 수 있다.
        3) 보통변수, 배열, 포인터, 등등 기초적인 변수의 선언법과 같다.
-----------------------------------------------------------------------
3> 구조체의 각 부분이 의미 하는것
-----------------------------------------------------------------------
        위와 같이 머리, 몸통, 꼬리부분이 의미하는  내용을 말로 조금더 정
확히 설명하면,
        1) struct  robot {       --> 나는  스트락춰를 하나 만들겠다.  그
                                        계획서의 제목은 "robot" 다.

        2) int   head;           --> 이  "struct robot"의 세부구조는  머   
           int  body;                리, 몸, 팔, 다리 로 이루어져 있다.
           char arms;   
           long legs;   

        3)   }  mazinga;           -->   계획서대로  "실제로"   만든것이
                                         mazinga 다

스트락춰의 3가지 부분은  이렇게 긴 말을 C 언어로 간략하게  표현하고 있는
것이다.이 중에서도 우리는 특히
        -------------------------------------------
        "꼬리"예 해당하는 mazinga 를 가장 주의깊게
        -------------------------------------------
봐야 한다.
        왜냐하면, 계획서란 말  그대로 계획서다. 아무리 기가  막힌 설계도
로 로보트를  만들겠다고 "뻥"을 쳐봐야,  우리는 관심을 가질 필요가  없다.
예나 지금이나  연구소에서 계획서란 "말잘하고  실력 없는 사람"이 제일  잘
만드는 법이다.
        우리는 그런 사실을 알고 있으니까 아무리  화려한 계획서를 봐도 일
단은 실제 로보트 "mazinga"를 보기전까지는  프로그램의 대상으로 봐 줄필요
가 없다.
        그러나 실제  작품인 "mazinga"를  보면, 여러분의 눈빛은  달라져야
한다."아니 로보트가 이세상에 하나 생겼군". 그리고  실제로 가서 만져 볼수
도 있는것이다.
-----------------------------------------------------------------------
4> 구조체를 쓰는 이유 ?
-----------------------------------------------------------------------
        구조체를 쓰는 이유란, 좀더 정확히  얘기하면, 구조체 변수 mazinga
를  쓰는 이유를  말하는것이다. 왜냐하면  그  요란한 스트락춰의  표현이란
mazinga 하나를 탄생 시키기 위한 과정에 지나지 않기 때문이다.
        그럼 왜 굳이  그 복잡한 절차를 거쳐서 mazinga를 만들어야  하나 ?
        이 대답은 여러분들이  이미 알고 있는지도 모른다. 우리는  이 세상
에서 이미 너무 많은 스트락춰 개념을 실 생활에서 사용하고 있다.
        등산을 자주가는 노련한 사람들은 배낭을 쌀  때 스트락춰 개념을 도
입한다. 즉  옷은 옷대로, 음식은  음식대로 각각 스트락춰 보따리를  만들고
그걸 배낭에 넣는다.  이때 물론 모든 짐을 마구 섞어서  배낭에 쑤셔넣고 산
을 가도 아무 상관없다. 그러나 산에서, 치솔  하나를 찾기 위해서 배낭을 통
째로 뒤집어 쏟아야 하는 불편함은 스스로 감수해야 한다.
        결론을 얘기하면, 스트락춰 변수 mazinga를 안  만들어 써도 아무 상
관없다. 그러나, 프로그램을  짤때 자기가 편하려면, 특히 자기의  복잡한 머
리를 시원하고 간결하게  유지하려면 이 스트락춰 변수를 쓸 필요가  생길 것
이다.
        여러분께서도 조금더 익숙해지면, "구조체를 쓰는이유  ?"에 대해 시
간과 종이를 낭비 하는일이 아주 쓸데 없는 일이 라는걸 알것이다.

-----------------------------------------------------------------------
5> 구조체 선언하는법 4가지 (실제 사용 3가지)
-----------------------------------------------------------------------
        구조체를 선언하는  형식은 4가지가 있을 수  있다. 왜냐하면,머리에
해당하는 태그명을 생략  할 수가 있고 또 꼬리에 해당하는  스트락춰 변수명
을 생략 할 수가 있기 때문이다. 그 다양한 형태가 [224쪽] 표이다.
        여기에서 <4>번 처럼  둘다 생략하는 경우는 아무 의미가  없기 때문
에 생략을 하고  나머지 경우만 살펴보기로 하자.
 

        이제 표를 유심히 보자. 더이상 장황한 설명이 필요 없을 것이다.
        지금 여러분은 "struct  robot" 와 "atom"을 열심히  비교하며 찾
았을것이다. 지금은 처음  배우는 단계이므로 이런 연습은  필요하다. 그러나
사실 중요한 점은 그것이 아니다.
        요번엔, 각 경우마다  atom이 있는지 만을 유심히 살펴  보라. 위
에서도 얘기를 했지만 스트락춰에서 가장 중요한  것은 "진짜로 만든 로보트"
atom다. 따라서 이 부분을 항상 "눈을 크게 뜨고  "찾아야 한다.  만일 변
수명이 안보이면 우리는  "걱정"을 할 단계에 까지 이르러야  한다.
"atom 아 어디갔니 ? ...."
        [224쪽]의 경우를 보면 <1>  <2>번의 경우는 고맙게도 atom이 눈에 보
인다. 그러나 <3>의  경우는 일단 변수명 atom이 없다. 이런 경우에는 atom을
찾을때 까지 절대 방심하면 안된다.
        -------------------------------------------------------------
         "atom는 나중에 어디에선가 등장함. 그때 까지 atom을 찾아야 됨"
        -------------------------------------------------------------

여기서 주의 할것은 표현을 이해 하는것이다. 아래를 보면,
struct robot {                       
                 int  head;
                 int  body;
                 char arms;
                 long legs;
       }   ;                            <--- 변수명 생략

struct robot  atom;                  <--- <요기>

위의 <요기>를 보면, 몸통이 날라간 상태라는걸 알  수 있다. 이 부분을 말로
해보면  다음과 같다.
        1. robot 라는걸 만들겠다
        2.  그러나 몸통 부분인 "상세 설게내역"은 없다.
        3. 그리고 진짜로 atom를 만들었다"

보통의 경우라면 이게  말이 되는가 ? 상세 설계도 없이  무슨 로보트를 만든
단 말인가 ? 완전히 사기꾼 같은 표현이다.
        그러나 위에서  몸통을 이미 선언  했다는 사실을 주목하자.  그래서
여러분께서도 짐작하겠지만, 위의 두 표현은  서로 보완적으로 "같이" 사용되
야 한다.

        이 두가지 표현은 멀리 떨어져 있을수도 있고,  또 반복되서 사용 될
수가 있다. 즉  설계도를 하나 만들어 놓고 사정이 있어서  시간이 조금 지난
다음에야 진짜 로보트  를 만들 수도 있고, 또 필요하면  그 설계도를 이용하
여 여러개를 만들수도 있다는 얘기다. 나중에  나오겠지만, 한 세트로 로보트
3개를 robocop[3] 이렇게  사용하는 것이다. 아래에 4개의 로보트가  같은 설
계도에 의해 만들어진 것을 보자.
struct robot {                       
                 int  head;
                 int  body;
                 char arms;
                 long legs;
       }   ;                            <--- 변수명 생략

struct robot  atom, robocop[3];      <-- 로보트 4 개 (1개 + 3개)

        이런 관점에서  보면 [224쪽]의 "<2> 태그명을  생략" 하는 표현은
나중에 이 설계도를 또  써먹을 수가 없다는 것을 알것이다.
설계도에 이름이 있어야 나중에라도 사용할것 아닌가 ?

따라서 [224쪽] <3>번 <변수명 생략> 같은 표현을  쓰는 이유는 다음과 같다.
        -----------------------------------------------------------
        번거로운 스트락춰의 몸통은 한번만 선언해 놓고 그 다음 부터
        는 간단하게 함수 머리만 갖고 다니겠다는 의도이다.
        -----------------------------------------------------------
-----------------------------------------------------------------------
6> typedef으로 struct의 표현을 간단하게 하자
-----------------------------------------------------------------------

typedef란  "type + define"의 준말로서 말그대로
        -----------------------------------------------
        typedef         -->  "타입을 (새로) 정의하는것"
        -----------------------------------------------
이다.여기서 말하는  "타입"이란 우리가 잘아는  char , int, long  "타입"을
의미하는것이다. 뭐하러 이제  간신히 익숙해진  char, int,long  따위의 "변
수 타입"을 새로 정의 하겠다는 말인가 ?  결론  부터 얘기 하면 이유는 다음
과 같다.
        ----------------------------------------------------
           1. 변수값이 무슨 의미인지 알기 쉽게 하자
           2. 긴 struct 따위의 type 명을 간단하게 쓰자
        ----------------------------------------------------
다음의 예를 보자

int lim_chungha = 39;           <-- <요기>
main()
{
        printf(" %d ", lim_chungha);
}

<문> 위에서 임청하의 무엇을 찍은것인가 ?
<답> 모르겠다.

그러면 다음을 보자

typedef  int    age;            <-- <요기>
age lim_chungha = 39;   
main()
{
        printf(" %d ", lim_chungha);
}
<문> 위에서 임청하의 무엇을 찍은것인가 ?
<답> 모르겠다.          <-- (바보)

즉 typedef이란 #define과 유사하게, "변수명의  타입"을 다른 타입으로 새로
정의하는것이다. 정리를 해보면
        ----------------------------------------
        #define  --> 주로 "상수"명을 새로 정의
        typedef  --> "변수의 타입"만 새로 정의
        ----------------------------------------

이다. 이제 다시  [55쪽]을 보자 2.변수의 데이타  타입의 단어들은 이제쯤
당연히 전부 외우고 있어야 한다.  그래야 새로운 이름이 등장하면, 속으로
"어떤  놈이 typedef를 사용했군 !  " 하고 프로그램을  읽을 수 있게 된다.

<문> 책을 보지 말고 다음에서 새로 typedef  되었을 가능성이 있는것은 무엇
인가요 ?
        char    a;
        int     a1;
        long    a2;
        word    a3;
        integer a4;
        byte    a5;
        double  a6;

struct 에서  typedef 의 사용 예는  [226쪽]에 잘  나와 있다.
일단 헤깔릴테니 빨간  형광펜으로 typedef 이란 단어에 전부  줄을 긋고나서
아래의 표현을 보자.

typedef  struct robot fighter_robot;  <--- 별명 선언

복잡하게 보일지 모르겠는데, 일단은 태그명 robot는  절대로 혼자 돌아 다니
지 않는다는 것을 기억하자. 그러면 위의 표현은  거의 3 단어로 봐도 무방하
다. 즉 아래와 아주 유사한 표현인것이다.

typedef         int     age;

즉 int 대신 age를 쓰겠다는 의미처럼,  struct reobot 대신 fighter_robot라
는 단어를  쓰겠다는 것이다. 그러면 아래의  두 표현이 같다는  것을 알것이
다.

struct robot    atom;        <-- <1>
fighter_robot     atom;      <-- <2>

[224쪽] 두번째  "<2>  태그명 생략"의 경우를 보면,  몸통
부분이 표현을 복잡하게  만들지만, 이것을 대표할 만한 태그명이  없기 때문
에 어쩔 수 없이  몽땅 끌고 다니는 형상 일 뿐이다. 즉 "대표  설계도 이름"
이 없으니, "상세 설계도를 몽땅 보여 주는 모습이다"

따라서 이제 일반적으로  생각해 보면, 느닷없이 우리가 모르는  단어 두개를
다음과 같이 봤다면,
xxx     yyy;
main()
{
}
yyy 는  변수명일 것이고, 그  앞에것은 새로 정의된 "새로운  타입"일거라는
짐작을 할 수 있어야 한다.
-----------------------------------------------------------------------
7> 구조체를 "새로운 타입"의 관점에서 보자
-----------------------------------------------------------------------
        구조체란 별게 아니다.  쉽게 얘기 해서 "char, int 따위의  보통 타
입의의 변수들의 묶음"일 뿐이다. 그래서 단어만  복잡할 뿐이지 아래와 똑같
이 생각해도 좋다.
        char            rambo;
        int             lim_chungha;
        struct robot    mazinga;

원래 "변수의 타입"이 하는 기능 이라는 것이 항상 두가지 였다. 즉
        1. 아파트 몇채를 차지 하나 ?
        2. 그 아파트에 어떤 "종류"(숫자 or 문자)의 값을 넣을건가 ?

이런 말을   대신해서 char, int 따위의 말로 하는것이다.  따라서 어떤 단어
든지 위의 두가지를 알아 볼수 있으면, 우리는  그것을 새로운 "데이타 타입"
으로 써도 좋다.  아직은 스트락춰의 데이타 구조를 안 봤지만,  일단 다음과
같이 기억하자

        -------------------------------------------------
        char, int 따위가 쓰이는곳에 무조건 "struct xxx"란
        단어를 써도 좋다
        -------------------------------------------------

<문> 아래 <요기>는  맞는 표현인가 ?
struct robot {
                char            aa;
                struct xxx      aa1;            <-- <요기>
                int             aa2;
        }

<답> 물론이다.

-----------------------------------------------------------------------
8> 구조체 변수의 초기화
-----------------------------------------------------------------------
        구조체 변수를 초기화 하는 방법은 "일차원  배열"을 초기화 하는 법
과 비슷하다.단지 구조체의  멤버들은 각각 변수타입이 틀릴 수  있으므로 초
기치 값이 그것과 정확히 일치해야함은 물론이다.
        앞으로 학생들 성적관리 프로그램을  짠다든지, 친구주소록을 짠다든
지 하는  따위의 자료관리와 관계된  프로그램을 짜보실 분들은 이  구조체를
열심히 해야  한다.앞으로 나올 화일의  생성,저장,읽기 등에 관련된  내용의
기초이기 때문이다.

구조체의 초기화는 한마디로 다음과 같이 한다.

struct information {
                 int  number
                 char name[10];
                 int  age;
                 char sex;
       } student = {
                    123, "Lim chungha", 39, 'F'
       }

유심히 보면, 몸통의 내부에서 선언된것과  같은 순서대로 데이타들이 들어가
있는것을 알것이다.

여러명을 취급할 땐 물론 배열을 쓴다.
struct information {
                 int  number
                 char name[10];
                 int  age;
                 char sex;
                 char address[40];    <--- <요기 1> 배열 크기 생략 불가
       };

struct information  student[] = {     <--- <요기 2> 배열 크기 생략 가능 

      1, "Lim chungha", 39,'F', "Hongkong Main street 123-1",
      2, "Ju yunbal"  , 25,'M', "Hongkong Main street 111-4",
      3, "Bu shman",    45,'M', "Uganda black stone village 21",

}

<질문 1>  위에서 <요기 1> 부분은 왜 배열 크기가 생략 불가능한가 ?
<답>    "상세 설계도"의 "상세"란 말이 의미 하는것을 모르겠어 ?
크기를 정확히 확정지어야 컴파일러가 집을 그 크기만큼 마련해 주지.

<질문 2> 위에서 <요기 2> 부분은 왜 배열 크기가 생략 가능한가 ?
<답>    이건 보통 1차원 배열에서 하는 방식과  같다.즉 초기화 시킨 데이타
를 보면 컴파일러가 [] 사이에 몇이 들어가야 할지  알 수 있지. 물론 이것도
컴파일러 만든 사람들이  생략 불가능하게 만들면 그뿐 이지만,  여기서는 허
용이 된다니까 외우고 쓰는것일 뿐이야.

너무도 당연한  얘기지만,구조체 멤버의 타입과  초기치 값의 타입이  정확히
같아야 한다는 걸 유의해야 한다.

-----------------------------------------------------------------------
9> 구조체의 메모리 구조
-----------------------------------------------------------------------
        백문이 불여일견 이라고  스트락춰를 이해 하기 위해서는  역시 메모
리 구조를  보는게 최고 좋은 방법이다.  앞으로 여러분은 이  메모리 구조를
머리속에 확실히 기억하고 있어야 한다. 그러면 말을 많이 할 필요가 없다.
        [229쪽]의 그림을 보면,  몸통 부분에 해당하는 각 멤버들의  크기는
우리가 지금까지  연습해 온것과 같다. 다만,  또하나의 문패가 붙어 있다는
것에 주목하자
        그림처럼, "스트락춰 변수명" mazinga는 항상
        ---------------------------------------------------
        1. 자기 몸통에서 "제일 처음 나오는 멤버의 집"에
           문패를 같이 달게 되있다.
        2. 그리고 그 문패의 영향력은 스트락춰 멤버 전부에게
           미친다
        ----------------------------------------------------
이 그림을 보고 있으면 우리는 많은 문제를 가볍게  이해 할 수 있다. 이를테
면, 이 스트락춰의  크기는 얼마인가 ? 주소는 어디서 부터  시작하는가 ? 하
는 것은 더이상 우리의 문제가 안될것이다.
-----------------------------------------------------------------------
10> 구조체의 멤버 참조법
-----------------------------------------------------------------------
        [229쪽]의  처음 그림처럼 스트락춰의  문패가 생기면 그 멤버 변수에
값을 대입하는 방법이 약간 복잡해 진다.
        즉 예를 들어 head에게  "head 야 123  가져라" 하고 부르는 건 틀린
표현이다. 아래 처럼 불러야 한다.

        -------------------------------
        mazinga 의  head  야 123 가져라
        -------------------------------
이걸 C 로는 다음과 같이 쓴다.
        -------------------------------
        mazinga. head   = 123
        -------------------------------

또 그 옆집 body에게 200 을 주고 싶으면 아래와 같이 한다.
        -------------------------------
        mazinga. body   = 200
        -------------------------------

        즉 "마침표  연산자"를 쓴다. [88쪽] 표를 보면  이 마침표 연산자
"." 도 우선순위가 최고 높다는걸 알것이다. 이건  무엇을 의미 하는가 하면,
mazinga 와 head를 떼기가 아주 힘들다는 걸 의미한다.

예를 조금더 들어 보면
struct robot {                       
                 int  head;
                 int  body;
                 char arms;
                 long legs;
       }  mazinga;
main()
{
        mazinga. head   = 111;
        mazinga. body   = 222;
        mazinga. arms   = 'y';
        mazinga. legs   = 333;
        robot.head      = 111;          <-- 이건 뭐야 ? (x)
}
-----------------------------------------------------------------------
11> 구조체의 크기에 관하여
-----------------------------------------------------------------------
        [229쪽]을 보면 구조체의 크기에  관해서는 달리 언급할 것도 없다.
그러나 표현법에 있어서는 약간  신경을 써야 할 것이 있다.
즉 구조체에서는  머리 ,몸통, 꼬리 제각각의  크기를 이용할 수가 있는데 그
사용법이 [231쪽]에  나온 다음과 같은 부분이다.

main()
{
   sizeof(struct robot)         <-- 1) 머리 크기        ( 9 바이트)

   sizeof(mazinga.head)         <-- 2) 몸통의 멤버크기  ( 2 바이트)
   sizeof(mazinga.body)                                 ( 2 바이트)
   sizeof(mazinga.arms)                                 ( 1 바이트)
   sizeof(mazinga.legs)                                 ( 4 바이트)

   sizeof(mazinga)              <-- 3) 꼬리 크기        ( 9 바이트)
}
        위에서 몸통 내부의  각 멤버크기는 단순히 데이타  타입에 따르는것
이다.그리고 머리의 크기와  꼬리의 크기가 같다는걸 알 수 있다.  이건 지극
히 당연한  사실이다. 그 설계도 대로  mazinga를 1 개  만들었는데 틀릴리가
없다. 그러나  배열을 사용하여 3개를  만들면, 설계도 크기의 3배가  될것이
다. 역시 [231쪽]의 (예제 1, 2, 3)을 풀어보기로 하자.
(직접 컴파일을 해봐야 합니다)
main()
{
        sizeof(robocop)         <-- 3) 꼬리 크기
        sizeof(robocop[0])      <-- <요기>
}
<문제> 위의 <요기>의 크기는 얼마인가 ?
-----------------------------------------------------------------------
12> 구조체의 주소에 관하여
-----------------------------------------------------------------------
        [229쪽]의 처음 그림을 보면,  역시 주소에 관한 것
도 쉽게 이해가 될것이다. 표기법도 똑같다.  여태까지 주소찾아 주는 연습을
열심히 해온 사람들은 따로 공부할 필요가 없을것이다.  즉 다음과 같이 주소
를 쓴다.

        마징가의 주소는 ?       -->  &mazinga   --> 100 ( 이라고 하자)
        마징가 head의 주소는 ?  -->  &mazinga.head      --> 100

<문> 위의 주소가 같단 말인가 ?
<답> [229쪽] 그림을 봐  두말할 것 있나 ?

배열의 주소를 찾아 주는것도 마찬가지다.  아직도 기억 하시는지 모르겠는데
베이스 캠프 주소의 표기법은 다음 두개가 같다고 했다.
        1. &rambo[0]
        2. rambo
따라서 다음과 같이 된다

        마징가 팔(arms[0])의 주소는 ?   --> mazinga.arms

<문> 위와 똑같은 표현은 어떤것인가 ?
        마징가 팔(arms[0])의 주소는 ?   --> &mazinga.arms[0]   (o)
        마징가 팔(arms[0])의 주소는 ?   --> mazinga.&arms[0]   (x)

<문> 위에서 틀린 이유는 ?
<답> 물론  표기법이기 때문에 이렇게  제일 앞에 &를 쓰는  것이지만,일단은
"시험 문제용"으로 다음과 같이 외우자.
        ---------------------------------------------------------
        "."(마침표 연산자) 의 바로 뒤에는 다른 연산자를 쓰지 못함.
        "->"(화살표 연산자)의 바로 뒤에도 마찬가지임.
        ---------------------------------------------------------
이것은 다음과  같은 이유에서이다.  위에서도 언급했다시피 "."  "->"따위의
연산자들은 결합력이 아주  강해서 갈라놓기가 아주 힘들다. 따라서  그 사이
로 비집고 들어가는 표현법은 허용이 안된다. 이제  말의 이해를 위해서는 다
음과 같은 (우리가 좋아하는) 한국말을 보자.

(나의엄마)의 주소 --->  (나.엄마) 의주소  
                  --->  &(나.엄마)      /* 결합력 강해서 괄호 생략가능
                  --->  &나.엄마

즉 이 표현은 "나의 주소"를 말하는 것이 아니다. 그리고 누군지도 모르는
(일반 명사인) "엄마"의 주소를 말하는 것은 더구나 아니다.
반드시 두개를 붙여야 의미가 정확한 "나의 엄마의 주소"를 말한다.
표기법을 유심히 보시고 눈에 익히시길 바란다.

<숙제> 제가 보내드린  menu.c의 struct 중에 하나를 typedef을  이용하여 다
        시 쓰고 컴파일 해 보세요. 실행결과가 같은가를 확인하세요.
<숙제> menu.c 에서 스트락춰에 관계된 표현을 전부 찾아보고 읽어 보세요.
<숙제> 다음은 conio.h 에 선언되 있는 스트락춰 입니다.

struct text_info {
        unsigned char winleft;
        unsigned char wintop;
        unsigned char winright;
        unsigned char winbottom;
        unsigned char attribute;
        unsigned char normattr;
        unsigned char currmode;
        unsigned char screenheight;
        unsigned char screenwidth;
        unsigned char curx;
        unsigned char cury;
};
문1> 선언된 형태로 보아 생략된 것은 무엇인가요 ? (머리, 꼬리)
문2> 이 구조체의 크기(sizeof(struct text_info))는 얼마인가요 ?
문3> 이 구조체의 메모리 맵(아파트 그림)을 그려 보세요. 
        (시작 주소는 임의로 결정 하세요)

<숙제> 다음은 stdio.h에 선언된 typedef 입니다.
 

typedef struct  {
        short           level;         /* fill/empty level of buffer */
        unsigned        flags;          /* File status flags    */
        char            fd;             /* File descriptor      */
        unsigned char   hold;           /* Ungetc char if no buffer */
        short           bsize;          /* Buffer size          */
        unsigned char   *buffer;        /* Data transfer buffer */
        unsigned char   *curp;          /* Current active pointer */
        unsigned        istemp;         /* Temporary file indicator */
        short           token;         /* Used for validity checking */
}       FILE;                           /* This is the FILE object */

        여기서 "FILE"  이란 단어가 대문자로  쓰여진 것을 유심히  보세요.
typedef을 쓸  경우 반드시 대문자로  쓰는 것은 아니지만(정해진 규칙이  없
음), 이것처럼 대문자로  쓰면 일단은 우리의 관심을 끌지 않습니까  ?  이처
럼 쓰는 것도 좋은 방법이라는 것을 아시고,  프로그램을 읽다가 대문자 단어
를 만나면, 이제는 두가지 경우를 생각 할 수 있어야 합니다
        1. #define으로 새로 정의 된 경우
        2. typedef으로 새로 정의 된 경우

문1> [226쪽] 형태중 어느 경우 인가요 ?
문2> 이 구조체는 나중에 총 몇 바이트의 메모리를 차지 할까요 ?
문3> 이 구조체의 메모리 맵(아파트 그림)을 그려 보세요. 
        (시작 주소는 임의로 결정 하세요)
*************************< 끝 마치며 >*********************************
수고 하셨습니다.
***********************************************************************