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

Text File | 1991-03-07 | 17.5 KB | 790 lines

├ ╠ANGUAGE ╘UTORIAL
-------------------
╨ART 11 OF 11


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

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


╙╘╥╒├╘╒╥┼╙ -

╔F WE WISH TO KEEP A RECORD OF, SAY,
FRIENDS ... INCLUDING NAME, ADDRESS,
BIRTHDATE, ETC. WE MIGHT DECLARE:

CHAR NAME[20];
CHAR ADDRESS[40];
CHAR BIRTHDATE[15];

...WHERE NAME, FOR EXAMPLE, IS AN
ARRAY OF 20 CHARACTERS WHICH IS MEANT
TO HOLD THE NAME OF ONE SUCH FRIEND,
AND ADDRESS HOLDS 40 CHARS, ETC. ╔F
WE WANT 100 SUCH RECORDS, WE COULD
USE:

CHAR NAME[100][20];
CHAR ADDRESS[100][40];
CHAR BIRTHDATE[100][15];

...WHERE NAME[0], NAME[1],NAME[2],
ETC. ARE EACH ARRAYS OF 20
CHARACTERS, ETC.

╫E WOULD PRINT OUR LIST VIA A
STATEMENT LIKE:

FOR (I=0; I<100; I++)
PRINTF("\N%S %S %S", NAME[I],
       ADDRESS[I],BIRTHDATE[I]);

╙INCE THE BIRTHDATE HAS THE FORM "╬OV
6, 1934" (FOR EXAMPLE) WE WOULD NEED
TO EXTRACT THE LAST NUMBER ( 1934),
AND PERFORM A SUBTRACTION, IN ORDER
TO DETERMINE HIS (HER?) AGE ... AND
WOULD NEED ALL SUCH NUMBERS IN ORDER
TO DEDUCE THE AVERAGE AGE OF OUR
FRIENDS. ╙O WE MIGHT DECLARE
BIRTHDATE TO BE A TRIO OF OBJECTS: AN
ARRAY OF CHARACTERS (TO HOLD THE
BIRTH-MONTH, LIKE "╬OV"), AN INTEGER
(TO HOLD THE BIRTH-DAY) AND A SECOND
INTEGER (TO HOLD THE BIRTH-YEAR) ...
THAT WAY WE COULD PERFORM SOME
ARITHMETIC ON THE INTEGER PARTS OF
THE BIRTHDATE.

CHAR NAME[100][20], ADDRESS[100][40];
CHAR BIRTH_MONTH[100][4];
INT  BIRTH_DAY[100], BIRTH_YEAR[100];

╘HE ABOVE WOULD DO IT. ╙UFFICIENTLY
MANY ARRAYS (OF CHARACTERS AND
INTEGERS) FOR 100 FRIENDS, EACH WITH
NAMES OF  19  CHARACTERS (OR LESS)
AND ADDRESSES OF  39  CHARACTERS (OR
LESS) AND  3  CHARACTERS FOR THE
BIRTH_MONTH (WE'LL NEED THE
TERMINATING '\0' IN EACH CHAR ARRAY!)
...AND 100 BIRTH_DAYS AND BIRTH_YEARS
(REMEMBER THAT BIRTH_DAY[0] TO
BIRTH_DAY[99] IS 100 BIRTH-DAYS!)


╔T WOULD BE NICE TO HAVE A ─┴╘┴ ╘┘╨┼
WHICH HELD ONE SUCH RECORD, WITH
NAME, ADDRESS, ETC. AND MIXED CHARS
AND INTS !!



...LET'S WELCOME THE ╙╘╥╒├╘╒╥┼ -

╔T IS SOMETIMES HELPFUL TO THINK OF A
STRUCTURE AS A TYPE OF ARRAY WHICH
CAN HOLD VARIABLES OF DIFFERING
TYPES.

╫E INVENT A STRUCTURE CALLED DATE
WHICH INCLUDES A 3 CHARACTER MONTH
( HENCE MONTH[4] ) AND TWO INTS
(DAY AND YEAR).

