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

Text File | 1991-03-07 | 15.0 KB | 663 lines

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


╬OTE: SUBSTITUTIONS FOR SPECIAL C
LANGUAGE CHARACTERS:

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


╨OINTERS AND ARRAYS -

╥ECALL THAT, WHEN WE REFER TO &X, C
WILL INTERPRET THIS AS THE ADDRESS
IN MEMORY OF THE VARIABLE X.  ╘HE
ADDRESS IN MEMORY OF A DATA ITEM IS
REFERRED TO AS THE 'LVALUE', OR
'LEFT VALUE' OF THAT ITEM. ╔T REFERS
TO THAT ITEM'S LOCATION. ╘HE
'RVALUE', OR 'RIGHT VALUE' OF A DATA
ITEM IS WHAT HAS BEEN STORED AT THE
LOCATION GIVEN BY THE 'LVALUE'. ╔N
OTHER WORDS THE 'LVALUE' IS WHAT HAS
BEEN ASSIGNED TO THE DATA ITEM.

╚ERE &X IS A POINTER.

╔F WE SET Y=&X, IN OUR PROGRAM, THEN
Y POINTS TO THE VARIABLE X  ( Y IS
NOW AN ADDRESS, IN MEMORY ).  ╘HIS
MEANS THAT THE RVALUE OF Y IS THE
LVALUE OF X. ╙O Y HOLDS THE LOCATION
OF X AND IS SAID TO POINT TO X.

╚OW DO WE DECLARE A POINTER VARIABLE?

╔N ADDITION TO THE & OPERATOR (WHICH
RETURNS THE ADDRESS, OR LVALUE, OF
THE VARIABLE WHICH FOLLOWS IT),
THERE IS THE C OPERATOR *.

╔F Y POINTS TO INT X, THEN *Y IS THE
CONTENTS OF THE MEMORY LOCATION
POINTED TO BY Y. ╫HEN A PROGRAM
REFERS TO *Y, THE C COMPILER WILL GO
TO THE ADDRESS GIVEN BY THE POINTER
Y, EXTRACT THE INTEGER IT FINDS
THERE, AND USE THIS INTEGER IN PLACE
OF *Y. ╫HEN Y POINTS TO X THE
EXPRESSION *Y GIVES US X'S LVALUE.
THIS POSES A PROBLEM.....

╚OW IS THE COMPILER TO KNOW WHETHER
THE CONTENTS OF THE ADDRESS Y,
(WHICH WE REFER TO AS *Y, IN OUR
PROGRAM) IS AN INTEGER OR A FLOATING
POINT NUMBER OR A CHARACTER
VARIABLE???

╙INCE AN INTEGER OCCUPIES 2 BYTES
(USUALLY ..DEPENDING UPON THE
COMPUTER YOU ARE USING) AND A SINGLE
CHARACTER VARIABLE UTILIZES JUST 1
BYTE (EVEN THOUGH ACTUAL STORAGE FOR
A CHARACTER IS 2 BYTES WHEN IT IS
MANIPULATED BY A FUNCTION, BUT MORE
OF THIS LATER) AND A FLOAT OCCUPIES
4 BYTES ...ETC...ETC...THEN IT'S
CLEARLY IMPORTANT THAT THE COMPILER
KNOW THAT Y IS POINTING TO AN INT OR
A CHAR OR A FLOAT ...ETC.

╙O ... WE MUST DECLARE THE TYPE OF
VARIABLE THAT Y POINTS TO! TO DO
THIS WE DECLARE THE CONTENTS OF Y,
WHICH IS *Y.

1 MAIN()
2 █
3 INT *Y;
4 INT X=123;  /* X=INTEGER 123  */
5 Y=&X;       /* Y=ADDRESS OF X */
6 PRINTF("THE VALUE OF X IS %D.",*Y);
7 ▌

╘HIS PROGRAM WILL (CORRECTLY) PRINT:
THE VALUE OF X IS 123.

╬OTE THAT, IN LINE 5, Y IS MADE A
POINTER, POINTING TO X AND X IS AN
INT ....SO  ...IN LINE 3 WE
DECLARE OUR POINTER Y AS: INT *Y
SINCE IT POINTS TO AN INT.

╥EMEMBER!! IF  SAM  IS A POINTER TO
SOME  VARIABLE,  THEN BE SURE TO
DECLARE *SAM AS THE SAME  TYPE AS
THE VARIABLE TO WHICH SAM POINTS!

