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

[연락처] : 605-8662 (서울) ("캠퍼스 C", 도서출판 "책과 스승")
           천리안 : go campusc  
           나우콤 : go lcampc
           하이텔 ID : campusc
****************************<< 목 차 >>************************************
<1> 파일에 관한 함수 소개
     1> fgets(), fputs()
     2> fseek(), ftell()
     3> fread(), fwrite()
     4> fclose()
<2> 파일 입출력을 이용한 예제
     1> 남의 소스 프로그램을 읽기는 어렵다.
     2> 학생들 성적 분류
**************************< 내용 시작 >********************************
<1> 파일에 관한 함수 소개
     1> fgets(), fputs()
     2> fseek(), ftell()
     3> fread(), fwrite()
     4> fclose()
***********************************************************************
1> fgets(), fputs()
-----------------------------------------------------------------------
        파일에 관한 함수는  종류도 많을 뿐 아니라 내용도 다소  복잡한 편
이다. 왜냐하면 여태까지 우리 프로그램은 "CPU와  메모리" 만 고려하면 되었
으나 이제부터는 "하드디스크" 까지 그 대상을  넓혀야 하기 때문이다. C에서
얘기하는 "파일" 이라는  것이 단순히 "하드디스크"만을 의미하는  것은 아니
지만, 좌우간 고려할  대상이 하나 더 늘었다는 자체가, 절차가  더 복잡하다
는 것을 의미한다.
        실제로 실용적인  프로그램을 짜기  위해서는 이 "파일"을  사용하는
것이 기본이다. 그러고 보면 우리는 기본을 다루기  위해 지난 30회를 공부해
왔는지 모른다.
        먼저, 다뤄야 될 함수의 종류를 잠깐  살펴보기로 하자. 초급 교재의
[362-363쪽](새 교재는 [378쪽])의 "입출력 함수"들의 리스트를 보자.

        보시다시피 많은  함수들이 있는데, 이  모든 함수를 전부  다루려는
것은 아니고 일단은 "f"로 시작되는 함수(예를  들면 fgets() 따위)를 살펴보
기로  하자. fgets()은  짐작하다시피 "File  + gets()"  의 합성어이다.  또
fputs()도 "File +  puts()"의 합성어이다. 이와같이 f로  시작되는 파일들은
대부분 "파일"에 관계되는 것들이다.
        이제  파일에 관련된  가장 기초적인  입출력 함수로서  "fgets()"과
"fputs()"의 의미를 살펴보기로 하자. 의미는 물론 다음과 같다.

        fgets() -->  "파일에서" 스트링을 읽어오자.
        fputs() -->  "파일로" 스트링을 쓰자.

함수들의 사용법을  완벽하게 익히려면 뭐니뭐니해도 교재  뒤의 "라이브러리
함수" 사용법을  참조하는 것이 최고다.  일단, 교재 [429쪽]에 있는 사용법을
참조 하자.
fputs() 에 관한 사용법도 직접 참조해 보시고,  이 함수의 사용 예를 간단하
게 들어보자.
---------------------------------------------------------
#include  <stdio.h>

main()
    {
    char    c, *s="";
    int     i;
    FILE    *fp1, *fp2;

    fp1=fopen("a_to_z", "w");       /* 임시로 파일 "a_to_z"을 생성 */

    for (c='A' ; c<='Z' ; c++)
        fputc(c, fp1);
    fclose(fp1);                   /* 데이타 'A' 부터 'Z' 까지 write */

    fp1 = fopen("a_to_z.xxx", "r");
    fp2 = fopen("temp.xxx",   "w");

    for (i=1 ; ! feof(fp1) ; i++) {
        printf("\n%s",   fgets(s, i, fp1) );   /* <--- <요기 1>   */
        printf("\t%c",   fputs(s, fp2) );      /* <--- <요기 2>   */
        fputc('\n', fp2);
    }

    fcloseall();            /* 열린 파일들 전부 닫음 */
    }
        <요기 1> 에서 fgets(s, i, fp1) ); 이  얘기 하는것은 "파일 fp1 에
서 문자 i 개를  읽어서 스트링 s가 가리키는 곳에다 넣어라"  이다. 말이 더
어려운데, 이제는 프로그램을 직접 읽으면서 그 내용을 이해하도록 하자.

        <요기 2> fputs(s,fp2) 은 "파일 fp2 에다  스트링 s를 써라." 이다.
