8bitfiles.net/archives/archives.tar/archives/genie-commodore-file-library/Information/C.TUTOR.2.SFX/lesson8

Text File | 1991-03-07 | 13.2 KB | 549 lines

├ ╠ANGUAGE ╘UTORIAL
-------------------
╨ART 8 OF 11


╬╧╘┼: ╙╒┬╙╘╔╘╒╘╔╧╬╙ ╞╧╥ ╙╨┼├╔┴╠ ├
╠┴╬╟╒┴╟┼ ├╚┴╥┴├╘┼╥╙:

╠┼╞╘ ├╒╥╠┘ ┬╥┴├╦┼╘:   █
╥╔╟╚╘ ├╒╥╠┘ ┬╥┴├╦┼╘:  ▌
┬┴├╦ ╙╠┴╙╚:           \
╘╔╠─┼:                »
╓┼╥╘╔├┴╠ ┬┴╥:         ▀
╒╬─┼╥╙├╧╥┼:           ñ


╞╔╠┼╙ -

╫HEREAS GETCHAR() AND PRINTF() WILL
GET CHARACTERS FROM THE KEYBOARD AND
PRINT TO THE SCREEN (THE 'STANDARD'
INPUT/OUTPUT), WE CAN ASK OTHER
FUNCTIONS AVAILABLE IN THE ├-LIBRARY
(AND ONES WE WRITE OURSELVES) TO
COMMUNICATE WITH A FILE ON DISK.

├ONSIDER THE EXCERPT:

1  MAIN(NUMBER,NAME)
2  INT NUMBER;
3  CHAR *NAME[];
4  █
5  ╞╔╠┼ *FP, *FOPEN();
6  FP=FOPEN(NAME[1],"R");
7  IF (FP == ╬╒╠╠) █
8  PRINTF("\N╙ORRY, CAN'T OPEN %S",
      NAME[1]);
9  EXIT(0);
10 ▌...
11 /*  REST OF PROGRAM GOES HERE */

╘HE ABOVE PROGRAM IS EXPECTED TO READ
A FILE ON DISK. ╫E COMPILE/LINK THE
PROGRAM, GIVING IT THE NAME READ.
╘HEN WE TYPE: READ LETTER. ╘HE
ARGUMENTS TO MAIN() ARE THE NUMBER 2
AND THE ┴╥╥┴┘ OF ╨╧╔╬╘┼╥╙ ( NAME[] )
POINTING TO THE STRINGS: READ AND
LETTER.

╫E DECLARE THE TWO ARGUMENTS OF
MAIN() TO BE INT AND CHAR *. ╔N OUR
EXAMPLE, NUMBER WILL HAVE THE VALUE 2
AND NAME[0] WILL BE A POINTER TO THE
STRING READ AND NAME[1] WILL POINT TO
LETTER. ╬OW WE ARE READY TO BEGIN
OUR MAIN() PROGRAM ....

╘O OPEN A DISK FILE, WE USE ╞╔╠┼
WHICH CALLS UPON THE ├-LIBRARY TO
LOOK AFTER THE MECHANICS OF
COMMUNICATING WITH THE OPERATING
SYSTEM IN ORDER TO ACCESS THE DISK.
┴FTER ╞╔╠┼ COME TWO POINTERS (WE KNOW
THEY'RE POINTERS BECAUSE OF THE *
..RIGHT?).

╧F COURSE, IF WE INTEND TO USE THE ├
STANDARD INPUT-OUTPUT FUNCTIONS, WE
HAD BETTER #INCLUDE "STDIO.H".

0  #INCLUDE <STDIO.H>

FP IS A POINTER VARIABLE WHICH POINTS
TO A ╞╔╠┼. FOPEN() IS A FUNCTION
WHICH RETURNS A POINTER TO A ╞╔╠┼.
╙O, OF COURSE, T+
VALUE RETURNED BY
FOPEN() IS ASSIGNED TO FP. ┴ FILE
POINTER IS SIMPLY THE NUMBER WHICH
YOUR COMPUTER'S OPERATING SYSTEM
ASSIGNS TO AN OPEN FILE. ╘HE
OPERATING SYSTEM USES THIS NUMBER IN
THE WAY THAT YOU USE A FILENAME IN
ACCESSING A FILE TO PERFORM READS AND
WRITES ON IT.