╫E ARE ACCUSTOMED TO SAYING INT X;
AND CHAR Y;, MEANING THAT X IS OF
─┴╘┴ ╘┘╨┼ INT AND Y IS OF ─┴╘┴ ╘┘╨┼
CHAR. ╙╧, WE WILL WANT TO SAY DATE
BIRTH; MEANING THAT BIRTH IS OF ─┴╘┴
╘┘╨┼ DATE MEANING A COLLECTION OF
OBJECTS:

A CHAR MONTH[4], AN INT DAY,
AND AN INT YEAR.

┬UT, IF DATE IS A STRUCTURE (WITH THE
ELEMENTS MENTIONED ABOVE) THEN WE
WILL REFER TO IT AS STRUCT DATE, TO
INFORM THE COMPILER THAT DATE IS NO
ORDINARY GUY BUT IS, IN FACT, A
STRUCT ...


╙╧, WE DECLARE BIRTH TO BE SUCH A
STRUCTURE (CALLED DATE) VIA:

STRUCT DATE BIRTH;

╙O WHY WOULDN'T WE JUST DEFINE A
STRUCTURE CALLED BIRTH, WHICH HAS THE
3 MEMBERS: MONTH[4] AND INT DAY AND
INT YEAR ??

┬ECAUSE WE WILL WANT TO USE THIS
STRUCT FOR OTHER DATES, LIKE:

STRUCT DATE DEATH;

╘OO MORBID?  ╘HEN HOW ABOUT:

STRUCT DATE ╫HEN╫E═ET;

╬OW, ╫HEN╫E═ET IS OF ─┴╘┴ ╘┘╨┼ DATE
TOO, CONTAINING THE SAME 3 ELEMENTS
OF CHAR MONTH[4] AND INT DAY AND INT
YEAR !!

(╬OTE: SOME COMPILERS MAY NOT
RECOGNIZE NAMES LIKE ╫HEN╫E═ET BUT
MAY RESTRICT NAMES TO, SAY, 8
CHARACTERS OR LESS).



╔NSIDE A ╙╘╥╒├╘URE -

┬EFORE WE SEE HOW TO DEFINE SUCH A
STRUCTURE AS DATE, LETS SEE HOW IT
COULD BE USED. ╔T WILL HAVE 3
MEMBERS: MONTH, DAY, YEAR.
╫E DECLARE:

STRUCT DATE BIRTH[100], ╫HEN╫E═ET[100];

...SO EACH OF BIRTH[0], BIRTH[1],
ETC. AND ╫HEN╫E═ET[0], ╫HEN╫E═ET[1],
ETC. ARE STRUCTS OF ╘┘╨┼ DATE.

╘HE WAY TO GET ACCESS TO THE MEMBERS
OF A STRUCTURE IS TO USE THE NAME OF
THE STRUCTURE FOLLOWED BY A PERIOD
FOLLOWED BY THE NAME OF THE MEMBER
OF THE STRUCTURE. ╞OR EXAMPLE, TO
ACCESS THE CHAR VARIABLE 'MONTH' IN
THE FIFTY-FOURTH 'BIRTH' STRUCTURE
WE WOULD SAY:

CHAR *PC;
PC = BIRTH[54].MONTH;

...NOW THE POINTER-TO-CHAR 'PC'
POINTS TO WHAT WE WANT TO ACCESS.

╫E REFER TO BIRTH[I].MONTH,
BIRTH[I].DAY AND BIRTH[I].YEAR AND TO
╫HEN╫E═ET[I].MONTH, ╫HEN╫E═ET[I].DAY
AND ╫HEN╫E═ET[I].YEAR FOR I=0, 1, 2,
... UP TO THE NUMBER OF FRIENDS WE
HAVE ...AND EACH REFLECTS THE 3
MEMBERS MONTH, DAY AND YEAR OF THE
DATE STRUCTURE.

╘O INPUT ALL THIS INFORMATION WE
MIGHT USE:

