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

[연락처] : 605-8662 (서울) ("캠퍼스 C", 도서출판 "책과 스승")
           천리안 : go campusc  
           나우콤 : go lcampc
           하이텔 ID : campusc
****************************<< 목 차 >>************************************
[1부] 문법편
------------
<1> C 를 배우기 위한 기본서적
         1. compiler  사용법
         2. 문법 책
         3. 라이브러리 레퍼런스(library reference)

<2> C 프로그램은 이렇게 생겼어요 ( 5 부분)
         1. 함수 아닌 부분
                1) #include 부분 (생략 가능)
                2) #define  부분 (생략 가능)
                3) 함수명 선언부분 (생략 가능)
                4) 변수 선언 부분 (생략 가능)
         2. 함수 부분
                5_1) main() 함수
                5_2) sub_routine() 함수 (생략 가능)

<3> 함수에 관하여
        1> 형태 (들여짜기(indent) 및 모양빚기)
        2> 기능(하는 일)
        3> 프로그램이 왜 점점 복잡해지나 ?
        4> 프로그램 내에서 함수 이름의 구분
        5>함수를 부르는 방법 3 가지
                1) " 쏴라"
                2) " 미사일을 쏴라"
                3) " 미사일을 쏴라 그리고 보고하라"
******************************< 내용 시작 >********************************
<1> C 를 배우기 위한 기본서적
         1) compiler  사용법
         2) 문법 책
         3) 라이브러리 레퍼런스(library reference)
***************************************************************************
        지난 시간 컴퓨터는 뜯어 보셨나요 ? 숙제를  확인 할 길은 없지만, 중요
한 사실은, 머리속에  우리의 프로그램이 뛰 놀 놀이터를 확실하게  이해 하고 있
어야 한다는 겁니다.
        지난 예비 강좌에도 실었지만 정리하는 의미에서 다시 합니다. 지난번에
컴파일러 팩키지(package)의 구성을 살펴 보았는데  컴파일러의 기능은, "C 언어" 
를 "기계어" 로 바꿔 주는 것입니다. 지극히  간단 하지요. 그러나 실제 컴파일러
의 디스켓에 들어 있는 내용을 보면 그렇게  간단한것은 아닙니다. 일반 유저들은
자세한 설명서가 없으면 쓰기가 어려울 정도입니다.
        그래서 컴파일러를 만들어  파는 회사에서는 꼭 사용  설명서 (매뉴얼)을
만들어 주는데 그게 위에  적어 놓은 3권 입니다. 이 중에  다음의 두권은 우리의
교재에 같이 실려 있어서 서점에서 비싸게 따로 살 필요가 없습니다.
        교재에 실린 책 : 1. 문법 책 
                         2. 라이브러리 레퍼런스
        그리고 1) compiler  사용법 은 각  컴파일러마다 사용법이 다르고, 컴파
일러를 살 때  따라 오는 것입니다. 따라서 서점에서 따로  사야될 필요는 없습니
다. 이것도 역시 잘  알아야 하지만, 지금 우리가 쓰는 터보 씨나 볼랜드  C++ 같
은 것은 메뉴  체계가 잘 되있어 비교적  이해 하기가 쉬울 뿐더러 현  단계 에서
그렇게 심각하게 파고  들 필요는 없습니다. 그러나 점점  프로그래밍에 익숙해질
수록 [30쪽]에  언급되어있는 "컴파일러의 사용법", "링커의  사용법", "라이브러
리 관리기의 사용법" 정도는 자세히 알아야합니다.
**************************************************************************
<2> C 프로그램은 이렇게 생겼어요 ( 5 부분)
         1> 함수 아닌 부분
                1) #include 부분 (생략 가능)
                2) #define  부분 (생략 가능)
                3) 함수명 선언부분 (생략 가능)
                4) 변수 선언 부분 (생략 가능)
         2> 함수 부분
                5) main() 함수
                5) 기타 sub_routine() 함수 (생략 가능)