5  ╞╔╠┼ *FP, *FOPEN();
6  FP=FOPEN(NAME[1],"R");

╘HIS CALLS UPON THE FOPEN() FUNCTION
TO OPEN A FILE. ╘HE POINTER TO THE
FILE ( WHICH IS RETURNED BY FOPEN() )
IS ASSIGNED TO FP. ╘HE "R" MEANS THAT
ACCESS TO THE FILE IS FOR "R"EADING
( AS OPPOSED TO "W"RITING OR
"A"PPENDING ).

╚OW DO WE TELL FOPEN() THE NAME OF
THE FILE WHICH WE WANT TO OPEN...?
NAME[] IS AN ┴╥╥┴┘ OF POINTERS, EACH
POINTING TO A STRING.

╫HEN WE TYPED READ LETTER, WE PASSED
TO OUR MAIN() PROGRAM THE TWO STRINGS
READ AND LETTER. ╬OW THE POINTER
NAME[0] POINTS TO READ AND NAME[1]
WILL POINT TO THE STRING LETTER ...

...SO WE GIVE THE NAME OF THE FILE TO
FOPEN(), NAMELY NAME[1].

6  FP=FOPEN(NAME[1],"R");
7  IF (FP == ╬╒╠╠) █
8  PRINTF("\N╙ORRY, CAN'T OPEN %S",
     NAME[1]);
9  EXIT(0);

╘HE FUNCTION FOPEN() IS CLEVER. ╔F IT
CAN'T OPEN THE FILE FOR SOME REASON
(FILE DOES NOT EXIST) IT RETURNS A
╬╒╠╠ POINTER. ╬╒╠╠ IS THE STANDARD ├
EXPRESSION FOR THE VALUE ZERO. (╬OTE
THIS IS NOT THE ┴╙├╔╔ CHARACTER '0'
BUT THE VALUE ZERO). ╫E CHECK, IN
╠INE 7, ╔╞ FP IS ┼╤╒╔╓┴╠┼╬╘ ( == ) TO
╬╒╠╠. ╔F SO, WE APOLOGIZE ( ╠INE 8 )
AND EXIT THE PROGRAM ( ╠INE 9 ).

╔N ╠INE 8 WE PRINTF NAME[1] AS A
%STRING (OF COURSE). ╘HE EXIT(0) (IN
╠INE 9 ) IS NEW. ╔T WILL EXIT OUR
MAIN() AND RETURN YOU TO THE
OPERATING SYSTEM (E.G. ─╧╙ ).
╔T ALSO CLOSES ANY OPEN FILES.

╬╧╘┼: ╫E GAVE TO FOPEN() THE STRING
WHICH NAME[1] POINTS TO, AND WE ALSO
GIVE IT TO PRINTF() (NAMELY LETTER,
IN THIS EXAMPLE).

