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

Text File | 1991-03-07 | 8.7 KB | 424 lines

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


╬OTE: SUBSTITUTIONS FOR SPECIAL C
LANGUAGE CHARACTERS:

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


╞OR, WHILE AND OTHER GOOD STUFF -

MAIN()
█  /* OPENING BRACKET OF MAIN() */
  INT I /* DEFINE I AS INTEGER */
  I=1;  /* DECLARE I TO BE 1 */
  WHILE (I<11);
      PRINTF("\N THE SQUARE OF %D IS
             %D",I,I*I);
      I=I+1;

▌ /* CLOSING BRACKET OF MAIN() */

╞IND THE ERROR ABOVE!

INT I SHOULD BE:  INT I;
WE FORGOT THE SEMI-COLON!

INT I;   WITH SEMI-COLON!

╬OW THAT WE'RE DEBUGGING OUR PROGRAM,
LET'S CHANGE THESE LINES SO THAT THE
DECLARATION AND THE INITIALIZATION OF
I ARE TOGETHER:

MAIN()
█
  INT I=1;
  WHILE (I<11) █
    PRINTF("\N THE SQUARE OF %D IS
           %D",I,I*I);
    I=I+1;
  ▌
▌


╚ERE'S SOMETHING NEW...IT SAYS TO
EXECUTE CERTAIN STATEMENTS AGAIN AND
AGAIN AS LONG AS I<11, WHICH MEANS
I LESS THAN 11.

╘HE CONDITION WHICH IS TESTED IN A
WHILE() LOOP APPEARS BETWEEN THE
ROUNDED BRACKETS:

WHILE (CONDITION)
  DO SOMETHING;


┴S LONG AS THE CONDITION IS TRUE THE
LOOP CONTINUES TO REPEAT. ╘HIS MEANS
THAT THE CONDITION WHILE(I>0) CAN BE
REPLACED AS FOLLOWS:

WHILE (I)
  DO SOMETHING;


╫HEN I BECOMES ZERO IT IS FALSE AND
THE LOOP STOPS EXECUTING.

┼XECUTE WHAT STATEMENTS? -

WHILE (I<11) █
  STUFF;
▌

┴LL THE 'STUFF' BETWEEN THESE CURLY
BRACKETS IS EXECUTED.
╘HIS 'STUFF' SAYS TO PRINTF:

THE SQUARE OF 'VALUE OF I' IS
'VALUE OF I*I' /* I TIMES I */


╨RETTY PROGRAMS -

╨ROGRAMS ARE EASIER TO READ WHEN
LINES ARE INDENTED APPROPRIATELY.

MAIN()  /* SEXY PROGRAM */
█   /* START MAIN() */
  INT I=1; /* DECLARE I=1 */
  WHILE (I<11)█   /* WHILE I<11 */
    PRINTF("\N THE SQUARE OF %D IS
            %D",I,I*I);
      /* PRINT I, I*I */
    I=I+1;  /* INCREMENT I */
  ▌  /* END OF WHILE */
▌ /* END OF MAIN  */

┴NYTHING BETWEEN /* AND */ IS A
COMMENT AND IS IGNORED BY THE C-
COMPILER (IT'S FOR HUMAN CONSUMPTION
ONLY) SO WE'VE ADDED A COMMENT TO
EVERY LINE. ╬OW WE CAN SEE WHAT THE
PROGRAM DOES BY READING ONLY THE
COMMENTS!  ╔NDENTING THE VARIOUS
PARTS MAKES FOR EASIER READING (AGAIN
FOR HUMAN CONSUMPTION ...THE
COMPILER DOESN'T CARE).

╘HE START AND END OF MAIN() ARE EASY
TO SPOT  (ALTHOUGH DIFFERENT
PROGRAMMERS USE DIFFERENT FORMATS, WE
WILL ALWAYS START AND END MAIN() WITH
█ AND ▌ IN THE FIRST COLUMN).

...AND WE START A WHILE LOOP WITH:
WHILE (....) █, AND END IT WITH ▌,
PLACED DIRECTLY BELOW THE W IN WHILE.

╫E WILL ALWAYS INDENT (BY 2 SPACES)
THESE INSIDE LOOPS.

╫HY WON'T THE FOLLOWING COMPILE?

MAIN()  /* SEXY PROGRAM */
█     /* START MAIN() */
  INT I=1; /* DECLARE I=1 */
  WHILE (I<11); █  /* WHILE I<11 */
    PRINTF("\N THE SQUARE OF %D IS
           %D",I,I*I);
      /* PRINT I, I*I */
    I=I+1;  /* INCREMENT I */
  ▌  /* END OF WHILE */
▌ /* END OF MAIN  */

╫HEREAS MOST C STATEMENTS END IN A
SEMI-COLON, THE WHILE (...) DOES NOT,
(USUALLY),WE MUST DELETE THE ; AFTER
THE WHILE.

MAIN()  /* SEXY PROGRAM */
█     /* START MAIN() */
  INT I=1;/* DECLARE I=1  */
  WHILE (I<11) █ /* WHILE I<11   */
    PRINTF("\N THE SQUARE OF %D IS
           %D",I,I*I);
      /* PRINT I, I*I */
    I=I+1;  /* INCREMENT I  */
  ▌  /* END OF WHILE */
▌ /* END OF MAIN  */

╘HE CONSTRUCTION:

I=1;
WHILE (I<11) █
  SOME STATEMENTS;
  I=I+1;
▌

╧CCURS SO OFTEN (IN ANY LANGUAGE)
THAT A SLICK MECHANISM EXISTS FOR
HANDLING THIS LOOP:

FOR (I=1; I<11; I=I+1) █
  SOME STATEMENTS;
▌

╘HE PARTS OF A FOR() LOOP:

FOR(A;B;C)

╨ART A: INITIALIZATION OF ONE OR MORE
VARIABLES. ╔F MORE THAN ONE SEPARATE
VARIABLES WITH A COMMA.

╨ART B: CONDITION WHICH IS TESTED.
WHILE THE CONDITION IS TRUE THE LOOP
REPEATS.

╨ART C: OPERATION ON THE LOOP
VARIABLES. ╧FTEN THIS IS TO INCREMENT
OR DECREMENT THEM.

╬ONE OF THE THREE PARTS NECESSARILY
NEEDS TO BE USED BUT THE SEMI-COLONS
MUST BE INCLUDED.

FOR(;;) █
  DO SOMETHING;
▌

╘HIS FOR LOOP WOULD EXECUTE FOREVER,
OR, PRESUMEABLY, UNTIL BROKEN OUT OF
IN THE 'DO SOMETHING' STATEMENTS.

╔N OUR PROGRAM THE FOR LOOP LOOKS
LIKE THIS:

MAIN()  /* SEXY PROGRAM */
█   /* START MAIN() */
  INT I;  /* DECLARE I*/
  FOR (I=1; I<11; I=I+1) █
    /* THE FOR LOOP */
    PRINTF("\N THE SQUARE OF %D IS
           %D",I,I*I);
      /* PRINT I, I*I */
  ▌  /* END OF FOR  */
▌ /* END OF MAIN  */

╬OTE THAT THE FOR LOOP AUTOMATICALLY
INITIALIZES I TO 1, THEN DOES THE
PRINTF() AGAIN AND AGAIN, EACH TIME
INCREMENTING I, UNTIL I HAS THE VALUE
11. ╘HE PROGRAM EXITS FROM THIS LOOP
AFTER PRINTF-ING FOR THE LAST TIME
WITH I=10 BECAUSE THE OPERATOR '<'
SPECIFIES THAT 'I' MUST BE 'LESS
THAN' 11. ╔N THIS CASE THE FOR LOOP
DOES EXACTLY WHAT THE WHILE LOOP DID
ONLY IN A MORE CONCISE FASHION.
╙OMETIMES IT IS MERELY A MATTER OF
STYLE AND CHOICE IN DECIDING WHICH OF
THE TWO, WHILE OR FOR, TO USE IN A
LOOP.

╘HE VALUE OF I, AFTER THE EXIT FROM
THE LOOP, IS 11.  ╘O CHECK IT ALL
OUT, WE LEAVE OUR WORD PROCESSOR
AFTER SAVING THIS SOURCE CODE UNDER
THE NAME PROGRAM2.C, THEN TYPE:

CC PROGRAM2.C

╘HEN (ASSUMING IT COMPILES WITHOUT
ERRORS!) WE FINISH WITH:

LINK PROGRAM2.O

╘HEN WE TYPE:

PROGRAM2

AND THE EXECUTABLE PROGRAM WILL LOAD
FROM DISK, THEN EXECUTE, TO GIVE:

 THE SQUARE OF 1 IS 1
 THE SQUARE OF 2 IS 4
 THE SQUARE OF 3 IS 9
 THE SQUARE OF 4 IS 16
 THE SQUARE OF 5 IS 25
 THE SQUARE OF 6 IS 36
 THE SQUARE OF 7 IS 49
 THE SQUARE OF 8 IS 64
 THE SQUARE OF 9 IS 81
 THE SQUARE OF 10 IS 100

╫HAT ABOUT THIS CASE? -

1 I=5;
2 WHILE (I<5) █
3 SOME STATEMENTS;
4 ▌

╔N THIS PIECE OF CODE, THE WHILE LOOP
WILL BE EXECUTED ONLY AS LONG AS I<5
(IE. I IS LESS THAN 5).  ╙INCE WE SET
I=5 IN LINE 1, THE LOOP WOULD BE
BYPASSED ALTOGETHER!

╘HE CONDITION, IN A WHILE LOOP, IS
CHECKED AT THE BEGINNING OF THE LOOP!

╒SUALLY THIS IS WHAT WE WANT ...BUT,
SOMETIMES IT IS NOT:

WHILE (SAM>100) █
------------------------------------
SOME STATEMENTS WHICH CALCULATE SOME
NUMBERS AND USE THESE TO COMPUTE THE
VALUE OF SAM.
------------------------------------
▌

╔N THIS PIECE OF CODE THE VALUE OF
SAM IS NOT EVEN KNOWN UNTIL WE GO
THROUGH THE WHILE LOOP ...SO WE WANT
TO CHECK THE WHILE-CONDITION AT THE
END OF THE LOOP !!!

─O THIS FOR A WHILE -

╫E REPLACE THE PREVIOUS CONSTRUCTION
BY A DO-WHILE LOOP:

DO █
------------------------------------
SOME STATEMENTS WHICH CALCULATE SOME
NUMBERS AND USE THESE TO COMPUTE THE
VALUE OF SAM.
------------------------------------
▌ WHILE (SAM>100);

╘HE WHILE-CONDITION IS CHECKED AT THE
END OF THE LOOP!

1 DOUBLE X=1.0, Y, E;
  /* DOUBLE PRECISION */
2 DO █ /* START OF THE DO-LOOP */
3   Y=2.0*SIN(X); /* CALCULATE Y */
4   E=FABS(Y-X);
    /* CALCULATE ERROR */
5   X=Y;  /* CHANGE X TO Y */
6 ▌ WHILE (E>.0000005);
  /* END CONDITION  */
7 PRINTF("X-2SIN(X)=%F WHEN X=%F",E,X);

╘HIS PROGRAM SEGMENT CALULATES THE
ROOT OF THE EQUATION:

X-2*SIN(X)=0

╔T STARTS WITH X=1.0, IN LINE 1, THEN
REPEATEDLY REPLACES X BY Y IN LINE 5,
WHERE Y IS CALCULATED AS 2.0*SIN(X)
IN LINE 3.

╫HILE THE CONDITION, THE FLOATING
POINT ABSOLUTE, OR 'FABS', VALUE OF
Y-X, CALCULATED IN LINE 4, IS GREATER
THAN .0000005 WE REPEAT THE LOOP.

╞INALLY, WHEN THE WHILE-CONDITION, IN
LINE 6, IS FALSE (I.E. WHEN E IS
EQUAL TO OR LESS THAN .0000005), WE
PRINT:

X-2SIN(X)=0.000000 WHEN X=1.895494

├ORRECT TO 6 DECIMAL PLACES SINCE A
%FLOAT IS 6 PLACES BY DEFAULT.

╔T'S NICE TO CHECK THE ERROR E AFTER
WE GO THROUGH THE LOOP!

┴ REVIEW -

WHILE (SOMETHING IS TRUE ) █
  DO THESE STATEMENTS;
▌

FOR (INITIALIZE VARIABLES;REPEAT,IF
     THIS IS TRUE;DO THIS AT END OF
     LOOP) █
  DO THESE STATEMENTS;
▌

╬OTE: IF THERE IS ONLY ONE STATEMENT
TO PERFORM, IN EITHER A WHILE OR A
FOR LOOP, THEN WE DON'T NEED THE █
AND ▌.

FOR (I=0; I<11; I=I+1)
  /* NO OPENING █ */
  PRINTF("\N THE SQUARE OF %D IS
         %D",I,I*I);
    /* OR CLOSING ▌ */

DO █
  DO THESE STATEMENTS;
▌ WHILE (SOMETHING IS TRUE);

╬OTE: THE WHILE WHICH OCCURS AT THE
END OF A DO LOOP NEEDS A SEMI-COLON.

╫E CAN ALSO INVOKE A FUNCTION, LIKE
GETCHAR(), AS A CONDITION, INSIDE A
WHILE STATEMENT:

MAIN()
█
  CHAR KEY;
  WHILE ( (KEY = GETCHAR()) != 'E' )
    PRINTF(" YOU PRESSED %C\N",KEY);
PRINTF("\N  THAT'S THE END!");
▌

╬OTE: '!=' MEANS 'NOT EQUAL TO' IN
C-SPEAK.

╫E WAIT FOR A SINGLE KEYPRESS
(THAT'S WHAT GETCHAR() DOES), AND
ASSIGN THE KEY TO THE CHAR VARIABLE
KEY VIA KEY=GETCHAR(), AND SO LONG AS
THE KEY PRESSED IS NOT EQUAL TO THE
LETTER 'E', WE PRINTF() THE KEY  (AS
A %CHARACTER) AND THEN A \NEWLINE.

╬OTE: SCANF("%C",&KEY) WOULD REQUIRE
YOUR PRESSING THE ENTER KEY AFTER
EACH OF THE LETTERS A, B, ETC., SO
WE USED GETCHAR().

╘HIS PROGRAM WOULD GIVE (IF YOU
PRESSED A THEN B THEN C ETC.):

A  YOU PRESSED A
B  YOU PRESSED B
C  YOU PRESSED C
D  YOU PRESSED D
E
   THAT'S THE END!

[END OF LESSON 4 OF 11]