PRINTF("\N ╬UMBER OF FRIENDS: ");
SCANF("%S",&NUMBER);
/* HERE WE ASK FOR THE NUMBER OF
FRIENDS, AND STORE IT IN NUMBER */
FOR (I=0; I<NUMBER; I++) █
/* THEN,WE GO THROUGH EACH OF NUMBER
OF FRIENDS, ASKING QUESTIONS */
PRINTF("\N ╞OR FRIEND %D",I);
/* REMIND THE USER WHICH FRIEND WE
ARE WORKING ON BY PRINTFING ...
╞OR FRIEND 1:  THEN,
╞OR FRIEND 2:  ETC. */
PRINTF("\N ┼NTER ═ONTH OF ┬IRTH ");
SCANF("%S",&BIRTH[I].MONTH);
/* ASK  ┼NTER ═ONTH OF ┬IRTH  AND
PUT THE ANSWER INTO &BIRTH[I].MONTH
(FOR THE ITH FRIEND) AND, AS
REQUIRED BY SCANF(),WE USE THE
&ADDRESS ! */
PRINTF("\N ┼NTER ─AY   OF ┬IRTH ");
SCANF("%S",&BIRTH[I].DAY);
PRINTF("\N ┼NTER ┘EAR  OF ┬IRTH ");
SCANF("%S",&BIRTH[I].YEAR);
...AND SO ON, FOR THE BIRTH.DAY AND
BIRTH.YEAR
...UNFORTUNATELY, THIS WON'T (QUITE)
WORK ...DO YOU SEE WHY?

╘HE NUMBER BEING INPUT VIA SCANF()
SHOULD HAVE A %D (FOR AN INTEGER).

...BUT THERE'S SOMETHING ELSE ...

PRINTF("\N ┼NTER ═ONTH OF ┬IRTH ");
SCANF("%S",&BIRTH[I].MONTH);

SCANF() WILL PUT THE 3 CHARACTERS
TYPED AT THE KEYBOARD, SAY "╬OV",
INTO THE MEMORY RESERVED FOR
BIRTH[I].MONTH, BUT ╫╧╬'╘ PUT IN A
'\0'! ├ REQUIRES THAT ALL STRINGS
BE TERMINATED WITH A ╬╒╠╠.

╫┼ MUST PUT IT IN ( ...WHILE WE'RE
PRAYING THAT THE USER DOESN'T TYPE
NOVEMBER, WHICH IS MUCH TOO LONG TO
FIT INTO THE 4 BYTES WE'VE RESERVED
FOR THE MONTH!)

╫E COULD INITIALIZE ALL THE BYTES IN
THE BIRTH.MONTH TO '\0' VIA:

FOR (I=0; I<100; I++) █
/* FOR ALL 100 FRIENDS */
  FOR (J=0; J<4; J++) █
/* FOR EACH OF 4 BYTES */
  BIRTH[I].MONTH+J='\0';
/* SET BYTE TO '\0' */
  █  /* END OF INNER "FOR" */
▌  /* END OF OUTER "FOR" */

... THEN (PROVIDED THE USER DOESN'T
TYPE MORE THAN A 3 CHARACTER MONTH!)
WE'VE GOT ALL THE '\0' STRING
TERMINATORS WE'LL NEED.

╘HIS LITTLE RITUAL IS NECESSARY
BECAUSE SCANF() IS MEANT AS A
GENERAL-PURPOSE INPUT ...INTS AND
FLOATS AND CHARS ETC.

┴ SPECIAL-PURPOSE INPUT ...JUST FOR
STRINGS OF CHARS ...WOULD BE SMART
ENOUGH TO APPEND THE '\0' (WOULDN'T
IT?)

╘HE STDIO.H LIBRARY OF ├-FUNCTIONS
WILL CONTAIN SUCH A FUNCTION.
GETS(&SAM) WILL GET A STRING AND PUT
IT INTO THE ADDRESS &SAM. ╩UST AS
SCANF() REQUIRES A POINTER TO THE
MEMORY LOCATION WHERE THE INPUT IS TO
BE STORED, SO DOES GETS().

╞OR EXAMPLE, WE WRITE:

