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

[연락처] : 605-8662 (서울) ("캠퍼스 C", 도서출판 "책과 스승")
           천리안 : go campusc  
           나우콤 : go lcampc
           하이텔 ID : campusc
****************************<< 목 차 >>************************************
<1> 변수의 기억부류 (Storage Class)
        1> 외부변수 와 내부변수 ( 선언 위치의 관점에서 )
        2> 내부 정적변수
        3> 레지스터 변수
        4> extern 변수
**************************< 내용 시작 >********************************
1> 외부변수 와 내부변수 ( 선언 위치의 관점에서 )
-----------------------------------------------------------------------
        C 프로그램의 구조에서  변수를 선언 할 수 있는 곳은,  위치의 관점
에서 보아 아래와 같이 2 군데이다.

int  lim_chungha;                       /* <---- 외부 변수 */

main()
{
        int   lim_chungha;              /* <---- 내부 변수(1) */
     

        printf(" good morning");
        class1();
}
class1()
{
        int lim_chungha;                /* <---- 내부 변수(2) */  

        printf(" lim_chungha age");
}

즉 정리를 해 보면
        ------------------------------------
         1. "함수의 내부" 에서 제일 첫 부분
         2. "함수의 외부" (main 함수 위쪽)
        ------------------------------------
이와 같이, 선언된  위치에 따라 우리는 변수  이름을 외부변수,내부변수라고
구별한다. 그러나  C 에서는 특별히 내부변수를,그  기능에 촛점을 맞춰 내부
변수라고 부르지 않고 "자동변수"라고 부른다. 즉 정리를 하면
        ------------------------------------
         1. 함수의 외부  --> "외부 변수"
         2. 함수의 내부  --> "자동 변수"(내부변수)
        ------------------------------------
위의 예 프로그램에서도 나와 있듯이, 이 외부변수와  자동 변수는 우리가 여
태까지 써왔던 평범한 변수 선언 방식이다. 다시 써보면

int rambo;              <-- 외부 변수

main()
{
        int rambo;      <-- 내부 변수

        rambo = 100;
}
그러면 과연 이  둘 사이에는 무슨 차이가  있는 것일까 ? 이걸  알아 보려면
다음과 같이 몇가지 측면에서 고려해 봐야 한다.
        -------------------------------------------------
        1. rambo 가 영향을 미치는 범위는 어디까지 인가 ?
        2. rambo 는 얼마나 오래 살아 있나 ?
        3. 처음에 값은 얼마로 결정되나 ? ( 초기값 )
        -------------------------------------------------

        나도 이제는 말을 그럴듯 하게 잘 하는것  같은데, 위와 같은 구분은
물론 정리해서 학습할 필요는 있지만, 내용을 이해  하는데는 별로 도움이 되
는것 같지않다.
        기본적인 내용은 이렇다.  여러분도 이제는 C 에서의 블럭 "{  }" 이
의미하는것을 어느정도 짐작 하시리라 믿는데,  블럭의 내부 라는것은 구체적
으로 얘기해서 "블럭"으로 쌓은 "교도소 방"이나, 혹은  "학교 교실" 같은 내
부 공간을 의미  하는 것이다. 교도소는 안 갔다 오신  분이 많겠지만 학교는
안 가본  분이 거의 없을 것이므로,  아래 프로그램을 학교  교실에 비유하면
다음과 같다.

int rambo;              <-- 요기

main()
{
        int rambo;      <-- 요기

        rambo = 100;
}
class1()
{
        int rambo;      <-- 요기

        rambo = 200;
}
class2()
{
        int rambo;      <-- 요기

        rambo = 300;
}

위 프로그램 에는  람보가 4 명 있다. 여기서 이해를  돕기위해 ,main()은 가
장 중요한 함수이므로, 학교에서 제일 높은 분인  "교장 선생님 방"이라고 가
정 한다. 그러면,

        1. 교장 선생님 방에     --> 람보 1명
        2. 학급 1 (class1)에    -->    //
        3. 학급 2 (class2)에    -->    //
        4. 학교 운동장(교실밖)  -->     //   (외부 변수)

        위에서 "학교 운동장"에 있는 람보는 두말할  것도 없이 main() 위에