***************************************************************************
        C 프로그램의 전반적인 모습을 이해 하기  위해서는 교재의 [52-54쪽] 의
구성만 알고 있으면  됩니다. 이 부분은 거의 바둑의 정석처럼  쓰이는 것이기 때
문에 여러분이 프로그램을  직접 작성하실 때 이것을 "샘플"로 삼아서  내용 수정
만 하시면 됩니다.
        이걸 다시 크게  분류해 보면, "함수부분인가" "아닌가"로 나눌  수 있습
니다. 함수는 밑에서  얘기 하겠지만, C 프로그램의 구성 요소중  가장 중요한 부
분이고, 사실상 함수가 아닌 부분은 전부 생략할  수 있기 때문에 프로그램은 "함
수로만  구성"되 있다고  해도 틀린말은  아닙니다. 게다가  함수 부분  중에서도
main() 함수 부분만 빼고  나머지 함수는 전부 생략 가능 하기  때문에, C는 사실
상 main() 함수 하나만 있어도 완전한 프로그램이 되는 것입니다.
        이와같이 C 프로그램은 생략가능한 부분이  많기 때문에 여러가지 형태로
보일 수  있습니다. 그러나 결국  완전한 부분은 지금보고 있는  [52-54쪽]이라는
것을 기억하시기 바랍니다.
**************************************************************************
<3> 함수에 관하여
        1> 형태 (들여짜기(indent) 및 모양빚기)
        2> 기능(하는 일)
        3> 프로그램이 왜 점점 복잡해지나 ?
        4> 프로그램 내에서 함수 이름의 구분
        5>함수를 부르는 방법 3 가지
                1). " 쏴라"
                2). " 미사일을 쏴라"
                3). " 미사일을 쏴라 그리고 보고하라"
**************************************************************************
<3> 함수에 관하여
        "함수"의 완전한 형태는 [268쪽]의 상자안에 자세히  나와 있습니다.  그
림에서 보다시피 사람처럼 "머리"와 "몸통"을  가졌지요. 함수머리에서 "xxx"라는
이름은 "임의의 이름"을 여러분 자신이 써넣을 수  있다는 것을 의미하고, 이것이
"함수 이름" 입니다.
        이 함수를 우리는  "xxx함수" 라고 부릅니다. 그러면  "main함수"는 아래
처럼 생겼겠지요.
                        main()
                        {
                

                        }
일반적으로 함수 형태의 특징은 이렇습니다.

        1) 반드시 xxx 에 연달아 소괄호 가 열리고 닫힙니다.
        2) 소괄호 사이에는 매개변수들이 있어도 되고 없어도 됩니다
        3) 중괄호가 열리고 닫힙니다

사실 위에서 줄은 아무렇게나 해도 상관이 없습니다.  아래는 컴파일러에게 다 똑
같이 여겨 집니다.
<경우 1 >  xxx() {           }

<경우 2 >  xxx() {          
      

           }

<경우 3 >  xxx()
           {          
      

           }

즉 컴파일러에게는 자기에게 필요한 머리  인 "xxx()" 와 몸통인 " {    } "만 있
으면 됩니다. 그러나 그렇다고 우리도 아무렇게나  쓰면 "절대"로 안됩니다. 여기
서는 반드시 다음과 같이 쓰도록 합니다.

<경우 3 >  xxx()
           {          
      

           }
        만일 이 습관을  제대로 들이지 않으면 자기가 짠 프로그램도  자기가 이
해를 하지 못하는 우스운 일이 벌어집니다. 여기서 용어 두가지 만 이해 합시다.

<용어 1> 들여 짜기(indent)
        이 뜻은  아실 겁니다.우리가 문서 만들  때 [탭]키를 쳐서  글자를 들여