1 PRINTF("\N ╚OW MANY FRIENDS DO
         YOU HAVE ");
2 SCANF("%D",&NUMBER);
3 FOR (I=0; I<NUMBER; I++) █
4 PRINTF("\N ╞OR FRIEND %D",I);
5 PRINTF("\N ┼NTER ═ONTH OF ┬IRTH ");
6 GETS(&BIRTH[I].MONTH);
7 PRINTF("\N ┼NTER ─AY OF ┬IRTH ");
8 SCANF("%D",&BIRTH[I].DAY);
9 PRINTF("\N ┼NTER ┘EAR OF ┬IRTH ");
10 SCANF("%D",&BIRTH[I].YEAR);
11 ▌

...AND THE GETS() IN LINE 6 WILL
COLLECT EACH CHARARACTER TYPED, AND
WHEN A \NEWLINE IS TYPED (THE ╥ETURN
OR ┼NTER KEY) IT WILL EXCHANGE IT FOR
A '\0' ...AND PUT EVERYTHING INTO THE
MEMORY LOCATION INDICATED.



─EFINING A ╙╘╥╒├╘URE -

╔T'S ABOUT TIME WE DEFINED OUR STRUCT
DATE :

 STRUCT DATE █
   CHAR MONTH[4];
   INT DAY;
   INT YEAR;
 ▌;

╬OTE THE STRUCTURE OF A STRUCTURE:
 STRUCT NAME █
   --- ALL THE ---
   --- MEMBERS ---
   --- GO HERE ---
 ▌;

╫E GIVE IT A NAME (LIKE DATE) SO WE
CAN DECLARE OTHER OBJECTS TO BE OF
THIS ─┴╘┴ ╘┘╨┼ ( REMEMBER BIRTH AND
╫HEN╫E═ET ? )
...AND AN OPENING AND CLOSING BRACES
...AND THE VARIOUS MEMBERS (LIKE
CHAR MONTH[4], ETC.)
...AND A FINAL  ▌;

FINAL ▌; ??

 STRUCT DATE █
   CHAR MONTH[4];
   INT DAY;
   INT YEAR;
 ▌;

╘HIS FINAL ▌; IS MEANINGFUL!

┬ECAUSE A STRUCT DATE IS TO BE USED
JUST LIKE INT OR CHAR, AND BECAUSE WE
USUALLY SAY INT X; OR CHAR X; (WITH A
FINAL ;), THEN WE TERMINATE A
STRUCTURE DEFINITION WITH A ; AND
EXPECT TO BE ABLE TO SAY:

STRUCT DATE █
  --- ETC ---
   ▌ X;
/* NOTE SIMILARITY WITH INT X; */


╙╧, FOR OUR EARLIER EXAMPLE, WE COULD
SAY:

 STRUCT DATE █
  CHAR MONTH[4];
  INT DAY;
  INT YEAR;
 ▌ BIRTH[100],╫HEN╫E═ET[100];

... AND WE'VE DEFINED OUR STRUCT DATE
┴╬─ DECLARED BIRTH[] AND ╫HEN╫E═ET[]
TO BE SUCH STRUCTURES ... ALL AT
ONCE!

╥EMEMBER: 'DATE' IS THE NAME OF A
╘┘╨┼ OF STRUCTURE AND THIS TYPE-NAME
OF A STRUCTURE IS CALLED A ╘┴╟.
┬OTH 'BIRTH[100]' AND
'╫HEN╫E═ET[100]' ARE NAMES OF
PARTICULAR STRUCTURES OF THE TYPE
WE'VE DEFINED AS 'DATE'.

╙O, YOU CAN ACHIEVE THE SAME RESULT
AS ABOVE BY WRITING:

  STRUCT DATE █
    CHAR MONTH[4];
    INT DAY;
    INT YEAR;
  ▌;

  STRUCT DATE BIRTH[100],
            ╫HEN╫E═ET[100];


╬OW LET'S RETURN TO THE RECORD OF OUR
"FRIENDS", WHICH INCLUDES NAME AND
ADDRESS AS WELL AS SOME DATES AS WELL
AS A NEW ADDITION TO WHAT CAN BE DONE
WITH STRUCTURES.



╙TRUCTURES WITHIN ╙TRUCTURES -
(NOBODY SAID THIS WAS EASY!)

╞OR EACH "RECORD" WE WILL DEFINE
ANOTHER STRUCTURE ... LET'S CALL IT
"RECORD":

 STRUCT  RECORD █
  CHAR NAME[20];
  CHAR ADDRESS[40];
  STRUC DATE BIRTH;
  STRUC DATE ╫HEN╫E═ET;
 ▌ FRIEND[100];

╬OTE THAT WE'VE NOT ONLY DEFINED THE
STRUCT CALLED RECORD BUT WE'VE ALSO
DECLARED 100 SUCH STRUCTURES, USING
THE "FINAL" NAME FRIEND[100];

...FRIEND[0] AND FRIEND[1] AND
FRIEND[2] ETC. ARE ┴╠╠ OF TYPE RECORD
AND HENCE CONTAIN THE MEMBERS: NAME,
ADDRESS, BIRTH AND ╫HEN╫E═ET.


╘HE FIRST TWO (NAME AND ADDRESS) ARE
CHARACTER ARRAYS ┬╒╘ THE LAST TWO
(BIRTH AND ╫HEN╫E═ET) ARE ...╙╒╥╨╥╔╙┼
(!) STRUCTURES OF ╘┘╨┼ DATE !!!

╫E NOW HAVE A STRUCTURE:

  STRUCT RECORD █
    CHAR NAME[20];
    CHAR ADDRESS[40];
    STRUCT DATE █
      CHAR MONTH[4];
      INT DAY;
      INT YEAR;
    ▌ BIRTH;
    STRUC DATE █
      CHAR MONTH[4];
      INT DAY;
      INT YEAR;
    ▌ ╫HEN╫E═ET;
  ▌ FRIEND[100];

┼ARLIER WE DECLARED 200 STRUCTURES OF
╘┘╨┼ DATE (NAMELY BIRTH[100] AND
╫HEN╫E═ET[100]). ╫E ALSO SAW HOW TO
REFER TO THE 3 MEMBERS OF BIRTH[47]
(FOR EXAMPLE) AS BIRTH[47].MONTH,
BIRTH[47].DAY AND BIRTH[47].YEAR.

╔N ORDER TO ACCESS THE INT VARIABLE
'DAY' WITHIN THE THIRTY-SEVENTH
STRUCT FRIEND, WITHIN THE STRUCT
BIRTH WE WOULD SAY:

INT *PI;
PI = FRIEND[37].BIRTH.DAY;

...OR, IN A PROGRAM WHERE YOU ARE
ASKING THE USER FOR INPUT YOU COULD
WRITE:

PRINTF("┼NTER DAY OF BIRTH: ");
GETS(&FRIEND[37].BIRTH.DAY);

╔T IS POSSIBLE TO HAVE STRUCTURES
WITHIN STRUCTURES!!

╚ERE IS A NOT-TOO-USEFUL, BUT QUITE
ILLUSTRATIVE, SAMPLE PROGRAM:

MAIN()
█
  INT NUMBER, I;
  STRUCT DATE █
   CHAR MONTH[4];
   INT DAY;
   INT YEAR;
  ▌;
  STRUCT RECORD █
   CHAR NAME[20];
   CHAR ADDRESS[40];
   STRUCT DATE BIRTH;
  ▌ FRIEND[100];

  PRINTF("\N╚OW MANY FRIENDS : ");
  SCANF("%D",&NUMBER);

  FOR (I=0; I<NUMBER; I++) █
   PRINTF("\N ╞OR FRIEND %D",I+1);
   PRINTF("\N╬AME? ");
   GETS(&FRIEND[I].NAME);
   PRINTF("\N┴DDRESS? ");
   GETS(&FRIEND[I].ADDRESS);
   PRINTF("\N═ONTH OF BIRTH? ");
   GETS(&FRIEND[I].BIRTH.MONTH);
   PRINTF("\N─AY OF BIRTH? ");
   SCANF("%D",&FRIEND[I].BIRTH.DAY);
   PRINTF("\N┘EAR OF BIRTH? ");
   SCANF("%D",&FRIEND[I].BIRTH.YEAR);
  ▌

 PRINTF("\N╙╒══┴╥┘ OF YOUR %D
        FRIENDS",NUMBER);
 FOR (I=0; I<NUMBER; I++)█
  PRINTF("\N╬AME:%S",
         FRIEND[I].NAME);
  PRINTF("\N┴DDRESS:%S",
         FRIEND[I].ADDRESS);
  PRINTF("\N┬ORN ON %S %D,%D",
         FRIEND[I].BIRTH.MONTH,
         FRIEND[I].BIRTH.DAY,
         FRIEND[I].BIRTH.YEAR);
 ▌
▌


...GIVING A (TYPICAL) PRINTOUT:

╬AME:╨ETER ╨ONZO
┴DDRESS:49 ═ARGARET ╙.,
  ╫ATERLOO, ╧NT.
┬ORN ON ╬OV 6,1934


╒╬╔╧╬╙ -

╘HERE IS ANOTHER MODE OF STORING
GROUPS OF VARIABLES IN ├ BESIDES
ARRAYS AND STRUCTURES AND IT'S CALLED
A ╒╬╔╧╬.

┴ UNION DECLARATION ESTABLISHES A
SMALL SEGMENT OF MEMORY WHICH
CONTAINS ╧╬╠┘ ╧╬┼ VARIABLE AT A TIME
OUT OF A SET OF DIFFERENT VARIABLES.

╔N MOST RESPECTS YOU CAN TREAT A
UNION IN THE SAME WAY THAT YOU TREAT
A STRUCTURE AS LONG AS YOU REMEMBER
THAT IT IS A STRUCTURE WHICH CAN
CONTAIN MANY DIFFERENT VARIABLE TYPES
ALL AT THE SAME TIME WHILE THE UNION
CAN ONLY CONTAIN ONE VARIABLE OUT OF
ITS SET OF DIFFERENT VARIABLES.

┴ UNION LOOKS JUST LIKE A STRUCTURE:

UNION NAME.TAG █
  CHAR C;
  INT I;
  FLOAT *F;
  DOUBLE D;
▌ WHATEVER;

╔N THE ABOVE WE HAVE DECLARED A UNION
WHICH HOLDS FOUR DIFFERENT VARIABLES
AND WE HAVE GIVEN IT THE TAG
'NAME.TAG' AND WE HAVE CREATED A
PARTICULAR UNION CALLED 'WHATEVER'.
╫HEN THE COMPILER SEES THIS
DECLARATION IT WILL RESERVE ENOUGH
MEMORY TO HOLD THE BIGGEST OF THE
VARIABLES IN THE UNION. ╔N THE CASE
OF ├ ╨OWER ON THE ├64 THIS WOULD BE
THE DOUBLE D, WHICH REQUIRES 5 BYTES
OF STORAGE. ┬Y RESERVING 5 BYTES FOR
THE UNION WHATEVER THE COMPILER
GUARANTEES THAT NO MATTER WHICH OF
THE FOUR VARIABLES IS PLACED IN THE
UNION AT ANY ONE TIME THERE WILL BE
ENOUGH SPACE FOR IT.

╔F WE WANT TO CREATE ANOTHER UNION
JUST LIKE THE ONE ABOVE WE NOW ONLY
HAVE NEED TO MAKE THIS DECLARATION:

UNION NAME.TAG SOMETHINGELSE;

╧NE IMPORTANT THING TO KEEP IN MIND
WITH UNIONS IS THAT IT IS UP TO THE
PROGRAMMER TO KEEP TRACK OF WHAT IS
IN THE UNION. ╔F YOU PUT DOUBLE D
INTO THE UNION AND THEN TRY TO PULL
OUT INT I THE PROGRAM WILL PULL OUT
TWO BYTES OF THE DOUBLE AND YOU WILL
GET A GARBAGE VALUE.
╔F YOU NEED SOME WAY TO FIND OUT WHAT
TYPE OF VARIABLE IS IN THE UNION YOU
CAN USE THE ╙╔┌┼╧╞ OPERATOR TO TELL
YOU THE SIZE OF THE UNKNOWN VARIABLE.
╔T WOULD BE USED SOMETHING LIKE THIS:

INT Y;
Y = SIZEOF(WHATEVER);

...AND Y WOULD BE EQUAL TO 5 IF THE
UNION CONTAINED A DOUBLE WHEN IT WAS
TESTED SINCE A DOUBLE TAKES 5 BYTES
OF STORAGE.



╨╧╔╬╘┼╥╙ TO ╙╘╥╒├╘╒╥┼╙ -

╧NE SOMETIMES FEELS FRUSTRATED IN
WRITING AN ELABORATE FUNCTION WHICH
DOES THE MOST WONDERFUL THINGS, ONLY
TO GET FROM SUCH A FUNCTION A SINGLE
INT OR FLOAT OR CHAR. ╥EMEMBER, YOU
CAN'T RETURN(A,B,C,D,E) AT THE END OF
THE FUNCTION, YOU CAN ONLY RETURN(A).

┬╒╘, THE FUNCTION CAN CREATE AN
ELABORATE STRUCTURE WHICH HOUSES ALL
THE WONDERFUL THINGS, THEN RETURN(A)
WHERE A IS A POINTER TO THE
STRUCTURE!

╔N FACT WE'VE USED SUCH A FUNCTION
...ONE WHICH RETURNS A POINTER.
┬EFORE ╔ TELL YOU WHICH FUNCTION IT
IS (FROM THE STDIO.H LIBRARY), LET'S
SEE HOW SUCH A FUNCTION SHOULD BE
DECLARED.

├ONSIDER THE FOLLOWING:

CHAR F();  WHICH DECLARES F() TO BE A
FUNCTION WHICH RETURNS A CHAR ╘HEN,
TO DECLARE A FUNCTION WHICH RETURNS A
POINTER TO A CHAR IT WOULD BE
SENSIBLE TO USE THE FORMAT: CHAR
*F();  ...RIGHT?
╥╔╟╚╘!

╙╧ ...IF THE FUNCTION F() WERE TO
RETURN A POINTER TO A STRUCTURE
CALLED SAM, WE'D DECLARE IT WITH:

SAM *F();

... RIGHT?

╥╔╟╚╘!

┴ND WHAT IF SAM WAS TYPEDEFINED TO BE
A STRUCTURE, AS IN:

TYPEDEF ╙OME╙TRUCTURE  ╙┴═;
/* REMEMBER THE USE OF CAPITALS! */

╘HEN THE FUNCTION F() WOULD BE
DECLARED:

╙┴═ *F();... RIGHT?

╬╧╫ ...REMEMBER WHEN WE USED:

╞╔╠┼ *FOPEN(); ???

╔N FACT, WHEN WE FOPEN() A FILE ON A
DISK, THE OPERATING SYSTEM RETURNS A
POINTER TO A STRUCTURE ( CALLED ╞╔╠┼
) AND THIS STRUCTURE CONTAINS ALL THE
WONDERFUL THINGS WE NEED TO KNOW
ABOUT THE FILE ...AND THAT'S WHY WE
ALSO DECLARE THIS POINTER FP:

╞╔╠┼ *FP, *FOPEN();

...AND SAY, SUBSEQUENT TO THE ABOVE
DECLARATION:

 FP=FOPEN();

...SO WE ASSIGN TO FP THE POINTER
RETURNED BY FOPEN().

╘HEN, WHEN WE WANT TO GET A CHARACTER
FROM THIS FILE, WE NEED ONLY PASS TO
GETC() THIS POINTER ( AS IN GETC(FP)
) AND NOW THE GETC() FUNCTION WILL BE
ABLE TO EXTRACT ALL THE WONDERFUL
THINGS IT NEEDS FROM THE STRUCTURE
╞╔╠┼.


╬╧╫, IF SAM *F(); IS THE WAY WE
DECLARE F() TO BE A ╞╒╬├╘╔╧╬ ╫╚╔├╚
╥┼╘╒╥╬╙ ┴ ╨╧╔╬╘┼╥ TO AN OBJECT OF
╘┘╨┼ SAM (WHICH COULD BE AN INT OR A
FLOAT OR A STRUCT ETC.), THEN HOW
SHOULD WE DECLARE F TO BE A ╨╧╔╬╘┼╥
╘╧ ┴ ╞╒╬├╘╔╧╬ ╫╚╔├╚ ╥┼╘╒╥╬╙ ┴╬ ╧┬╩┼├╘
OF ╘┘╨┼ SAM? ╔T WOULD BE:

SAM  (*F)();

...SAYS THAT F IS NOW THE POINTER
...BECAUSE WE USED (*F) ...AND IF WE
WANT TO ACCESS THE THING WHICH F
POINTS TO WE WOULD USE THE TECHNIQUE
OF ╔╬─╔╥┼├╘╔╧╬ (GO BACK AND REVIEW IF
YOU DON'T REMEMBER!). ╘HE THING IT
POINTS TO ╔╙ *F ( REMEMBER THAT INT
*X; DECLARES X TO BE A POINTER TO AN
INT, AND THE INT ╔╙ *X )

╙╧, SINCE (*F) IS TO BE A FUNCTION,
WE SAY (*F)() !

...AND WE'VE SEEN THIS CURIOUS
NOTATION BEFORE TOO!

╙UPPOSE THAT PTR IS A POINTER TO A
STRUCTURE, DECLARED USING *PTR SO
THAT (*PTR) ╔╙ THE STRUCTURE ITSELF.
╙UPPOSE THE STRUCTURE HAD A MEMBER
CALLED 'NAME'. ╘HEN WE'D REFER TO
THIS MEMBER AS:

(*PTR).NAME

...AS IN (*PTR).NAME="╟EORGE"; WHICH
ASSIGNS '╟EORGE' TO THE VARIABLE
'NAME' IN WHATEVER STRUCTURE IT IS
THAT PTR POINTS TO.

┴NOTHER (SIMPLER) NOTATION FOR THE
SAME THING IS:

PTR -> NAME = "╟EORGE";
/* USE ONLY IF PTR IS A POINTER */

...AND IF THE STRUCTURE HAD A MEMBER
BIRTH WHICH WAS ITSELF A STRUCTURE
CONTAINING A MEMBER CALLED MONTH,
THEN WE CAN USE THE NOTATION:

PTR -> BIRTH.MONTH;
/* WHICH MEANS (*PTR).BIRTH.MONTH */

...AS IN PTR->BIRTH.MONTH="═AY";

┴╬─, IF BIRTH HAPPENED TO BE A
POINTER TOO, WE'D USE:

PTR -> BIRTH -> MONTH

╥EMEMBER:

╒SE:   SAM.BIRTH
IF SAM IS A STRUCTURE.

╒SE:   SAM->BIRTH
IF SAM IS A POINTER TO A STRUCTURE.



╨OINTERS TO ╒NIONS -

╒NIONS CAN ALSO HAVE POINTERS TO THEM
VERY MUCH LIKE STRUCTURES DO.
╞OR EXAMPLE, IF YOU KNOW THAT THE
UNION WHATEVER (WHICH WE DECLARED
ABOVE) CONTAINS A DOUBLE AND YOU
WANTED TO ASSIGN THAT DOUBLE TO
ANOTHER DOUBLE VARIABLE CALLED, SAY,
D.ANSWER YOU COULD USE A POINTER AND
IN THIS CASE THE POINTER IS CALLED
U.PTR:

DOUBLE D.ANSWER; /* DECLARE DOUBLE */
UNION NAME.TAG █
  CHAR C;
  INT I;
  FLOAT *F;
  DOUBLE D;
▌ WHATEVER;      /* DECLARE UNION */
UNION NAME.TAG *U.PTR;
/* DECLARE A POINTER TO UNION */

U.PTR = WHATEVER; /* POINT IT */
WHATEVER = D; /* DOUBLE IN UNION */
D.ANSWER = U.PTR -> D;
/* D.ANSWER NOW CONTAINS THE VALUE
   OF D */


[┼ND OF PART 11 OF 11]