#include <iostream>
#include <new>
#include <stdio.h>
using namespace std;
class LinkList
{

  public:
  template <class X> X *CreateObject(X Head);
  template <class X> X *FindEndObject(X *Node);
  template <class X> void AddToLinkList(X *Adding,void *LastObject);
  template <class X> void MakeNewObject(X NewThing);
  void *Next;
  static void *Head;

};
class Player
{
 public:
 LinkList Node;
 char Face[20];
};

int main(int argc, char *argv[])
{
   Player Frank;
   Frank.Node.Head = &Frank

}

template <class X> X *LinkList::CreateObject(X Head)
{
  X *Sample = new X;
  return Sample;
  
}

template <class X> X *LinkList::FindEndObject(X *Node)
{
    X* tmpRoom = static_cast<X*>(Node);
    while(tmpRoom->Next)
    {
      tmpRoom = static_cast<X*>(tmpRoom->Next);
    }
    return tmpRoom;
}

template <class X> void LinkList::AddToLinkList(X *Adding,void *LastObject)
{
  X* Temp = reinterpret_cast<X*>(LastObject);
  Temp->Next = Adding;
}

template <class X> void LinkList::MakeNewObject(X NewThing)
{
  AddToLinkList(CreateObject(NewThing),FindEndObject(Next));

}

void* LinkList::Head(0);

Quote:Original post by Fruny
How would I use the standard library to solve this problem? I never seen anything in it that would help me besides using vectors.

There is a std::list class template.

And I heard some where their is a serious down fall to using vectors something like it takes alot more memory.

std::vector does over-allocate to allow you to add elements without requiring an allocation every time, but it is not a "serious downfall".

And these link list will be 1000 plus long so there will already be alot of meomory being used.

1000+ elements is not a lot. Unless your objects are tiny, the linked list overhead: two pointers per list object and two pointers per element (it is a doubly-linked list) is not worth losing sleep over.