Check at the bottom to see a super quick usage tutorial

Changes from 1.9 to 2.0 FINAL:
Wow this bug was in the 1.9 FINAL code for 8 months before I finally found
it!  Tells you how often I use the "safe" functions.  Either ways the func
worked but it copied the data so you couldn't modify the data in the list
and it left the copy open for memory leaks since the specs didn't say you
needed to delete the memory after this call!  I know it's "less safe" now
but it is "proper."  Use the bool GetItem(int, linkdata&) if you want the
"safe" functionality.
A confliction with the BSD link function was also fixed by capitalizing
the word Link.  This is an internal modification and will not affect
anything you will see, except you can use this list if you are using UNIX
BSD sockets now without resorting to the annoying namespace {}.
The names were changed from .cc to .cpp to ensure better compatability
with Microsoft and Borland compilers.

Changes from 1.8b to 1.9 FINAL:
  Fixed bug when a negative index was passed to a function
  MakeLinear returns NULL when the list is empty, as it should

Changes from 1.7 to 1.8b:
  Fixed some silly errors forgetting template lines and now I find out you
   can't use templates in a dedicated .cc file!

Changes from 1.7 to 1.8:
 LinkList restructuring -- seperate code/include files.
 Added void Swap(LinkList<linkdata> &l) to swap this list with parameter
 Added bool IsOverEnd() which is alike to the old IsAtEnd, true if list has
  run over
 Changed bool IsAtEnd() which returns true if the list is on the last
  element

Changes from 1.6 to 1.7:
 _DeleteThis now returns all memory back like it's supposed to
 Added some additional line-by-line comments, espically in the Advanced
  functions

Changes from 1.5 to 1.6:
 Added bool IsAtEnd() function, useful in sorting/searching to determine if
  an element wasn't found
 _AddHere(linkdata*) and _MoveHere(linkdata*) now update Length() correctly
 Took off the lame unsigned int crap.  Now LinkList has a maxium of only
  2 billion elements now.  This should clear up a lot of unsinged to signed
  confusions.  Sorry for being so lame guys!

Changes from 1.4 to 1.5:
 Fixed bug in destructor that didn't release all memory back
 Added Clear() function to delete all data in LinkList (start anew)
 Acutally updated the #define linklistver this time
 Added MakeLinear() to get linear copies of LinkList

Changes from 1.3 to 1.4:
 Added #define TDLinkList option to allow LinkLists of LinkLists
 Added _AddHere(linkdata*) and _MoveHere(linkdata*) to allow for sorted
  LinkLists

Changes from 1.2 to 1.3:
 Rewrote _DeleteThis() function which had serious memory leaks.

Changes from 1.1 to 1.2:
 Some additional comments and bug fix in _MoveData when it didn't increment
  the length

PURPOSE:
I designed this class with game programming in mind, with OOP in mind. My
 designed use was to pass through the array each frame, and on the way
 through, change data, delete it, add data, etc.  The functions beginning
 with the underscore are made for this purpose, and should not be used
 unless comfortable with pointers, and breaching information hiding for the
 sakes of speed and efficiency.  It was meant for speed, a dynamic array
 that could add or lose huge amounts of data per frame.  I made it templated
 so that any large object could be used.  I intended on using large objects
 in the linklist, that is the reason why everything is in pointers and not
 copied.  The non-optimized functions are to allow the class to be accessed
 in a more casual (not speed-pressed) programming environment, and as a
 pointer/linklist learning tool.

NOTE TO NOVICES:
 This file is fully commented so it is easy to learn from.
 The bool functions, and other functions that pass data by reference are
 in general pretty safe to use.  Stay away from the pointer functions
 unless you make sure you are in bounds and/or check for a NULL return.

NOTE TO ADVANCED:
 I left out a lot of slow error-checking statements,
 espcially in the optimzed routines.  Be advised to check wether each
 function copies, and what it does in an error.  I had a few choices to
 deal with errors, and I didn't want to add iostream.h for stderr, to
 decrease mem use.  If you play the cards right, error-check should never be
 needed.  Use the fact that the optimzed functions allow breaches in the
 information hiding, access sequentially, and modify info and move on.

DATA STORAGE:
The data is stored in a stack-like LIFO, the last item added is element 0.

WHAT CAN BE STORED?:
linkdata can refer to any structure of data since there is no operators
 required in this class besides the = operator (not the copy constructor).

SPEED CONCERNS:
Keep in mind that any indexed accesses will be very slow, so use the
 GetNext() functions and similars.

ERROR CHECKING:
In general, bool functions return true on success, and false on failure.
In general, linkdata * functions return the ptr on success, NULL on failure.
 ***NOTE:*** Checking for NULL is highly recommended on the linkdata *
   functions.  If you don't want to do this, use the functions with refrence

SAMPLE CODE:
Look at LinkEx.cc for sample interaction with the class.
 (Avaliable at http:skyscraper.fortunecity.com/solarcity/552/)

USAGE:
There should be only 2 main ways to access the LinkList, which are the following:
(Untweaked, simple, easy to learn, and slightly slower and a tad more inflexable)
  LinkList<linkdata> l; //linkdata is the data type that is chosen
  l.AddItem(somedata);  //somedata is of type linkdata
  l.SetToStart();       //ALWAYS call this before running a tranversal loop
  linkdata somevar;
  while (GetNext(somevar)) { //The next value is stored in somevar
    DoStuffToData(somevar);
    //Cannot delete while in loop like advanced functions
  }

(Tweaked out, dangerous, super fast, and very flexable, breaks every nice
  comp. sci. rule ever created)

  LinkList<linkdata> l;
  linkdata *data = new data;
  *data = something;
  l._MoveData(data);        //Memory allocation is LinkList's responsibility now
  l.SetToStart();
  int l = l.Length();
  for (int c=0; c<l; c++) {
    data = l._GetNext();    //The data the ptr points too isn't copied!
    DoStuffTo(data);        //Feel free to modify the data!
      (or if using classes, structs)
    l._GetNext()->SomeFunctionOrData(); //Act like it's an object
      (or)
    *l._GetNext() = *LinkDataPtr; //modify!  Break out of info hiding!

    if(DoWeNeedToDelete(data))
      l._DeleteThis();      //_DeleteThis counts as an advance
    else
      l._Advance();         //Go on to next element
  }