그러나 이때는 "써야할 갯수(바이트수)"를 지정하지 않았는데,

<문제> 이유는 무엇일까 ?
<답>  이제는  "스트링의 끝"에 NULL(0x00)이 있기 때문에 그런  길이를 명시
        하지 않아도 된다.

-----------------------------------------------------------------------
2> fseek(), ftell()
-----------------------------------------------------------------------
        우리는 모니터 화면에 커서가 있는것을  안다. 이것은 텍스트 모드에
서 뿐만 아니라 그래픽 모드에서도 마찬가지 였다.  글자나 점 하나를 모니터
의 특정한 곳에  찍고 싶으면, 이 커서를  그 곳에다 갖다 놓고  그다음 찍는
행위를 해야한다.
        이와같은 개념은  "파일"을 취급할 때도 마찬가지이다.  하지만 파일
은 하드디스크에 들어  있는 것이기 때문에, 모니터처럼 고정된  좌표를 가지
지 못한다는 것에 큰 차이가 있다.
        언젠가 파일을 "두루마리 편지"라고 비유한  적이 있는데, 이제 현대
식으로 다시 비유를  해보면, 도트 프린터의 "연속용지"에 파일이  전부 인쇄
된 것과  유사하다고 생각해 볼 수  있다. 아시다시피 이  상태에서는 파일의
크기(프린트 용지의  길이)가 고정적일 수가  없다. 어떤 파일은  한장짜리가
될 수도 있고, 어떤 것은 베게로 베고 잘 수 있을 정도로 두꺼울 수도 있다.

       파일을 "읽기 위해"  fopen() 하면 이 "파일 커서"(사실  이런 용어는
안쓰지만 이해를 돕기위해서  씁니다)는 인쇄된 연속용지 "첫장의  제일 첫글
자"를 가리키고 있다. 이건 어디서나 상식이다.
        그리고 이 파일 커서를 움직이려면 fseek()를  쓴다. 이 파일 커서는
돌아 다닐 수  있는 곳이 파일의 크기에 따라 가변적이므로  모니터에서 쓰듯
이 좌표를 줄 수 없다는 것은 당연하다. 그래서  돌아 다니는 방법이 조금 복
잡하다. 말로 하면, "현재 위치에서 5글자 뒤로 가"를 다음과 같이 쓴다.

fseek(fp,5L,SEEK_CUR)      <--- "현재 위치"에서 5글자 뒤로 가
fseek(fp,5L,SEEK_SET)      <--- "파일 제일 처음 글자"에서 5글자 뒤로 가
fseek(fp,-5L,SEEK_END)     <--- "파일 제일 끝 글자"에서 5글자 앞으로 가
                                (뒤로는 더이상 못간다. 상식 !)

      여기서 "뒤로 " 라는 얘기는 한글자씩  오른쪽 옆으로 움직이는걸 얘기
한다. 즉 우리가 책을 읽어나가는 방향이다. 이 때  물론, 한 줄 끝에 이르면
다음 줄 첫 글자로 이동한다.
      이때 "SEEK_" 로 시작되는 이름들은 대문자로 쓴  걸 보아 벌써 어디선
가 정의 되있다는  것을 알것이다. 따라서 우리는 무조건  외어서 써야하는데
그 의미는 위에서 얘기한데로 다음과 같다.
        --------------------------------------------------------
        SEEK_CUR        -->  "현재(current) 위치에서"를 의미한다.
        SEEK_SET        -->  ""파일 제일 첫글자 에서"를 의미한다.
        SEEK_END        -->  "파일 제일 끝 글자 에서"를 의미한다.
        ---------------------------------------------------------

<숙제> 이런 상수들은 전부"헤더 파일"에 선언되 있다는  것을 알 수 있을 것
        입니다. 어떤 헤더  파일에 정의되 있는지 찾아 보세요.  (노턴 유틸
        리티를 가지고 있는 분들은 TS( Text Search) 명령을 쓰세요.)
        그리고 만일,  아직도 이런 툴(tool)을  안가지고 있는 분들은  빨리
        구해서 활용을  해야 합니다. 프로그래머들에게는 이런  툴은 필수적
        입니다.

        실제로 파일을 열어놓고  이 파일 커서가 돌아다니기  시작하면 조금
정신이 없다. 왜냐하면 이건 모니터상에  깜박이는게 아니고 우리 머리속에서
만 움직이는 것이다.  따라서 누가 조금만 정신을 어지럽히면  현재 커서위치
를 놓치고 만다.
        큰 파일을 취급할땐, 연속용지로 치면  길이가 무척 길어서 경부고속