짜는 걸 말합니다.  이유는 분명 합니다. "보기  좋고 한눈에 이해 하기  쉽게 하
자"는 겁니다. 나중에 또 나오지만 C 에서는  관습적인 규칙이 있습니다. 즉 함수
몸통의 시작 부분 "{" 가 열리고 나면 그 다음 줄은 꼭 들여 짜기를 합니다
(암기 필요)

<용어 2> Nest(중첩)
        이걸 우리말로 "중첩"이라고 하면 적절할 지  모르겠는데 아주 중요한 개
념 입니다. 보통 낱말의 뜻은 "보금자리, (새의)  둥지" 같은 뜻 이지만 여기서는
그런 뜻이 아니고 줄줄이 중첩 되는 개념 입니다.  말이 이상한데 예를 들면 이런
겁니다.
        설마 등산갈 때 쓰는 밥그릇(코펠)을 모르는 분은  안 계시겠지요 ? 이런
형태가 그릇이 중첩(nesting)  된 것입니다. 또 야외용 물컵에도  그런게 있지요.
컵안에 또 작은 컵이 있고 그안에 또 있고 ... 하는 식으로 말 입니다.
        개념은 이해가 되었을 것이고 C 의 중괄호 "  { } "들이 nesting 되는 모
습을 보십시오( 중괄호만 보세요)

main()
{
        if(a > 10) {    <-- 중괄호 열리고 다음 줄 "탭"
                a++;
                b++
                for(a=0; a < 10; a++) {    <-- 중괄호 열리고 다음 줄 "탭"
                        printf(" 이건 보지 마세요");
                }       <-- 중괄호 닫히고 다음 줄 정상적으로 복귀
        }       <-- 중괄호 닫히고 다음 줄 정상적으로 복귀
}

들여 짜기를 하면 이런 중첩(nesting) 되는 구조가 되는 것입니다.

---------------------------------------------------------------------------
2> 함수의 기능 (하는 일)
---------------------------------------------------------------------------
        이것은 수학에서의  "함수(function)"와 똑같은 개념입니다.  어떤 "일을
할수 있는 최소 단위" 입니다. C 프로그램에서  어떤 일을 하고싶으면 반드시 "함
수의 형태"를 가지고 "그안"에서 해야합니다. 예를 들어 "a  와 b 를 더해서 c 에
넣고 싶다" 는 일을 하고 싶으면 아래의  왼쪽같이 몸통 안에서 일을 해야됩니다.
오른쪽 처럼 몸통 밖으로 실행문이 나와서는 안된다는 겁니다.

main()                         main()
{                              {
    c = a + b;                 }
}                              c = a + b;

        구체적으로 "함수의 기능"은  "군인 한명"에 비유 될 수  있습니다. 그리
고 프로그램은 전쟁에 비유됩니다. 군인은  전쟁에서 싸워이기기 위해 조직적으로
역할을 분담하고 있습니다.  즉 군인 한사람 마다,  예를들어 소총수,운전병,취사
병,특공대원, 총사령관  등 각자 할일이  명백하지요.만일 누구라도 자기  역할을
다하지 못하면 전쟁에 집니다.
        프로그램도 마찬가지  입니다.각자 함수의 일을  정확히 하지 못하면  이
프로그램은 돌지 않습니다. 함수 중에서도 main() 함수  가 총사령관 에 해당하고
모든 명령은 여기서 부터 시작합니다.
--------------------------------------------------------------------------
<중요> C 에서 main() 함수 하나는 반드시 있어야 한다.

        C 에서는  유독 "main"이란  함수명을 특별하게 취급하여"main()  함수는
딱 하나만 존재해야 하며 프로그램은 여기서 부터  시작한다" 라고 규정하고 있습
니다. 따라서 C 프로그램을 읽으려면 다음과 같이 합니다.
        (1) 아무리 크고 복잡한 프로그램을 보더라도 일단은 main() 을찾는다.
        (2) 그리고  다른 모든 것을  무시하고 거기부터 한줄 한줄  읽어나간다.  
         main() 함수의 몸통 끝에 다다르면 다 읽은것이다.