IF X IS AN INT  AND Y=&X THEN
DECLARE: INT *Y
IF X IS A CHAR AND Y=&X THEN
DECLARE: CHAR *Y
IF X IS A FLOAT AND Y=&X THEN
DECLARE: FLOAT *Y



╓ARIABLES AND THEIR HOMES IN MEMORY -

╫E'VE MENTIONED THAT THE CHAR C
UTILIZES 1 BYTE OF MEMORY, AND THAT
INT I OCCUPIES 2 BYTES AND FLOAT F
OCCUPIES 4 BYTES.

╙UPPOSE PC=&C IS A POINTER TO C,
AND PI=&I AND PF=&F.

╫HERE DOES PC+1 POINT TO ?

╫HERE DOES PI+1 POINT TO ?

╫HERE DOES PF+1 POINT TO ?

╘HE FACT THAT PC IS A POINTER TO A
CHAR, BECAUSE WE WOULD HAVE DECLARED
IT WITH CHAR *PC, AND BECAUSE A CHAR
ONLY OCCUPIES 1 BYTE, THEN C IS
SMART ENOUGH TO KNOW THAT PC-2 IS
THE ADDRESS OF THE MEMORY LOCATION 2
BYTES BELOW PC.

╬OW PI POINTS TO A (2 BYTE) INT, SO
C ARRANGES THAT PI-1 POINTS 2 BYTES
EARLIER THAN PI ...THAT WAY IT WILL
POINT TO THE IMMEDIATELY PRECEDING
INTEGER.

╔N THE CASE OF FLOATS, PF+1 POINTS
TO THE VERY NEXT FLOAT, 4 BYTES PAST
WHERE PF POINTS.

╔N 'THE C PROGRAMMING LANGUAGE', BY
╦ERNIGHAN & ╥ITCHIE THE POINT IS
MADE THAT, 'POINTER ARITHMETIC IS
CONSISTENT...ALL POINTER
MANIPULATIONS AUTOMATICALLY TAKE
INTO ACCOUNT THE SIZE OF THE OBJECT
POINTED TO...'

╬OTE:IF WE HAVE...

MAIN()
█
  FLOAT F,*PF;
  F=12.3;
  PF=&F;
▌

╔S THERE ANY TIME THAT WE WILL KNOW
WHAT IS 4 BYTES PAST THE ADDRESS OF
F?  ╘HERE IS ONE CIRCUMSTANCE WHERE
WE WILL KNOW "WHAT COMES AFTER".


┴RRAYS -

┘OU MAY RECALL, FROM AN EARLIER
LESSON, THAT WE DEFINED A STRING BY
DECLARING IT TO BE AN ARRAY OF
(SINGLE) CHARACTERS.

╫E'LL REPRODUCE IT HERE:

CHAR X[10];
DEFINES AN ARRAY OF 10 ELEMENTS.
X[0]='A';
THE FIRST ELEMENT IS THE CHAR A.
X[1]='B';
THE SECOND ELEMENT IS THE CHAR B.
X[2]=' ';
THE THIRD ELEMENT IS THE CHAR (SPACE).
X[3]='\0';
THE LAST ELEMENT IS THE 'NUMBER' 0.
PRINTF("THE STRING IS %S",X);
PRINT THE STRING, UP TO THE 0.

...AND THE PRINTOUT WOULD BE:
THE STRING IS AB

MAIN()
█
CHAR X[10], *PX;
X[0]='A';
X[1]='B';
X[2]=' ';
X[3]='\0';
PRINTF("THE STRING IS %S",X);
▌

╬OW, IF WE DEFINE PX=&X[0], A
POINTER TO THE FIRST ELEMENT IN THE
ARRAY X[], THEN: WHAT CHARACTER DOES
PX+2 POINT TO?
╘O THE CHARACTER ' ' (A SPACE).

PRINTF("%C%C%C",*PX,*(PX+1),*(PX+2));
WHAT WILL THE ABOVE PRINT?

AB (A SPACE ON THE END HERE)


PRINTF("%C",*PX); WOULD PRINT THE
CONTENTS OF MEMORY LOCATION PX,
NAMELY A, AND PRINTF("%C",*(PX+1));
PRINTS B, AND PRINTF("%C",*(PX+2));
PRINTS (SPACE), AND ALL THREE GIVE:

AB (WITH A SPACE AT THE END)

