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

Text File | 1991-03-07 | 12.1 KB | 541 lines

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


╬OTE: SUBSTITUTIONS FOR SPECIAL C
LANGUAGE CHARACTERS:

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



╙TRINGS 'N' THINGS -

╫HEN WE DECLARE:

CHAR X;

╫E TELL THE C COMPILER THAT X IS A
CHARACTER VARIABLE (SO WE MAY DEFINE
X='Z'; FOR EXAMPLE).

┬UT WHAT IF WE WISH TO ASSIGN TO X
THE STRING: 'HELLO' ?  ╔N ORDER TO
IDENTIFY A STRING (AS OPPOSED TO A
SINGLE CHARACTER) WE WRITE:

X="HELLO";

╒SING THE DOUBLE QUOTE AND WE TELL
PRINTF() TO PRINT X USING A STRING
FORMAT, %S:

MAIN()
█
CHAR X;     /* DECLARE
               CHAR X; AS USUAL */
X="HELLO";  /* USE DOUBLE
               QUOTES TO DEFINE X */

PRINTF("STRING X IS %S.",X);
/* USE %S TO PRINTF A STRING */

/* REMEMBER THIS IS A COMMENT IGNORED
   BY THE COMPILER */
▌

╘HE ABOVE PROGRAM (WHEN COMPILED AND
RUN) PRINTS:

STRING X IS HELLO.

╔T HAS THE SAME FORMAT AS THE
DECLARATION OF A SINGLE CHARACTER
VARIABLE!  (LESSON 6 WILL PROVIDE
MORE DETAIL). ╘HIS DECLARATION OF A
STRING X MAY NOT BE ACCEPTABLE TO
YOUR PARTICULAR C-COMPILER.

─OUBLE QUOTES AND STRINGS, SINGLE
QUOTES AND CHARACTERS -

├ONSIDER THE FOLLOWING:

MAIN()
█
CHAR X,Y;   /* X, Y ARE BOTH CHAR */
X="A";      /* X IS IN DOUBLE
               QUOTES */
Y='A';      /* Y IS IN SINGLE
               QUOTES */
PRINTF("X IS %S AND Y IS %S",X,Y);
/* BOTH PRINTED AS A %STRING? */
▌

╫HAT DO YOU THINK WILL BE PRINTED?

X IS A AND Y IS

╘HE X-STRING IS OK..BUT NOT THE Y!