선언된 "외부 변수"를  말한다. 이것은 어떤 블럭에도 쌓이지  않았으므로 넓
은 운동장에 개방되 있는 상태라고 보면 된다.
         이제 우리가  옛날에 다니던 중고등학교를 생각하면  모든상황은 정
확하게 똑같다. 즉,
-----------------------------------------------------------------
1. 모든 교실,교장 선생님 방에서 창밖 운동장의 람보를 볼 수 있다.(당연)
2. 우리 교실에서는 옆 교실에 누가 있는지 볼 수 없다. (당연)
-----------------------------------------------------------------

너무도 당연한 2 가지 사실을 적었는데 문제를 내 보자.

<문> 현재 위의 상황에서 우리가 볼수 있는 람보는 최대한 몇명인가 ?
<답> 2 명  ( 우리 교실 + 운동장 )

<문> 만일 한명만 볼 수 있다면 몇 가지 경우나 있겠나 ?
<답> 2 가지 ( 1. 교실 안에만 있을 경우
              2. 운동장 에만 있을 경우 )

내가 문제를 내는것은 주로 국민학교 수준인것 같다.  그럼 다음 문제는 어떤
가 ?

<문> 지금 람보가 2 명 있다. (교실 안 + 운동장)
    교실안 에서 "람보야" 라고 부른다면 누구를 부르는 것일까 ?

<답> 교실안 람보

위 문제의 답을  모든 사람이 맞추었는지는 잘 모르겠지만,  혹시 틀렸더라도
지금부터는 이 사실을 정확히 알아야 한다. 이것도  내 생각엔 거의 상식일거
라고 믿는데,  우리가 교실에서 "영삼아"  하고 부른다면, 교실에 같이  있는
친구 이름을  부르는 것이지, 운동장에 서  있는 대통령 이름을  부르는 것은
아닐 것이다. 그렇다면 다음의 답은 무엇인가 ?

<문제>
int youngsam = 100;
main()
{
        int youngsam = 200;

        printf(" %d", youngsam );
}

<답> 200

        물론 우리 교실에  "영삼"이가 없다면 우리는 전부 창 밖을  볼 것이
다. 그러면 다음의 답은 무엇인가 ?

<문제>
int youngsam = 100;
main()
{
        printf(" %d", youngsam );
}
<답> 100

그런데 운동장에도 "영삼"이  없다면 당연히 부른 놈이 미친  놈이다. 따라서
아래는 미친 프로그램이다.

main()
{
        printf(" %d", youngsam );
}

이런 미친  프로그램을 짜는 사람한테, "컴파일러"  가 하는 욕을  듣고 싶은
분은 위의 프로그램을  그대로 짜서 컴파일을 시켜보라. 영어로는  뭐라고 욕
을 하는지...

<문제> 그러면 다음은 미친 프로그램인가 아닌가 ?

main()
{
        printf(" %d", youngsam );
}
class1()
{
        int youngsam = 100;
}
<답> 교장 선생님 방에서 1반의 "영삼" 이 보이나 ?

<문제> 다음은 미친 프로그램인가 아닌가 ?
main()
{
        int youngsam = 100;
        class1();
}
class1()
{
        printf(" %d", youngsam );
}

<답> 아무리 교장  선생님 방에 있어도 교실  1에서 볼 수 없는  것은 마찬가
지.

그럼 아래의 결과는 무엇인가 ?

<문제>

int rambo = 100;        

main()
{
        int rambo = 200;

        printf(" %d\n", rambo );
        class1();
        class2();
}
class1()
{
        int rambo = 300;

        printf(" %d\n", rambo );
}
class2()
{
        printf(" %d\n", rambo );
}