도로를 쭉  따라가며 펼쳐 놔야한다. 그러다가  한 순간에 커서를  놓치면 이
놈이 천안에 가있는지 대전에 가있는지 알기 어렵다.  물론 그렇다고 전혀 못
찾는건 아니다.
        이 때 "커서야  어디있니 !" 이렇게 외치는게 ftell()  이다. 쓰는법
을 정확히 알아보기 위해 [439쪽]을 참조하자. 이 사용법은
더이상 내가 설명을 안해도 잘 아실 줄로 믿는다.  예를 들면 다음과 같이 쓰
라는 얘기다.

#include  <stdio.h>
main()
{
       int  i;
       long  ll;
       FILE *from;

       ll = ftell(from);
}

        ftell() 의 대답(리턴  값)은 long형 이므로, long 타입 변수  ll 이
받은게 당연하다. 또  사용법에서 언급하는 ftell(FILE *fp)의  "FILE *fp"는
from 변수의 타입과 같음을 보라.
        그러면 여기서, "왜  long형으로 대답하는지" 그 이유를 를  짚고 넘
어가기로 하자. "어디있니  ?"의 대답이 long 형 이면 4  바이트(32 비트) 크
기이다. 즉 4G 바이트 만큼 멀리갈 수 있다는 얘기다.
        여러분의 하드디스크가 얼마나 큰지 모르겠는데,  나는 지금 420M(메
가) 짜리 하드 디스크를 쓰고 있다. 이것은  요즘 유행으로 봐서는 그다지 큰
것도 아닌 것  같다. 만일 이런 하드디스에 하나 짜리  파일이 통째로 들어가
있어도 ftell()은 가볍게 대답할 수 있는 거리다. 
        단 여기서 주의할 것은, 대답하는  거리는 무조건 "파일의 처음"에서
부터 떨어진 거리를  말한다. 여기에는 빨간 형광펜으로 밑줄을  "쫙" 그어두
기로 하자. 그러나 곰곰이 생각해보면 너무 당연한 얘기이기도 하다.
        왠가하면 아마 지금도 교통방송에서는 어느  여자 아나운서의 낭랑한
목소리를 들을 수 있을테니까.

        "경부 고속도로, "서울 기점 200Km 지점"에서  두 차가 장렬하게
        닿았습니다."

아마도 그 여자  아나운서는 "C 언어"를 모를테지만 그래도  사고지점을 우리
에게 알려주는 방법은 ftell()의 "리턴값"과 같은 것이다.
        "서울 기점 200Km" 면 아마 대전  근처가 아닐까 짐작하는데, 아무리
그래도 "대전 북방 2Km"따위로 얘기하지 않고,  기준점을 "서울"로 잡은 것이
다. 그게 "파일의 처음 위치"이다.
        이제 다음의 예를 읽어보면서, "파일  커서"가 (개구리 처럼) 어디로
튀는지 잘 쫓아가 보기로 하자.
------------------------------------
#include  <stdio.h>

main()
{
    char    c;
    int     i;
    FILE    *fp;

    fp=fopen("a_to_z", "w+b");

    for (c='A' ; c<='Z' ; c++)
        fputc(c, fp);

    fseek(fp, 0, SEEK_SET);

    for (i=0 ; i<3 ; i++)
        printf("\n%c   : %d",   fgetc(fp), ftell(fp) );
    putchar('\n');

    fseek(fp, -5, SEEK_END);

    for (i=0 ; i<3 ; i++)
        printf("\n%c   : %d",   fgetc(fp), ftell(fp) );
    putchar('\n');

    fseek(fp, -10, SEEK_CUR);

    for (i=0 ; i<3 ; i++) {
        printf("\n%c   : %d",   fgetc(fp), ftell(fp) );
        fseek(fp, -2, SEEK_CUR);
    }
    fclose(fp);
}
<문제> 답을 미리 적어보고 실행해보세요.

-----------------------------------------------------------------------
3> fread(), fwrite()
-----------------------------------------------------------------------
        이 함수들은  특정 자료형을 글자  단위로 입출력하지 않고  "덩어리
단위"로 읽고 쓴다. 다음의 예를 보자.
main()
{
        FILE *fp; 
        char name[20] =  "Lim chungha";

        fp = fopen("xxx.xxx","w");
        fwrite(name, 20,1,fp);          <-- (요기)
}
        (요기)를 말로  하면  "name[] 에  있는 데이타들을 파일  fp에 쓰는
