Indirection (Poe, Nov 23 1993, 48) | Documentation bulletin board | bulletin boards

           A
          / \      _             Play Now                         Nemesis on 
          | |     | |  _______   _        _   _______    _______   _    _______
          | |\    | | |   ____| |  \    /  | |   ____|  /   ____| | |  /   ____|
 /-------/-------------------------------------------------------------------,
O= Home <=XX|  About  News  Pics  Adventurers  Wizards  Download  Connect     >
 \-------\-------------------------------------------------------------------'
          | |   \   | |  |____  | |      | | |  |____   ___ \  \  | |  ___ \  \
          | |     \_| |_______| |_|      |_| |_______| |_______/  |_| |_______/
          \ /
           V

Nemesis bulletin boards: Documentation bulletin board, note 23

Indirection (Poe, Nov 23 1993, 48)

At times I like to bring in new concepts for people who either didn't know
about them, or never really understood what was happening when they used them.
Indirection is a very useful way of accessing modules of code, objects, and 
variables in memory.  First, I should talk about the concept of pointers.

Without knowing, most LPC coders use pointers all the time.  Pointers are 
variables which "point" at areas in memory (primary or secondary).  They are
very useful to people who know how to use them.

	Consider that you have a variable called 'bopeep' of type integer.  
Somewhere in memory, the computer has allocated a few bytes to store this. It
happens that in Nemesis it's 4 bytes.  If you want to use the number in that
memory location you use the variable name 'bopeep'. 

	For example:  printf("%d\n", bopeep);

	Every variable has a numerical address in memory.  There is a specific
operator you can use to find the address of the variable, here's how:

			&bopeep

	The '&' (address of) operator when added to the beginning of a variable
makes the statement take on the numerical value of the address.  This in itself
is not very useful.  But this is where pointers come in.

	Consider that you have a variable and you want to pass it to a function
which will change the variable without having to use a return value... Well, in
that case you need a pointer.  To use a pointer first you need to declare it
like any other variable.  If we want a pointer to bopeep we need to declare a
pointer of the same type, integer.

		Example: int *sheep;

	This declares a pointer with the name sheep, but we haven't assigned
any value to it yet... right now it's just pointing off somewhere (who knows).
Now we need to assign the sheep to bopeep ;).

		We can do: sheep = &bopeep;

	In the example above we are assigning a pointer 'sheep' to the memory
location of bopeep.  Sheep is "pointing at" bopeep.

		Example: *sheep = 1;

	"That which is pointed to by sheep gets 1."  This places the value 1
into the memory location being pointed to by sheep.  Since sheep is pointing at
bopeep, the variable bopeep now has the value of 1.  

	In LPC we have objects.  Objects are simply pointers to places in memory
where programs are loaded.  Since we have all these functions, we don't usually
realize that they are pointers.  The functions take care of the dereferencing
for us.  Similarly, strings are actually arrays of characters.  The name of a
string is a pointer to the first member of the array, but strings can also be
accessed as an array.  Functions like printf take a pointer and when they go to
display the information, they print out each member of the array until they come
to a NULL character that marks the end.

	Since objects are pointers to loaded programs, we can use a special 
operator to access functions in them.  The '->' member access operator, tells
the computer to look into the object and call the function. 

	Example:  this_player()->query_name();

	This tells the computer to look for the object called this_player() and
do the function query_name() in that loaded program.

	The member access operator can also be used with a string file name. 
This comes in handy when an object hasn't been loaded into memory.  If the 
object hasn't been compiled and loaded, the computer loads it and calls the 
function in it.

		Example:  "players/poe/object/sheep"->baa();

	I hope you have the chance to use some of these concepts in your coding,
they've been very useful to me.

>>-Poe-> Chris.


P.S. (Admins) Please feel free to correct me if I've stated anything wrong.

This board is to document how to code various stuff in Nemesis.
Within Nemesis it is located in the inner guild in the village.
If you have written documents that should be placed here or
if you think something important is missing please contact an
Archwizard - see 'help admin' or https://nemesis.de/lpc/help/admin .
Nowadays especially new features etc. are posted here.
The board contains 49 notes:

This page was generated in LPC

Imprint / Impressum