쉬운 문제인데 이상하게  프로그램으로 써 놓으면 정신 없는 것  같은 경향이
있다. 그러나 이런 문제는 위에 적은 "당연한  두가지"만 기억하고 있으면 별
문제 없을 것이다. 이런 사항을 다시 정리해 보면
        ---------------------------------------------------
        1. 변수가 ( 내부 + 외부) 에 있으면 내부변수를 쓴다.(당연)
        2. 내부 변수가 없으면 외부 변수를 쓴다. (당연)
        3. 다른 함수안에 있는 변수명은 쓰지 못한다.(보이지가 않는걸 !)
        ---------------------------------------------------

        이런 문제가 위에서  어렵게 얘기했던 "변수가 영향을  미치는 범위"
에 관한 문제이다. 즉,
        ---------------------------------------------------------
        1. 운동장에 있는 외부변수는 모든 교실에서 참조 할 수 있다.
        2. 내부 변수는 자기 교실 에서만 불러서 쓴다.
        ---------------------------------------------------------
 

        두번째로 고려 해  볼것은 역시 위에서 얘기했던, " 이  변수가 얼마
나 오래 살아 있나" 하는 문제인데, 여기서  살아 있다는 뜻은 "집(아파트)을
차지하고 " 있다는 것이다. 여러분도 아다시피  이 변수들은 메모리 내부에서
아파트를 차지 하고  있는 것인데, 이 메모리라는게 결코 값이  싸다고 할 수
가 없어서 우리도 근근히 1 M , 혹은 4  M 정도만  쓰는 지경이다. 따라서 변
수가 필요없게 되면 "집에서 내슛아 버리고" 항상  공간을 확보해 놔야 할 필
요가 있다.
        결론 부터 얘기 하면
---------------------------------------------------------------
1. 운동장에 있는 외부변수는 프로그램이 도는 동안 계속 살아 있다.
2. 내부 변수는 자기 블럭에서 프로그램이 도는 동안에는 살아 있고,
   블럭이 끝나버리면 변수도 자동으로 없어진다.
---------------------------------------------------------------

위를 외울려고  할 필요는 없을 것이다.  상식에 준해서 운동장에  있는 외부
변수야 어떤 놈이  부를지 아무도 모르기 때문에 항상 살려  놔야 한다. 그러
나 내부변수는  어차피 자기 내부 에서만  쓰는 것이기 때문에,  자기 블럭이
현재 사용되지 않는다면, 존재하고 있을 이유가  없다. 구체적으로 예를 들어
보면,

int rambo = 100;        
main()
{
        class1();
}
class1()
{                                       <-- 요기서 내부 변수 생김
        int rambo = 300;

        printf(" %d", rambo );
}                                       <-- 요기서 내부 변수 소멸

위 프로그램에서 운동장  람보는 (int 타입이므로) 항상 2 바이트의  집 차지
를 하고  있다. 그러나, 교실 1의  람보는 자기 함수(class1())이  수행 되는
동안만 살아 있다, 즉  class1() 의 "{" 가 열리면 2 바이트를 차지  하고 있
다가  "}" 가  닫히면 죽고 만다.  이 내부 변수를 "자동  변수" 라고 부른다
고 했는데 이유가 바로 이것이다. 즉 "자동 변수"란
        -------------------------------------------
        "자동" 으로 생기고 "자동"으로 죽는 변수
        -------------------------------------------
의 준말인것이다. 따라서  아래와 같은 예를 보면 , 람보의  아파트가 생겼다
가 죽고, 또 생기고 하는 과정을 반복하는게 상상 되어야 한다.

main()
{
        int i;
 

        for(i=0; i < 100; i++) {
                class1();           <-- 호출 할 때마다
        }
}
class1()
{
        int rambo = 300;            <-- 이 람보 생멸 반복

        printf(" %d", rambo );
}

        이런 내용을  이해하면 3번째 문제인  "초기값이 어떻게 결정  되나"