╔F X IS DEFINED AS A STRING (USING
THE DOUBLE QUOTES) AND IS PRINTED
(VIA PRINTF()) USING THE %STRING
FORMAT, THEN THE PRINTOUT IS OK. ┬UT
IF Y IS DEFINED AS A SINGLE CHARACTER
(USING SINGLE QUOTES) BUT IS PRINTED
USING THE %STRING FORMAT THEN
PRINTF() GETS CONFUSED (..OR MAYBE
IT'S WE WHO ARE CONFUSED!).  ╘HIS
SAYS SOMETHING INTERESTING ABOUT
PRINTF().

╫HEN WE TELL PRINTF() TO PRINT A
%STRING (EITHER X OR Y) PRINTF()
EXPECTS THE ADDRESS OF THE FIRST
CHARACTER OF THE STRING. ╫HEN WE ASK
TO PRINTF() A %CHARACTER IT EXPECTS
THE ACTUAL CHARACTER ITSELF.

╫E NORMALLY DON'T WORRY ABOUT
THIS...JUST DEFINE THE VARIABLE X AS
A STRING (USING DOUBLE QUOTES) AND
ASK PRINTF() FOR THE %S FORMAT AND,
AUTOMATICALLY, THE ADDRESS OF X IS
GIVEN TO PRINTF() AND PRINTING BEGINS
WITH THE FIRST CHARACTER FOUND AT
THAT ADDRESS AND CONTINUES UNTIL THE
LAST CHARACTER (...AND HOW DOES
PRINTF()  KNOW WHEN IT HAS REACHED
THE LAST CHARACTER? ... PATIENCE).

╔F  WE DEFINE Y USING SINGLE QUOTES
AND USE THE %C FORMAT IN PRINTF()
THAT'S OK TOO. ╘HE C LANGUAGE LOOKS
AFTER GIVING THE ACTUAL CHARACTER TO
PRINTF() (RATHER THAN THE ADDRESS).


X="Z";  /* X IS IN DOUBLE QUOTES */
PRINTF("X IS %S",X);

X IS Z
/* THIS IS THE PRINTOUT..OK! */

╔F %S IS USED IN THE PRINTF()
STATEMENT, AND IF X IS DECLARED AND
DEFINED AS A STRING, THEN C WILL LOOK
AFTER GIVING TO PRINTF() THE ADDRESS
WHERE X IS STORED.

╬OW CONSIDER:

Y='Z';  /* Y IS IN SINGLE QUOTES */
PRINTF("Y IS %C",Y);

Y IS Z
/* THIS IS THE PRINTOUT..OK! */

╚ERE Y IS IN SINGLE QUOTES (HENCE A
SINGLE CHARACTER) AND THE %C TELLS
PRINTF() THAT THE 'VALUE' OF Y WHICH
IT RECEIVES IS TO BE INTERPRETED AS
THE ACTUAL CHARACTER ITSELF (IN THIS
EXAMPLE, THE CHARACTER Z), SO A Z IS
(CORRECTLY) PRINTED.

╬OW CONSIDER:

Y='Z';  /* Y IS IN SINGLE QUOTES */
PRINTF("Y IS %S",Y);

Y IS
/* THIS IS THE PRINTOUT NOT OK! */

╬OW Y IS A SINGLE CHARACTER (Z, IN
SINGLE QUOTES)  BUT BECAUSE WE ASKED
TO HAVE IT PRINTED AS A %STRING,
PRINTF() GOES TO THE MEMORY ADDRESS
GIVEN BY THE 'VALUE' OF Y AND PRINTS
CHARACTERS ON THE SCREEN (ACCORDING
TO THE NUMBERS IT FINDS IN MEMORY)!
╘HE 'VALUE' GIVEN TO PRINTF() WAS
USED AS A POINTER INSTEAD OF THE
ACTUAL CHARACTER TO BE PRINTED...AND
PRINTF() WENT TO SOME STRANGE ADDRESS
IN MEMORY TO FIND THE %STRING TO
PRINT!!

┼VEN IF WE DO IT RIGHT AND DEFINE A
STRING WITH DOUBLE QUOTES AND USE %S
IN THE PRINTF() FORMAT (SO THE
ADDRESS OF THE BEGINNING OF OUR
STRING IS PASSED TO PRINTF())
THEN....  HOW DOES PRINTF() KNOW WHEN
IT HAS COME TO THE END OF OUR
STRING??

╚OW DOES A STRING END? -

╫HEN WE SAY X="HELLO"; THE C COMPILER
WILL PUT THE CORRECT 'VALUES' FOR THE
CHARACTERS H, E, L, L, O INTO MEMORY
AND ADD, AT THE END (AFTER THE O) THE
'VALUE' 0.  IT IS THIS 'VALUE' 0
WHICH SIGNALS THE END OF THE STRING.


╬OTE: EVERY CHARACTER SUCH AS A, B,
Z, #, ETC.  HAS A CERTAIN 'VALUE' (OR
'NUMBER') ASSOCIATED WITH IT. ╔N
ASCII (AMERICAN STANDARD CODE FOR
INFORMATION INTERCHANGE) THE 'VALUE'
OR 'NUMBER' ASSOCIATED WITH A IS 65
(IN DECIMAL) AND THE 'VALUE' OR
'NUMBER' ASSOCIATED WITH 0 IS 48 (IN
DECIMAL).  ╬OTICE THAT IT IS NOT THE
'NUMBER' 0 WHICH IS ASSOCIATED WITH
THE CHARACTER 0 BUT RATHER THE
'NUMBER' 48! ╙O...THE 0 WHICH
TERMINATES STRINGS CANNOT BE CONFUSED
WITH THE CHARACTER  0.  ┴FTER ALL,
THE STRING MAY, IN FACT, BE DEFINED
BY: X="10" WHICH WILL BE STORED IN
MEMORY AS THE TWO 'NUMBERS'
ASSOCIATED WITH THE TWO CHARACTERS 1
AND 0 (NAMELY THE TWO 'NUMBERS' 49
48) FOLLOWED BY THE TERMINATING
NUMBER 0.

