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

Text File | 1991-03-07 | 13.8 KB | 640 lines

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


╬OTE: SUBSTITUTIONS FOR SPECIAL C
LANGUAGE CHARACTERS:

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

╔NPUT AND ╧UTPUT -

╒SING A WORD PROCESSOR, WE BEGIN OUR
C-PROGRAM WITH MAIN() AND A LEFT
CURLY BRACKET █.  ╬OW WE CAN WRITE A
PROGRAM AND FINISH IT WITH A
RIGHT CURLY BRACKET ▌:

MAIN()
█
.........................
YOUR PROGRAM GOES IN HERE
.........................
▌

┼VERYTHING BETWEEN █ AND ▌
CONSTITUTES ONE FUNCTION AND IN THIS
CASE IT IS THE FUNCTION MAIN().

┼VERY C PROGRAM MUST HAVE A MAIN()
FUNCTION BECAUSE THIS IS WHERE
EXECUTION BEGINS.

┴LL C PROGRAMS ARE COMPOSED OF ONE OR
MORE FUNCTIONS. ╫RITING A TASK, OR A
RELATED SET OF TASKS, IN TERMS OF
FUNCTIONS ALLOWS YOU TO BREAK A
PROGRAM INTO LOGICAL PARTS. ┘OU WILL
FIND THAT THIS MAKES PROGRAM FLOW AND
EXECUTION MUCH EASIER TO TRACE AND
DEBUGGING LESS OF A CHORE.  ╞UNCTIONS
CAN BE SAVED IN A LIBRARY AND REUSED
IN OTHER PROGRAMS. ╫HEN YOUR LIBRARY
IS LARGE ENOUGH WRITING A PROGRAM IS
MADE EASIER BECAUSE YOU CAN CALL ON
ALREADY-WRITTEN FUNCTIONS.

╧NE OF THE THINGS WE WILL WANT TO DO
IS PRINT TO THE SCREEN.  ╘HERE IS A C
COMMAND CALLED 'PRINTF', MEANING
PRINT WITH FORMAT.

PRINTF("THIS IS SOME TEXT TO PRINT.");

╘HE ABOVE COMMAND WILL SIMPLY PRINT:

THIS IS SOME TEXT TO PRINT.

(ALMOST) EVERY C STATEMENT
ENDS IN A SEMI-COLON!

═ORE ON PRINTF -

╘HE FORMAT PART OF PRINTF COMES IN
HANDY IF WE WANT TO PRINT,SAY,A
NUMBER WITH A SPECIFIED NUMBER OF
DECIMAL PLACES.

PRINTF("%D",X);
╘HE SYMBOL '%' INDICATES THAT THE
VALUE OF A VARIABLE IS SUBSTITUTED
HERE. ╘HE 'D' MEANS PRINT THE DECIMAL
NUMBER REPRESENTED BY THE VARIABLE X.

PRINTF("%6D",X);
╘HIS SAYS THE DECIMAL NUMBER X IS
PRINTED TO 6 DIGITS.

╚ERE'S ALMOST A WHOLE PROGRAM:

MAIN()
█
X=1234
PRINTF("THE ANSWER IS %6D",X);
▌

┴ND WE EXPECT THE PROGRAM TO GIVE
THE OUTPUT:

THE ANSWER IS 1234

...BUT IT WON'T ( YET ).
IN FACT, YOUR C-COMPILER WON'T
COMPILE THE PROGRAM!

┴ LOOK AT DATA TYPES -

╫HEN WE WRITE X=1234 WE EXPECT THE C
COMPILER TO RESERVE SOME MEMORY FOR
THE VARIABLE X AND PLACE IN THIS
MEMORY THE NUMBER 1234.  ╔F,
SUBSEQUENTLY, WE WRITE X=12345678,
WILL THIS FIT INTO THE MEMORY
RESERVED FOR THE VARIABLE X?  ╔N
ORDER TO KNOW ,IN ADVANCE,HOW MUCH
MEMORY TO SET ASIDE FOR EACH VARIABLE
WE USE IN OUR C PROGRAM, WE MUST
DECLARE THE VARIABLE TYPE.╔F X IS AN
INTEGER (SO WE WILL NOT SET X=1.234)
THEN WE SAY SO WITH THE DECLARATION:

INT X;

╔F X WILL TAKE ON VALUES LIKE 1.234
(A FLOATING POINT NUMBER) THEN
WE WRITE:

FLOAT X;

╔F X IS A CHARACTER VARIABLE
(FOR EXAMPLE X='A') THEN
WE DECLARE THIS TOO:

CHAR X;

─ECLARING THE DATA TYPE -

NOW WE MAY WRITE:

MAIN()
█
INT X;
X=1234;
PRINT("THE ANSWER IS %6D",X);
▌

┴ND NOW OUR PROGRAM WILL PRINT:

THE ANSWER IS 1234

╫HAT WILL THE FOLLOWING PROGRAM PRINT?

MAIN()
█
FLOAT X;
X=1234;
PRINT("THE ANSWER IS %6D",X);
▌

┬ECAUSE WE DECLARED X TO BE A
FLOATING POINT NUMBER THE VALUE OF X
IS STORED IN A DIFFERENT FORMAT IN
MEMORY. ┴S A FLOAT, X=1234 WILL BE
STORED AS A NUMBER LESS THAN 1
TOGETHER WITH AN EXPONENT
("SCIENTIFIC NOTATION").
╘HE ABOVE PROGRAM WILL PRINT:

THE ANSWER IS 0

MAIN()
█
FLOAT X;
PRINT("THE ANSWER IS %6D",X);
▌

╬OTE THE D.

╘HE PRINTF COMMAND EXPECTED A NUMBER
IN DECIMAL FORMAT.  ┬UT X WAS STORED
IN MEMORY IN FLOAT FORMAT.
╘HE RESULT IS A MISINTERPRETATION
OF THE VALUE OF X BY PRINTF!

MAIN()
█
FLOAT X;
X=1234;
PRINT("THE ANSWER IS %.1F",X);
▌

╬OTE THE F AND THE '.1'.

╘O TELL PRINTF THE FORMAT IN WHICH X
WAS STORED, WE USE AN F AND THE
NUMBER OF PLACES BEFORE AND AFTER THE
DECIMAL IN THE "FORMAT" PORTION OF
THE PRINTF COMMAND (I.E. THE PART
WITHIN QUOTES). ╞OR A FLOAT THE
DEFAULT, OR ASSUMED, FORMAT IS 6
PLACES IF NONE IS SPECIFIED.
╙O THE ABOVE PROGRAM WILL PRINT:

THE ANSWER IS 1234.0

╫HAT WILL THIS PROGRAM PRINT?

