Мова програмування Сі

Інформація про навчальний заклад

ВУЗ:

Київський національний університет імені Тараса Шевченка

Інститут:

Факультет інформаційних технологій

Факультет:

Факультет комп’ютерних наук

Кафедра:

Інформатики

Інформація про роботу

Рік:

2026

Тип роботи:

Лекція

Предмет:

Програмування

Група:

КН-11

Коротко про документ

Про що ця робота

Цей документ є українським перекладом класичного керівництва та довідника з мови програмування Сі. У матеріалі детально розглядаються синтаксис, типи даних, оператори, функції та взаємодія з операційною системою UNIX.

У роботі розглядаються

Мова програмування Сі
Типи даних
Оператори та вирази
Функції
Вказівники та масиви
Структури
Введення і виведення

Зміст і розділи

Вступ
Типи, оператори і вирази
Управління
Функції і структура програми
Вказівники і масиви
Структури
Введення і виведення
Інтерфейс з UNIX

Для кого:Студенти технічних спеціальностей, розробники та початківці у програмуванні.

Викладачі:Браян Керніган, Денніс Рітчі

Ключові поняття

Сівказівникмасивфункціяструктурапам'ятьсимволрядокбітфайл

Схожі матеріали

Структуры в мові програмування Сі Переглянути → Ввод и вывод в мові C Переглянути → Язык программирования C Переглянути → Мова С Переглянути → Динамічне виділення пам’яті в мові програмування С Переглянути → Хрестоматія з програмування на C в Unix Переглянути →

Частина тексту файла (без зображень, графіків і формул):