하는 문제를 "자동적"으로 이해 할지도 모른다.
-------------------------------------------------------------
1. 외부 변수    --> 프로그램 시작 될 때 한번만 0 으로 초기화 시킴
2. 자동 변수    --> 생멸이 빈번하니 초기화 시키기 귀찮구나 !
-------------------------------------------------------------
        즉 1.외부변수야 생기는  과정이 딱 한번이니까 처음에  서비스 차원
에서 0  으로 전부 넣어준다.  그러나 2.자동변수는 귀찮아서 초기화  시키지
않고 내버려  둔다. 따라서 처음에 이  상태의 값은 아무 의미가  없다. 이걸
우리말로 "쓰레기"라고 하고 영어로는 "garbage" 라고 한다.
        그래서 다음과  같이 내부 변수를  아무 초기화 없이 사용하려고  하
면, 컴파일러가 경고를 해준다 .

main()
{
        int rambo;

        printf("%d", rambo);
}

< 경고 > "쓰레기 찍어서 뭐할려구..?"
<영어 경고> "Possible use of rambo before definition in function main"
            의 메세지 의미이다.

        이와 같은 모든  상식을 알면 변수를 외부에 쓸까 내부에  쓸까 하는
문제는 자동적으로 결정이 될것이다. 실제 프로그램 작성시에는 보통
        -------------------------------------------------------------
        여러 함수에서 부를 일이 있으면 (grobal 변수)    --> 외부변수
        한 함수 내부에서만 조촐하게 쓰이면(local 변수) --> 내부변수
        -------------------------------------------------------------

를 쓴다. 그리고 초기화에 관한 문제는
        ---------------------------------------------------
        내부 변수든 외부 변수든,무조건 자기가 직접 초기화를
        ---------------------------------------------------
시키길 권한다. 즉 아래  <예 1>처럼 i 라는 변수가 0으로  초기화 된다는 사
실을 안다고 "생략" 하는 것보다는, 아래 <예  2>처럼 직접 다시 초기화를 시
켜 주라는 얘기다.

------------------<예 1>------------------
int i
main()
{
        for(  생략  ; i < 100; i++) {
        }
}
-------------------<예 2>-----------------
int i
main()
{
        for( i = 0 ; i < 100; i++) {
        }
}

        왜냐하면 이렇게 가시적으로 써주는게,  가득이나 골치아픈 프로그래
머를 조금이라도 편하게 해 줄 수 있기 때문이다.

        위에서 설명한 사항을 표로 정리  한것이 [148쪽]에 나와 있다.
표의 오른쪽 끝에 보면 "예" 칸이 있는데,지금 설명한 부분중에
        -------------------------------------------
        1.  외부 변수는         -->  표의 "예" (3)
        2.  자동 변수는         -->  표의 "예" (6)
        -------------------------------------------
에 해당한다. 그리고  [148쪽])의 아래 <사용 예>  부분은 아래에 표시한 것과
같다.

< 사용 예 >

        int     xxx_1;          <-- 예 (3)      (외부 변수)
extern  int     xxx_2;          <-- 예 (4)      (extern 변수)
static  int     xxx_3;          <-- 예 (2)      (외부 정적 변수)

main()
{
        (auto)  int     xxx_4;  <-- 예 (6)      (자동 변수)
        static  int     xxx_5;  <-- 예 (1)      (내부 정적 변수)
      register  int     xxx_6;  <-- 예 (7)      (레지스터 변수)
}
-----------------------------------------------------------------------
2> 내부 정적변수
-----------------------------------------------------------------------
        이건 [148쪽]) 표에서 "예  (1)" 에 해당하는 것이다. 프로그램을
읽다보면 다음과 같이 선언된 것을 볼 수 있다.
main()
{
      static int rambo;
 

}
        이것은 자동 변수  앞에 static 이라는 단어만 붙인것인데,  이 변수
의 의미도 역시  3 가지 측면에서 찾아 봐야 한다.