╔T IS POSSIBLE TO DEFINE A STRING BY
DEFINING AN ARRAY OF SINGLE
CHARACTERS. ┴LTHOUGH WE WILL TALK
(LATER) ABOUT ARRAYS, NOW IS AN
OPPORTUNE TIME TO TALK BRIEFLY ABOUT
SUCH A DEFINITION OF A STRING
BECAUSE, IN THIS INSTANCE, WE MUST
DEFINE THE LAST SINGLE CHARACTER IN
THE ARRAY AS THE SPECIAL TERMINATING
CHARACTER, 0.

╙PECIAL 0 -

╩UST ONE WORD ABOUT 'STRING ARRAYS' -

CHAR X[10];
/* DEFINES AN ARRAY OF 10 ELEMENTS */
X[0]='A';
/* FIRST ELEMENT IS CHARACTER A */
X[1]='B';
/* SECOND ELEMENT IS CHARACTER B */
X[2]='';
/* THIRD ELEMENT IS CHARACTER  */
X[3]='\0';
/* LAST ELEMENT IS THE 'NUMBER' 0! */

PRINTF("THE STRING IS %S",X);
/* PRINT THE STRING, UP TO THE 0 */

╘HE PRINTOUT WOULD BE:

THE STRING IS AB

╬OTE THE STRANGE WAY WE HAD TO DEFINE
THE TERMINATING ELEMENT SO THAT C
WOULD RECOGNIZE IT AS THE 'NUMBER' 0
AND NOT THE 'CHARACTER' 0 ... WE USED
\0  INSIDE  SINGLE QUOTES IN THE
STATEMENT:

X[3]='\0';

╧THER SPECIAL CHARACTERS LIKE \0  -

╔N ORDER TO DEFINE THE SPECIAL
CHARACTER 0 WHICH TERMINATES A STRING
WE REFERRED TO IT AS \0. ╘HE
BACKSLASH \ NOTIFIES C THAT THE VERY
NEXT CHARACTER IS TO BE INTERPRETED
IN A SPECIAL MANNER. ╘HE BACKSLASH IN
C IS AN ESCAPE CHARACTER WHICH TELLS
THE COMPILER TO INTERPRET THE
CHARACTER WHICH IMMEDIATELY FOLLOWS
IN A PARTICLAR WAY (WE'VE SEEN THIS
KIND OF THING BEFORE: % MEANS THE
NEXT CHARACTER(S) IS 'SPECIAL' IN A
PRINTF() FORMAT....AS IN %S).

╘HERE ARE OTHER \CHARACTER
COMBINATIONS IN C. ╔N EACH CASE THEY
ARE USED TO DEFINE A CHARACTER WHICH
CANNOT (NORMALLY) BE TYPED INTO YOUR
TEXT. ╞OR EXAMPLE YOU MAY HAVE
NOTICED THAT THE STATEMENTS:

CHAR X,Y;
X="Z";
Y='Z';
PRINTF("X IS %S Y IS %C",X,Y);

╫ILL PRINT:

X IS Z Y IS Z

╬OW SUPPOSE WE WANTED TO PRINT:X IS Z
AND Y IS Z ON TWO SEPARATE LINES!
╘HEN WE TELL PRINTF() TO PRINT A
'SPECIAL' CHARACTER, \N, MEANING A
NEWLINE:

CHAR X,Y;
X="Z"; Y='Z';
PRINTF("X IS %S \N Y IS %C",X,Y);
/* NOTICE THE \N */

╘HIS IS THE PRINTOUT:

X IS Z
 Y IS Z

├AREFULLY NOTICE THE SPACE BEFORE THE
'Y' AS WELL AS THE LINEFEED AND
CARRIAGE RETURN. THE LINEFEED-
CARRIAGE-RETURN COMBINATION IS CALLED
A 'NEWLINE' AND REPRESENTED BY '\N'.

╙PECIAL \CHARACTERS  -