데, 덩어리는  20 바이트가  한묶음이고 그런걸  한 덩어리 쓰라"는  얘기다.
즉,  이 경우에는 한 사람의 이름을 파일에 쓰라는 얘기이다.
        여기서 name[]의 크기는  사람 이름을 위한 길이를  임의로 넉넉하게
[20] 바이트로 잡았다. fread() 도 마찬가지다.
main()
{
        FILE *fp; 
        char name[20];

        fp = fopen("xxx.xxx","r");
        fread(name, 20,1,fp);           <-- (요기)
}
        fread()를 실행하기  전에 name[20]이라는 배열에는 아무  값도 안들
어가 있다. 그러나  위 fwrite()에서 임 청하의 이름을 xxx.xxx  에 성공적으
로 썼다면   위의 (요기)를 실행하고 나면 name[]에 임청하라는  이름이 들어
가 있을 것이다.
        이것도 말로  하면 "파일 fp 에서  읽는데 쓸 곳은 name  (즉 name[]
배열의 첫집)이다. 크기는 20 바이트짜리 덩어리 한 묶음이다"
      이제 다음의 예제를 보자. 친구의  이름과 전화번호를 입력받아 파일에
저장하고 화면에 보여준다.
------------------------------
#include <stdio.h>
main(int argc, char *argv[])
{
        int c;
        FILE *fp;
        struct {
                char name[20];
                char tel_no[20];
        } entry;

        char yn;

        clrscr();
        /*------------< write record to file >--------------*/
        if((fp = fopen("friends.tel","w")) == NULL) {
                printf(" can't open ..");
                exit(1);
        }

        do {
                  printf("\n 이름  : ");
                  gets(entry.name);
                  printf(" 전화번호 : ");
                  gets(entry.tel_no);
                  fwrite(&entry, sizeof(entry),1,fp);

                  printf("\n 계속할까요 (y/n) ? ");
                  yn = getch();
        } while ( yn == 'y' || yn == 'Y');

        fclose(fp);

        /*----------< display records >--------------*/
        clrscr();

        if((fp = fopen("friends.tel","r")) == NULL) {
                    printf(" Can't open file \n");
                    putch(0x07);
                    exit(1);
        }
        while(fread(&entry, sizeof(entry),1,fp) == 1) {
                    printf(" %s    %s\n", entry.name, entry.tel_no);
        }
        fclose(fp);
        getch();

}
-----------------------------------------------------------------------
4> fclose()
-----------------------------------------------------------------------
        서랍을 "열고" 파일을  꺼냈으므로 다 쓴 후 파일을 닫는  것은 지극
히 당연하다. 그러나  실제로는 사무실에서 서랍을 안닫고 다니는  사람도 많
이 볼 수 있을 것이다. 그렇다고해도 사무실에서  그다지 큰 문제를 발생시키
지는 않는다. (욕을 좀 먹겠지만)
        여기서도 마찬가지 이긴하다. 굳이 fclose()를  안해도 별 탈은 없지
만 그렇다고 그걸  권장하는 것은 절대 아니다. 파일이 더  이상 필요가 없어
진 시점  에서 반드시 fclose를 써서  닫아야한다. 지금 단계에서  그렇게 큰
프로그램을 짜지는 않겠지만, 파일을 한꺼번에 열수  있는 갯수는 30개, 혹은
40개 따위로, 한정되 있는 것이므로 혹시나 더이상  열 파일이 없을때는 기존
의 안 쓰는 파일을 닫아야 하는 것이다.
        그리고 파일을 닫아야  컴퓨터 메모리의 "버퍼"에 저장되  있던 데이
터들도 비로소 하드디스크로 저장이 되는 것이다.
        좌우간 "열었으면 닫아야지 왜 안닫어요 ?" 이게  내가 하고 싶은 말
이다.
***********************************************************************
<2> 파일 입출력을 이용한 예제
*********************************************************************** 
1> 남의 소스 프로그램을 읽기는 어렵다.
----------------------------------------------------------------------- 
         "남의 소스 프로그램을 읽기는 어렵다."
그렇다 당연한 말이다.  이건 비단 초보자 뿐만 아니라  전문가에게도 마찬가
지이다. 그러나 차이는 약간있는 것같다.
        흔히 초보자들은 다른  사람이 짜놓은 크고 복잡한  프로그램을 보고
