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

Text File | 1991-03-07 | 9.8 KB | 380 lines

├ ╠ANGUAGE ╘UTORIAL
-------------------
╠ESSON 7 OF 11


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

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


═ORE ╞╒╬├╘╔╧╬╙, INCLUDING MAIN() -

┘OU MAY RECALL, IN A PREVIOUS LESSON,
THAT WE PASSED FLOAT ARGUMENTS X AND
Y TO A FUNCTION ( WHICH WE CALLED
AVERAGE(X,Y) ) WHICH RETURNED THE
AVERAGE: (X+Y)/2. ╔T WAS SOMETHING
LIKE:

1  MAIN()
   █
2    FLOAT X,Y,A;
3    PRINTF("\N ┼NTER TWO NUMBERS
        (SEPARATED BY A SPACE) : ");
4    SCANF("%F%F",&X,&Y);
5    A=AVERAGE(X,Y);
6    PRINTF("\N ╘HE AVERAGE OF %F
        AND %F IS %F",X,Y,A);
7  ▌
8  FLOAT AVERAGE (A,B);
9  FLOAT A, B;
10 █
11   FLOAT Z;
12   Z=(A+B)/2;
13   RETURN(Z);
14 ▌

╘HE FUNCTION AVERAGE(A,B) WAS INVOKED
IN LINE 5, WHERE WE PASSED IT COPIES
OF THE VARIABLES X AND Y. ╘HE
FUNCTION ITSELF STARTS IN LINE 8 AND
IT MAKES NO DIFFERENCE WHAT NAME THE
FUNCTION GIVES TO ITS ARGUMENTS
..THEY ARE, AFTER ALL, ONLY PRIVATE
COPIES OF THE TWO VARIABLES WHICH
MAIN() USES. ╫HATEVER AVERAGE DOES
WITH ITS COPIES, IT DOES ╬╧╘ EFFECT
THE ORIGINAL X AND Y.  ╫E COULD HAVE
SIMPLIFIED THE FUNCTION BY REPLACING
LINES 11, 12, 13 BY:

RETURN( (A+B)/2);

┴NYWAY, WE MENTIONED THAT PRINTF(),
SCANF(), GETCHAR() AND MAIN() WERE
┴╠╠ FUNCTIONS. ╫HEREAS ╫┼ WRITE THE
FUNCTIONS MAIN() AND (IN THIS
EXAMPLE) AVERAGE(), THE OTHERS ARE A
STANDARD PART OF THE ├ LIBRARY.
╘HERE IS NO DIFFERENCE BETWEEN THE
WAY THAT ├ LIBRARY FUNCTIONS AND
USER-WRITTEN ├ FUNCTIONS WORK IN A ├
PROGRAM. ┴ LIBRARY OF FUNCTIONS IS
INCLUDED WITH ALL ├ COMPILERS TO
PROVIDE PREWRITTEN, STANDARD VERSIONS
OF FUNCTIONS WHICH ARE COMMONLY
REQUIRED BY MOST ├ PROGRAMS. ╙OME
COMPILERS WILL PROVIDE THE ├ SOURCE
CODE FOR THE STANDARD LIBRARY
FUNCTIONS AND SOME WILL NOT. ╩UST
REMEMBER THAT THESE STANDARD LIBRARY
FUNCTIONS ARE NO DIFFERENT THAN THE
ONES YOU WILL WRITE FOR YOUR OWN
PROGRAMS. ╫HEN YOU BECOME SKILLFUL
ENOUGH IN ├ PROGRAMMING YOU MAY WELL
DECIDE TO WRITE YOUR OWN VERSIONS OF
THE STANDARD LIBRARY FUNCTIONS TO
REPLACE ONES THAT CAME WITH YOUR
COMPILER.

╒SER-WRITTEN FUNCTIONS PERFORM TASKS
REQUIRED BY A SPECIFIC PROGRAMMING
TASK. ╘HESE FUNCTIONS CAN ALSO BE
PLACED IN A LIBRARY MAINTAINED BY THE
PROGRAMMER TO HAVE THEM AVAILABLE FOR
FUTURE PROGRAMMING TASKS. ╧NCE USER-
WRITTEN FUNCTIONS ARE AVAILABLE FROM
A LIBRARY THEY MAY BE CALLED BY A ├
PROGRAM IN THE SAME MANNER AS THE
ORIGINAL ├ LIBRARY FUNCTIONS THAT
CAME WITH THE COMPILER. ═OST ├
COMPILERS HAVE A LIBRARY UTILITY FOR
THE PURPOSE OF MAINTAINING USER-
WRITTEN FUNCTIONS IN LIBRARY FORM.


╙OME ├-COMPILERS AUTOMATICALLY GIVE
YOUR MAIN() PROGRAM ACCESS TO THE
STANDARD INPUT OUTPUT ( STDIO )
ROUTINES SUCH AS PRINTF(), ETC. ┬╒╘,
═╧╙╘ ─╧ ╬╧╘.

╘O BE SURE THAT YOU INCLUDE THESE
STDIO FUNCTIONS IN YOUR MAIN()
PROGRAM (ASSUMING YOU WILL BE USING
THEM) YOU SHOULD BEGIN YOUR
PROGRAM...

#INCLUDE <STDIO.H>  /* ╒SE THIS! */
MAIN()
........
........


╫HEN THE ├-COMPILER SEES THE #INCLUDE
<STDIO.H> IT WILL APPEND TO YOUR
MAIN() PROGRAM ALL THE INPUT-OUTPUT
FUNCTIONS IN THE ├ LIBRARY.
─ON'T FORGET #INCLUDE <STDIO.H>. ╔T
MAY ALSO BE WRITTEN IN THE FORMAT
#INCLUDE "STDIO.H". ├HECK YOUR
COMPILER DOCUMENTATION FOR DETAILS.

╘HE USE OF THE LINE:

#INCLUDE...

IN A ├ PROGRAM IS AN INSTRUCTION TO A
PART OF THE COMPILER CALLED A
'PREPROCESSOR'. ╘HE #INCLUDE
INSTRUCTION TO THE PREPROCESSOR TELLS
IT TO FIND THE SPECIFIED FILE AND ADD
THAT WHOLE FILE TO YOUR PROGRAM. ╘HIS
USUALLY MEANS THAT THE HEADER FILE
MUST BE LOCATED ON THE SAME DISK AS
YOUR PROGRAM SOURCE FILE WHEN BEGIN
TO COMPILE IT BUT SEE YOUR COMPILER
DOCUMENTATION FOR DETAILS.

╔T IS STANDARD PRACTICE TO CALL THESE
#INCLUDE'D FILES 'HEADER' FILES. ╘HEY
ARE CALLED HEADER FILES BECAUSE THEY
APPEAR AT THE HEAD OF A PROGRAM. ╘O
DESIGNATE THESE HEADER FILES IT IS
STANDARD PRACTICE TO GIVE THE
FILENAMES OF HEADER FILES AN
EXTENSION OF '.H' AS YOU SAW ABOVE
FOR THE STANDARD INPUT-OUTPUT HEADER
FILE (IE. STDIO.H).


╬OW, IF PRINTF() AND SCANF() AND
AVERAGE() ETC. CAN BE PASSED
ARGUMENTS, WHY NOT MAIN() ???
┴S A MATTER OF FACT, WE ├┴╬ PASS
ARGUMENTS TO MAIN().

╙UPPOSE YOUR MAIN() PROGRAM WAS
EXPECTED TO ADD A SERIES OF NUMBERS
AND THAT YOU COMPILED/LINKED IT WITH
THE NAME SUM. ╬OW YOU COULD RUN THE
SUM PROGRAM BY TYPING ITS NAME, SUM,
AFTER WHICH A SCANF() FUNCTION CALL
(IN THE PROGRAM) WOULD INPUT THE
NUMBERS WHICH WERE TO BE ADDED. ╘HEN
YOUR PROGRAM WOULD PRINTF() THE SUM.

┬╒╘, WOULDN'T IT BE NICE TO RUN THE
SUM PROGRAM BY TYPING:

SUM  10.5 -15.23 6.7

...ON THE COMMAND LINE AND HAVE THE
SUM PROGRAM RUN, AND ALSO HAVE THE
NUMBERS 10.5 -15.23 AND 6.7 PASSED
TO THE PROGRAM AS  ARGUMENTS?
╫E'LL TALK ABOUT HOW TO DO THIS.


╘HE MAIN() ARGUMENTS -

╚ERE WE #INCLUDE THE STDIO.H LIBRARY
(WE'LL NEED THIS STUFF).

0  #INCLUDE <STDIO.H>
1  MAIN(NUMBER,TERM)
   /* NUMBER & TERM ARE ┴╥╟╒═┼╬╘╙
      OF THE FUNCTION MAIN()    */
2  INT NUMBER;
   /* FIRST MAIN() ARGUMENT     */
3  CHAR *TERM[];
   /* SECOND MAIN() ARGUMENT    */
4  █
   /* OPENING BRACKET OF MAIN() */

╘HE FIRST ARGUMENT (HERE CALLED
NUMBER) IS ┴╠╫┴┘╙ AN INTEGER!  ╘HE
SECOND ARGUMENT (HERE CALLED TERM) IS
┴╠╫┴┘╙ DECLARED AS:

CHAR *NAME[];

...NAME OF SECOND ARGUMENT GOES IN
HERE (IN OUR EXAMPLE, IT'S TERM).
┬┼├┴╒╙┼ IT IS DECLARED CHAR *TERM WE
SEE THAT TERM IS A POINTER!  ┬┼├┴╒╙┼
WE REFER TO IT AS TERM[] WE SEE THAT
TERM IS AN ┴╥╥┴┘!

╔N FACT, THE SECOND ARGUMENT IS
┴╠╫┴┘╙ AN ┴╥╥┴┘ OF ╨╧╔╬╘┼╥╙ WHICH
POINT TO CHARACTER STRINGS (THAT'S
WHY WE SAID CHAR).  ╔F WE CALLED UPON
OUR (COMPILED/LINKED) PROGRAM WITH
THE COMMAND STRING:

SUM  10.5 -15.23 6.7

THEN THIS CONTAINS 4 ELEMENTS, NAMELY:

SUM AND 10.5 AND -15.23 AND 6.7

...(SEPARATED BY A SPACE).

╔T IS THE NUMBER 4 WHICH GETS PASSED
TO MAIN() AS ITS FIRST ARGUMENT!
(..IN OUR EXAMPLE, NUMBER IS THE
INTEGER 4). ┴ND THE SECOND ARGUMENT?
╘HE SECOND ARGUMENT WHICH GETS PASSED
TO MAIN() IS (ARE?) THE STRINGS:

SUM AND 10.5 AND -15.23 AND 6.7

┬╒╘, MAIN() RECEIVES THIS LIST OF
STRINGS AS AN ┴╥╥┴┘ OF ╨╧╔╬╘┼╥╙.
(╥EMEMBER THAT IN ├ THE FIRST ELEMENT
IN AN ARRAY IS ELEMENT NUMBER ZERO).

TERM[0] POINTS TO THE STRING SUM
TERM[1] POINTS TO THE STRING 10.5
TERM[2] POINTS TO THE STRING -15.23
TERM[3] POINTS TO THE STRING 6.7

╬╧╘┼: WHEN WE REFER TO THE STRING
-15.23 WE MEAN A COLLECTION OF 7
CHARACTERS: '-' AND '1' AND '5' AND
'.' AND '2' AND '3' AND '\0'.
(REMEMBER THE '\0' WHICH TERMINATES
STRINGS?) ╫E MAY PICK OUT THE NUMBERS
10.5 AND -15.23 ETC. BY REFERRING TO
TERM[1] AND TERM[2] ETC.

╧F COURSE, THEY ARE ╬╧╘ (REALLY)
NUMBERS (?!@#$) BUT STRINGS OF ┴╙├╔╔
CHARACTERS. ╘O ADD THEM UP, WE MUST
CONVERT THEM TO FLOATING POINT
NUMBERS....


╙OME ╙╒═ PROGRAMMING ...
╚ERE IS THE COMPLETE PROGRAM WITH
BOTH REMARKS AND INSERTED
EXPLANATIONS:

0  #INCLUDE <STDIO.H>
1  MAIN(NUMBER,TERM)
2  INT NUMBER;
   /* FIRST  MAIN() ARGUMENT */
3  CHAR *TERM[];
   /* SECOND MAIN() ARGUMENT */
4  █
   /* ╬╧╫ START MAIN()   */
5  FLOAT NEXT, SUM=0;
   /* COUPLE OF FLOATS   */
6  INT N;
   /* AN INT TO COUNT TERMS  */
7  FOR (N=1; N<NUMBER; N++) █
   /* LOOP THRU' TERMS   */
╚ERE WE BEGIN OUR LOOP, WHICH SUMS
THE TERMS.  ┬EGINNING WITH TERM[1]
(THE FIRST NUMBER) WE LET N CYCLE
THRU' THE TERMS (INCREMENTING EACH
TIME, WITH N++).

8  NEXT=ATOF(TERM[N]);
   /* ├╧╬╓┼╥╘ NEXT TERM  */
╚ERE'S OUR CONVERSION OF THE ┴╙├╔╔
STRING (ONE FOR EACH NUMBER) TO A
FLOAT. (╘HIS ASCII TO FLOAT FUNCTION
IS PART OF ANY RESPECTABLE ├-LIBRARY
...WHICH IS ONE REASON WHY WE
#INCLUDED STDIO.H).  ╬OTE THAT WE
GIVE TO ATOF() THE POINTER TO THE
┴╙├╔╔ STRING, NAMELY TERM[N] (FOR
EACH VALUE OF N IN OUR FOR-LOOP).

9  SUM=SUM+NEXT;
   /* ADD IT TO SUM  */
╚ERE WE ADD THE FLOAT ( GENERATED IN
╠INE 8 BY ATOF() ) TO OUR SUM ( WHICH
WAS INITIALIZED TO 0 IN ╠INE 5 ).

10 PRINTF("\N%8.3F",NEXT);
   /* PRINT EACH TERM*/
╩UST TO PROVE THAT ATOF() IS DOING
ITS JOB, WE'LL PRINT EACH FLOAT WHICH
IT GENERATES ...EACH ON A \NEWLINE.

11 ▌
   /* END OF FOR-LOOP*/

12 PRINTF("\N╙╒═=%8.3F,SUM);
   /* PRINT THE SUM  */
╫E END THE FOR-LOOP, AFTER WHICH WE
PRINTF() OUR SUM (USING 8 POSITIONS
ON THE SCREEN, AND PRINTING TO 3
DECIMAL PLACES).

13 ▌
   /* END OF MAIN()  */

╞OR READABILITY HERE IS THE PROGRAM
WITHOUT COMMENTS OF ANY KIND AND
FORMATTED,NEARLY,AS ├ SOURCE CODE
LISTINGS SHOULD APPEAR:

#INCLUDE <STDIO.H>

MAIN(NUMBER,TERM)
INT NUMBER;
CHAR *TERM[];
█
  FLOAT NEXT, SUM=0;
  INT N;

  FOR (N=1; N<NUMBER; N++) █
    NEXT=ATOF(TERM[N]);
    SUM=SUM+NEXT;
    PRINTF("\N%8.3F",NEXT);
  ▌
  PRINTF("\N╙╒═=%8.3F,SUM);
▌

╔N RESPONSE TO SUM  10.5 -15.23 6.7,
OUR PROGRAM WILL PRINT:

    10.500
    -15.230
    6.700
╙╒═=   1.970
╬OTE: ┼ACH TERM IS PRINTED AFTER
4 SPACES, AND 4 SPACES WAS JUST
ENOUGH FOR:

╙╒═=

┴LTHOUGH ( IN OUR PROGRAM ) TERM[0]
IS SUPPOSED TO POINT TO THE NAME OF
THE PROGRAM ( IN OUR EXAMPLE IT WAS
SUM ) SOME ├-COMPILERS DO ╬╧╘ PROVIDE
THIS! ╔N PARTICULAR, SOME ═╙-─╧╙
COMPILERS DO ╬╧╘ PASS THE NAME TO THE
COMPILED PROGRAM, SO SOME ├-COMPILERS
RUNNING UNDER ═╙-─╧╙ DO NOT (├┴╬╬╧╘)
IMPLEMENT THIS FEATURE OF THE ├
LANGUAGE. ╔NSTEAD, REFERENCE TO THIS
ZEROTH STRING MAY YIELD GARBAGE OR A
BLANK (╬╒╠╠) STRING. ╞ORTUNATELY,
├ ╨OWER DOES ALLOW YOU TAKE ADVANTAGE
OF COMMAND LINE ARGUMENTS.


[┼ND OF ╠ESSON 7 OF 11]