---------------------------------------------------------------------------
<3> 프로그램이 왜 점점 복잡해지나 ?
      main() 함수와 기타 함수들의 관계 (총사령관 과 기타 병사들)
---------------------------------------------------------------------------
        C 의 프로그램은  실제로 많은 함수들을 서로 부르고  불리면서 복잡하게
구성되 있습니다. 그러나  그것도 일정한 규칙이 있어서 보기처럼  그렇게 복잡한
것은 아닙니다. 다음의 예를 보시고 어떻게 프로그램이  확장 되나가는지 한번 이
해해 보세요.

<예>    조그만 싸움을 할땐 총사령관 한 사람만  나가서 싸웁니다. 즉 위에서 예
를 든것 처럼  main() 함수 하나만 있으면 충분합니다. 그러나  소말리아 전투 처
럼 조그만 전쟁이 벌어지면 병사를 몇명 데리고  가야 합니다.우리도 병사에 해당
하는 "함수를  만들어야" 합니다.이걸 우리는  흔히 "함수를 짠다"고 얘기하고  C
용어로는 "함수를 정의(definition)"한다 라고 합니다. 즉  "이 함수는 이런 이런
일들을 한다..." 고 정의 하는 것입니다.

함수는 머리와 몸통을  가진 병사와 같기 때문에 이렇게 따로  따로존재해야 합니
다
main()
{
}
soldier1()
{
}
soldier2()
{
}

임산부가 애기를 갖고 있듯이 아래처럼 존재하는것은 말할것도 없이 틀린
것입니다.
main()
{
     baby()
     {
     }
}
따라서 혹시 위의 형태로 "baby"가 존재한다면 그것은 "함수가 아닙"니다.

싸움이 시작되면 총사령관은 바빠집니다. 마구 병사들을 부릅니다.
        "쏴라",
        "취사병은 밥해놔라"
우리도 함수를 불러야 합니다.
main()
{
        fire();
        do_cook();
}
여기서 몸통은 없어졌지요  ? 항상 머리만 부릅니다. 만일 몸통까지  쓰면 2 쌍둥
이 애기를 배고 있는  형태입니다. 위의 2 개는 함수이기 때문에  그렇게 쓰면 컴
파일러가 화를 냅니다.

그러나 위와 같이만 프로그램을 짜면 될까요  ? 당연히 틀렸습니다.병사가 있어야
부르지요. 따라서 아래같이 "머리 + 몸통" 형태로 함수를 "짜 주어야" 합니다.

main()
{
      gunshot();
      do_cook();
}
gunshot()
{
}
do_cook()
{
}

자 프로그램이 조금 복잡해 졌지요? 이제 좀 더 크게 전쟁을 벌여볼까요 ?
육해공군을 총동원합니다. 총사령관이 또 부릅니다."공군 사령관 폭격 개시",
 "해군제독 잠수함 발진"
우리도 부릅시다
main()
{
      airforce_commender();
      navy_commender();
}
airforce_commender()
{
      plain_go_and_fire();
}
navy_commender()
{
      submarine_go();
}

        여기서는 일단  공군사령관을 불렀습니다. 그렇습니다.  총사령관이 비행
기 조종사에게 직접 명령하는 것은 좋지않다는 것을  누구라도 잘 압니다. 그러나
부를 수 없다는  것은 아닙니다. 단지 비효율적이라는 이유로  공군사령관을 통해
서 부를 뿐이지요.
        위도  역시   완전한  프로그램이  아닙니다.   plain_go_and_fire()  과
submarine_go() 함수가 존재하지  않기 때문입니다. 첨가 시키면 다음과  같이 다
소 복잡해집니다.
main()
{
      airforce_commender();
      navy_commender();
}
airforce_commender()
{
      plain_go_and_fire();
}
navy_commender()
{
      submarine_go();
}
plain_go_and_fire()
{
}
submarine_go()
{
}
        자 이제 짐작이 가시지요 왜 프로그램이 복잡해  지는지 ? 부르는데는 아