╫E HAVE THE FOLLOWING 'SPECIAL'
CHARACTERS:

\N      THE NEW LINE.
\T      THE TAB CHARACTER.
\0      THE 0 TERMINATOR (NULL
        CHARACTER), ASCII 'VALUE' 0.
\B      THE BACKSPACE.
\"      THE DOUBLE QUOTE.
\\      THE BACKSLASH CHARACTER.

╫HAT WOULD THE FOLLOWING PRINT?

INT AGE;
AGE=100;
PRINTF("\"SAM\" IS %D YEARS OLD\T\T
       TODAY.",AGE);

╘HE PRINTOUT:

"SAM" IS 100 YEARS OLD         TODAY.

╬OTICE THE QUOTATION MARKS AND TABS.

╧THER 'FORMAT' INFO YOU CAN GIVE TO
PRINTF().
╫E'VE SEEN THE %D (FOR DECIMAL NUMBER
PRINTOUTS) AND WE'VE SEEN %F (FOR
FLOATING POINT NUMBERS), AND %C AND
%S FOR CHARACTERS AND STRINGS, BUT WE
HAVE ALSO %O (FOR OCTAL NUMBERS) AND
%X (FOR HEXADECIMAL NUMBERS) AND %E
(NUMBERS EXPONENTIAL FORMAT, SUCH AS
-7.001100E+03). ╔N EACH CASE YOU MAY
QUALIFY THE ABOVE FORMAT INSTRUCTION
WITH A FIELD WIDTH SPECIFICATION,
SUCH AS:

INT A=123;
PRINTF("%6D",A);
/* PRINTOUT: 123 */

FLOAT B=123;
PRINTF("%6.3F",B);
/* PRINTOUT: 123.000 */

CHAR C='1';
PRINTF("%6C",C);
/* PRINTOUT:      1 */
/* NOTE: CHAR IS RIGHT-JUSTIFIED */

CHAR D="123";
PRINTF("%6S",D);
/* PRINTOUT:   123 */

INT E=123;
PRINTF("%6O",E);
/* PRINTOUT:   173 */
/* 'O' INDICATES AN OCTAL NUMBER */

FLOAT F=123;
PRINTF("%6E",F);
/* PRINTOUT:     1.230000E+02 */

INT G=123;
PRINTF("%6X",G);
/* PRINTOUT:    7B */
/* 'X' INDICATES HEXADECIMAL NUMBER */


╟OOD FORM .. BAD FORM  -

╘HE COMPOUND STATEMENT:

FLOAT B=123;PRINTF("%6.3F",B);

╚ERE WE DECLARED B TO BE A FLOAT AND,
AT THE SAME TIME, WE DEFINED IT TO BE
123 (AS IN FLOAT B=123;). ╘HAT'S
LEGAL AND HAVING THE DECLARATION AND
DEFINITION ON ONE LINE SAVES SPACE.
┬UT WE ALSO ADDED PRINTF("%6.3F",B);
ON THE SAME LINE.  ╘HAT'S CONSIDERED
BAD FORM BECAUSE IT MAKES A PROGRAM
VERY DIFFICULT TO READ. ┴VOID PLACING
MORE THAN ONE STATEMENT ON A LINE.

╬OTE: FOR FLOAT B=123; 6.3F DOESN'T
PROVIDE ENOUGH FIELD WIDTH (IF WE
WANT 3 DECIMAL PLACES) SO PRINTF()
EXPANDS THE FIELD WIDTH TO 7, AS
REQUIRED TO ACCOMMODATE 123.000,
WHERE THE DECIMAL POINT, PLUS 3
DIGITS BEFORE IT AND 3 AFTER IT,
MAKE A FIELD WIDTH OF 7.

┘OU WILL ALSO HAVE NOTICED THAT THE
STATEMENT:

CHAR D="123";
PRINTF("%6S",D);
/* PRINTOUT:   123 */

╘HE '123' IS RIGHT-JUSTIFIED IN A
FIELD WIDTH OF 6. YOU MAY ASK
PRINTF() TO LEFT-JUSTIFY THE 123 BY
SPECIFYING:

CHAR D="123";
PRINTF("%-6S",D);
/* PRINTOUT: 123 */

╬OTICE THE FORMAT SPECIFICATION %-6S
WITH '-' MEANING LEFT-JUSTIFY.

╔F B="1234567"; THEN (AS EXPECTED)
PRINTF() WILL MAKE THE FIELD WIDTH 7
(TO ACCOMMODATE 1234567)...EVEN IF WE
ASKED FOR %6S! ╔F YOU REALLY MEAN 6
(AND WANT TO CUT OFF THE STRING) THEN
USE THE SPECIFICATION:

%.6S

CHAR D="1234567";
PRINTF("%.6S",D);
/* PRINTOUT: 123456 */
/* NOTE THE .6 */

┴ NOTE ON FORMAT SPECIFICATIONS  -

╔F S HAS BEEN DECLARED AND DEFINED AS
A STRING:

S="I'M A STRING"

(WITH 12 CHARACTERS) THEN WE MAY
SELECT ANY NUMBER OF CHARACTERS AND
PRINT THEN IN A SPECIFIED FIELD
WIDTH:

PRINTF("%S",S);
/* PRINTOUT: I'M A STRING */

PRINTF("%20.12S",S);
/* PRINTOUT:           I'M A STRING */

PRINTF("%-20.12S",S);
/* PRINTOUT: I'M A STRING */

PRINTF("%20.10S",S);
/* PRINTOUT:            I'M A STRI */

PRINTF("%-20.10S",S);
/* PRINTOUT: I'M A STRI */
/* PRINTS ONLY 10 CHARACTERS */

═ORE NOTES ON FORMAT SPECIFICATIONS -

╔F X HAS BEEN DECLARED AND DEFINED AS
AN INT:

X=123

╘HEN WE HAVE:

PRINTF("%D",X);
/* PRINTOUT: 123 */

PRINTF("%10D",X);
/* PRINTOUT:       123 */

PRINTF("%-10D",X);
/* PRINTOUT: 123 */

PRINTF("%010D",X);
/* PRINTOUT: 0000000123 */

PRINTF("%010X",X);
/* PRINTOUT: 000000007B */
/* 'X' INDICATES HEXADECIMAL */
/* THIS '0' PADS WITH 0'S */

╙OME FINAL NOTES ON FORMAT -

╔F X HAS BEEN DECLARED AND DEFINED AS
AN FLOAT:

X=123.456

╘HEN WE HAVE:

PRINTF("%F",X);
/* PRINTOUT: 123.456000 */

PRINTF("%10.4F",X);
/* PRINTOUT       123.4560 */

PRINTF("%-10.2F",X);
/* PRINTOUT 123.46 */

╥EMEMBER NUMERICAL AND CHARACTER
VARIABLES ARE PASSED TO FUNCTIONS,
LIKE FOR EXAMPLE PRINTF(), BY VALUE.
╘HIS MEANS THAT THE FUNCTION ISN'T
ACTUALLY USING THE INITIALLY-DEFINED
VARIABLE BUT A COPY OF IT WHICH IS
PRIVATE TO THAT FUNCTION. ╘HIS IS
WHAT IS MEANT WHEN IT IS SAID THAT C
IS A LANGUAGE WHICH UTILIZES 'CALL BY
VALUE'.  ╘HE IMPORTANCE OF 'CALL BY
VALUE' WILL BECOME INCREASINGLY CLEAR
AS YOU BECOME FAMILIAR WITH C.
╔N THE CASE OF STRINGS AND ARRAYS,
HOWEVER, THE FUNCTION IS RECEIVING A
POINTER TO THE FIRST ELEMENT IN
EITHER A STRING, OR, AN ARRAY (IN
FACT, A STRING IS AN ARRAY).
┴ POINTER TO SOMETHING PROVIDES THE
ADDRESS OF THAT SOMETHING TO A
FUNCTION OR STATEMENT. ╘HE FUNCTION
IS, THEREFORE, WORKING DIRECTLY WITH
THE ORIGINALLY-DEFINED VARIABLE
ELEMENTS OF STRINGS AND ARRAYS.

[END OF LESSON 2 OF 11]