, . C .. , .. . "C"( "") - , - , , - . "C" " ", "" , . - , , . "C", "UNIX" DEC PDP-11, - . , "C" "UNIX" ( - , ) "C". "C" , IBM SYSTEM/370, HONEYWELL 6000, INTERDATA 8/32. "C", , - - , , , "C"-. , "C". , - - , . , , . , - , - , . - , - , . , , , , . - ; - , - , , . , . , "C" , - - . , . , . , . , - , , , -, , - . , , , , , , , , , , , - , , , , - - . . . A ........................................1 0.1. .......................................7 1. .................................. 1.1. H....................................... 1.2. ........................ 1.3. FOR................................... 1.4. ........................ 1.5. ........................ 1.5.1. ........................ 1.5.2. ............................ 1.5.3. ............................. 1.5.4. ................................ 1.5.5. ................................. 1.6. ........................................ 1.7. ........................................ 1.8. - .................. 1.9. ............................... 1.10. : ........... 1.11. ......................................... 2. , ........................ 2.1. ............................... 2.2. .......................... 2.3. ...................................... 2.3.1. ......................... 2.3.2. ........................ 2.3.3. ........................... 2.4. ....................................... 2.5. ........................ 2.6. ....... 2.7. ........................... 2.8. ............... 2.9. .................. 2.10. .............. 2.11. ............................. 2.12. ............... 3. .................................. 3.1. .............................. 3.2. IF - ELSE...................................... 3.3. ELSE - IF...................................... 3.4. .................................. 3.5. - WHILE FOR............................ 3.6. DO - WHILE................................ 3.7. BREAK................................. 3.8. CONTINUE.............................. 3.9. GOTO .......................... 4. ...................... 4.1. .............................. 4.2. , ......... 4.3. ...................... 4.4. ............................. 4.5. , ......... 4.5.1. ............................. 4.6. ......................... 4.7. ......................... 4.8. .............................. 4.9. .................................. 4.10. ....................................... 4.11. "C"......................... 4.11.1. ............................. 4.11.2. M............................. 5. ............................ 5.1. ............................. 5.2. .................. 5.3. ............................ 5.4. ............................ 5.5. ................... 5.6. - ........................... 5.7. ............................ 5.8. ; ....... 5.9. .............. 5.10. ................ 5.11. .................... 5.12. ........................... 6. ......................................... 6.1. .............................. 6.2. ............................ 6.3. ................................ 6.4. ......................... 6.5. , ................. 6.6. ................................ 6.7. ........................................... 6.8. .................................... 6.9. ............................... 7. ...................................... 7.1. ............. 7.2. - GETCHAR PUTCHAR...................................... 7.3. - PRINTF............... 7.4. - SCANF................. 7.5. .............. 7.6. ................................ 7.7. - STDERR EXIT............... 7.8. ............................. 7.9. ................ 7.9.1. ...... 7.9.2. UNGETC............................... 7.9.3. .......................... 7.9.4. ........................... 8. UNIX............................ 8.1. ............................. 8.2. / - READ WRITE........................................ 8.3. , , (UNLINK)....................................... 8.4. - SEEK LSEEK............. 8.5. - FOPEN GETC....... 8.6. - ............... 8.7. - ................. : 'C'. 9.1. ....................................... 10. ............................ 10.1. .................................... 10.2. ()......................... 10.3. ................................. 10.4. ...................................... 10.4.1. .............................. 10.4.2. ...................... 10.4.3. ......................... 10.4.4. .......................... 10.5. ......................................... 10.6. .............. 11. ............................ 12. ?............................ 13. L-.............................. 14. .................................... 14.1. ................................ 14.2. FLOAT DOUBLE............................ 14.3. ............. 14.4. .............................. 14.5. ................................ 14.6. .................. 15. ......................................... 15.1. ............................ 15.2. ............................... 15.3. ..................... 15.4. ............................ 15.5. ................................ 15.6. ............................. 15.7. ............................. 15.8. ''......................... 15.9. ''.......... 15.10. ''........... 15.11. ''........................ 15.12. ''..................... 15.13. .............................. 15.14. .......................... 15.15. ............................... 16. .......................................... 16.1. .................... 16.2. ............................. 16.3. ...................................... 16.4. ............................... 16.5. ................ 16.6. .................................. 16.7. .................................... 16.8. TYPEDEF........................................ 17. ......................................... 17.1. .......................... 17.2. ( ).................. 17.3. ............................. 17.4. WHILE................................. 17.5. DO.................................... 17.6. FOR................................... 17.7. SWITCH................................ 17.8. BREAK................................. 17.9. CONTINUE.............................. 17.10. .............................. 17.11. GOTO.................................. 17.12. ............................ 17.13. ................................ 18. ............................... 18.1. .................... 18.2. ..................... 19. , ............ 19.1. ................... 19.2. ....... 20. .................... 20.1. .................................. 20.2. ............................... 20.3. ............................ 21. .................................. 22. ..................................... 22.1. ........................ 22.2. ........................................ 22.3. , ................ 22.4. ................ 23. ............................. 24. ....................... 25. ....................................... 26. ...................... 26.1. ...................................... 26.2. ....................................... 26.3. ...................................... 26.4. ............................ 26.5. ................................... 27. ............................ 28. .................................. 29. "C". 0.1. "C" - . "UNIX" , "UNIX" - "C". , , - ; , , , . "C" - " ". ; , "C" , , , , . , - . "C" , - , - , , , . , , PL/1, . - , , - ; ""(HEAP), " ", -68. , "C" -: READ WRITE . - . , "C" , - : , , , , , . - (", , ?!"), . "C" , . "C" . - , ; , 80 - . . - , "C", - , , , . PDP -11, , 32- . , - , - -, , - , , , - ; "C". - , "C" , "C" - , . - "UNIX", "C". 13000 800 - . , "UNIX" - "C"; "UNIX"( ) PDP-11. "C" , - "" - , .. , - . , - "UNIX", : HONEYWELL, IBM INTERDATA. "C" - , -, , - - (ANSI). "UNIX" PDP-11, INTERDATA 8/32. - , - -, , - . "C" - . 7000 , -, 95 . , , - , "C". "C" - , BCPL , . BCPL "C" "B", 1970 "UNIX" PDP-7. "C" BCPL , - . BCPL "B" - "" ; - , - - . "C" - , - . , - , , , , . "C" - , : - , (IF), (WHILE, FOR) (DO) (SWITCH). ( BCPL, ; ). "C" . - , . " ", - , , . - , - . , - "", .. . , . "C" - . - , , - , - . - . , - - . "C" 68. - , - PL/1. , - .. , - , . - LINT , . LINT - , , - . , - , - , .. , - LINT, - , , , , -68. LINT , . , "C", , . - ; ; - , - . "C" - - . . 1 "C". - , , , - - . , , ; , , N=N+1. , , . ; , , - . 2- 6- "C" , 1, - - , , . 2 , . 3 : IF-ELSE ,WHILE ,FOR .. 4 - , - .. 5 . 6 . 7 -- "C", . - - , "C", , , - , . 8 "C" - "UNIX". -, . "UNIX", - , "UNIX", - , , - . A "C". "" - "C" ( - ) . "C" , - , - - - . - . , , "UNIX" PDP-11 , "C". "C" - . * 1. * "C". - - , , . (, ). - , , , - : , - , , . - "C", - , , , "C", . , , . - , - , - , , - . , - , - , . , . , . - , , - . , . . , , - , 2. 1.1. H - . - , , - : : HELLO, WORLD. - ; , - , , , , . - , . "HELLO, WORLD" "C" : MAIN () { PRINTF("HELLO, WORLD\N"); } - . , "UNIX" , ".C" , , HELLO.C , - CC HELLO.C - , , - .OUT . A.OUT HELLO, WORLD ; - . 1-1 --------------- . - . . "C"-, , "", , . "C" PL/1, .. MAIN. , MAIN - ; - MAIN. , - MAIN. MAIN , , - , . . , , ; IN - , (). - , , { }, DO-END PL/1 BEGIN-END - , .. - , . CALL, PL/1. - , . PRINTF("HELLO, WORLD\N"); , PRINTF "HELLO, WORLD\N". PRINTF , - ( - - ). , . , - "...", ' ' ' '. - PRINTF . \N "C" ' ', - . \N ( - ), , - . - \N - PRINTF; - PRINTF("HELLO, WORLD "); "C"- . PRINTF , . - , , MAIN() { PRINTF("HELLO, "); PRINTF("WORLD"); PRINTF("\N"); } , \N . - '', \N , - . "C" : \ - , \B - , \" - \\ . 1-2 --------------- , - , , PRINTF \X, X - , . 1.2. , C = (5/9)*(F-32). 0 -17.8 20 -6.7 40 4.4 60 15.6 ... ... 260 126.7 280 137.8 300 140.9 : /* PRINT FAHRENHEIT-CELSIUS TABLE FOR F = 0, 20, ..., 300 */ MAIN() { INT LOWER, UPPER, STEP; FLOAT FAHR, CELSIUS; LOWER = 0; /* LOWER LIMIT OF TEMPERATURE TABLE */ UPPER =300; /* UPPER LIMIT */ STEP = 20; /* STEP SIZE */ FAHR = LOWER; WHILE (FAHR <= UPPER) { CELSIUS = (5.0/9.0) * (FAHR -32.0); PRINTF("%4.0F %6.1F\N", FAHR, CELSIUS); FAHR = FAHR + STEP; } } /* PRINT FAHRENHEIT-CELSIUS TABLE FOR F = 0, 20, ..., 300 */ , - , . /* */ - ; - . - , - . "C" - , . , . - , , INT LOWER, UPPER, STEP; FLOAT FAHR, CELSIUS; INT , ; FLOAT , .. , . INT , TAK FLOAT , - . PDP-11, , INT 16-- , .. , -32768 +32767. FLOAT - 32- , 10-38 10+38. 2 - . "C" - , INT FLOAT: CHAR - SHORT LONG DOUBLE -; 2. , - , - , ; . LOWER = 0; UPPER =300; STEP = 20; FAHR =LOWER; . - . , , - . WHILE: WHILE (FAHR <= UPPER) { .... } . (FAHR UPPER), ( , { } ). , , - . ( FAHR UPPER ), , . - , . WHILE , , , , , , WHILE (I < J) I = 2 * I; , WHILE, , , . . "C" - , . () . - ; . - - . . - CELAIUS CELSIUS = (5.0/9.0) * (FAHR-32.0); 5.0/9.0 5/9 , "C", - , , . - , 5/9 , , , . , , , , 5.0/9.0 0.5555... . 32.0 32 , , FAHR FLOAT , 32 FLOAT ( 32.0) . , ; - , , . , - , 2. , FAHR = LOWER; WHILE (FAHR <= UPPER) , , - . , PRINTF. PRINTF , 7. - , , % , - /, , .../ - . , PRINTF("%4.0F %6.1F\N", FAHR, CELSIUS); %4.0F , - - . %6.1F , , F6.1 F(6,1) PL/1. : %6F , ; %2 , ; %F , . PRINTF : %D - - , % - , % - - , % - , %S - %% - %. % - PRINTF , , .. ; - ; . , PRINTF "C"; "C" -. PRINTF ; - , , "C"-. , - - 7. - , . - SCANF 7, 7.4. SCANF PRINTF , , . 1-3 ---------------- - , . 1-4 ---------------- - . 1.3. FOR , . - : MAIN() /* FAHRENHEIT-CELSIUS TABLE */ { INT FAHR; FOR (FAHR = 0; FAHR <= 300; FAHR = FAHR + 20) PRINTF("%4D %6.1F\N", FAHR, (5.0/9.0)*(FAHR-32.0)); } , -. - - ; FAHR , INT ( , %D PRINTF). - FOR , , , , PRINTF , . - "C" - , , . PRINTF , %6.1F, . FOR - , - WHILE. , WHILE . FOR , . FAHR = 0 . - , , : FAHR <= 300 , , ( PRINTF ). FAHR =FAHR + 20 . , - . , WHILE , , . - - . WHILE FOR - , . FOR - , , , - WHILE , - . 1-5 --------------- - , , .. 300 0. 1.4. , . " ", 300 20, - - ; , , , - , - . "C" - , " - ". #DEFINE , , . - - . , #DEFINE LOWER 0/* LOWER LIMIT OF TABLE */ #DEFINE UPPER 300 /* UPPER LIMIT */ #DEFINE STEP 20 /* STEP SIZE */ MAIN () /* FAHRENHEIT-CELSIUS TABLE */ { INT FAHR; FOR (FAHR =LOWER; FAHR <= UPPER; FAHR =FAHR + STEP) PRINTF("%4D %6.1F\N", FAHR, (5.0/9.0)*(FAHR-32)); } LOWER, UPPER STEP - . , - . - , . , , FOR . 1.5. , . , , . 1.5.1. - . GETCHAR() - , - , . , C = GETCHAR() 'C' . , 7. PUTCHAR(C) GETCHAR : PUTCHAR (C) 'C' - , . PUTCHAR PRINTF ; , . PRINTF , GETCHAR PUTCHAR - . - "C", . 1.5.2. GETCHAR PUTCHAR , - -, - . - . - : WHILE ( ) , "C", - : MAIN() /* COPY INPUT TO OUTPUT; 1ST VERSION */ { INT C; C = GETCHAR(); WHILE (C != EOF) { PUTCHAR (C); C = GETCHAR(); } } != " ". , - . , GETCHAR - , , ; , , . - , , , - . , EOF , . - EOF -1, 0, #DEFINE EOF -1 #DEFINE EOF 0 EOF - , GETCHAR , , - . 'C' INT , CHAR , , GETCHAR . 2, INT, - EOF. , "C", . "C" , C = GETCHAR() ; - , . - 'C' - WHILE , : MAIN() /* COPY INPUT TO OUTPUT; 2ND VERSION */ { INT C; WHILE ((C = GETCHAR()) != EOF) PUTCHAR(C); } , 'C' , . - WHILE, . WHILE . , , , WHILE , - MAIN . - GETCHAR - . - "C", - . , . . , . != , =, - , != - =. , C = GETCHAR() != EOF C = (GETCHAR() != EOF) , , , 'C' 0 1 , - GETCHAR . 2/. 1.5.3. ; . MAIN() /* COUNT CHARACTERS IN INPUT */ { LONG NC; NC = 0; WHILE (GETCHAR() != EOF ) ++NC; PRINTF("%1D\N", NC); } ++NC; , ++, - . NC = NC + 1 , ++NC . - -- . ++ -- (++NC), (NC++); , 2, , ++NC, NC++ - NC. - . LONG, INT . PDP-11 - 32767, INT , ; "C" HONEYWELL IBM LONG INT . %1D PRINTF , LONG . , - DOUBLE / FLOAT /. - FOR WHILE , - . MAIN() /* COUNT CHARACTERS IN INPUT */ { DOUBLE NC; FOR (NC = 0; GETCHAR() != EOF; ++NC) ; PRINTF("%.0F\N", NC); } PRINTF %F FLOAT , DOUBLE ; %.0F - . FOR , - . "C" , FOR . , - , , . , . - , , - , WHILE FOR - GETCHAR , , , - , .. . . - WHILE FOR , , .. . , - , , . , " ". WHILE FOR - . 1.5.4. . , \N, . MAIN() /* COUNT LINES IN INPUT */ { INT C,NL; NL = 0; WHILE ((C = GETCHAR()) != EOF) IF (C =='\N') ++NL; PRINTF("%D\N", NL); } WHILE IF , ++NL. IF , , / , /. - , , . == "C" "" / .EQ. /. , =, . "C" - - , , - , . - , , - - ; . , , 'A' - ; ASCII / / 65, . , 'A' , 65: . , , - . '\N' . , '\N' - , ; "\N" - , . - 2. 1-6 ---------------- , . 1-7 ---------------- , , - . 1.5.5. , , , - , , - . / - 'WC' 'UNIX'/ #DEFINE YES 1 #DEFINE NO 0 MAIN() /* COUNT LINES, WORDS, CHARS IN INPUT */ { INT C, NL, NW, INWORD; INWORD = NO; NL = NW = NC = 0; WHILE((C = GETCHAR()) != EOF) { ++NC; IF (C == '\N') ++NL; IF (C==' ' \!\! C=='\N' \!\! C=='\T') INWORD = NO; ELSE IF (INWORD == NO) { INWORD = YES; ++NW; } } PRINTF("%D %D %D\N", NL, NW, NC); } , , . - INWORD , - ; " ", NO. YES NO 1 0, - . , , , , - - , . , - , - . NL = NW = NC = 0; . , , - - . - , , NC = (NL = (NW = 0)); \!\! OR , IF( C==' ' \!\! C=='\N' \!\! C=='\T') " - , - , - ..."./ \T /. && AND. , && \!\! , , , , , . , 'C' , , 'C' , . , , , . ELSE "C", , , , IF, . : IF () -1 ELSE -2 , - IF-ELSE. , - -1; - -2. . , ELSE , - IF , . 1-9 ---------------- ? K ? 1-10 ----------------- , - , . 1-11 ---------------- , ""; , - , , . 1.6. - , /, , / . , - , - "C". , , . : MAIN() /* COUNT DIGITS, WHITE SPACE, OTHERS */ { INT C, I, NWHITE, NOTHER; INT NDIGIT[10]; NWHITE = NOTHER = 0; FOR (I = 0; I < 10; ++I) NDIGIT[I] = 0; WHILE ((C = GETCHAR()) != EOF) IF (C >= '0' && C <= '9') ++NDIGIT[C-'0']; ELSE IF(C== ' ' \!\! C== '\N' \!\! C== '\T') ++NWHITE; ELSE ++NOTHER; PRINTF("DIGITS ="); FOR (I = 0; I < 10; ++I) PRINTF(" %D", NDIGIT[I]); PRINTF("\NWHITE SPACE = %D, OTHER = %D\N", NWHITE, NOTHER); } INT NDIGIT[10]; , NDIGIT . "C" / 1, PL/1/, - NDIGIT[0], NDIGIT[1],..., NDIGIT[9]. FOR , . , , - , , I , - . . , , IF( C >= '0' && C <= '9')... , 'C' , , / C - '0'/. , - '0', '1' .. , - , , '0' '9'. , . - , CHAR INT, - INT, TAK - CHAR INT. ; , C -'0'- 0 9 , '0' '9' 'C', , - , NDIGIT. , , - , IF (C >= '0' && C <= '9') ++NDIGIT[C-'0']; ELSE IF(C == ' ' \!\! C == '\N' \!\! C == '\T') ++NWHITE; ELSE ++NOTHER; IF () ELSE IF () ELSE - , . , - ; '', . /, '' - , /. , '', ELSE, . E ELSE '' ( ), . IF ELSE ELSE IF () - , , . SWITCH (), 3, - . , - , , - . , SWITCH, 3. 1-12 ---------------- , . - - ; . 1.7. "C" - PL/1, .. - - , , . . , , ; , . "C" , , . - , - , , . PRINTF, GETCHAR PUTCHAR; . "C" - , ** PL/1, - POWER(M,N), - N. POWER(2,5) 32. - , **, - - , - , . POWER , . MAIN() /* TEST POWER FUNCTION */ { INT I; FOR(I = 0; I < 10; ++I) PRINTF("%D %D %D\N",I,POWER(2,I),POWER(-3,I)); } POWER(X,N) /* RAISE X N-TH POWER; N > 0 */ INT X,N; { INT I, P; P = 1; FOR (I =1; I <= N; ++I) P = P * X; RETURN (P); } : ( , ) , { } - . , - , , , , . , - "C"- , , , . POWER PRINTF("%D %D %D\N",I,POWER(2,I),POWER(-3,I)); POWER, , , . POWER(2,I) - , 2 I. / ; 4/. POWER - , . INT X,N; . ; - . , - POWER, - : - . I P; I POWER I MAIN. , POWER, MAIN RETURN, , PL/1. . - - ; RETURN, , , " " , - . 1-13 ---------------- , OWER(C), - 'C', C'- , , 'C'-. 1.8. - "C" - , , , PL/1. "C" " ". , / /, . - , , - PL/1, " ", - , . , "C" - ; . , , , . , , - . , , POWER - POWER(X,N) /* RAISE X N-TH POWER; N > 0; VERSION 2 */ INT X,N; { INT P; FOR (P = 1; N > 0; --N) P = P * X; RETURN (P); } N ; - , . I . N POWER , - POWER. , . /- , /, - . - 5. , , , . / /. . - - . 1.9. - "C" . - , , - . : WHILE ( ) IF ( ) , . , , , . , . GETLINE, ; - GETCHAR. , . GETLINE - ; - , . , - ; , , 1. , , - . , COPY , - . , GETLINE COPY . : #DEFINE MAXLINE 1000 /* MAXIMUM INPUT LINE SIZE */ MAIN() /* FIND LONGEST LINE */ { INT LEN; /* CURRENT LINE LENGTH */ INT MAX; /* MAXIMUM LENGTH SEEN SO FAR */ CHAR LINE[MAXLINE]; /* CURRENT INPUT LINE */ CHAR SAVE[MAXLINE]; /* LONGEST LINE, SAVED */ MAX = 0; WHILE ((LEN = GETLINE(LINE, MAXLINE)) > 0) IF (LEN > MAX) { MAX = LEN; COPY(LINE, SAVE); } IF (MAX > 0) /* THERE WAS A LINE */ PRINTF("%S", SAVE); } GETLINE(S,LIM) /* GET LINE INTO S,RETURN LENGTH */ CHAR S[]; INT LIM; { INT C, I; FOR(I=0;I<LIM-1 && (C=GETCHAR())!=EOF && C!='\N';++I) S[I] = C; IF (C == '\N') { S[I] = C; ++I; } S[I] = '\0'; RETURN(I); } COPY(S1, S2) /* COPY S1 TO S2; ASSUME S2 BIG ENOUGH */ CHAR S1[], S2[]; { INT I; I = 0; WHILE ((S2[I] = S1[I] != '\0') ++I; } MAIN GETLINE - , . GETLINE CHAR S[]; INT LIM; , , - . S , MAIN . GETLINE RETURN - , POWER. ; , COPY, - . , GETLINE \0 / , /. - "C": "C" - "HELLO\N" , , \0, - , PRINTF, : ------------------------------------------------------------------------ ! H ! E ! L ! L ! O ! \N ! \0 ! ------------------------------------------------------------------------ %S , PRINTF - , . COPY, , , \0, S2. / , \0 /. , , , , - . , MAIN, , - ? GETLINE : - , - . , MAIN , , , . . GETLINE - , . GETLINE . - COPY / /, - , . 1-14 ----------------- , . 1-15 ----------------- 80 - . 1-16 ----------------- , , , . 1-17 ----------------- REVERSE(S), - S . , . 1.10. : MAIN(LINE, SAVE ..) - MAIN, MAIN . ; , I GETLINE I COPY. - , - , , - . , , . - . / 4 - , - /. - , , . , . - , , .. , - , . ( "COMMON" "EXTERNAL" PL/1). - , - . , , , , , , - . - ; . - , ; EXTERN, . , - , LINE, SAVE MAX . , . #DEFINE MAXLINE 1000 /* MAX. INPUT LINE SIZE*/ CHAR LINE[MAXLINE]; /* INPUT LINE */ CHAR SAVE[MAXLINE];/* LONGEST LINE SAVED HERE*/ INT MAX;/*LENGTH OF LONGEST LINE SEEN SO FAR*/ MAIN() /*FIND LONGEST LINE; SPECIALIZED VERSION*/ { INT LEN; EXTERN INT MAX; EXTERN CHAR SAVE[]; MAX = 0; WHILE ( (LEN = GETLINE()) > 0 ) IF ( LEN > MAX ) { MAX = LEN; COPY(); } IF ( MAX > 0 ) /* THERE WAS A LINE */ PRINTF( "%S", SAVE ); } GETLINE() /* SPECIALIZED VERSION */ { INT C, I; EXTERN CHAR LINE[]; FOR (I = 0; I < MAXLINE-1 && (C=GETCHAR()) !=EOF && C!='\N'; ++I) LINE[I] = C; ++I; } LINE[I] = '\0' RETURN(I) } COPY() /* SPECIALIZED VERSION */ { INT I; EXTERN CHAR LINE[], SAVE[]; I = 0; WHILE ((SAVE[I] = LINE[I]) !='\0') ++I; } MAIN, GETLINE COPY - , - - . , - , , - , . - , . - EXTERN; EXTERN. EXTERN - : , - , EXTERN . EXTERN MAIN, GETLINE COPY , , . , - EXTERN. , , 1, - 2, - , 2 EXTERN. 4. , - . "" - , - ; "" , , . , , , , , , - - , - . , . - , , - . - , - , . , , , , . 1-18 --------------- FOR GETLINE - . , , - . ? 1.11. , "C". , , , - - : - , , . "C", . , , , "C", - . 1-19 --------------- DETAB, , - . - , , N . 1-20 ---------------- ENTAB, - , . - , DETAB. 1-21 ---------------- "" , N , N - . , - - , , . 1-22 ---------------- "C"- - . "- " . 1-23 ---------------- "C"- - , , . , , , . ( , ). * 2. , * , . - , , , - , . , - . - . - . 2.1. , - - . ; - . "_" ; . ; - "" - , - . , . , , - , - . - . , IF, ELSE, INT, FLOAT .., : . ( ). , - , , - , - . 2.2. "C" - : CHAR , . INT , - . FLOAT . DOUBLE . , - INT: SHORT (), LONG () UNSIGNED ( ). SHORT LONG . - 2 N, N - - INT; . : SHORT INT X; LONG INT Y; UNSIGNED INT Z; C INT , . , ; - . 1 --------------------------------------------------------- ! DEC PDP-11 HONEYWELL IBM 370 INTERDATA ! 6000 8/32 ! ! ASCII ASCII EBCDIC ASCII ! ! CHAR 8-BITS 9-BITS 8-BITS 8-BITS ! INT 16 36 32 32 ! SHORT 16 36 16 16 ! LONG 32 36 32 32 ! FLOAT 32 36 32 32 ! DOUBLE 64 72 64 64 ! ! --------------------------------------------------------- , SHORT LONG - - ; INT "" . , SHORT LONG - . , - , , SHORT , LONG. 2.3. INT FLOAT . , 123.456-7, "" 0.123 FLOAT . DOUBLE, "E" FLOAT, DOUBLE. 123L. - , INT, - LONG. - : 0() INT , 0X . , - 31 037 - 0X1F . - L, LONG. 2.3.1. - , , , , ''. - . , ASCII , '0', 48, EBCDIC - 240, 0. '0' , 48 240, - . - - , , - . - . - , , , \N ( ), \T (), \0 ( ), \\ ( ), \' ( ) .. , . , - , '\DDD' DDD - , #DEFINE FORMFEED '\014' /* FORM FEED */ '\0', - 0, 0 , . 2.3.2. - , - . - , , , - , , #DEFINE MAXLINE 1000 CHAR LINE[MAXLINE+1]; SECONDS = 60 * 60 * HOURS; 2.3.3. - , , , , , "I AM A STRING" /* - */ "" /* NULL STRING */ /* - */ , . , - , ; \". , . - , - - \0. , - , , , . , - . STRLEN(S) - S \0. STRLEN(S) /* RETURN LENGTH OF S */ CHAR S[]; { INT I; I = 0; WHILE (S[I] != '\0') ++I; RETURN(I); } , : 'X' - , "X". - , , . - , ( ) \0. 2.4. , , . - , , , , INT LOWER, UPPER, STEP; CHAR C, LINE[1000]; - ; INT LOWER; INT UPPER; INT STEP; CHAR C; CHAR LINE[1000]; , - . - , . - , , , , CHAR BACKSLASH = '\\'; INT I = 0; FLOAT EPS = 1.0E-5; , , . - , . , - , , (.. ). , , , . , . 2.5. +, -, *, / %. -, +. . X % Y X Y , , , Y . , - , 4, 100, , 400 . - IF(YEAR % 4 == 0 && YEAR % 100 != 0 \!\! YEAR % 400 == 0) ELSE % FLOAT DOUBLE. + - , *, / %, - . . ( ). - + - ; - - , . , +(B+C) - (A+B)+C. - - , , - . , - (.. - ), . 2.6. => > =< < . - - : == != . - , I<LIM-1 I<(LIM-1), . && \!\! . , && \!\!, , - , . - . , , - GETLINE, 1. FOR(I=0;I<LIM-1 && (C=GETCHAR()) != '\N' && C != EOF; ++I) S[I]=C; , , S, I<LIM-1 . - , . 'C' EOF - GETCHAR : , . && , \!\!, . - , I<LIM-1 && (C = GETCHAR()) != '\N' && C != EOF . != , (C = GETCHAR()) != '\N' . ! 0, 1. ! IF( ! INWORD ) IF( INWORD == 0 ) T , . ! INWORD (" "). . 2-1 --------------- , FOR, &&. 2.7. , - . , , , , , F+I. - , , - FLOAT , . -, CHAR INT : CHAR - INT. - . ATOI, . ATOI(S) /* CONVERT S TO INTEGER */ CHAR S[]; { INT I, N; N = 0; FOR ( I = 0; S[I]>='0' && S[I]<='9'; ++I) N = 10 * N + S[I] - '0'; RETURN(N); } KAK 1, S[I] - '0' S[I] , '0', '1' .. . CHAR INT LOWER, . - , LOWER . ASCII. LOWER(C) /* CONVERT C TO LOWER CASE; ASCII ONLY */ INT C; { IF ( C >= 'A' && C <= 'Z' ) RETURN( C + '@' - 'A'); ELSE /*@ 'A' */ RETURN(C); } ASCII, , , , - Z , . EBCDIC IBM 360/370 , - . - . , - , CHAR - . - CHAR INT ? - , , - . (PDP-11, ) CHAR, 1, (" "). - , - . "C" , - , - . - , , , . , 1 EOF. CHAR C; C = GETCHAR(); IF ( C == EOF ) ... , , '' , CHAR, EOF , . , - INT CHAR - , GETCHAR. INT CHAR - - . GETCHAR ( ) , , EOF. - EOF CHAR, INT. , , I>J, , && \!\!, - 1, , 0, . , ISDIGIT = C >= '0' && C <= '9'; ISDIGIT 1, - , 0 - . ( IF, WHILE, FOR .. "" " "). - , . , + *, ( ), , "" "" - "" . , . - CHAR SHORT INT, FLOAT DOUBLE. - , DOUBLE, DOUBLE, DOUBLE. - , LONG, LONG, LONG. - , UNSIGNED, UNSIGNED UNSIGNED. - INT, INT. , FLOAT - DOUBLE; "C" - . ; , . - , , . INT CHAR - . - INT I; CHAR C; I = C; C = I; '' . , . FLOAT, I INT, = I; I = ; ; FLOAT INT . DOUBLE FLOAT . - CHAR - . , - : , CHAR SHORT INT, FLOAT DOUBLE. INT DOUBLE , CHAR FLOAT. , ("") - , (CAST). , ( ) , . : , . - , SQRT DOUBLE , - - . , N - , SQRT((DOUBLE) N) SQRT N DOUBLE. (, N ; N ). - , - , . 2-2 --------------- HTOI(S), - - . 1 9 F. 2.8. "C" . - ++ 1 , - -- 1. ++ , , , IF(C == '\N') ++I; , ++ -- ( , ++N), ( : N++). N. ++N N , N++ N , . , , , , ++N N++ - . N = 5, = N++; 5, = ++N; 6. N 6. ; =(I+J)++ . , , , , , IF ( C == '\N' ) NL++; . , - . , , SQUEEZE(S,C), '' S, , . SQUEEZE(S,C) /* DELETE ALL C FROM S */ CHAR S[]; INT C; { INT I, J; FOR ( I = J = 0; S[I] != '\0'; I++) IF ( S[I] != C ) S[J++] = S[I]; S[J] = '\0'; } , , '', - J, J - 1, . IF ( S[I] != C ) { S[J] = S[I]; J++; } GETLINE, 1, IF ( C == '\N' ) { S[I] = C; ++I; } IF ( C == '\N' ) S[I++] = C; STRCAT(S,T), S, S . , S . STRCAT(S,T) /* CONCATENATE T TO END OF S */ CHAR S[], T[]; /* S MUST BE BIG ENOUGH */ { INT I, J; I = J = 0; WHILE (S[I] != '\0') / *FIND END OF S */ I++; WHILE((S[I++] = T[J++]) != '\0') /*COPY T*/ ; } T T S , ++ - I J. 2-3 --------------- SQUEEZE(S1,S2), S1 , - S2. 2-4 --------------- ANY(S1,S2), - S1 - S2 , S1 S2, -1. 2.9. ; FLOAT DOUBLE. & AND \! OR ^ OR << >> \^ ( ) "\" . AND ; , C = N & 0177 '' N , - . '' OR - : C = X MASK , MASK. & '' && \!\! , - . , =1, Y=2, &Y , X&&Y ./?/ << >> , . , <<2 , , 4. - , PDP-11, - /" "/, - /" "/. \^ ; - , 1 0 . - X & \^077 . , X&\^077 , , , X&0177700, - , 16 . , \^077 - , , . , GETBITS(X,P,N), - / / N . , 0, N - - . , GETBITS(,4,3) - , 4,3 2. GETBITS(X,P,N) /* GET N BITS FROM POSITION P */ UNSIGNED X, P, N; { RETURN((X >> (P+1-N)) & \^(\^0 << N)); } X >> (P+1-N) . X UNSIGNED , - , , , . \^0 1; N - \^0<<N N ; \^ N . 2-5 --------------- GETBITS , - . 2-6 --------------- WORDLENGTH(), , .. - INT. , .. . 2-7 --------------- RIGHTROT(N,B), N B . 2-8 --------------- INVERT(X,P,N), (.. 1 0 ) N X, - P, . 2.10. , I = I + 2 I += 2 +=. ( +, - ) =, - + - * / % << >> & \^ \! 1 2 - , 1 = 2 1 = (1) (2) , 1 . 2: X *= Y + 1 X = X * (Y + 1) X = X * Y + 1 BITCOUNT, 1 . BITCOUNT(N) /* COUNT 1 BITS IN N */ UNSIGNED N; ( INT B; FOR (B = 0; N != 0; N >>= 1) IF (N & 01) B++; RETURN(B); ) , , . : " 2 I" " I 2", " I, 2 I". , I += 2. , , YYVAL[YYPV[P3+P4] + YYPV[P1+P2]] += 2 T , , , - , . - - . , ; WHILE ((C = GETCHAR()) != EOF) , (+=, -= ..) , - . . 2-9 --------------- X&(X-1) 1 X.(?) BITCOUNT. 2.11. IF (A > B) Z = A; ELSE Z = B; Z . , "?:", - . 1 ? 2 : 3 1. (), 2, . - 3, . - 2 3. , Z , Z = (A > B) ? A : B; /* Z = MAX(A,B) */ , - , . 2 3 , , . , F FLOAT, N - INT, (N > 0) ? F : N DOUBLE , N . ?: , , - . , , . - . , - N , 10 , ( ) . OR (I = 0; I < N; I++) PRINTF("%6D%C",A[I],(I%10==9 \!\! I==N-1) ? '\N' : ' ') N- . - . , , - , , - . 2-10 --------------- LOWER, , IF-ELSE . 2.12. - , , . , , ; - . , , *, / % , , - + -. OPERATOR ASSOCIATIVITY () [] -> . LEFT TO RIGHT ! \^ ++ -- - (TYPE) * & SIZEOF RIGHT TO LEFT * / % LEFT TO RIGHT + - LEFT TO RIGHT << >> LEFT TO RIGHT < <= > >= LEFT TO RIGHT == != LEFT TO RIGHT & LEFT TO RIGHT ^ LEFT TO RIGHT \! LEFT TO RIGHT && LEFT TO RIGHT \!\! LEFT TO RIGHT ?: RIGHT TO LEFT = += -= ETC. RIGHT TO LEFT , (CHAPTER 3) LEFT TO RIGHT -> . - ; 6 SIZEOF ( ). 5 * ( - ) & (). , - &, ^ == !=. , , - IF ((X & MASK) == 0) ... . , , (*, +, &, ^, ), , . - ; , - , - . "C", , . - X = F() + G(); F, G, ; - , F, G , , X . - . , PRINTF("%D %D\N",++N,POWER(2,N)); ( ) , N POWER. , - , ++N; PRINTF("%D %D\N",N,POWER(2,N)); , , " " - . , , , . - A[I] = I++; , I - . - . , ( ), - - , - . : , , . , , , , - , . ( - LINT , - . * 3. * - . - "C"; , . 3.1. , X=0, I++, PRINTF(...), , - , , , X = 0; I++; PRINTF(...); "C" - , , - . /( /) , . , - , , - IF, ELSE, WHILE FOR.( - ; 4). , . 3.2. IF - ELSE IF - ELSE - . IF () -1 ELSE -2, ELSE . - ; "" /.. /, -1. / /, ELSE, -1 -2. IF - , . - IF () IF ( !=0) , - . , ELSE IF - ELSE - , , ELSE IF. - ELSE - IF, ELSE. , IF ( N > 0 ) IF( A > B ) Z = A; ELSE Z = B; ELSE IF, - , ELSE IF. , , - : IF (N > 0) { IF (A > B) Z = A; } ELSE Z = B; T IF (N > 0) FOR (I = 0; I < N; I++) IF (S[I] > 0) { PRINTF("..."); RETURN(I); } ELSE /* WRONG */ PRINTF("ERROR - N IS ZERO\N"); ELSE IF , , - ELSE IF. - . , , IF (A > B) Z = A; ELSE Z = B; Z=A . , IF , Z=A, , - . 3.3. ELSE - IF IF () ELSE IF () ELSE IF () ELSE , . IF - . ; - , - , . - , . ELSE , . ; ELSE , , "" . - , , V. V - . ( 0 N-1), V, -1, V. BINARY(X, V, N) /* FIND X IN V[0]...V[N-1] */ INT X, V[], N; { INT LOW, HIGH, MID; LOW = 0; HIGH = N - 1; WHILE (LOW <= HIGH) { MID = (LOW + HIGH) / 2; IF (X < V[MID]) HIGH = MID - 1; ELSE IF (X > V[MID]) LOW = MID + 1; ELSE /* FOUND MATCH */ RETURN(MID); } RETURN(-1); } - , , V[MID]; ELSE - IF - . 3.4. SWITCH , . 1 , - , - IF...ELSE IF...ELSE. . MAIN() /* COUNT DIGITS,WHITE SPACE, OTHERS */ { INT C, I, NWHITE, NOTHER, NDIGIT[10]; NWHITE = NOTHER = 0; FOR (I = 0; I < 10; I++) NDIGIT[I] = 0; WHILE ((C = GETCHAR()) != EOF) SWITCH (C) { CASE '0': CASE '1': CASE '2': CASE '3': CASE '4': CASE '5': CASE '6': CASE '7': CASE '8': CASE '9': NDIGIT[C-'0']++; BREAK; CASE ' ': CASE '\N': CASE '\T': NWHITE++; BREAK; DEFAULT : NOTHER++; BREAK; } PRINTF("DIGITS ="); FOR (I = 0; I < 10; I++) PRINTF(" %D", NDIGIT[I]); PRINTF("\NWHITE SPACE = %D, OTHER = %D\N", NWHITE, NOTHER); - ( - ) (CASE). , , . - , CASE, , . , DEFAULT. DEFAULT , , - , . - . . BREAK - . , , , . BREAK RETURN . , BREA WHILE, FOR DO. , . , - , , . - BREAK, . , . - , , . BREAK - ( DEFAULT), . , - , . 3-1 -------------- EXPAND(S, T), - S , , \N \. . 3.5. - WHILE FOR WHILE FOR. WHILE () . , . , , . FOR ( 1; 2; 3) 1; WHILE ( 2) { 3; } FOR . , 1 3 - , 2 - . , . 1 - 3, . - , 2, , , FOR (;;) { ... } , , ( BREAK RETURN). WHILE FOR - , . WHILE ((C = GETCHAR()) == ' ' \!\! C == '\N' \!\! C == '\T') ; /* SKIP WHITE SPACE CHARACTERS */ , , WHIL . FOR, , , , . FOR (I = 0; I < N; I++) "C" N , DO PL/1. , , , , , . FOR , . FOR , - , . ATOI, . ; + -. ( 4 ATOF, ). : - , - , - . , . ATOI(S) /* CONVERT S TO INTEGER */ CHAR S[]; { INT I, N, SIGN; FOR(I=0;S[I]==' ' \!\! S[I]=='\N' \!\! S[I]=='\T';I++) ; /* SKIP WHITE SPACE */ SIGN = 1; IF(S[I] == '+' \!\! S[I] == '-') /* SIGN */ SIGN = (S[I++]=='+') ? 1 : - 1; FOR( N = 0; S[I] >= '0' && S[I] <= '9'; I++) N = 10 * N + S[I] - '0'; RETURN(SIGN * N); } , - . - . , , - , . - . , - . SHELL(V, N) /* SORT V[0]...V[N-1] INTO INCREASING ORDER */ INT V[], N; { INT GAP, I, J, TEMP; FOR (GAP = N/2; GAP > 0; GAP /= 2) FOR (I = GAP; I < N; I++) FOR (J=I-GAP; J>=0 && V[J]>V[J+GAP]; J-=GAP) { TEMP = V[J]; V[J] = V[J+GAP]; V[J+GAP] = TEMP; } } . - , N/2 , . , - ; - . , - . , - FOR , , . "C" ",", - FOR. - , , , . , FOR , , - . REVERSE(S), S . REVERSE(S) /* REVERSE STRING S IN PLACE */ CHAR S[]; { INT C, I, J; FOR(I = 0, J = STRLEN(S) - 1; I < J; I++, J--) { C = S[I]; S[I] = S[J]; S[J] = C; } } , , .., . 3-2 --------------- EXPAND(S1,S2), -Z S1 ...XYZ S2. - . --, -Z0-9 --Z. ( , -, , ). 3.6. DO - WHILE 1, WHILE FOR , - , . "C", DO-WHILE, , ; . - : DO WHILE () , . , .. , . , DO-WHILE , WHILE FOR, . , - , , , ITOA, - ( ATOI). , . , - . - , . ITOA(N,S) /*CONVERT N TO CHARACTERS IN S */ CHAR S[]; INT N; { INT I, SIGN; IF ((SIGN = N) < 0) /* RECORD SIGN */ N = -N; /* MAKE N POSITIVE */ I = 0; DO { /* GENERATE DIGITS IN REVERSE ORDER */ S[I++] = N % 10 + '0';/* GET NEXT DIGIT */ } WHILE ((N /=10) > 0); /* DELETE IT */ IF (SIGN < 0) S[I++] = '-' S[I] = '\0'; REVERSE(S); } DO-WHILE , , , N, S - . , DO-WHIL, , , WHILE WHILE. 3-3 -------------- ITOA , .. N A -2 -1, - . . , - . 3-4 -------------- ITOB(N,S), - N - S. ITOH, . 3-5 --------------- I, , - . - ; - , , , . 3.7. BREAK - , . BR FOR, WHILE DO , - . BR ( - ). - . - BR , . #DEFINE MAXLINE 1000 MAIN() /* REMOVE TRAILING BLANKS AND TABS */ { INT N; CHAR LINE[MAXLINE]; WHILE ((N = GETLINE(LINE,MAXLINE)) > 0) { WHILE (--N >= 0) IF (LINE[N] != ' ' && LINE[N] != '\T' && LINE[N] != '\N') BREAK; LINE[N+1] = '\0'; PRINTF("%S\N",LINE); } } GETLINE . LINE (, --N N ) - , - , . - , , N - (.., ). , , . BR : WHILE ((N = GETLINE(LINE,MAXLINE)) > 0) { WHILE (--N >= 0 && (LINE[N] == ' ' \!\! LINE[N] == '\T' \!\! LINE[N] == '\N')) ; ... } , - . , - &&, \!\!, ! , - . 3.8. CONTINUE CONTINUE BR, - ; - (FOR, WHILE, DO ). WHILE DO - ; FOR - . ( CONTINUE , . CONTINUE ). , - ; . FOR (I = 0; I < N; I++) { IF (A[I] < 0) /* SKIP NEGATIVE ELEMENTS */ CONTINUE; ... /* DO POSITIVE ELEMENTS */ } CONTINUE , , - , , - . 3-6 ------------------------------------------------------------------------ , - , . ( UNIQ UNIX). 3.9. GOTO "C" GOTO, - , . GOTO , . GOTO . , , GOTO . , , , . BR, . : FOR ( ... ) FOR ( ... ) { ... IF (DISASTER) GOTO ERROR; } ... ERROR: CLEAN UP THE MESS , - . , - , . , - GOTO. . (- 5). - : FOR (I = 0; I < N; I++) FOR (J = 0; J < M; J++) IF (V[I][J] < 0) GOTO FOUND; /* DIDN'T FIND */ ... FOUND: /* FOUND ONE AT POSITION I, J */ ... , GOTO, , , , - . - , : FOUND = 0; FOR (I = 0; I < N && !FOUND; I++) FOR (J = 0; J < M && !FOUND; J++) FOUND = V[I][J] < 0; IF (FOUND) /* IT WAS AT I-1, J-1 */ ... ELSE /* NOT FOUND */ ... , , GOTO, . * 4. * - , , - . - , , , , . "C" ; "C"- , . ; . , . "- " /GETCHAR , PUTCHAR/ /SIN, COS, SQRT/. . 4.1. - , - . / - GREP "UNIX"/. , "THE" - NOW IS THE TIME FOR ALL GOOD MEN TO COME TO THE AID OF THEIR PARTY NOW IS THE TIME MEN TO COME TO THE AID OF THEIR PARTY : WHILE ( ) IF ( ) , , . , , - - . , . " " - GETLINE, , - 1, " " - PRINTF, - . , , . , - PL/1: INDEX(S,) , , S, T, -1, S . 0, 1, "C" . - , - INDEX; . , - , - . , - , . - , , INDEX, . - 5 , , . GETLINE; 1. #DEFINE MAXLINE 1000 MAIN() /* FIND ALL LINES MATCHING A PATTERN */ { CHAR LINE[MAXLINE]; WHILE (GETLINE(LINE, MAXLINE) > 0) IF (INDEX(LINE, "THE") >= 0) PRINTF("%S", LINE); } GETLINE(S, LIM) /* GET LINE INTO S, RETURN LENGTH * CHAR S[]; INT LIM; { INT C, I; I = 0; WHILE(--LIM>0 && (C=GETCHAR()) != EOF && C != '\N') S[I++] = C; IF (C == '\N') S[I++] = C; S[I] = '\0'; RETURN(I); } INDEX(S,T) /* RETURN INDEX OF T IN S,-1 IF NONE */ CHAR S[], T[]; { INT I, J, K; FOR (I = 0; S[I] != '\0'; I++) { FOR(J=I, K=0; T[K] !='\0' && S[J] == T[K]; J++; K++) ; IF (T[K] == '\0') RETURN(I); } RETURN(-1); } ( , ) , { , } , - ; DUMMY () { } . / - /. - , ; . . - / /; . , , , . RETURN - , - . RETURN : RETURN () , . , RETURN ; - . - - , "" , . E , , - . "" , , . - LINT . "C"-, - , . "UNIX", , 'CC', 1. , MAIN., GETLINE.C INDEX. . CC MAIN.C GETLINE.C INDEX.C , MAIN.O, GETLINE.O INDEX.O - , A.OUT . - , MAIN.C, CC MAIN.C GETLIN.O INDEX.O 'CC' "." "." , . 4-1 ---------------- RINDEX(S,T), S -1, S T. 4.2. , - - . , , , , WHILE (GETLINE(LINE, MAXLINE) > 0) , , - , . , , - INT. CHAR - INT, , - CHAR. , . , - - ? , SQRT, SIN COS DOUBLE; . , , ATF(S), S - . ATF - I, 2 3; - , , , ./ - ; , /. -, ATF , INT. - FLOAT DOUBLE, - , ATOF FLOAT; - , , DOUBLE. , : DOUBLE ATOF(S) /* CONVERT STRING S TO DOUBLE */ CHAR S[]; { DOUBLE VAL, POWER; INT I, SIGN; FOR(I=0; S[I]==' ' \!\! S[I]=='\N' \!\! S[I]=='\T'; I++) ; /* SKIP WHITE SPACE */ SIGN = 1; IF (S[I] == '+' \!\! S[I] == '-') /* SIGN */ SIGN = (S[I++] == '+') ? 1 : -1; FOR (VAL = 0; S[I] >= '0' && S[I] <= '9'; I++) VAL = 10 * VAL + S[I] - '0'; IF (S[I] == '.') I++; FOR (POWER = 1; S[I] >= '0' && S[I] <= '9'; I++) { VAL = 10 * VAL + S[I] - '0'; POWER *= 10; } RETURN(SIGN * VAL / POWER); } , , , , ATOF , INT . / /, , - , , . #DEFINE MAXLINE 100 MAIN() /* RUDIMENTARY DESK CALKULATOR */ { DOUBLE SUM, ATOF(); CHAR LINE[MAXLINE]; SUM = 0; WHILE (GETLINE(LINE, MAXLINE) > 0) PRINTF("\T%.2F\N",SUM+=ATOF(LINE)); DOUBLE SUM, ATOF(); , SUM DOUBLE , ATOF , DOUBLE . , SUM, ATOF(...) . ATOF , "C" , , . ATOF - MAIN - , . ATOF / /, , ATOF DOUBLE, MAIN , INT , - . / LINT /. ATOF, , , - ATOI ( INT): ATOI(S) /* CONVERT STRING S TO INTEGER */ CHAR S[]; { DOUBLE ATOF(); RETURN(ATOF(S)); } RETURN. RETURN () . RETURN - F, DOUBLE, - INT, ATOI INT. ( 2, INT ). 4-2 ---------------- ATOF , 123.45-6 'E' - , . 4.3. 1 , - , .. , . , . - , - , - . , ; . , - . , - . 5 , - . , . , , - , - - . , , , - , - , MAX PL/1. , , , - . "C" - - PRINTF . , - . PRINTF - , , - , . . , - , - ; - , , ( ) . 4.4. "C" - , , . - "" - "", , . - , - , . , "C" . "", , ( , ), . - COMON EXTERNAL PL/1. , , - , . , , . - , , . , , - , . , , 1, - , . . , . . - . - - ; - . , , - . , - . , , , - , . . , , . +,-,*,/ = ( ). - , . ; - (1-2)*(4+5)= 12-45+*= . - ; , ( ) , - . 1 2 , -1. 4 5 - ,9. -1 9 , -9.- = , ( ). ,, , - . , - . , . , - : WHILE( , IF ( ) LSE IF ( ) ELSE , , - , , . . . - MAIN , . MAIN , - ; - . , PUSH ( ) POP ( ), MAIN. . - ; , -, - , , - 3. #DEFINE MAXOP 20 /* MAX SIZE OF OPERAND, OPERTOR * #DEFINE NUMBER '0' /* SIGNAL THAT NUMBER FOUND */ #DEFINE TOOBIG '9' /* SIGNAL THAT STRING IS TOO BIG * MAIN() /* REVERSE POLISH DESK CALCULATOR */ /( INT TUPE; CHAR S[MAXOP]; DOUBLE OP2,ATOF(),POP(),PUSH(); WHILE ((TUPE=GETOP(S,MAXOP)) !=EOF); SWITCH(TUPE) /( CASE NUMBER: PUSH(ATOF(S)); BREAK; CASE '+': PUSH(POP()+POP()); BREAK; CASE '*': PUSH(POP()*POP()); BREAK; CASE '-': OP2=POP(); PUSH(POP()-OP2); BREAK; CASE '/': OP2=POP(); IF (OP2 != 0.0) PUSH(POP()/OP2); ELSE PRINTF("ZERO DIVISOR POPPED\N"); BREAK; CASE '=': PRINTF("\T%F\N",PUSH(POP())); BREAK; CASE 'C': CLEAR(); BREAK; CASE TOOBIG: PRINTF("%.20S ... IS TOO LONG\N",S) BREAK; /) /) #DEFINE MAXVAL 100 /* MAXIMUM DEPTH OF VAL STACK */ INT SP = 0; /* STACK POINTER */ DOUBLE VAL[MAXVAL]; /*VALUE STACK */ DOUBLE PUSH(F) /* PUSH F ONTO VALUE STACK */ DOUBLE F; /( IF (SP < MAXVAL) RETURN(VAL[SP++] =F); ELSE /( PRINTF("ERROR: STACK FULL\N"); CLEAR(); RETURN(0); /) /) DOUBLE POP() /* POP TOP VALUE FROM STEACK */ /( IF (SP > 0) RETURN(VAL[--SP]); ELSE /( PRINTF("ERROR: STACK EMPTY\N"); CLEAR(); RETURN(0); /) /) CLEAR() /* CLEAR STACK */ /( SP=0; /) C CLEAR, PUSH POP. GETOP . 1, - , - . , - PUSH, POP CLEAR, . MAIN , - . , = , - PUSH(POP()); , , . , + * , , , - , - / . 4-3 --------------- . - /%/ . "- ", . - . / , - /. 4.5. , , "C"-, ; , . : , - ? , - ? 4.5.1. , . , , , , , , - . . - , , . , VAL, SP, PUSH, POP CLEAR , , : INT SP = 0; DOUBLE VAL[MAXVAL]; DOUBLE PUSH(F) {...} DOUBLE POP() {...} CLEAR() {...} VAL SP PUSH, POP CLEAR ; . , - , - , , , EXTERN. - . / , - ../; . INT SP; DOUBLE VAL[MAXVAL]; SP VAL, - - . EXTERN INT SP; EXTERN DOUBLE VAL[]; SP INT, VAL DOUBLE / /, - . , , ; - EXTERN . / EXTERN , /. - . , EXTERN . , VAL SP - , PUSH, POP CLEAR - . : 1: ------------------------------------------------------------------------ INT SP = 0; /* STACK POINTER */ DOUBLE VAL[MAXVAL]; /* VALUE STACK */ 2: ---------- EXTERN INT SP; EXTERN DOUBLE VAL[]; DOUBLE PUSH(F) {...} DOUBLE POP() {...} CLEAR() {...} EXTERN ' 1' , ; ' 2'. , #INCLUDE, EXTERN . GETOP, . - : , . , . / / NUMBER , . , - , - . GETOP / / , - . , NUMBER . , GETOP - , - ; TOOBIG . GETOP(S, LIM) /* GET NEXT OPRERATOR OR OPERAND */ CHAR S[]; INT LIM; { INT I, C; WHILE((C=GETCH())==' '\!\! C=='\T' \!\! C=='\N') ; IF (C != '.' && (C < '0' \!\! C > '9')) RETURN(C); S[0] = C; FOR(I=1; (C=GETCHAR()) >='0' && C <= '9'; I++) IF (I < LIM) S[I] = C; IF (C == '.') { /* COLLECT FRACTION */ IF (I < LIM) S[I] = C; FOR(I++;(C=GETCHAR()) >='0' && C<='9';I++) IF (I < LIM) S[I] =C; } IF (I < LIM) { /* NUMBER IS OK */ UNGETCH(C); S[I] = '\0'; RETURN (NUMBER); } ELSE { /* IT'S TOO BIG; SKIP REST OF LINE */ WHILE (C != '\N' && C != EOF) C = GETCHAR(); S[LIM-1] = '\0'; RETURN (TOOBIG); } } 'GETCH' 'UNGETCH'? , , , , , . , : , - , . , , . , " " . , , - , - , . , - , . - GETCH , - ; UNGETCH , GETCH . , , . UNGETCH - , . GETCH , - ; , GETCHAR. , . - GETCH UNGETCH - , . , GETCH, UNGETCH : #DEFINE BUFSIZE 100 CHAR BUF[BUFSIZE]; /* BUFFER FOR UNGETCH */ INT BUFP = 0; /* NEXT FREE POSITION IN BUF */ GETCH() /* GET A (POSSIBLY PUSHED BACK) CHARACTER */ { RETURN((BUFP > 0) ? BUF[--BUFP] : GETCHAR()); } UNGETCH(C) /* PUSH CHARACTER BACK ON INPUT */ INT C; { IF (BUFP > BUFSIZE) PRINTF("UNGETCH: TOO MANY CHARACTERS\N"); ELSE BUF [BUFP++] = C; } , , - . 4-4 ---------------- UNGETS(S) , . UNGETS BUF BUFP UNGETCH ? 4-5 ---------------- , . - GETCH UNGETCH . 4-6 ---------------- GETCH UNGETCH - EOF . , , EOF, . 4.6. , EXTERN, . , . , , - , , , - , . , - , . , - , , , PRINTF , . , , - . , , BUF BUFP GETCH-UNGETCH, , - GETCH UNGETCH , - . STATIC CHAR BUF[BUFSIZE]; /* BUFFER FOR UNGETCH */ STATIC INT BUFP=0; /*NEXT FREE POSITION IN BUF */ GETCH() {...} UNGETCH() {...} BUF BUFP; , . , , , - STATIC , - . , , , . ; . , , STATIC ; , . "C" "STATIC" , , "". ; / / - , , - . , . - , GETCH UNGETCH "" ; BUF BUFP , . PUSH, POP CLEAR ; VAR SP . 4.7. - . REGISTER , - . , - , REGISTER, , . REGISTER REGISTER INT X; REGISTER CHAR C; ..; INT . REGISTER - - . : F(C,N) REGISTER INT C,N; { REGISTER INT I; ... } - , . - , - . - REGISTER . ( 5). - . , , PDP-11 REGISTER , INT, CHAR . 4.8. "C" - PL/1 ; . , , . (- ) - , , , - . , - , , , . IF (N > 0) { INT I; /* DECLARE A NEW I */ FOR (I = 0; I < N; I++) ... } I "" IF; I I - . . INT X; F() { DOUBLE X; ... } X F - DOUBLE, F - . : INT X; F(X) DOUBLE X; { ... } F X , . 4.9. , , . , , , . , - ; - - (). ( ) - , : INT X = 1; CHAR SQUOTE = '\''; LONG DAY = 60 * 24; /* MINUTES IN A DAY */ - , . . - : , - . , 3 BINARY(X, V, N) INT X, V[], N; { INT LOW = 0; INT HIGH = N - 1; INT MID; ... } BINARY(X, V, N) INT X, V[], N; { INT LOW, HIGH, MID; LOW = 0; HIGH = N - 1; ... } , - . - . , . . - , - , . 1, MAIN() /* COUNT DIGITS, WHITE SPACE, OTHERS */ ( INT C, I, NWHITE, NOTHER; INT NDIGIT[10]; NWHITE = NOTHER = 0; FOR (I = 0; I < 10; I++) NDIGIT[I] = 0; ... ) INT NWHITE = 0; INT NOTHER = 0; INT NDIGIT[10] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }; MAIN() /* COUNT DIGITS, WHITE SPACE, OTHERS */ ( INT C, I; ... ) , - , - . , - , - . . , , , - . ; - : CHAR PATTERN[] = "THE"; , : CHAR PATTERN[] = { 'T', 'H', 'E', '\0' }; , - , . ( \0). 4.10. "C" ; , . . , - : , . . - , 3 ITOA, - . PRINTD . PRINTD(N) /* PRINT N IN DECIMAL */ INT N; { CHAR S[10]; INT I; IF (N < 0) { PUTCHAR('-'); N = -N; } I = 0; DO { S[I++] = N % 10 + '0'; /* GET NEXT CHAR */ } WHILE ((N /= 10) > 0); /* DISCARD IT */ WHILE (--I >= 0) PUTCHAR(S[I]); } - , PRINTD , , - . PRINTD(N) /* PRINT N IN DECIMAL (RECURSIVE)*/ INT N; ( INT I; IF (N < 0) { PUTCHAR('-'); N = -N; } IF ((I = N/10) != 0) PRINTD(I); PUTCHAR(N % 10 + '0'); ) , - , . - , PRINTD(123) PRINTD N = 123. 12 PRINTD, , 3. PRINTD 1 ( ), 2. , - - . - . , - . - , , ; 6. 4-7 -------------- , PRINTD - ITOA; .. - . 4-8 -------------- REVERSE(S), S. 4.11. "C" "" . - , , #DEFINE; . 4.11.1. #DEFINE ( ) "" . #INCLUDE "FILENAME" FILENAME. ( - ). , #DEFINE EXTERN . #INCLUDE. #INCLUDE . - , - , , , - . , - -TO , . 4.11.2. #DEFINE TES 1 - . #DEFINE , ""; - . - ; , \ . " " , #DEFINE, - . - , , - . , , , YES - , PRINTF("YES") - . #DEFINE K, , , . , , #DEFINE THEN #DEFINE BEGIN { #DEFINE END ;} IF (I > 0) THEN BEGIN A = 1; B = 2 END - , - . , , MAX : #DEFINE MAX(A, B) ((A) > (B) ? (A) : (B)) X = MAX(P+Q, R+S); X = ((P+Q) > (R+S) ? (P+Q) : (R+S)); " ", , - . - ; MAX , . , MAX, . - ; , , , , - . - , - . (- #DEFINE SQUARE(X) X * X , SQUARE(Z+1)). : , , . . 7 - -, GETCHAR PUTCHAR ( PUTCHAR - ), . . 4-9 --------------- SWAP(X, Y), - INT. ( ). * 5. * - , - . "C". , - , - , , , - . GOTO, - , . A, ; , - - . , , - . - . 5.1. , - "" - . , - , , INT, - , . & , = &; ; , "- " . & , &(-1) &3 - . - . * , . , Y INT, Y = *; Y , . - = &; Y = *; Y , Y = X; , : INT X, Y; INT *PX; X Y . INT *PX; ; , *PX INT. , PX *PX, INT. - , . , . , DOUBLE ATOF(), *DP; , ATOF() *DP DOUBLE. , - , . . , PX X, *PX - , X. Y = *PX + 1 Y , 1 X; PRINTF("%D\N", *PX) X; D = SQRT((DOUBLE) *PX) D X, - SQRT X DOUBLE. ( 2). Y = *PX + 1 * & , , , PX, 1 Y. - , Y = *(PX + 1) . PX X, *PX = 0 X , *PX += 1 , (*PX)++ ; - , , * ++, - , PX, - , . , , , . PY - INT, PY = PX PX PY, PY , PX. 5.2. "" - " ", - - . , ? , - SWAP. SWAP(A, B); SWAP : SWAP(X, Y) /* WRONG */ INT X, Y; { INT TEMP; TEMP = X; X = Y; Y = TEMP; } - SWAP A B . , . : SWAP(&A, &B); & , &A A. SWAP - . SWAP(PX, PY) /* INTERCHANGE *PX AND *PY */ INT *PX, *PY; { INT TEMP; TEMP = *PX; *PX = *PY; *PY = TEMP; } , . ( , SWAP O , - ). GETINT, , , . GETINT , - , . - , EOF, . , 7 SCANF, , - GETINT EOF ; - . , . - . - GETINT: INT N, V, ARRAY[SIZE]; FOR (N = 0; N < SIZE && GETINT(&V) != EOF; N++) ARRAY[N] = V; V - , . , GETINT &V V. V , GETINT , - . GETINT ATOI: GETINT(PN) /* GET NEXT INTEGER FROM INPUT */ INT *PN; { INT C,SIGN; WHILE ((C = GETCH()) == ' ' \!\! C == '\N' \!\! C == '\T'); /* SKIP WHITE SPACE */ SIGN = 1; IF (C == '+' \!\! C == '-') { /* RECORD SIGN */ SIGN = (C == '+') ? 1 : -1; C = GETCH(); } FOR (*PN = 0; C >= '0' && C <= '9'; C = GETCH()) *PN = 10 * *PN + C - '0'; *PN *= SIGN; IF (C != EOF) UNGETCH(C); RETURN(C); } *PN GETINT - INT. GETCH UNGETCH ( 4) , , , . 5-1 --------------- GETFLOAT, GETINT . GETFLOAT - ? 5.3. "C" - , , - . , - , . - , , . INT A[10] 10, .. 10 - , A[0], A[1], ..., A[9]. A[I] I - . PA - , INT *PA PA = &A[0] , PA A; , PA A[0]. X = *PA A[0] X. PA - A, PA+1 - , PA-I , I - , PA, PA+I , I . , PA A[0], *(PA+1) A[1], PA+I - A[I], *(PA+I) - A[I]. A. " 1 ", , - , , , . , I PA+I , PA. - . - . - . . - , PA=&A[0] PA = A , - , , A[I] *(A+I). A[I] "C" *(A+I); . & , , &A[I] A+I : A+I - I- A. , PA , : PA[I] - *(PA+I). , , , , . , . - , PA=A PA++ . - , : A=PA A++, P=&A . , . - , , , .. - , . - STRLEN, - . STRLEN(S) /* RETURN LENGTH OF STRING S */ CHAR *S; { INT N; FOR (N = 0; *S != '\0'; S++) N++; RETURN(N); } S , ; S++ - STRLEN , STRLEN . - CHAR S[]; CHAR *S; ; - , , - . , , - , , , , - . , - . , - . , A - , F(&A[2]) F(A+2) F A[2], &A[2], A+2 , A. F : F(ARR) INT ARR[]; { ... } F(ARR) INT *ARR; { ... } F, , - , . 5.4. P , , , P++ P , , P +=I P , - , I - . . "C" ; , . ( , ) - . : ALLOC(N) - P, - N , - ALLOC - ; FREE(P) , . "", FREE , , ALLOC. , ALLOC FREE - , - . "C" , , , , 8 . , , - ALLOC - . , - , ALLOCBUF. ALLOC FREE. , , . , .. - , ALLOC FREE, - . ; - . , ALLOCBUF . , ALLOCP. - ALLOC N , - , ALLOCBUF. - , ALLOC ALLOCP (.. ), N, . - FREE(P) ALLOCP P , P ALLOCBUF. DEFINE NULL 0 /* POINTER VALUE FOR ERROR REPORT */ DEFINE ALLOCSIZE 1000 /* SIZE OF AVAILABLE SPACE */ TATIC CHAR ALLOCBUF[ALLOCSIZE];/* STORAGE FOR ALLOC */ TATIC CHAR *ALLOCP = ALLOCBUF; /* NEXT FREE POSITION */ HAR *ALLOC(N) /* RETURN POINTER TO N CHARACTERS */ INT N; ( IF (ALLOCP + N <= ALLOCBUF + ALLOCSIZE) { ALLOCP += N; RETURN(ALLOCP - N); /* OLD P */ } ELSE /* NOT ENOUGH ROOM */ RETURN(NULL); ) REE(P) /* FREE STORAGE POINTED BY P */ HAR *P; ( IF (P >= ALLOCBUF && P < ALLOCBUF + ALLOCSIZE) ALLOCP = P; ) . , - , , - NULL ( ) , - - . STATIC CHAR *ALLOCP = ALLOCBUF; ALLOCP , ALLOCBUF, .. - . - , STATIC CHAR *ALLOCP = &ALLOCBUF[0]; , - . IF (ALLOCP + N <= ALLOCBUF + ALLOCSIZE) , , - N . , - ALLOCP , - ALLOCBUF. , ALLOC ( ). , ALLOC - , , . "C" , , - , . , , NULL, , - . , - , - - . IF (ALLOCP + N <= ALLOCBUF + ALOOCSIZE) IF (P >= ALLOCBUF && P < ALLOCBUF + ALLOCSIZE) - . - , . P Q , , <, >= .., . , P < Q , P , Q. == != . - NULL. , , . , . , - . -, , . P + N N- , P . , - P ; - N P - , P. , PDP-11 1 CHAR, 2 INT SHORT, 4 LONG FLOAT 8 DOUBLE. : P Q , P-Q - P Q. - STRLEN: STRLEN(S) /* RETURN LENGTH OF STRING S */ CHAR *S; { CHAR *P = S; WHILE (*P != '\0') P++; RETURN(P-S); } P S, - . WHILE - , \0. \0 , WHILE , 0, - . WHILE (*P) P++; P , P++ - P , - . P-S , .. . : FLOAT, - , CHAR, P FLOAT, P++ P FLOAT. , ALLOC, FLOAT, CHAR, ALLOC FREE CHAR FLOAT. - , , . ( - , - ), - . , , - , , FLOAT DOUBLE. 5.5. , , , "I AM A STRING" . \0, . , - . - , , , PRINTF ("HELLO, WORLD\N"); , , - , ; PRINTF - . , - . MESSAGE CHAR *MESSAGE; MESSAGE = "NOW IS THE TIME"; MESSAGE . ; . "C" - . , - -, 7. - STRCPY(S,T), - S. , , T S S = T : STRCPY(S, T) /* COPY T TO S */ CHAR S[], T[]; { INT I; I = 0; WHILE ((S[I] = T[I]) != '\0') I++; } STRCPY - . STRCPY(S, T) /* COPY T TO S; POINTER VERSION 1 */ CHAR *S, *T; { WHILE ((*S = *T) != '\0') { S++; T++; } } , STRCPY S T , . , , , - S T \0. STRCPY , . : STRCPY(S, T) /* COPY T TO S; POINTER VERSION 2 */ CHAR *S, *T; { WHILE ((*S++ = *T++) != '\0') ; } S T . - *T++ , T - ; ++ T, - . S, S . , , - \0, T S. , - \0 , STRCPY(S, T) /* COPY T TO S; POINTER VERSION 3 */ CHAR *S, *T; { WHILE (*S++ = *T++) ; } - , . , - "C"-. - STRCMP(S, T), - S , , , , S, T. - , S T . STRCMP(S, T) /* RETURN <0 IF S<T, 0 IF S==T, >0 IF S>T */ CHAR S[], T[]; { INT I; I = 0; WHILE (S[I] == T[I]) IF (S[I++] == '\0') RETURN(0); RETURN(S[I]-T[I]); } STRCMP : STRCMP(S, T) /* RETURN <0 IF S<T, 0 IF S==T, >0 IF S>T */ CHAR *S, *T; { FOR ( ; *S == *T; S++, T++) IF (*S == '\0') RETURN(0); RETURN(*S-*T); } ++ -- , , * ++ --, . *++P P , P, *--P P. 5-2 --------------- STRCAT 2: STRCAT(S, T) T S. 5-3 --------------- STRCPY. 5-4 -------------- - , . GETLINE / 1 4/, ATOI, ITOA / 2, 3 4/, REVERSE / 3/, INDEX GETOP / 4/. 5.6. - , , ""-- . , - , - ; . , , , , - . - , , STRSAVE(S), S , - ALLOC, . : CHAR *STRSAVE(S) /* SAVE STRING S SOMEWHERE */ CHAR *S; { CHAR *P, *ALLOC(); IF ((P = ALLOC(STRLEN(S)+1)) != NULL) STRCPY(P, S); RETURN(P); } : *STRSAVE(S) /* SAVE STRING S SOMEWHERE */ { CHAR *P; IF ((P = ALLOC(STRLEN(S)+1)) != NULL) STRCPY(P, S); RETURN(P); } - , INT, . , - - . . (- LINT , ). 5.7. "C" - , - . . . , 1- 60- - 61- . : DAY_OF_YEAR , MONTH_DAY - . , : MONTH_DAY(1977, 60, &M, &D) M 3 D 1 (1- ). - , . - , , , . : STATIC INT DAY_TAB[2][13] = { (0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31), (0, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31) }; DAY_OF_YEAR(YEAR, MONTH, DAY) /* SET DAY OF YEAR */ INT YEAR, MONTH, DAY; /* FROM MONTH & DAY */ { INT I, LEAP; LEAP = YEAR%4 == 0 && YEAR%100 != 0 \!\! YEAR%400 == 0; FOR (I = 1; I < MONTH; I++) DAY += DAY_TAB[LEAP][I]; RETURN(DAY); { MONTH_DAY(YEAR, YEARDAY, PMONTH, PDAY) /*SET MONTH,DAY */ INT YEAR, YEARDAY, *PMONTH, *PDAY; /* FROM DAY OF YEAR */ { LEAP = YEAR%4 == 0 && YEAR%100 != 0 \!\! YEAR%400 == 0; FOR (I = 1; YEARDAY > DAY_TAB[LEAP][I]; I++) YEARDAY -= DAY_TAB[LEAP][I]; *PMONTH = I; *PDAY = YEARDAY; } DAY_TAB DAY_OF_YEAR, MONTH_DAY, - . DAY_TAB , - . "C" , - . DAY_TAB[I][J] DAY_TAB [I, J] . , . , .. - . - , ; - . DAY_TAB - , 1 12, 0 11. , , - . , - ; , , , . - , 13 INT. , - DAY_TAB F, F : F(DAY_TAB) INT DAY_TAB[2][13]; { ... } , - F : INT DAY_TAB[][13]; INT (*DAY_TAB)[13]; , 13 . , [] - , *; , INT *DAY_TAB[13]; 13 . 5.8. ; , - . . - , SORT - UNIX. 3 , - . - , , , , . - , . . - (, , ALLOC), . . , STRCMP. , , . : . : , - , . - -. , , , . , . - , , , -1. , - , . #DEFINE NULL 0 #DEFINE LINES 100 /* MAX LINES TO BE SORTED */ MAIN() /* SORT INPUT LINES */ \( CHAR *LINEPTR[LINES]; /*POINTERS TO TEXT LINES */ INT NLINES; /* NUMBER OF INPUT LINES READ */ IF ((NLINES = READLINES(LINEPTR, LINES)) >= 0) \( SORT(LINEPTR, NLINES); WRITELINES(LINEPTR, NLINES); \) ELSE PRINTF("INPUT TOO BIG TO SORT\N"); \) #DEFINE MAXLEN 1000 READLINES(LINEPTR, MAXLINES) /* READ INPUT LINES */ CHAR *LINEPTR[]; /* FOR SORTING */ INT MAXLINES; \( INT LEN, NLINES; CHAR *P, *ALLOC(), LINE[MAXLEN]; NLINES = 0; WHILE ((LEN = GETLINE(LINE, MAXLEN)) > 0) IF (NLINES >= MAXLINES) RETURN(-1); ELSE IF ((P = ALLOC(LEN)) == NULL) RETURN (-1); ELSE \( LINE[LEN-1] = '\0'; /* ZAP NEWLINE */ STRCPY(P,LINE); LINEPTR[NLINES++] = P; \) RETURN(NLINES); \) , , . WRITELINES(LINEPTR, NLINES) /* WRITE OUTPUT LINES */ CHAR *LINEPTR[]; INT NLINES; \( INT I; FOR (I = 0; I < NLINES; I++) PRINTF("%S\N", LINEPTR[I]); \) CHAR *LINEPTR[LINES]; , LINEPTR LINES , - CHAR. , LINEPTR[I] - , *LINEPTR[I] . LINEPTR , - WRITELINES, - , - . : WRITELINES(LINEPTR, NLINES) /* WRITE OUTPUT LINES */ CHAR *LINEPTR[]; INT NLINES; \( INT I; WHILE (--NLINES >= 0) ...

Лекція Програмування

Допоможи студентському архіву