1. rambo 가 영향을 미치는 범위는 어디까지 인가 ?
        당연히 블럭 안에 있으니까 함수 내부에서만 쓴다.

2. rambo 는 얼마나 오래 살아 있나 ?
        바뀐 부분은 여기인데,  static 이라는 단어 뜻 그대로  생멸을 반복
하지 않고 "삶을  안정되게 지속한다"는 뜻이다. 따라서 이것은  값을 일정하
게 유지 하고  싶을 때 쓰는것이고, 그건 결국 초기화를  한번만 하겠다는 의
미이다.

3. 처음에 값은 얼마로 결정되나 ? ( 초기 값 )
        초기화 값은 처음  한번만 0 으로 된다. 선언된 위치로  보아 부를때
마다 초기화를 할 것 같은데 주의를 해야 한다.

<문> 다음의 문제를 풀면서 차이를 알아보라.
main()
{
        int i;
        for (i=0; i < 5; i++);
                sub1();
}
sub1()
{
 static int age = 18;
        int weight = 40;

        age++;
        printf("age = %d\n", age);

        weight++;
        printf("weight = %d\n", weight);
}
-----------------------------------------------------------------------
3> 레지스터 변수
-----------------------------------------------------------------------
        선언법은 아래와 같다.
main()
{
        register int    i;

}

        우리가 짠 프로그램은  전부 메모리안에서 돌아간다는 것을  알 것이
다. 변수들도 메모리안에 들어가는 것은 모두  마찬가지 인데, 그러나 이렇게
"register"를 선언하면  특별히 "그  변수 만"은  메모리 아파트에  넣지말고
CPU 안의 레지스터에 넣어 달라는 것이다.
        이것은 엄청난  특혜이다. "메모리 아파트"와  "CPU의 레지스터"들은
다같이 데이타를 보관하는  역할을 하지만, 이 둘은 수준이 다르다.  특히 어
떤 차원에서 그런가  하면 "읽어 오는 속도"에 있어서 수준이  다르기 때문에
둘은 감히 비교의 대상이 안된다.
        상품마다 틀리지만,  메모리에서 데이타를  한번 읽어오려면  access
time이 약  100 ns (나노 초  : 10의 -9승  초) 쯤 된다.  그러나 일반적으로
CPU에서 레지스터를 읽는 시간은 불과 5 ns (CPU  마다 다름) 등과 같이 레벨
이 틀리다.
        따라서 가능하기만  하다면 모든 변수를  CPU 레지스터 에서  쓴다면
프로그램의 실행 속도는 획기적으로 빨라 질 수 있을 것이다.
        그러나 문제는 돈이다. 그렇게 만들면 CPU가  너무 비싸져서 좋은 줄
은 알지만 할수 없이 적정한 수준에서 만들어야 한다.
        지난 시간에  레지스터를 살펴  보았으므로 레지스터가 몇개쯤  있는
지는 알것이다.  따라서 우리는 이 와중에  가능한 많이 "레지스터  변수" 로
선언하고  써야  하는데,   현재  터보  씨  에서는  SI   (Source  Index)와
DI(Destination Index) 두개만을 쓸수 있도록 하고 있다.
        그리고 함수 내부에서 선언되는 순서대로  처음 2개에 자동적으로 할
당하고 있다. 초보자가  이런것 까지 배워서 쓸려면 시간이  걸릴테니까 친절
하게도 이런 배려를 한 모양이다. 예를 보면
main()
{
        int     lim_chungha;            <-- 자동으로 레지스터 변수
        int     rambo;                  <-- 자동으로 레지스터 변수
        int     i;

}
        사용 용도는 이미  여러분이 짐작 할 것이다. 좌우간  많이 쓰이는데
만 쓰면 된다. 그런건 주로 순환문의 카운터 변수 i,j 따위이다.