무 제한이  없습니다. 몇번을 부르든지  몇단계를 거치든지 말입니다. 단  main()
은 아무도 부를  수 없습니다. 그리고 군대에서는 부하가 상관을  불러서 일을 시
킬 수는 없지 않습니까 ? (요즘은 가끔 길들이기도 하는 모양이지만...)
        여기서는 상관 없습니다.  위에 있건 아래있건 맘대로  부릅니다. 심지어
는 자기 자신도 부릅니다.어때요 아주 좋은 언어지요 ?
        그러나 이것은 장점이자 단점이 될 수 있습니다.  어떤 기준을 가지고 일
관성있게 불러야지 제멋대로 부르다가는 결국 자기 자신이 고생 합니다.
        보통 C  에서 부르는 규칙은, 위에서  예를 든것 처럼 군대,  회사, 혹은
주먹세계처럼 상하 관계가 분명한 집단에서 부하를  부르는 식으로 하면 정확합니
다.
***************************************************************************
4> 프로그램 내에서 함수 이름의 구분

        이제 함수 이름을  구별 할수는 있을 겁니다.즉 xxx() 처럼  소괄호() 앞
에 오는 이름이 함수명 입니다. 이런것도 역시  함수명 입니다.xxx(int a); 즉 소
괄호 사이에 글자들이 들어가 있어도 상관 없다는 뜻 입니다.
이런 형태에 다음과 같은 4개의 예외가 있지만 이 얘기는 나중에 하기로 합니다.
        1. if()         2. for()
        3  while()      4. switch()

이 함수의 이름들도 3 가지 역할로 나눌 수 있습니다. 즉
  <1> 함수 정의(짠다)  --> 함수의 "머리"와 "몸통"을 전부 우리가 만든다
  <2> 함수 호출(부른다) --> 함수의 "머리"만 온다.(다른 함수 몸통 안에서)
  <3> 함수 선언(알려준다) --> 함수의 "머리"만 온다.(main() 함수 위에서)

   tank_shot();       <--- 함수 선언 ("이런게 아래에 있어요" 하는 뜻)
   main()             <--- 함수 정의 ( 짰다. 총사령관 만듦.)
   {
        tank_shot();  <--- 함수 호출 ( 불렀다. 일을 시킬라고.)
   }

   tank_shot()        <--- 함수정의 ( 짰다. 병사하나 만들었다)
   {
   }

<1>  "함수를 짠다" 고 하는 것은 아시겠지요  ? 머리와 몸통을 전부 만드는 겁니
        다.
<2> "함수를 부른다"는  것도 머리만 쓰면 되지만 반드시 기억  할것은 다른 함수
        몸통의 내부에서 부를 경우만 입니다.
<3> main() 위에 이름만 적는 경우도 있습니다.이건  "총사령관에게 보여 주는 출
        석부" 라고 생각하면 됩니다. 병사가 많아지면  다 기억을 못해서 명단을
        위와같이 보여줍니다.
                또 람보  같이 특수한  병사를 만들어  놨으면 일부러  위와같이
        main() 함수 밖에서  머리만 xxx(); 써줍니다. 위치가 "함수  밖" 이라는
        걸 꼭 확인해야 합니다.이걸 우리는 "함수의 선언"이라고 합니다.

이제  위와같이 똑같은 이름 3개 의 의미를 아시겠지요 ?
[269쪽] 부터 이 내용에 관한 정리가 되어있습니다.
********************************************************************
5> 함수를 부르는 방법 3 가지
      1. " 쏴라"
      2. " 미사일을 쏴라"
      3. " 미사일을 쏴라 그리고 보고하라"
********************************************************************
        이제 함수 이름 및 위치를 보고 그 역할을  구별 할 수는 있을 겁니다.그