"대단한놈" 이라고 부러움과 함께 낭패감을 가지는  것 같다. "저렇게 복잡한
것을 나도 짤 수 있을까 ?" 하는 생각을 하며 말이다.
        사실 다 짜 놓은 프로그램이 복잡해 지는  건 사실이다. 그렇다고 해
서 천재적인 인간들만 저런 복잡한 것을 짤  수 있다고 생각하는 것은 오산이
다.
       자기가 직접 큰 프로그램을 짜 본  사람들은 프로그램이 어떻게 (자기
의 의도와 상관없이) 점점 복잡해 지는지를 잘 알 것이다.
       이런 속 사정을 체험해 보려면 직접 큰  프로젝트에 참여하는 것이 가
장 좋은 일이다.  그러나 혼자서는 그런 프로젝트를 시작하기도  어려울 것같
다.
        지난번에도 석사 논문으로 프로그램을 짜겠다는  한 학생이 찾아와서
조언을 구했다. 얘기를 나누다 보니 내가 보기에는  모든 문제는 완벽히 해결
이 되었고 문제는 단지 "프로그램 코딩(쳐 넣는  것)"만 하면 되는 상태였다.
그래서

        나      : "쳐 넣어라"
        학생    : "어떻게 쳐요"
        나      : "손가락으로 치지 발가락으로 치나 ?"
        학생    : "어디서 부터 쳐요 ?"
        나      : "..."

        그렇다 내가 "초보자"들이 어렵게 느끼는 것을  이해한 것은 바로 그
순간이었다. 다 지어놓은  집만 지적하며 "저렇게 지으면 되잖아 !"  하고 암
만 큰소리를 쳐봐야  될 일이 아닌 것이다.
        내가 해줘야  될 일은 집은 짓는  과정을 보여주는 것이다.  더 좋은
일은 각 공정마다 일을 시키는 것이다.
        기회가 있으면 이  강좌에서 프로젝트를 하나 추진하겠다. 그  때 많
은 분들이 참여해주시면 감사하겠고, 일단  여기서는 지난번에 어떤 정신나간
일본놈이 만든 것 같은 "독가스 제조 화학공장" 짓는 모습을 보여드리겠다.
        이 것을  다 짓고 난  후의 화학공장은 정신없고 복잡하기  그지없지
만, 그것은 결과일 따름이고, 그 과정은 그다지  어려울 것이 없다는 것을 보
여드리고 싶다.

        첫째날, 허허 벌판에  수도 파이프가 지나간다. 어디서  어디로 흐르
는지 한 눈에 볼수있다.
        둘째날 가스 파이프가 노란색으로 지나가는걸  본다. 중간에 수도 파
이프와 쫑나는(부딪히는)  부분이 있어서, 설계도를 고치고  적당히 비켜가는
것도 지켜본다. 속으로  생각한다. "자식들 ! 벌써부터  땜빵이구나". 하지만
아직도 노란색 만 쫓아서 가스 파이프를 찾는 건 별로 어려운 일이 아니다.
        셋째날, 오늘은 빨간 파이프가 지나간다.  파이프 표면에는 해골바가
지도 이쁘게 그려져  있다. 아마 이게 독가스가 지나가는 관인  모양이다. 빨
간색이라서 그런지 눈에 "팍팍"띈다.
        넷째날 이후, 이런 식으로 수십 가지의 파이프 들을 설치 했다.

        결론을 말하면  이게 프로그램을 짜는  사람의 입장이다. 그리고  다
지어 놓은 공장을 구경하는 사람들이 남의 소스를 읽어보려는 사람이다.
        사실 그 공장을 전부 설계,시공한 사람들 일지라도   나중에 모든 파
이프를 한눈에 이해 하기는 힘들다. 자기들도  설계도를 뒤져봐야 안다. 하물
며 아무것도 모르는 사람들은 오죽하겠는가 ?
      따라서 우리가 남의 프로그램을 읽을때도  파이프가 한가지씩 지나가는
과정을 거꾸로 추적해 나가야 한다. 절대로 모든  부분을 한눈에 이해 할수는
없다는 것을 아셔야 한다. 요령은 다음과 같다.
<요령 1>  main() 함수 부터 시작하여  가능한 한 전반적인  흐름을 이해한후
        subroutine의 기능을 하나씩 분석한다.