1 CHAR X[4];
2 X[0]='A';
3 X[1]='B';
4 X[2]=' ';
5 X[3]='\0';
IN THIS PROGRAM EXCERPT, WE DEFINED
SOME ELEMENTS OF THE ARRAY X[10] BY
SAYING ( LABORIOUSLY ):X[0]='A';
X[1]='B'; X[2]=''; X[3]='\0';

╞OR A CHAR ARRAY WE CAN ALSO SAY:

CHAR X[4]= 'A','B',' ','\0' ;
OR ALSO:
CHAR X[4]="AB \0";

┴S A KIND OF SHORTHAND WHICH MAKES
LINES 2-5 UNNECESSARY.

╞OR AN INT ARRAY WE CAN SAY:

INT X[3]=11,12,13;

╒NDER CERTAIN CONDITIONS, ALL ARRAYS
MAY BE INITIALIZED (DEFINED AS THEY
ARE DECLARED). ╫E'LL TALK ABOUT
THIS LATER.

═ORE POINTERS AND ARRAYS

╫HEN WE DEFINE AN ARRAY, SAY:
INT S[10];
EACH OF S[0], S[1], ETC.
ARE (2 BYTE) INTEGERS.
...AND HERE'S SOMETHING SPECIAL:

S,ALL BY ITSELF,IS A POINTER TO S[0]

1 MAIN()
2 █
3 INT S[3];
  /* DEFINE INTEGER ARRAY */
4 S[0]=11; S[1]=12; S[2]=13;
  /* DEFINE MEMBERS OF S[] */
5 PRINTF("%D",S[0]);
  /* PRINT FIRST INTEGER   */
6 PRINTF("\N%D",*S);
  /* PRINT WHAT S POINTS TO*/
7 ▌

╠INE 5 WILL PRINT 11 AND LINE 6 WILL
PRINT 11!..PROVING THAT S[0] AND *S
ARE THE SAME, RIGHT? ╙O S IS A
POINTER TO S[0], RIGHT? ╧F COURSE
IT WOULD HAVE BEEN EASIER TO SAY:
3 INT S[3]=11,12,13; AND OMIT LINE
4!  ╬OW, SINCE AN ARRAY (ANY ARRAY,
WHETHER INTS OR CHARS OR FLOATS) HAS
ITS NAME AS A POINTER (..THINK ABOUT
THAT! ), THEN NOT ONLY WILL S[2]
GIVE THE 3RD ELEMENT IN THE ARRAY,
BUT SO WILL *(S+2) GIVE THE 3RD
ELEMENT!

╚ERE'S A PROGRAM YOU'VE SEEN IN AN
EARLIER LESSON (ON STRINGS):

1 MAIN()
  █
2 CHAR S;
  /* DECLARE A CHAR VARIABLE */
3 S="I AM A STRING";
  /* INITIALIZE AS A STRING  */
4 PRINTF("%S",S);
  /* PRINT THE STRING  */
5 PRINTF("\N%S",S+2);
6 ▌

╠INE 2 DECLARES S TO BE OF TYPE CHAR.
LINE 3 DEFINES  S TO BE A STRING
(DOUBLE QUOTES, REMEMBER?). ╠INE 4
PRINTS THE %STRING, GIVING: I AM A
STRING LINE 5 PRINTS: AM A STRING
IE. TWO PAST WHERE S POINTS.

╚ERE, JUST AS FOR AN ARRAY, S IS A
POINTER TO THE STRING "I AM A
STRING". ╔N FACT, S POINTS TO THE
FIRST ELEMENT: I.  ╚ENCE, S+2 POINTS
TO THE 3RD ELEMENT (A) AND PRINTF()
WILL (UPON RECEIPT OF A %STRING
ADDRESS) PRINT EVERYTHING FROM THAT
ADDRESS UP TO THE SPECIAL TERMINATING
'\0' (...REMEMBER HIM?).

╘HE NAME OF A STRING VARIABLE IS A
POINTER TO THE FIRST ELEMENT IN THE
STRING!

╘HE NAME OF AN ARRAY VARIABLE IS A
POINTER TO THE FIRST ELEMENT IN THE
ARRAY !

╥EMEMBER!

╬OW, IF WE DECLARE CHAR A[30]; THE C-
COMPILER KNOWS THAT 'A' REFERS TO A
COLLECTION OF 30 CHARS ...AND IT
KNOWS THIS EVEN BEFORE WE DEFINE THE
ELEMENTS A[0], A[1], ETC.

