/* 

	Here, i will attempt to show you some simple concepts of 'pointers'
	Including a few common uses, as well as the differences
	between a dereference and a  reference pass...

*/

/* standard include file for IO.... */

#include <stdio.h>
#include <stdlib.h>


/* Main function */

int main ( int argc, char * argv[] )

/*
	The above is a stack pointer, it's placed on the current
	execution space of the program (the memory is allocated at startup).
	There's no heap used here and thus we don't 'free' any memory.
	argv[] is a string constant,
	it's the command line passed to the program
	on startup. Where [0] is the actual executable name
*/

{

	/* Now, let's make a pointer! */

	char *FirstPointer; /* This is a 'stack pointer' */

/*

	Remember that the above IS a pointer, but it's an stack-space
	one. Meaning it's allocated at startup.

	The stack can only be a certian size, if all the data 
	won't fit on it, it may get cut off or give
	undefined behaviour. So let's convert our 'stack' to a
	'heap pointer below
*/

	FirstPointer = (char *) malloc(sizeof(char) * 200000);

/*
	OK! Now we have a nice, BIG space in the 'heap' (the rest of the 
	system's RAM that's not beeing used by a program). We'll just
	work with data under 200000 bytes long for now so as not to cause
	a memory leak. So, what shal we -do- with our baby? Hmm, i have
	an idea.....
*/

	*FirstPointer = (char *)"Hello There, i belong on the heap!\n";

/*	Let's make it say something for us!
	The trick here is the asterisk (*) will 'dereference' the pointer.
	When we dereference a pointer, we no longer worry about the
	memory address, we worry about, and work with the DATA!
	If we work by REFERENCE we are working with the ADDRESS!
	The &-sign is the reference operator, we'll work with that soon.
*/

	/* Let's put something on screen... */

	printf("%s", FirstPointer);

/*	Ok, we have text-on-screen action! Sexy! Now, let's make another
	pointer, here's where reference play comes in!
*/

	char *SecondPointer; /* Another char (byte) pointer, to match types with the first one. */

/*	Now let's see what happens if we do the following.... */

	SecondPointer = (char *)&FirstPointer;

/*	We passed the ADDRESS of the 'FirstPointer' (our heap pointer)
	to our second, which can accept the address, let's print the
	second one to the screen!
*/

	printf("%s", SecondPointer);

/*	Sweet, more screen action! Now let's do something a bit odd....
*/

	char *ThirdPointer; /* Wow this crap is becomming common.... */

	ThirdPointer = (char *) *SecondPointer;

/* 	Hmm, interesting... We have just copied the data from the FIRST
	pointer to the third! But how???

	It's simple, when we did the address assign (&FirstPointer)
	earlier in the code, it placed the address in SecondPointer.
	That links SecondPointer and FirstPointer together! They can share
	data now. ThirdPointer now equals the data of second pointer, 
	which by address points to first pointer, so we have a circle.

	Let's see it in action.....
*/

	printf("%s", ThirdPointer);

/*	Yay, more output, But what happens if we do something like this?
*/

	printf("%s  %s   %s", &FirstPointer, &SecondPointer, &ThirdPointer);

/*	Well, what'cha know? We have the addresses on screen of all
	three pointers! Two of them (first and second) should be the same
	While third should be different.....

	Reason for third beeing different???

	We didn't assign it ANY Address, ONLY data!

	Ok, we have worked with our pointers and are all done....
	What do we do now? THat funny malloc() stuff did something
	right? Yes it did! It told the kernel of the OS to allocate
	some of the computer's RAM so we could put stuff in it.
	Now we need to be nice to the OS and our computer and
	give the RAM back with free(). Free() tells the kernel
	'We're done, you can have this back now'. If a program with an
	malloc() ends without a free() to release, you have a memory leak.

	A memory leak is when RAM is allocated and not freed once the 
	stack is destroyed (main returns and exits). The RAM is still
	there and possibly usable, but it hasn't been set back to 
	zero-byte yet. So to be nice let's free......
*/

	free(FirstPointer); /* Done, no mem leaks now! */

	/* And a nice return to let the kernel know we're all done */

	return 0;

}