럼 이제 함수의 호출 부분 중에서 부르는 방법  3 가지를 다시 예를 들지요. 총사
령관이 소총수 한테 "쏴라" 하면 그냥 쏩니다. 즉
 main()
{
    fire();
}
        그러나 람보 한테 "쏴라" 그러면 람보는 총을  못 쏩니다. 왜냐하면 그는
무기가 너무  많아서 뭘 쏠지 모르기  때문입니다. 이와같이 일을  많이할수 있는
함수를 부를때는 "미사일을 쏴라"하고 구체적으로 불러야 합니다. 즉
main()
{
     fire(missile);
}

또 "미사일 과 화살을 쏴라" 할때는
main()
{
     fire(missile,arrow);
}
쉽지요 ?
여기서 missile 과 arrow 처럼 소괄호 사이의  단어를 argument라고 부릅니다. 다
음 시간에 할 "변수명" 들이지요. 모양은 다양하지만  일단우리는 () 사이의 콤마
"," 로 이 매개 변수들이 몇 개인지 셀 수 있습니다.

clrscr();                              <-- 0 개
draw_menu();                           <-- 0 개
exit(0);                               <-- 1 개
clear_string(x,y,wordlong);            <-- 3 개
prt_string(new_x,new_y,word_array);    <-- 3 개
srand((unsigned) time (&t));           <-- 1 개 (콤마 가 없어요)

      마지막으로 "미사일을 쏴라 그리고 보고하라" 는  일을 할때는 다음과 같이
합니다.
main()
{
     ok = fire(missile);
}
즉 fire(missile)이 일을  하고나서 "잘 쐈음" 이나 "폭탄이  없어서 못쐈음"하는
따위의 결과를 보고하는 형태입니다. 위에서는 결과가 ok  라는 변수에 들어 갑니
다. 이 형태의 특징은 함수머리 왼쪽에 꼭다른 글자들이 있다는 겁니다. 즉

keyin = getch();                  <--getch() 왼쪽
stream = fopen(filep,"rt");       <--fopen() 왼쪽
if(!bioskey(1))                   <--bioskey() 왼쪽

        이것들은 물론 우리가  함수를 짤때 위의 3 가지중 어떤방법을  쓸 지 미
리 결정해야 합니다.

---------------< 참고 >---------------------
1. /*     */  :  이 사이는 설명문(주석문 이다)
        프로그램을 보면 /*    */ 쌍을 볼 수 있습니다. 이건 프로그램  과는 아
무 상관  없는 설명문 입니다. 자기가  메모를 하고 싶은 모든것을  씁니다. 쓰는
요령은 다음과 같습니다
                ---------------------------
                1)  아무데나 써도 무관.
                2)  몇줄이라도 무관.
                3)  가능한 자주 사용할것 
                ---------------------------
                예 1)   /* good */

                예 2)   /*
                           good also    
                        */

<숙제>  오늘 내용은 사실  설명 처럼 간단 한것은 아닙니다. 우리는  사실 이 함
        수로 두달을 보내야  되고 지금은 그 시작에 불과 합나다.  그래서 이 부
        분은 계속 읽어 보는 것이 필요합니다. 다음 숙제를 하세요

        1> BGIDEMO.C 를 터보 디렉토리 밑에서 찾는다.
           (C:\> ff bgidemo.c 를 하세요) 노턴 유틸리티에 있습니다.
        2> bgidemo.c를 위에서 설명한 프로그램의의 5 가지 형태에 맞춰
                 분류 하세요
        3> 위에서 설명한, 3가지 함수명의 사용 예를 실제로 찾아 보세요.

                1. 함수 정의(짠다)
                         --> 함수의 "머리"와 "몸통"을 전부 우리가 만든다
                2. 함수 호출(부른다)
                         --> 함수의 "머리"만 온다.(다른 함수 몸통 안에서)
                3. 함수 선언(알려준다)
                         --> 함수의 "머리"만 온다.(main() 함수 위에서)

******************************< 끝 맺으며 >********************************
수고 하셨습니다.
***************************************************************************