<요령 2> 변수명 하나씩만 잡고 그 값이 어떻게 변하는 지 추적한다.
        교재 첫 부분의  "에디터 활용기능"([^q] + [f]따위)을  이용하면 변
        수의 흐름은 비교적 쉽게 추적이 된다.

간단하게 적긴 했지만  말 처럼 그렇게 쉬운 작업은 아니다.  그리고 이런 작
업은 중급 과정에서 아주 많이 해보실 기회가 있을 것이다.
이제 파일 관련 프로그램의 연습을 위해, 아래  프로그램을 tool.c 라고 자르
고 실행해 보기로 하자
-----------------------------------------------------------------------
2> 학생들 성적 분류
-----------------------------------------------------------------------
        다음은 간단한  성적 분류 프로그램이다.  물론 실용적인 것이  되진
못한다. 하지만 기본적인 내용은 충분하다.
        파일을 입출력하는 프로그램을 짜려면 먼저  "파일의 데이타 형태"를
먼저 디자인해야 한다.  아래의 예는 한학생에 대하여 4 가지  정보가 저장되
있다.
        1. 학생번호  
        2. 국어성적 
        3. 영어성적 
        4. 수학성적
        파일의 크기는  가능한 작아야 한다. 왜냐하면  하드디스크를 불필요
하게 낭비할 필요가 없고, 또 파일이 커지면  파일을 읽는데 느려지기 때문이
다. 따라서 파일의 내용에 "5. 평균점수" 을 첨가  할 수도 있지만 그것은 기
본데이타로 계산이 가능  하므로 넣지않았다. 먼저 간단한 데이타  파일을 만
들어야 한다.  일반적인 에디터로  작성한 후  "텍스트 모드"로  저장하거나,
c:\> copy con score.man  을 이용하여 간단하게 만들수도 있다.
데이타는 위의 디자인에 따라 다음과 같이 치기로 하자.

                 1 70 90 88
                 2 77 88 66
                 3 34 22 11
                 4 77 88 99

이제 아래를 실행해 본다.
-------------------------
#include <stdio.h>

#define     MAX_STUDENT      60

struct student {
                        int num;
                        int  kor,eng,math;
                        float ave;
                } man[MAX_STUDENT];
int all;

main()
{
           int i;

           input();
           sort();
           clrscr();
           for(i=0; i < all ; i++)
                   printf("<%3d>  -- %5.2f\n",man[i].num, man[i].ave);
}
/*-------------< sub routine >----------------*/
input()
{
          int i;

        FILE *fp;
        char yn;

        /*------------< write record to file >--------------*/
        if((fp = fopen("score.man","r")) == NULL) {
                printf(" can't open ..");
                exit(1);
        }

        for(all=0; all < MAX_STUDENT; all++) {
                fscanf(fp,"%d%d",&man[all].num,&man[all].kor);
                if(feof(fp))
                          break;
                fscanf(fp,"%d%d",&man[all].eng,&man[all].math);
                man[all].ave  =  (float)(man[all].kor +  man[all].eng  +
man[all].math)/3;
        }
        fclose(fp);
}
/*---------------------------------------------*/
sort()
{
          struct student tmp;
          int i,j;

          for(i=0; i < all; i++)
                  for(j=i; j < all; j++)
                           if(man[i].ave < man[j].ave) {
                                    tmp = man[i];
                                    man[i] = man[j];
                                    man[j] = tmp;
                           }
}
<숙제> 현재 데이타  파일명이 "score.mam"으로 고정 되있는데,  임의의 파일
        명을 받을 수 있도록 고쳐 보세요.
<숙제> 현재는  평균점수만 소팅(크기대로 분류)가 가능한  상태인데, 국어점
        수로 소팅하게 고쳐 보세요.
<숙제> 정식으로 쓸  수 있도록 학생이름 성별 학급 등을  첨가하여 struct를
        첨가해 보고 화면에 보이도록 프로그램을 수정해 보세요.
<숙제> 이 프로그램을  "메뉴 선택 파일"에 첨가해서 또 자기의  용도에 맞게
        수정하여 자기의 작품으로  만들어 보세요. (이게 마지막  숙제 입니
        다)
**************************< 끝 맺으며 >********************************
1회에서 이 컴퓨터를 켰었는데 이제는  파워를 내려야겠군요.
나중에 중급 강좌에서 새롭게 만날 수 있기를 바라고
그동안 수고 많이 하셨습니다......
***********************************************************************