1  MAIN(NUMBER,NAME) 2  INT NUMBER;
3  CHAR *NAME[]
4  █
5    ╞╔╠┼ *FP, *FOPEN();
6    FP=FOPEN(*NAME[1],"R");
7    IF (FP == ╬╒╠╠) █
8     PRINTF("\N╙ORRY, CAN'T OPEN
          %F",NAME[1]);
9     EXIT(0);
10   ▌
11  /* NOW WE READ FROM THE FILE */
12  CHAR C;
13  WHILE ( (C=GETC(FP)) != ┼╧╞  )
14  PRINTF("%C",C);
15  ▌ /* END OF MAIN() */

╬OW WE DECLARE A CHAR C ( ╠INE 12 )
AND CONTINUALLY GETC() FROM THE FILE
WHICH WE OPENED ( IN ╠INE 6 ).
╥EFERENCE TO THIS OPEN FILE IS VIA
ITS FILE POINTER FP ... HENCE WE USED
GETC(FP) TO TELL THE GETC() FUNCTION
WHICH FILE TO GET THE NEXT CHAR FROM.
( GETC() IS IN STDIO.H ).

╫E (IN THIS EXAMPLE) PRINTF() THE
CHAR TO THE SCREEN, WHILE C IS ╬╧╘
┼╤╒╔╓┴╠┼╬╘ ( != ) TO THE ┼╧╞
CHARACTER (WHICH SHOULD INDICATE ┼ND
╧F ╞ILE ...IF ALL GOES WELL). ╘HE
STANDARD ┼╧╞ CHARACTER IS -1.

╬╧╫... ╚OW MANY ERRORS IN THE ABOVE
PROGRAM?

╠INE 3 NEEDS A SEMI-COLON!

3  CHAR *NAME[] TCH! TCH!

╠INE 6 SHOULD GIVE NAME[1] TO
FOPEN(), ╬╧╘ *NAME[1]

6  FP=FOPEN(*NAME[1],"R"); ╫╥╧╬╟!

╠INE 8 NEEDS A %STRING FORMAT, ╬╧╘ A
%FLOAT!

8  PRINTF("\N╙ORRY, CAN'T OPEN %F",
      NAME[1]); ╫╥╧╬╟!

...AND WE NEED TO #INCLUDE <STDIO.H>
 AS ╠INE 0

0  #INCLUDE <STDIO.H>
1  MAIN(NUMBER,NAME)
2  INT NUMBER;
3  CHAR *NAME[];
4  █
5  ╞╔╠┼ *FP, *FOPEN();
6  FP=FOPEN(NAME[1],"R");
7  IF (FP == ╬╒╠╠) █
8  PRINTF("\N╙ORRY, CAN'T OPEN
      %S",NAME[1]);
9  EXIT(0);
10 ▌


┴ ╒SEFUL ╙AMPLE PROGRAM -

╠ET'S CONTINUE BY EXPANDING THE
PROGRAM INTO ONE WHICH WILL READ A
FILE ON DISK AND COUNT THE NUMBER OF
TIMES THE LETTERS 'A' THROUGH 'Z'
OCCUR. ╘HIS IS AN EXAMPLE OF THE TYPE
OF FEATURE WHICH WOULD BE INCLUDED AS
A PART OF A TEXT OR WORD PROCESSOR.
╘HE NUMBER OF CHARACTERS TO BE
CHECKED IS ARBITRARILY LIMITED TO
1000 BUT YOU COULD INCREASE IT.
╞OR SIMPLICITY'S SAKE WE WILL ONLY BE
COUNTING LOWER-CASE LETTERS BUT YOU
MAY WANT TO TRY INCLUDING AN UPPER-
CASE COUNT LATER AS AN EXERCISE.

╫E'LL COMPILE/LINK THE PROGRAM UNDER
THE NAME 'COUNT' AND WE WILL TYPE ON
THE COMMAND LINE:

COUNT FILENAME

TO COUNT THE LETTERS 'A'-'Z' IN A
FILE. ╚ERE IS A PRELIMINARY VERSION
OF THE WHOLE PROGRAM:

#INCLUDE <STDIO.H>

MAIN(NUMBER,NAME)
INT NUMBER;
CHAR *NAME[];
█
  ╞╔╠┼ *FP, *FOPEN();

  FP=FOPEN(NAME[1],"R");
  IF (FP == ╬╒╠╠) █
    PRINTF("\N╙ORRY, CAN'T OPEN
      %S",NAME[1]);
  EXIT(0);
  ▌
  CHAR C; /* CHARACTERS FROM FILE */
  INT N[26], I;
    /* COUNT FOR EACH LETTER*/
  FOR (I=0;I<26;I++)
    N[I]=0;  /* COUNT SET TO ZERO */
  FOR (I=0;I<1000;I++) █
    /* GO THRU 1000 CHARS */
    C=GETC(FP);
    /* GET A CHAR FROM FILE */
    IF (C>='A'&& C<='Z')
    /* IS IT BETWEEN A & Z? */
      [C-'A']++;
    /* YES? THEN INCREMENT COUNT */
  ▌ /* END OF FOR */
  PRINTF("\N╔N THE FILE %S :
  ",NAME[1]);
  /* PRINT FILE NAME */
  FOR (I=0;I<26;I+=2)
  /* GO THRU ALPHABET */
  PRINTF("\N%C%S%3D : %C%S%3D",
    'A'+I,  " COUNT = ",N[I],
    'A'+I+1," COUNT = ", N[I+1],);
   /* THE FORMAT STRING CAUSES EACH
      LETTER TO BE PRINTED FOLLOWED
      BY A COUNT OF HOW MANY TIMES
      THAT LETTER APPEARS, AND IT
      DOES THIS TWICE */
▌  /* END OF MAIN()*/


╠ET'S LOOK AT PARTS OF THE PROGRAM -

CHAR C; /* CHARACTERS FROM FILE */

╘HIS VARIABLE WILL HOLD EACH
CHARACTER FROM THE FILE AS GETC()
READS IT.

INT N[26], I;
/* COUNT FOR EACH LETTER*/

╚ERE WE DECLARE SOME STUFF, NOTABLY
THE ┴╥╥┴┘ N[26] WHICH WILL HOLD THE
NUMBER OF TIMES EACH OF THE 26
LETTERS FROM 'A' TO 'Z' OCCUR
...HENCE IT'S AN INTEGER ┴╥╥┴┘.

FOR (I=0;I<26;I++)
  N[I]=0;
/* COUNTS SET TO ZERO */

╚ERE WE SET ALL THE INTEGERS IN THE
┴╥╥┴┘ TO 0  ...YOU CAN NEVER TELL
WHAT GARBAGE MIGHT BE IN THOSE MEMORY
LOCATIONS SO THEY SHOULD ALWAYS BE
INITIALIZED TO ZERO.

FOR (I=0;I<1000;I++) █
/* GO THRU 1000 CHARS   */

C=GETC(FP); /* GET A
CHAR FROM FILE */

IF (C>='A'&& C<='Z')
/* IS IT BETWEEN A & Z? */

╬OW WE GO THROUGH 1000 CHARACTERS IN
THE FILE AND GETC(FP) EACH CHARACTER,
GIVING THE FILE POINTER FP TO THE
LIBRARY FUNCTION GETC() AND GETTING
IN RETURN A CHARACTER C WHICH WE
CHECK TO SEE IF IT'S ╟╥┼┴╘┼╥ OR ┼╤╒┴╠
TO THE CHARACTER 'A'  ┴╬─  ( && ) IF
IT'S ╠┼╙╙ OR ┼╤╒┴╠ TO THE CHARACTER
'Z'.
(╥EMEMBER NOT CONFUSE &&, THE
LOGICAL ┴╬─ OPERATOR, WITH &, THE
BITWISE ┴╬─ OPERATOR).

IF (C>='A'&& C<='Z')
/* IS IT BETWEEN A & Z? */
  [C-'A']++;
/* YES? THEN INCREMENT COUNT */

IF WE GET A CHARACTER BETWEEN 'A' AND
'Z' WE INCREMENT THE APPROPRIATE
MEMBER OF OUR ┴╥╥┴┘ N[] ...BUT HOW ??

╬OW C IS A (SINGLE) BYTE IN MEMORY,
CONTAINING THE 'VALUE' OF THE
CHARACTER. ╘HIS 'VALUE' WOULD BE 65
FOR AN 'A' AND 66 FOR A 'B', ETC. (IN
┴╙├╔╔). ╔F THE 'VALUE' OF THE
CHARACTER RETURNED BY GETC() WERE 69
(FOR EXAMPLE) THEN WE MUST HAVE AN
'E'. ╙INCE 'E' IS THE FIFTH LETTER
IN THE ALPHABET WE WOULD WANT TO
INCREMENT N[4] WHICH IS THE FIFTH
ELEMENT IN OUR ARRAY (REMEMBER ├
ARRAYS START WITH ELEMENT ZERO!).
┴RRAY ELEMENT N[4] HOLDS THE NUMBER
OF TIMES AN 'E' WAS FOUND. ┴╬─, THE
'VALUE' OF C MINUS THE 'VALUE' OF 'A'
IS 69-65=4 ...THAT IS, C-'A' HAS THE
'VALUE' 4 ... ╙╧ WE INCREMENT
N[C-'A'] (WHICH ╫╔╠╠ INCREMENT N[4] ).


   ▌  /* END OF FOR */


╬OW WE END THE IF AND THE FOR. ╘HE
NUMBERS IN THE ┴╥╥┴┘ N[] WILL GIVE US
WHAT WE WANT.

PRINTF("\N╔N THE FILE %S : ",NAME[1]);
     /* PRINT FILE NAME  */

╬OW (JUST FOR KICKS) WE PRINT THE
NAME[1] OF THE FILE WE OPENED...

FOR (I=0;I<26;I+=2)
/* GO THRU ALPHABET */

╬OW WE GO THROUGH ALL 26 LETTERS (AND
ALL 26 'COUNTS' STORED IN THE ┴╥╥┴┘
N[] ) AND, SINCE OUR FINAL PRINTF()
STATEMENT PRINTS TWO LETTERS EACH
TIME THROUGH, WE USE I+=2 WHICH
ADDS 2 TO I EACH TIME THROUGH THE FOR
LOOP.

PRINTF("\N%C%S%3D : %C%S%3D",
'A'+I,  " COUNT =  ", N[I], 'A'+I+1,
" COUNT =  ",N[I+1]);

╬OW WE PRINT EACH LETTER AS A
%CHARACTER, GIVING TO PRINTF() THE
NUMBERS 'A'+0, THEN 'A'+1, THEN
'A'+2, ETC. (MEANING, THE ┴╙├╔╔
'VALUES' 65 THEN 66 THEN 67 ETC.).
╘HEN WE PRINT A CHARACTER %STRING.
╫E ALSO PRINT N[0], N[1], N[2] ETC.
WHICH ARE THE VARIOUS 'COUNTS' (FOR
AN 'A', 'B', 'C', ETC.)
╬OTE THAT WE CHOSE TO SPECIFY A
FORMAT WHICH SAYS TO PRINT, FIRST A
%CHARACTER, THEN A %STRING, THEN A
%DECIMAL (FIELD WIDTH 3).
...AND WE DO THIS ╘╫╔├┼ (BEFORE WE GO
TO A NEWLINE) WHICH IS WHY WE
INCREASED I BY 2 EACH TIME THROUGH
THE LOOP (AS IN I+=2).

╘HIS IS ONE OF THE ╘╫╧ PRINTOUTS ON
EACH LINE OF THE SCREEN: ╞IRST THE
%CHARACTER (AS 'A'+I) THEN THE
%STRING (" COUNT =  ") THEN THE
%DECIMAL ( N[I] ) WITH FIELD WIDTH 3,
THEN A SEMI-COLON TO DIVIDE THE TWO
COLUMNS, AND THEN THE
%CHARACTER%STRING%DECIMAL FORMAT IS
REPEATED ON THE SAME LINE.
▌
..AND THIS (WOULD YOU BELIEVE) IS THE
END OF MAIN()

╒SING THE PROGRAM WE JUST WROTE
(CALLED COUNT.C, BEFORE IT WAS
COMPILED AND LINKED) AS A SAMPLE TEXT
FILE WE GET:

COUNT COUNT.C

╔N THE FILE COUNT.C :
A COUNT =  18 : B COUNT =   3
C COUNT =  19 : D COUNT =   4
E COUNT =  32 : F COUNT =  22
G COUNT =   3 : H COUNT =   9
I COUNT =  25 : J COUNT =   0
K COUNT =   0 : L COUNT =   5
M COUNT =  11 : N COUNT =  31
O COUNT =  19 : P COUNT =   9
Q COUNT =   0 : R COUNT =  23
S COUNT =   9 : T COUNT =  22
U COUNT =   7 : V COUNT =   0
W COUNT =   1 : X COUNT =   1
Y COUNT =   2 : Z COUNT =   3

╬OTE: THE COUNTS FROM YOUR OWN FILE
MAY BE SLIGHTLY DIFFERENT.


┴ ┬ETTER WAY OF GETTING OUR OUTPUT -

╧UR MECHANISM FOR PRINTING TWO-TO-A-
LINE IS AWKWARD. ╫E REALLY WANT TO
LET I GO FROM 0 TO 25 AND, EACH TIME
I IS EXACTLY DIVISIBLE BY 2, PRINTF()
A NEWLINE. ╘HIS 'EXACT DIVISIBILITY'
CAN BE TESTED BY DIVIDING  BY 2 AND
CHECKING IF THE REMAINDER IS ZERO.

╘O GET THE REMAINDER, WHEN I IS
DIVIDED BY 2, WE USE:

I%2  /* SOMETHING ╬┼╫ */

╔T IS VERY IMPORTANT TO NOTICE THAT
THE SYMBOL '%' HAS TWO VERY DIFFERENT
USES AND MEANINGS IN THE ├ LANGUAGE.
╫E HAVE ALREADY SEEN THAT IN PRINTF()
THE % IS USED AS A CONVERSION
CHARACTER TO TELL PRINTF() WHAT TYPE
OF VARIABLE TO EXPECT IN THE SECOND
SET OF ARGUMENTS.( % DOES THE SAME
THING IN THE FUNCTION SCANF() ).
╔N THE EXAMPLE WE ARE NOW LOOKING AT
THE '%' SYMBOL IS THE ┬╔╬┴╥┘ ═╧─╒╠╒╙
OPERATOR. ╘HE EXAMPLE: I%2 MEANS WE
ARE PERFORMING MODULO DIVISION ON THE
VARIABLE 'I'. ═ODULO DIVISION YIELDS
THE REMAINDER OF A DIVIDE OPERATION
AS ITS RESULT.

╬OW THE LAST PART OF OUR PROGRAM CAN
BE REWRITTEN AS:

FOR (I=0;I<26;I++) █
  /* GO THRU ALPHABET */
  IF (I%2==0)
    PRINTF("\N");
    /* NEWLINE IF I%2==0 */
  ELSE
    PRINTF(": ");
  PRINTF("%C%S%3D",'A'+I,
    " COUNT =  ", N[I]);
    /* PRINT LETTER COUNT */
▌

╘HE 'IF' STATEMENT IN THE ABOVE WILL
ONLY ALLOW A NEWLINE TO BE PRINTED IF
THERE IS NO REMAINDER FROM A DIVISION
OF THE VARIABLE 'I' BY TWO. ╔N OTHER
WORDS, ONLY AFTER EVERY SECOND LETTER
OF THE ALPHABET. ╘HE 'ELSE' STATEMENT
WILL PRINT A ':' AFTER ALL OF THE
ODD-NUMBERED CHARACTERS TO DIVIDE THE
TWO COLUMNS OF LETTERS AND THEIR
COUNTS ...MUCH NICER CODE, SINCE WE
CAN EASILY PRINT 3 OR 4 TIMES ON A
LINE BY CHANGING THE NUMBER 2 IF OUR
CODE SHOULD EVER CALL FOR IT.

╚ERE IS A COMPLETE, UNCOMMENTED
LISTING OF THE FINAL VERSION OF OUR
PROGRAM:

/* ├╧╒╬╘.├ - COUNTS THE NUMBER OF
LOWER-CASE ALPHABETIC CHARACTERS IN A
FILE */

#INCLUDE <STDIO.H>

MAIN(NUMBER,NAME)
INT NUMBER;
CHAR *NAME[];
█
  ╞╔╠┼ *FP, *FOPEN();

  FP=FOPEN(NAME[1],"R");
  IF (FP == ╬╒╠╠) █
    PRINTF("\N╙ORRY, CAN'T OPEN
      %S",NAME[1]);
  EXIT(0);
  ▌
  CHAR C;
  INT N[26], I;
  FOR (I=0;I<26;I++)
    N[I]=0;
  FOR (I=0;I<1000;I++) █
    C=GETC(FP);
    IF (C>='A'&& C<='Z')
      [C-'A']++;


  PRINTF("\N╔N THE FILE %S :
  ",NAME[1]);
  FOR (I=0;I<26;I++)
    IF (I%2==0)
    PRINTF("\N");
    ELSE
      PRINTF(": ");
    PRINTF("%C%S%3D",'A'+I,
    " COUNT =  ", N[I]);
  ▌
▌

[┼ND OF ╨ART 8 OF 11]