MAIN()
█
CHAR X;
X='A';
PRINTF("AS A CHARACTER, X HAS THE
        VALUE %C",X);
▌

╘HE VARIABLE X WAS DECLARED TO BE OF
TYPE CHARACTER AND IT WAS ASSIGNED
THE VALUE 'A'. ╙O THE OUTPUT IS:

┴S A CHARACTER, X HAS THE VALUE A

╔NTEGERS AND ╞LOATS -

FLOAT X;
X=1234+1/2;

╔N THE ABOVE PROGRAM SEGMENT, WHAT
DO YOU THINK THE VALUE OF X IS?
╔T'S 1234.0 !!!
╬UMBERS LIKE 1234 AND 1 AND 2 ARE
AUTOMATICALLY INTEGERS AND
DIVIDING THE LAST TWO WOULD GIVE 0
(DROPPING THE FRACTIONAL PART!) SO
1234+0 GIVES 1234 WHICH (BECAUSE X
IS A FLOATING POINT NUMBER) IS NOW
CONVERTED TO A FLOAT AND ASSIGNED
TO X !!!
╔N ORDER TO YIELD THE VALUE 1234.5
WE INCLUDE THE DECIMAL POINTS:

X=1234.+1./2.;

┴ND NOW ALL NUMBERS ARE FLOATING
POINT AND X WILL BE ASSIGNED THE
VALUE 1234.5, SO ...INCLUDE THE
DECIMAL POINTS WHEN NECESSARY!

FLOAT X;
X=1234+1./2.;

╚ERE THE 1./2. IS EVALUATED AS .5
(A FLOAT, BECAUSE OF THE DECIMAL
POINTS) AND 1234 IS CONVERTED TO A
FLOAT THEN ADDED, GIVING 1234.5
WHICH IS ASSIGNED TO X.

FLOAT X;
X=1234+1./2;

╚ERE, THE DECIMAL ASSOCIATED WITH 1.
CAUSES THE 2 TO BE CONVERTED TO A
FLOAT, SO 1./2 GIVES .5, AND THE
ADDITION OF 1234 (WHICH IS FIRST
CONVERTED TO A FLOAT) GIVES 1234.5,
WHICH IS THEN ASSIGNED TO X.  ╘HE
CONCLUSION? ├ TENDS TO CONVERT
NUMBERS IN A MIXED EXPRESSION TO
FLOATING POINT BEFORE EVALUATION
....BUT DON'T RELY ON IT!  ╔F YOU
WANT FLOATING POINT OPERATIONS
INCLUDE THE DECIMAL POINTS!

╔NPUT FROM THE KEYBOARD WITH SCANF() -

╬OW THAT WE'VE BEEN INTRODUCED TO
PRINTF (WHICH WILL PRINT THINGS ON
THE SCREEN, OR TO THE PRINTER, OR TO
A DISK FILE, AS WE WILL SEE...) WE
SHOULD INTRODUCE SCANF WHICH ALLOWS
US TO INPUT NUMBERS FROM THE
KEYBOARD.

MAIN()
█
CHAR X;
SCANF("%C",X);  /* NOTE THE %C! */
PRINTF("YOU PRESSED THE %C KEY",X);
▌

╔N THE ABOVE THE PHRASE "NOTE THE
%C!" PLACED BETWEEN THE SYMBOL
COMBINATIONS '/*' AND '*/' IS A
COMMENT TO OUR PROGRAM. ╘HIS SERVES
THE SAME PURPOSE AS 'REM' IN THE
┬┴╙╔├ LANGUAGE. ╔T PROVIDES FOR AN
INFORMATIONAL COMMENT TO CLARIFY THE
MEANING OF A PART OF A PROGRAM.
┼VERYTHING PLACED BETWEEN '/*' AND
'*/' IS IGNORED BY THE COMPILER.

╘HE SCANF COMMAND WAITS FOR THE USER
TO TYPE SOMETHING, AND SCANF("%C",X)
PUTS THE CHARACTER TYPED, INTO THE
MEMORY RESERVED FOR THE VARIABLE X.
╫HEN THE COMPILED PROGRAM IS RUN IT
WILL WAIT FOR THE USER TO PRESS A KEY
(FOLLOWED BY THE ENTER KEY).  ╙UPPOSE
YOU RAN THE PROGRAM AND PRESSED THE A
KEY (THEN ENTER).  ╫HAT WOULD THE
PROGRAM PRINT ON THE SCREEN?
YOU PRESSED THE KEY...
...IT DIDN'T WORK!!!

┴BOUT MEMORY LOCATIONS...AND THE
'&' PREFIX -

MAIN()
█
CHAR X;
SCANF("%C",X);
PRINTF("YOU PRESSED THE %C KEY",X);
▌

╫HEN SCANF() IS USED, WE MUST TELL IT
WHERE,IN MEMORY,TO PUT THE CHARACTER
X.SAYING SCANF("%C",X) IS NOT ENOUGH!
╘O IDENTIFY THE MEMORY ADDRESS FOR
THE VARIABLE X, WE PREFIX X WITH &.
╔F X IS ANY VARIABLE (INT OR FLOAT OR
CHAR) THEN &X IS THE ADDRESS IN
MEMORY OF X.

&X=ADDRESS

╘HE ABOVE PROGRAM MUST BE CHANGED
TO READ:

MAIN()
█
CHAR X;
SCANF("%C",&X);   /* NOTE THE &X. */
PRINTF("YOU PRESSED THE %C KEY",X);
▌

...THEN IT WILL WAIT FOR A KEY-PRESS
(FOR EXAMPLE THE LETTER Z) AND PRINT:

YOU PRESSED THE Z KEY

╙INCE CHAR X; RESERVED ONLY ENOUGH
SPACE FOR ONE CHARACTER, WHAT WOULD
THE PRINTOUT BE IF YOU PRESSED
SEVERAL KEYS...SAY PQR?  ╫HEN YOU
PRESSED ENTER KEY...ONLY ONE
CHARACTER IS DISPLAYED!

╫HAT'S WRONG WITH THE FOLLOWING
PROGRAM?

MAIN()
█
INT X;
CHAR Y;
FLOAT Z;
PRINTF("ENTER 3 NUMBERS(SEPARATED
        BY A SPACE)");
SCANF("%D%C%F",&X,&Y,&Z);
PRINTF("X=%C Y=%F Z=%D",X,Y,Z);
▌

╬OTE THAT X, Y AND Z ARE DECLARED
INT, CHAR AND FLOAT.

PRINTF("ENTER 3 NUMBERS(SEPARATED
        BY A SPACE)");

╘HIS LINE JUST PRINTS INSTRUCTIONS:
ENTER 3 NUMBERS(SEPARATED BY A SPACE)

SCANF("%D%C%F",&X,&Y,&Z);

╘HIS LINE WAITS FOR YOU TO TYPE IN
THE 3 NUMBERS.
╬OTE THE '&' REQUIRED BY SCANF()!

PRINTF("X=%C Y=%F Z=%D",X,Y,Z);

╬OW WE PRINTF() THE 3 NUMBERS,
EXPECTING THE PRINTOUT TO APPEAR AS:
X=123 Y=123 Z=123
(ASSUMING THE NUMBERS WERE ALL 123).

╫HAT DO YOU THINK GETS PRINTED ON
THE SCREEN?

┴LAS, WE GAVE PRINTF() THE DATA TYPES
IN THE WRONG ORDER!  ┴LTHOUGH SCANF()
GOT THE INTEGER X AS 123, AND PUT IT
IN THE RIGHT MEMORY LOCATION ('CAUSE
WE SAID &X)...AND IT ALSO GOT Y AS 1
(NOT 123), A SINGLE CHAR.....
(BECAUSE THE Y MEMORY LOCATION ONLY
HOLDS A SINGLE CHARACTER!) AND IT
ALSO GOT Z AND STORED IT AS A
FLOATING POINT NUMBER, AND PUT IT IN
THE CORRECT MEMORY LOCATION.  ╙O WHAT
GETS PRINTED?

MAIN()
█
INT X;
CHAR Y;
FLOAT Z;
PRINTF("ENTER 3 NUMBERS (SEPARATED
        BY A SPACE)");
SCANF("%D%C%F",%X,%Y,%Z);
PRINTF("X=%C Y=%F Z=%D",X,Y,Z);
▌

╘HE PRINTOUT PRODUCED BY THE ABOVE
PROGRAM (AFTER ENTERING 123
FOR EACH OF X, Y AND Z, SEPARATED
BY A SPACE) IS:

X= Y=-2.000000 Z=16478

╙O PRINTF() WAS CONFUSED ONCE MORE!

╞IRST: IT INTERPRETED X AS A
CHARACTER VARIABLE (!) AND OUT CAME
.  (THE ASCII CODE FOR '' IS 123
...BUT MORE ON ASCII LATER).

╙ECOND: IT PRINTED THE CONTENTS OF
SEVERAL MEMORY LOCATIONS, STARTING
WITH THE ONE RESERVED FOR Y (A CHAR)
AS A FLOATING POINT NUMBER (AND OUT
CAME -2.000000).

╘HIRDLY: IT WENT TO THE MEMORY
LOCATION RESERVED FOR Z (WHICH HELD A
FLOATING POINT NUMBER ... IN
"SCIENTIFIC" FORMAT, REMEMBER?) AND
INTERPRETED IT AS AN INTEGER, NAMELY
16478 !!!

╥EVIEW OF PRINTF() AND SCANF() -

PRINTF("TEXT AND 'FORMAT' INFO",
IN HERE ARE THE VARIABLES,IF ANY,
SEPARATED BY COMMAS, TO BE
PRINTED);

┬ETWEEN THE QUOTATION MARKS IS THE
FORMAT INFORMATION REQUIRED BY
PRINTF() FOR THE STRING AND/OR
VARIABLE(S) TO BE PRINTED.  ╘EXT MAY
BE MIXED WITH THE VARIOUS %D, %C AND
%F FORMAT INFORMATION.

SCANF("NO TEXT, JUST 'FORMAT' INFO",
VARIABLE NAMES SEPARATED BY COMMAS);

┬ETWEEN THE QUOTATION MARKS IS THE
VARIABLE TYPE AND FORMAT INFORMATION
FOR SCANF().
SCANF("NO TEXT, JUST 'FORMAT' INFO",
VARIABLE NAMES SEPARATED BY COMMAS);
┴FTER THE QUOTED PART IS THE NAMES OF
THE VARIABLES, LIKE X,Y,Z....RIGHT?
WRONG! WRONG! WRONG!
╔T HAS TO BE THE ADDRESSES OF THE
VARIABLES, LIKE &X,&Y,&Z!
╬OTE: THESE ADDRESSES ARE CALLED
POINTERS,  BECAUSE  THEY 'POINT'
TO THE MEMORY LOCATIONS WHICH ARE
RESERVED FOR THE VARIABLES.

╙OME FINAL COMMENTS ABOUT PRINTF()
AND SCANF() -

╫E SAW, EARLIER IN THIS LESSON, THE
STATEMENT:

PRINTF("THE ANSWER IS %6D",X);

╫E MAY SPECIFY THE NUMBER OF SCREEN
POSITIONS (THE FIELD WIDTH) WHICH THE
NUMBER IS TO OCCUPY WHEN PRINTF() IS
INVOKED (IN THE ABOVE EXAMPLE, IT'S 6
POSITIONS). ╞OR AN INTEGER, THAT'S
ALL THAT'S NECESSARY, BUT FOR A
FLOATING POINT NUMBER WE MAY ALSO
SPECIFY THE NUMBER OF DIGITS AFTER
THE DECIMAL.╔F WE JUST SAY %F THEN
WE WILL GET 6 DECIMAL PLACES BY
DEFAULT.

PRINTF("THE ANSWER IS %.3F",X);

╔N THIS STATEMENT, IF X WERE A FLOAT
AND EQUAL TO 12.3456 THEN WHAT DO YOU
THINK WOULD BE PRINTED?  ╘HE ANSWER
IS 12.346 ROUNDED TO 3 DECIMAL PLACES!

MAIN()
█
FLOAT X;
X=-12.3456;
PRINTF("X=%6.3",X);
▌

╬OTE THAT X=-12.3456 CANNOT BE
PRINTED IN 6 POSITIONS WITH 3 DECIMAL
PLACES.  ╘HE FIRST 6 POSITIONS WOULD
GIVE ONLY X=-12.34 (OR X=-12.35 IF
ROUNDED). ╙INCE PRINTF() IS A SMART
GUY (GAL?) IT ROUNDS THE NUMBER TO
THE FIELD WIDTH AS NECESSARY IN ORDER
TO INCLUDE THE DECIMAL POINT WHICH
ALSO ACCOUNTS FOR ONE POSITION IN THE
FIELD WIDTH ...AND PRINTS:

X=-12.346

╞OR NUMBERS (EITHER INT OR FLOAT) THE
FIELD WIDTH IS UNDERSTANDABLE....BUT
WHAT ABOUT CHAR VARIABLES WHICH ARE
SINGLE CHARACTERS AND WILL ONLY
OCCUPY ONE SCREEN POSITION ANYWAY?

╫HAT DO YOU THING THIS WILL PRINT?

X='Z';
PRINTF("X=%6C",X);

╘HE OUTPUT IS:

X=     Z

╘HE Z IS RIGHT-JUSTIFIED IN
A FIELD WIDTH OF 6!

╙OMETHING CALLED 'CAST' -

╙UPPOSE YOU DESPARATELY NEED TO HAVE
AN INTEGER VARIABLE CONVERTED TO A
FLOATING POINT NUMBER. ═AYBE YOU
WANTED TO COMPUTE THE SINE OF AN INT
CALLED X. USING SIN(X) IS NO GOOD
BECAUSE THE SIN(X) FUNCTION ONLY
WORKS FOR FLOATING X.  ┘OU COULD USE
A "SPARE" FLOAT VARIABLE, SAY:

FLOAT Y;
Y=X;

╫HICH DOES AN AUTOMATIC CONVERSION
WHEN IT ASSIGNS THE X-VALUE TO Y,
FROM INT TO FLOAT. THEN USE:

'SIN(Y)'

╫HICH IS OK SINCE Y IS NOW A FLOAT.
╧R, RATHER THAN HAVING TO DECLARE
'FLOAT Y;' JUST TO HAVE Y IN RESERVE
FOR THIS "CONVERSION" PURPOSE, YOU
MAY USE A CAST.

╘HE STATEMENT 'SIN( (FLOAT)X )', WILL
TEMPORARILY CONVERT THE  INTEGER X TO
A FLOAT (FOR PURPOSES OF COMPUTING
THE SIN) BUT LEAVE X UNCHANGED.  ╘HIS
IS CALLED A CAST (IN C-SPEAK).

INT X;
X=10;

PRINTF("HERE'S AN INTEGER, PRINTED TO
6 DECIMAL PLACES! %.6F",(FLOAT)X);

╘HE ABOVE CASTS THE INTEGER X FOR
PRINTF AS A FLOAT, AND YOU GET THE
OUTPUT:

HERE'S AN INTEGER, PRINTED TO
6 DECIMAL PLACES! 10.000000

┴ FINAL NOTE ON DATA TYPES -

╫E HAVE TALKED ABOUT NUMBERS STORED
(IN MEMORY) IN INT AND FLOAT FORMAT.
HERE ARE SOME OTHERS:

─OUBLE -
╫HEREAS THE INT FORMAT CAN REPRESENT
AN INTEGER IN THE RANGE -32768 TO
32767 (WITH SIGN) AND THE FLOAT
FORMAT CAN HOLD A NUMBER WITH 6
SIGNIFICANT FIGURES  (ROUGHLY) WE
ALSO CAN DECLARE A NUMBER TO BE
DOUBLE WHICH IS AN EXTENDED FLOATING
POINT NUMBER AND GIVES (ABOUT) 13
SIGNIFICANT FIGURES. [NOTE TO USERS
OF ├ ╨OWER - FLOAT AND DOUBLE ARE
IDENTICAL]

╒NSIGNED -
╫E CAN HAVE AN INTEGER WHICH RUNS
FROM 0 TO 65535 BY DECLARING IT TO BE
UNSIGNED (WHICH THEN IS ALWAYS
NON-NEGATIVE). ┴LTHOUGH THIS TYPE
OCCUPIES THE SAME MEMORY SPACE AS
INT, DROPPING THE 'SIGN' ALLOWS FOR
DOUBLE THE MAGNITUDE OF INTEGER.

╠ONG -
WE CAN ALSO HAVE A LONG INT WHICH
OCCUPIES TWICE AS MUCH MEMORY AND CAN
REPRESENT INTEGERS FROM (ABOUT)
-2,000,000,000 TO +2,000,000,000.
[NOTE THAT WITH ├ ╨OWER LONG AND
INT ARE IDENTICAL]

┬ASIC DATA TYPES IN C:

INT      - WHOLE NUMBER
FLOAT    - MAY HAVE FRACTIONAL PART
CHAR     - A CHARACTER (SINGLE BYTE)
LONG     - LONG INTEGER
DOUBLE   - DOUBLE-PRECISION FLOAT
UNSIGNED - POSITIVE INTEGER

╘HE SIZES OF NUMERICAL TYPES MAY
DIFFER FROM ONE MACHINE TO ANOTHER.
┘OU MAY ALSO FIND THAT SOME COMPILERS
DO NOT SUPPORT LONG, DOUBLE, OR
UNSIGNED DATA TYPES.

╥EMEMBER ...(ALMOST) ALL C STATEMENTS
END IN A SEMI-COLON!!!!

[END OF LESSON 1 OF 11]