따라서 같은 프로그램을 짜도 아래 같이 짜는 사람은 바보다.
main()
{
        int     lim_chungha;            <-- 자동으로 레지스터 변수
        int     rambo;                  <-- 자동으로 레지스터 변수
        int     i,j;

        for(i=0; i < 0xffff; i++)
                for(j=0; j < 0xffff; j++)
                        printf(" 늦어 늦어");

                
}

다음과 같이 순서만 약간 바꾸면 더 빠른 결과를 얻을 수 있다.
main()
{
        int     i,j;                    <-- 자동으로 레지스터 변수
        int     lim_chungha;    
        int     rambo;          

        for(i=0; i < 0xffff; i++)
                for(j=0; j < 0xffff; j++)
                        printf(" 빠르다 빨러");

                
}
-----------------------------------------------------------------------
4> extern 변수
-----------------------------------------------------------------------
        [148쪽]의 예 (4) 번이다. 이  내용은 간단하다.
단순히
        ------------------------------------------------------------
        "이 변수는 다른 소스 파일에 있고 링크 할 무렵에 나타 날테니까
        걱정하지 마라"
        ------------------------------------------------------------
고 컴파일러에게 알려  주는 역할을 하는 것이다. 즉 다음과  같은 보통 프로
그램을 보자

int rambo;
main()
{
        rambo++;
        sub();
}
sub()
{
        rambo++;
}
나중에 이런 프로그램을 여럿이 짜거나 혹은  혼자서라도 프로그램이 너무 커
지면, 소스 파일을 여러개로 나누는 경우가 생긴다.  즉 위를 분할 해서 따로
따로 집에서 컴파일 한다면
---------------------
<파일 1>  <my.c >
int rambo;
main()
{
        rambo++;
        sub();
}
--------------------
<파일 2>  <your.c>
sub()
{
        rambo++;
}
-------------------
위에서 <파일 2>  <your.c>를 컴파일 할 사람은 아마 황당할  것이다. main()
도 없고,  변수 rambo도 없다. 나중에  링커의 기능을 조금더  공부하면 이런
내용은 이해가 확실히 될것이다. 하지만 지금  단계에서는 <파일 2>를 가져간
사람은 아래와 같이 써주면 된다는 사실을 알자.
--------------------
<파일 2>  <your.c>

exterrn int rambo;              <-- 요기
sub()
{
        rambo++;
}
-------------------
        이렇게 하면 rambo라는  변수는 현재 없지만, 나중에  나타날 것임을
컴파일러에게 알려 주는 것이다. 따라서 현재는  서로 컴파일 까지만 하고(링
크는 하지  말고) 다시 모여서 그걸로  하나의 완성된 실행  파일을 만들어야
한다. 실제로 팀을  이루어 큰 프로그램을 짤 때는 이런  과정을 거치기도 한
다.
        여기서 정리  차원에서 권고를 하면,  나중에 C++을 공부 할  분들은
특히 변수의 선언 위치에 관심을 갖고 "가급적  내부 변수"를 쓰는 습관을 들
이시라고 권한다. 왜냐하면   "외부변수"로 쓰면, 위에서  설명했다시피 누구
나 고개만 돌리고 부르기만 하면 사용 가능하므로,  문제가 생길 소지가 크기
때문이다. 이것은  마치 집안의 화장실보다  운동장에 개방되 있는  화장실이
더 지저분해지기 쉬운 것과 마찬가지이다.
        이번 강좌의 내용은  이해와 더불어 약간의 암기가  필요한 내용이므
로 [148쪽]의  도표를 항상 참조하시면서 정리를  하는 것이 좋다. 그러나
표의  7가지 경우를 전부 달달 외울 필요는  없다. 실제로 많이 사용하는 것은
오늘  언급한 부분이고 그 나머지는 거의 사용되지  않기 때문이다.

<숙제> 새교재 [356쪽] 부터 시작되는 "데이터를 이용한 그래프 작성"에서
변수의 선언 위치를 유심히 보고 오늘 얘기한 내용을 점검해 보세요.
**************************< 끝 마치며 >********************************
수고 하셨습니다.
***********************************************************************