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

Text File | 1991-03-07 | 9.6 KB | 465 lines

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


╬OTE: SUBSTITUTIONS FOR SPECIAL C
LANGUAGE CHARACTERS:

LEFT CURLY BRACKET:   █
RIGHT CURLY BRACKET:  ▌
BACKSLASH:            \
TILDE:                »
VERTICAL BAR:         ▀
UNDERSCORE:           ñ



╞UNCTIONS() -

╫HEN WE BEGIN OUR C PROGRAM WITH
MAIN() WE ARE DEFINING A FUNCTION.
┼XECUTION OF OUR C PROGRAM WILL BEGIN
AT THE STATEMENTS WHICH MAKE UP THIS
FUNCTION (AND IT IS THIS PROPERTY
WHICH MAKES THE NAME MAIN SPECIAL).

MAIN()
█
FLOAT X,Y,A;
PRINTF("\N ENTER TWO NUMBERS
       (SEPARATED BY A SPACE) : ");
SCANF("%F%F",X,Y);
A=AVERAGE(X,Y);
PRINTF("\N THE AVERAGE OF %F AND %F
       IS %F",X,Y,A);
▌

╚ERE WE DEFINE THREE FLOAT VARIABLES
CALLED X, Y AND A.THEN WE PRINTF
INSTRUCTIONS ASKING FOR INPUT (NOTE:
IT IS SCANF() WHICH ACTUALLY WAITS
FOR AND GETS THE INPUT).  ╘HE USER
MUST ENTER A SPACE TO SEPARATE THE
TWO NUMBERS.  (PRESSING THE TAB KEY
BETWEEN NUMBERS WILL ALSO 'SEPARATE'
THEM). ╬OTICE THAT PRINTF() IS A
FUNCTION, JUST LIKE MAIN(). ╫HEN WE
INVOKE THIS FUNCTION WE PASS TO IT A
FORMAT STRING (BETWEEN QUOTES) AND
(SOMETIMES BUT NOT IN THIS CASE) A
LIST OF VARIABLES TO BE PRINTED. ╔N
THIS EXAMPLE THERE IS ONLY THE FORMAT
STRING (WHICH PRINTS A NEWLINE
FIRST):

"\N ENTER TWO NUMBERS (SEPARATED BY
       A SPACE) : "

╬OW WE USE THE FUNCTION SCANF() TO
INPUT THE TWO NUMBERS X AND Y. ╬OTE
THAT SCANF() ALSO REQUIRES A FORMAT
STRING (NAMELY "%F%F") AND A VARIABLE
LIST X,Y.

FLOAT X,Y,A;
PRINTF("\N ENTER TWO NUMBERS
       (SEPARATED BY A SPACE) : ");
SCANF("%F%F",X,Y);

├AN YOU PICK OUT THE ERROR IN THIS
STATEMENT?

╘HE FUNCTION SCANF() REQUIRES THAT WE
PASS TO IT THE  ADDRESSES OF X AND Y
BY USING &X AND &Y...REMEMBER?

╘HEREFORE:

SCANF("%F%F",X,Y);

╙HOULD BE:
SCANF("%F%F",&X,&Y);

╥EMEMBER!!

╚ERE WE SEE ANOTHER FUNCTION CALLED
AVERAGE(). WE PASS TO THIS FUNCTION
THE VALUES OF TWO VARIABLES, X AND Y.

SCANF("%F%F",&X,&Y);
A=AVERAGE(X,Y);

╘HE C LANGUAGE RECOGNIZES A FUNCTION
BY THE FACT THAT IT IS GIVEN A NAME
(LIKE MAIN, SCANF, PRINTF OR AVERAGE)
FOLLOWED IMMEDIATELY BY PARENTHESES
(....). WITHIN THE ( AND THE ) IS
INFORMATION WHICH IS PASSED TO THE
FUNCTION.  ╒NLIKE SCANF() AND
PRINTF() (WHICH ARE INCLUDED IN THE C
LIBRARY OF FUNCTIONS AND ARE
AVAILABLE FOR OUR USE), THE FUNCTION
WHICH WE ARE CALLING AVERAGE() IS ONE
WHICH WE MUST WRITE OURSELVES.

MAIN()
█
FLOAT X,Y,A;
PRINTF("\N ENTER TWO NUMBERS
       (SEPARATED BY A SPACE) : ");
SCANF("%F%F",&X,&Y);
/* NOTE: WE'VE CHANGED TO &X,&Y */
A=AVERAGE(X,Y);
PRINTF("\N THE AVERAGE OF %F AND %F
       IS %F",X,Y,A);
▌

╘HE FUNCTIONS SCANF() AND PRINTF()
PERFORM THEIR TASK AND RETURN
NOTHING, BUT OUR FUNCTION AVERAGE()
IS EXPECTED TO RETURN THE AVERAGE OF
THE TWO VARIABLE VALUES WE PASSED TO
IT.

╔N OUR PROGRAM ABOVE WE ASSIGN THIS
'RETURNED AVERAGE' TO THE FLOAT
VARIABLE WE ARE CALLING 'A'....AND
PASS TO PRINTF() A FORMAT STRING,
"\NTHE AVERAGE OF %F AND %F IS %F",
INDICATING THAT WE WANT CERTAIN TEXT
PRINTED (AFTER A NEWLINE) AS WELL AS
3 %FLOAT NUMBERS.

╘HE VARIABLE LIST WHICH WE PASS TO
PRINTF() (NAMELY X,Y,A) TELLS
PRINTF() WHICH 3 %FLOAT VALUES ARE TO
REPLACE THE 3 %F WHICH OCCUR IN THE
'FORMAT' INFORMATION.

╫RITING THE FUNCTION AVERAGE() -

╠IKE THE FUNCTION MAIN(), WE BEGIN
WITH AVERAGE() AND AN OPENING █. ┬UT,
UNLIKE MAIN(), THE FUNCTION AVERAGE
IS TO RECEIVE TWO VARIABLES....SO,
BEFORE OUR OPENING █, WE WRITE:

AVERAGE(X,Y)
FLOAT X,Y;
█  /* THE OPENING  OCCURS AFTER THE
      DECLARATION FLOAT X,Y */


╘HE FIRST STATEMENT IN A FUNCTION
EVEN BEFORE THE █ MUST BE A
DECLARATION OF THE ARGUMENT TYPES!
╔F THE BRACKETS () FOLLOWING A
FUNCTION NAME CONTAINS ONE OR MORE
VARIABLES THEN THAT FUNCTION HAS ONE
OR MORE ARGUMENTS.

╠ET'S CONTINUE WRITING OUR AVERAGE()
FUNCTION:

AVERAGE(X,Y)
FLOAT X,Y;
█
FLOAT Z;
Z=(X+Y)/2;
RETURN(Z);
▌

╘HE FLOAT Z; (WITHIN THE BODY OF OUR
FUNCTION) DECLARES THE VARIABLE Z TO
BE A FLOAT.

FLOAT Z;
Z=(X+Y)/2;

╘HE 'Z=(X+Y)/2' ASSIGNS TO Z THE
AVERAGE OF X AND Y.

Z=(X+Y)/2;
RETURN(Z);

╘HE 'RETURN(Z);' WILL RETURN THE
VALUE OF Z (SO IT CAN BE USED IN OUR
MAIN() PROGRAM.

╘HE WHOLE THING, INCLUDING MAIN(), IS
NOW:

MAIN()
█
FLOAT X,Y,A;
PRINTF("\N ENTER TWO NUMBERS
       (SEPARATED BY A SPACE) : ");
SCANF("%F%F",&X,&Y);
A=AVERAGE(X,Y);
PRINTF("\N THE AVERAGE OF %F AND %F
       IS %F",X,Y,A);
▌ /* NOTICE THAT MAIN() ENDS HERE */

AVERAGE(X,Y)
FLOAT X,Y;
█
FLOAT Z;
Z=(X+Y)/2;
RETURN(Z);
▌

┴CTUALLY, THIS PROGRAM WON'T (QUITE)
WORK...BUT LET'S SEE HOW TO GET IT TO
COMPILE AND RUN.

╚OW TO COMPILE -

╫E SAVE OUR PROGRAM ON DISK AND LEAVE
OUR WORD PROCESSOR, GIVING OUR
PROGRAM A NAME: PROGRAM1.C ( NOTE THE
NECESSARY '.C' ).

╘HEN WE WOULD ASK THE C-COMPILER TO
COMPILE IT, WITH THE COMMAND:

CC PROGRAM1.C

╬OTE: THE COMPILER COMMAND 'CC' MAY
BE DIFFERENT FOR YOUR OWN COMPILER.

╔F YOU ARE USING ├ ╨OWER AND YOU ARE
EITHER USING TWO DRIVES, OR, HAVE PUT
THE COMPILER PROGRAM PLUS THE HEADER
FILES AND YOUR SOURCE CODE ALL ON ONE
DISK, THEN YOU CAN USE THE COMMAND:
CC -P PROGRAM1.C
AND YOU WON'T BE PROMPTED TO SWAP
DISKS DURING COMPILATION.

╫ITH THIS COMMAND THE COMPILER LOOKS
FOR A FILE ON THE DISK WITH THE NAME
PROGRAM1.C AND GENERATES A FILE
CALLED PROGRAM1.O ( AN OBJECT FILE).

┴FTER THE COMPILER HAS DONE ITS THING
IT'S OUR TURN AGAIN.

╫E ASK TO LINK THE OBJECT FILE BY
ISSUING THE COMMAND:

LINK PROGRAM1.O

╔F YOU ARE USING ├ ╨OWER AND YOU
WISH TO RUN THE PROGRAM OUTSIDE OF
THE SHELL YOUR COMMAND LINE SHOULD
BE: LINK -S PROGRAM1.O

╘HE LINKER WORKS ON THE PROGRAM1.O
FILE AND GENERATES AN EXECUTABLE
PROGRAM CALLED:  PROGRAM1.COM

╞INALLY, WE MAY ISSUE THE COMMAND:

PROGRAM1

TO RUN OUR PROGRAM.

╬OTE: THE  COMMANDS  NECESSARY  TO
COMPILE  AND  LINK,  AND THE EVENTUAL
NAME OF THE EXECUTABLE PROGRAM, MAY
VARY FROM ONE C-COMPILER TO ANOTHER.

╘HE REASON FOR THE 2-STEP PROCESS OF
COMPILE THEN LINK IS THAT WE MAY
WRITE (FOR EXAMPLE) THE AVERAGE()
FUNCTION SEPARATELY, AND COMPILE IT
SEPARATELY (GENERATING AN OBJECT
FILE, SAY AVERAGE.O, THEN LINK THE
MAIN() FUNCTION TO THE AVERAGE()
FUNCTION BY ISSUING THE COMMAND:

LINK PROGRAM1 AVERAGE

(WHERE WE HAVE CALLED THE MAIN()
FUNCTION PROGRAM1.C WHEN WE SAVED IT
TO DISK BEFORE LEAVING THE WORD
PROCESSOR/TEXT EDITOR).

╬OW SUPPOSE WE HAVE (SUCCESSFULLY)
COMPILED AND LINKED PROGRAM1
(OUR PROGRAM WILL ACTUALLY COMPILE
WITHOUT ANY ERROR MESSAGES).

╫E HAVE ON DISK PROGRAM1.COM WHICH WE
EXECUTE BY ISSUING THE COMMAND:

PROGRAM1

╘HE PROGRAM WILL PRINT:

(FIRST CURSOR WAITS FOR 2 NUMBERS)
ENTER TWO NUMBERS (SEPARATED BY A
SPACE) :

╫E TYPE:

21 22  (LEAVING A SPACE BETWEEN).

╘HEN PRESS THE ENTER (OR RETURN) KEY
AND EXPECT TO GET:

THE AVERAGE OF 21.000000 AND
22.000000 IS 21.500000

╧UR PROGRAM STATEMENT WAS:

PRINTF("\N THE AVERAGE OF %F AND %F
       IS %F",X,Y,A);

(AND THE %F GIVES 6 DECIMAL
PLACES...BY DEFAULT ).

┴LAS, WHAT WE GET IS:

THE AVERAGE OF 21.000000 AND
22.000000 IS 21.000000

╠ET'S LOOK AT THE FUNCTION AVERAGE()
AGAIN:

AVERAGE(X,Y)
FLOAT X,Y;
█
FLOAT Z;
Z=(X+Y)/2;
RETURN(Z);
▌

╥EMEMBER THIS:

┴LL FUNCTIONS WILL RETURN AN INTEGER
UNLESS YOU SAY OTHERWISE!


╙O, THE VALUE OF Z WHICH AVERAGE()
RETURNED WAS CHANGED FROM 21.5 ( THE
FLOATING POINT AVERAGE OF THE TWO
FLOATING POINT NUMBERS 21 AND 22 ) TO
21. ╘HE FRACTIONAL PART WAS TRUNCATED
SINCE ( UNLESS WE SAY OTHERWISE ) OUR
FUNCTION RETURNS AN INTEGER!

┴ND HOW DO WE TELL THE C-COMPILER
THAT AVERAGE() IS TO RETURN A
FLOATING POINT NUMBER?

╫E WRITE THE AVERAGE() FUNCTION WITH
A TYPE DECLARATION BUILT INTO ITS
NAME!

FLOAT AVERAGE(X,Y)
/* NOTE THE FLOAT */
FLOAT X,Y;
█
FLOAT Z;
Z=(X+Y)/2;
RETURN(Z);
/* NOW RETURN(Z) GIVES A FLOAT */
▌

╞UNCTIONS HAVE A PRIVATE COPY OF
THEIR ARGUMENTS -

MAIN()
█
FLOAT X,Y,A;
PRINTF("\N ENTER TWO NUMBERS
       (SEPARATED BY A SPACE) : ");
SCANF("%F%F",&X,&Y);
A=AVERAGE(X,Y);
PRINTF("\N THE AVERAGE OF %F AND %F
       IS %F",X,Y,A);
▌
FLOAT AVERAGE(X,Y);
FLOAT X,Y;
█
FLOAT Z;
Z=(X+Y)/2;
RETURN(Z);
▌

┴LTHOUGH WE CALLED THE TWO ARGUMENTS
OF AVERAGE()  X  AND  Y (JUST AS
MAIN() DID), THIS IS NOT NECESSARY!
╘HE FUNCTION AVERAGE() ONLY GETS A
COPY OF THE VARIABLES WHICH APPEAR IN
ITS ARGUMENT LIST AND MAY GIVE THESE
COPIES ANY NAME IT LIKES  (THEY ARE
NOT THE ORIGINAL  X  AND  Y  WHICH
MAIN() USES!).

╘HE ABOVE PROGRAM MIGHT BE CHANGED TO
READ:

MAIN()
█
FLOAT X,Y,A;
PRINTF("\N ENTER TWO NUMBERS
       (SEPARATED BY A SPACE) : ");
SCANF("%F%F",&X,&Y);
A=AVERAGE(X,Y);
PRINTF("\N THE AVERAGE OF %F AND %F
       IS %F",X,Y,A);
▌
FLOAT AVERAGE(SAM,SALLY)
FLOAT SAM, SALLY;
█
FLOAT GEORGE;
GEORGE=(SAM+SALLY)/2;
RETURN(GEORGE);
▌

╙INCE COPIES OF CHAR AND INT AND
FLOAT VARIABLES ARE PASSED TO A
FUNCTION, THE FUNCTION MAY MANIPULATE
THESE VARIABLES AS IT SEES FIT. ╘HE
ORIGINAL VALUES REMAIN  UNCHANGED.
╘HIS  MECHANISM  FOR CALLING A
FUNCTION AND PASSING VARIABLES IS
CALLED : CALL BY VALUE.

╘HE EXCEPTION OCCURS WHEN WE PASS A
STRING VARIABLE TO A FUNCTION. ╔N
THIS CASE, SINCE A STRING MAY BE
ARBITRARILY LONG (!), IT SEEMS
INEFFICIENT TO PROVIDE A COPY OF THE
STRING ... SO C WILL PASS THE ADDRESS
IN MEMORY WHERE THE STRING BEGINS.
THIS IS CALLED : CALL BY REFERENCE.

├ALL BY VALUE IS A MIXED BLESSING. ╫E
CANNOT (FOR EXAMPLE) CALL UPON AN
EXCHANGE(X,Y) FUNCTION TO EXCHANGE
THE VALUES OF INT VARIABLES X AND Y:

EXCHANGE(X,Y)
INT X, Y;
█
INT TEMP;
TEMP=X;
X=Y;
Y=TEMP;
RETURN;
▌

╚ERE, THE VALUES OF X AND Y ARE ONLY
EXCHANGED IN EXCHANGE(), NOT IN
MAIN().  ┬UT DON'T DESPAIR, THERE ARE
WAYS AROUND THIS AS WE WILL SEE IN
THE FOLLOWING LESSONS.


[END OF LESSON 3 OF 11]