┬UT, IF WE DECLARE CHAR S;, HOW IS
THE COMPILER TO KNOW WHETHER S IF A
SINGLE CHAR OR A STRING OF CHARS. ╔F,
SUBSEQUENTLY, WE SAY S="I AM A
STRING" THEN S IS A STRING ...BUT IF
WE SAY S='A' THEN S IS JUST ONE CHAR
...BUT SHOULD WE REALLY MAKE THE
COMPILER FIGURE THIS OUT? ┴FTER ALL,
THE COMPILER WOULD RESERVE A SINGLE
BYTE IN MEMORY FOR JUST ONE CHAR BUT
MAY HAVE TO RESERVE DOZENS OF BYTES
FOR A STRING OF CHARS!

═ORAL: DECLARE A SINGLE CHARACTER AS:

CHAR S;

DECLARE A STRING OF CHARS AS:

CHAR *S;

╙INCE WE (AND THE COMPILER) KNOW THAT
THE NAME OF A STRING IS A POINTER
THEN THE DECLARATION CHAR *S;
(FOLLOWED PERHAPS BY S="I'M A
STRING") JUST ANTICIPATES THE
SUBSEQUENT USE OF S AS THE NAME OF A
STRING (AS OPPOSED TO A SINGLE
CHARACTER).

CHAR S;
S="I AM A STRING";
PRINTF("%S",S);


┴LTHOUGH WE HAVE USED THE ABOVE
FORMAT IN EARLIER LESSONS...

╔T MAY NOT COMPILE!
...AND IF IT DOES

╔T MAY NOT WORK!

CHAR *S;
╔F WE USE CHAR *S THEN ALL COMPILERS
WILL ACCEPT IT.

╙O IN SUMMARY,WE HAVE:
╔F S IS THE NAME OF A STRING (DEFINED
WITH DOUBLE QUOTES) THEN S S+1 S+2
ETC POINT TO THE 1ST 2ND 3RD
ETC. MEMBERS OF THE STRING.  ╔F S IS
THE NAME OF AN ARRAY (DEFINED WITH
S[0]=... ETC.) THEN S S+1 S+2 ETC.
POINT TO THE 1ST 2ND 3RD ETC. MEMBERS
OF THE ARRAY.  ╬OW, DON'T THINK THAT
STRINGS AND ARRAYS ARE THE SAME
...AFTER ALL A STRING IS ONLY AN
ARRAY OF (SINGLE) CHAR VARIABLES
WHEREAS WE CAN ALSO HAVE ARRAYS OF
INTS OR FLOATS OR OTHER INTERESTING
DATA TYPES.

╞URTHER, THE NAME OF A STRING
POINTER IS A VARIABLE:

1 MAIN()
  █
2 CHAR *X, *Y, *Z;
  /* 3 POINTERS TO STRINGS */
3 X="ABC";
  /* X POINTS TO STRING ABC */
4 Y="DEF";
  /* Y POINTS TO STRING DEF */
5 Z=X;
  /* Z POINTS TO STRING ABC */
6 PRINTF(" THE X-STRING IS %S",Z);
7 Z=Y;
  /* Z POINTS TO STRING DEF */
8 PRINTF(" THE Y-STRING IS %S",Z);
9 ▌

╔N LINE 5 WE MAKE Z POINT TO THE SAME
THING THAT X POINTS TO
...AND LINE 6 PRINTS:

THE X-STRING IS ABC

╔N LINE 7 WE MAKE Z POINT TO THE
SAME THING THAT Y POINTS TO
...AND LINE 8 PRINTS:

THE Y-STRING IS DEF

┬UT, WE COULD ALSO SAY:

X=Y;

┴ND MAKE X POINT TO THE Y-STRING!


╙TRINGS AND 1-DIMENSIONAL
CHAR ARRAYS -

╙UPPOSE WE MAY DECLARE STRINGS C AND
X BY USING:

1 CHAR C[9]='C','-','S','T','R',
             'I','N','G','\0';
2 CHAR *X="X-STRING";

╔N THE FIRST INSTANCE, C IS A POINTER
TO AN ARRAY OF CHARACTER VARIABLES
(8 CHARS: C-STRING, PLUS THE
TERMINATING '\0').

╔N THE SECOND INSTANCE, X IS ALSO A
POINTER, BUT NOW IT'S A POINTER TO A
STRING: X-STRING WITH (AGAIN) THE
TERMINATING '\0' (WHICH C LOOKS AFTER
APPENDING).

╙O WHAT'S THE DIFFERENCE BETWEEN
CHAR C[]   AND   CHAR *X ???

╔N THE FIRST CASE, C IS A CONSTANT
POINTER TO THE FIRST ELEMENT OF THE
ARRAY ...AND CANNOT BE CHANGED. ╔N
THE SECOND CASE, X IS A VARIABLE
POINTER TO THE FIRST ELEMENT OF THE
STRING ...AND CAN BE CHANGED!

1 CHAR C[9]='C','-','S','T',
             'R','I','N','G','\0';
2 CHAR *X="X-STRING";
3 PRINTF("  %S   %S ",C,X);
  /* PRINT %STRINGS  C AND X */
4 X=C;
  /* MAKE X POINT TO C  */
5 PRINTF("  %S   %S ",C,X);
  /* PRINT %STRINGS  C AND X */

╩UST TO SHOW THAT IT IS X (AND NOT C)
WHICH IS A VARIABLE, WE
DECLARE/DEFINE THEM BOTH IN LINES 1
AND 2.  THEN PRINT THEM BOTH IN LINE
3. WE WOULD GET:

  C-STRING   X-STRING

╘HEN WE CHANGE X, IN LINE 4, SO IT
POINTS TO THE SAME THING AS C DOES,
THEN PRINT THEM BOTH AGAIN, IN LINE
5 WE'D GET:

  C-STRING   C-STRING

┘OU MUST NOT TRY:

C=X;

┬ECAUSE IT WON'T COMPILE!

┴RRAY NAMES POINT (ALWAYS AND
FOREVER) TO THE FIRST ELEMENT OF THE
ARRAY!

╔N ADDITION TO AN ARRAY SUCH AS X[10]
(WITH 10 ELEMENTS, WHICH MAY BE
CHAR,INT,FLOAT,ETC.),HERE'S A DOUBLE
ARRAY:

FLOAT X[5][7];

╘HIS DECLARES AN ARRAY OF 5*7=35
FLOATING POINT NUMBERS. ╫E MAY DEFINE
ANY OR ALL OF THEM (FOR EXAMPLE WE
MAY WRITE X[2][1]=1.5). ╫E THINK OF
THIS ARRAY AS BEING ARRANGED LIKE SO:

X[0][0] X[0][1] X[0][2] X[0][3]
X[0][4] X[0][5] X[0][6] X[1][0]
X[1][1] X[1][2] X[1][3] X[1][4]
X[1][5] X[1][6] X[2][0] X[2][1]
X[2][2] X[2][3] X[2][4] X[2][5]
X[2][6] X[3][0] X[3][1] X[3][2]
X[3][3] X[3][4] X[3][5] X[3][6]
X[4][0] X[4][1] X[4][2] X[4][3]
X[4][4] X[4][5] X[4][6]

╥EMEMBER IN C ARRAYS ALWAYS START
WITH ELEMENT NUMBER ZERO!

╬OW, IF WE DEFINE X[2][1]=1.5,
THE NUMBER 1.5 GOES HERE:

X[2][1]

...AND, AS YOU MIGHT EXPECT, WE CAN
HAVE 3-DIMENSIONAL ARRAYS, ETC.

X[I][J][K]


╫HEN WE DECLARE A MULTI-DIMENSIONAL
ARRAY, AS IN FLOAT X[5][7], THE C-
COMPILER KNOWS THAT EACH ELEMENT
OCCUPIES 4 BYTES IN MEMORY (BECAUSE
IT'S AN ARRAY OF FLOATS) ...HENCE IT
KNOWS NOT ONLY HOW MUCH MEMORY IS
NEEDED BUT WHERE EACH ELEMENT IS.
╙TARTING AT THE ADDRESS OF THE FIRST
ELEMENT, &X[0][0], WE FIND THE
ADDRESS OF X[2][1] BY MOVING 7*2+1=15
ELEMENTS ALONG THE ARRAY ...AND AT 4-
BYTES-PER-ELEMENT THAT MEANS MOVING
4*15=60 BYTES THROUGH MEMORY.

╬OTICE HOW IMPORTANT THE NUMBER OF
COLUMNS IS TO THE C-COMPILER (IN THE
DECLARATION FLOAT X[5][7] WITHOUT
THIS DIMENSION THE COMPILER WOULDN'T
KNOW HOW TO GET TO X[2][1]!

╔N FACT, YOU MAY LEAVE OUT THE NUMBER
OF ROWS IN DECLARING THIS ARRAY
(AND USE FLOAT X[][7] INSTEAD!)!

┴ 2-DIMENSIONAL ARRAY IS TREATED (BY
C) AS A 1-DIMENSIONAL ARRAY EACH OF
WHOSE ELEMENTS IS A 1-DIMENSIONAL
ARRAY.

╘HE ARRAY FLOAT X[5][7] CONSISTS OF 5
1-DIMENSIONAL ARRAYS, CALLED (IN C-
SPEAK), X[0], X[1], X[2], ETC. AND
EACH OF THESE 1-DIMENSIONAL ARRAYS
HAS 7 ELEMENTS.

╙INCE (FOR EXAMPLE) THE ELEMENT 3  OF
AN ARRAY SAM IS CALLED SAM[3] THEN
ELEMENT 3 OF THE (1-DIMENSIONAL)
ARRAY X[2] IS CALLED X[2][3]
...WHICH EXPLAINS THE C-NOTATION
FOR 2-DIMENSIONAL ARRAYS, X[I][J],
RATHER THAN (THE MORE USUAL) X[I,J].

╔N FACT, YOU MAY REFER TO X[2][3] AS
(X[2])[3] ...MEANING ELEMENT 3 OF
THE (1-DIMENSIONAL) ARRAY X[2]
(ACTUALLY THE 4TH ELEMENT SINCE THE
FIRST IS ELEMENT 0 !!!@#$*).

X[2][0] X[2][1] X[2][2] X[2][3]
X[2][4] X[2][5] X[2][6]


╔F C REGARDS X[5][7] AS CONSISTING OF
5 1-DIMENSIONAL ARRAYS X[0], X[1],
X[2], X[3], AND X[4] THEN WHAT DOES
(FOR EXAMPLE) X[2] REFER TO ?  ╫HAT
HAPPENS IF WE PRINTF() X[2]?  ╔S X[2]
JUST A NOTATION OR DOES IT REFER TO
ONE OF THE 5*7=35 MEMBERS OF X[5][7]?

┴CTUALLY, ├ IS VERY CLEVER. X[2] (ALL
BY ITSELF) IS A POINTER TO THE FIRST
ELEMENT IN THE 1-DIMENSIONAL ARRAY
X[2], NAMELY  X[2][0] !

╥EMEMBER: ALTHOUGH X[2][0] GIVES THE
VALUE OF ELEMENT X[2][0], X[2] GIVES
THE ADDRESS OF X[2][0]!!

╙INCE X[2] IS A POINTER TO X[2][0],
THEN ADDRESS ARITHMETIC CAN BE USED
TO OBTAIN THE ADDRESS OF ANY ELEMENT
IN THE 1-DIMENSIONAL ARRAY X[2].

╘HAT MEANS THAT WE COULD IDENTIFY THE
ELEMENT X[I][J] BY POINTING JUST J
ELEMENTS PAST THE ADDRESS OF X[I][0].

╘HAT MEANS THAT X[I]+J IS A POINTER
TO X[I][J]

╘HAT MEANS THAT THE 'VALUE' OF THIS
ELEMENT IS *(X[I]+J).

╥EMEMBER: IF X[I]+J IS A POINTER,
THEN *(X[I]+J) IS WHAT IT POINTS TO!
AND THAT MEANS THAT *(X[2]+3) AND
X[2][3] ARE EQUIVALENT



╫HAT'S IN A NAME ? (OF AN ARRAY) -

╘HE  NAME  OF A  1-DIMENSIONAL ARRAY
IS A POINTER TO THE FIRST ELEMENT OF
THE ARRAY!


╙O, IF X IS AN ARRAY, DECLARED AS
INT X[10], THEN X IS A POINTER TO
X[0] (SINCE X IS 1-DIMENSIONAL).

┴ND, IF X IS AN ARRAY, DECLARED AS
INT X[10][15], THEN X[7] IS A
POINTER TO X[7][0] (SINCE X[7] IS
1-DIMENSIONAL).  SOUNDS OK!
...AND FINALLY, WE MAY:

PRINTF("%D",X[7][2]);

╘O PRINT THE VALUE OF
THE ELEMENT, OR WE MAY:

PRINTF("%D",*(X[7]+2));

╘O PRINT THE VALUE OF THE SAME
ELEMENT.

[END OF LESSON 6 OF 11]