#ifndef _IMBASE_CPP_
#define _IMBASE_CPP_

#include "list.h"
#include "IMBase.h"


util::list<IMBase*> IMBase::activeList;		///< The list of active objects (with ref_count > 0)
util::list<IMBase*> IMBase::deadList;		///< The list of dead objects (with ref_count == 0)


#endif

#ifndef _IMBASE_H_
#define _IMBASE_H_

#include "list.h"

/**
 * Provides the basic menmory managment for objects.
 */
class IMBase
{
private:

	static util::list<IMBase*> activeList;		///< The list of active objects (with ref_count > 0)
	static util::list<IMBase*> deadList;		///< The list of dead objects (with ref_count == 0)

	long ref_count;			///< Reference variable

public:

	// functions
};

IMBase.obj : error LNK2001: unresolved external symbol 
"public: __thiscall util::list<class IMBase *>::list<class IMBase *>(void)" (??0?$list@PAVIMBase@@@util@@QAE@XZ)
IMBase.obj : error LNK2001: unresolved external symbol 
"public: __thiscall util::list<class IMBase *>::~list<class IMBase *>(void)" (??1?$list@PAVIMBase@@@util@@QAE@XZ)
Debug/test.exe : fatal error LNK1120: 2 unresolved externals

#ifndef _UTIL_LIST_H_#define _UTIL_LIST_H_#include <stddef.h>namespace util{/** * A templated doubly linked list class */template <class T>class list{private:	/**	 * A node in a doubly linked list.	 */	struct Node{		T obj;			///< An object of type T		Node* next;		///< A pointer to the next node		Node* prev;		///< A pointer to the previous node		/**		 * Constructor		 * \param o A const reference to an object of type T		 * \param n A pointer to the next node in the list		 * \param p A pointer to the previous node in the list		 */		Node(const T& o, Node* n = NULL, Node* p = NULL)			:	obj(o), next(n), prev(p)		{	}	};	Node* head;				///< The first linked list element in the list	unsigned int size;		///< The number of elements in the listpublic:	/**	 * An iterator that is used to step through the linked list	 */	struct iterator{	private:		friend class list<T>;		///< Declare this a friend to list<T> so, list<T> can access its members		Node* current;				///< The current list element being pointed to	public:		/**		 * Constructor		 * \param n A pointer to an element in the list		 */		iterator(Node* n = NULL)			:	current(n)		{	}		/**		 * Overloaded operator*  (for de-referencing)		 * \return A reference of type T to the object element of the		 */		T& operator*()		{	return current->obj;	}		/**		 * Overloaded prefix operator++ (but will be used as postfix default function for iterator)		 * Moves the iterator forward in the list		 */		void operator++(int j)			{				if( current == NULL )				return;			else				current = current->next;		}		/**		 * Overloaded prefix operator-- (but will be used as postfix default function for iterator)		 * Moves the iterator backward in the list		 */		void operator--(int j)		{			if( current == NULL )				return;			else				current = current->prev;		}		/**		 * Overloaded operator==		 * \param i A const reference to an iterator object		 * \return true if current pointer is equal to i.current pointer, else false		 */		bool operator==(const iterator& i)	{	return current == i.current;	}		/**		 * Overloaded operator!=		 * \param i A const reference to an iterator object		 * \return true if current pointer is not equal to i.current pointer, else false		 */		bool operator!=(const iterator& i)	{	return current != i.current;	}		/**		 * Overloaded assignment operator		 * \param i A const refernce to an iterator object		 * \return A reference to 'this' iterator object		 */		iterator& operator=(const iterator& i)		{			if( &i != this )				current = i.current;			return *this;		}	};	// iterator	/**	 * Constructor	 */	list();	/**	 * Copy constructor	 * \param l A const reference to a list object	 */	list(const list& l);	/**	 * Destructor	 */	~list();	/**	 * Delete all elements in the list.	 */	void clear();	/**	 * Return an iterator to the first element in the list	 * \return An iterator object to the first element in the list.	 */	iterator begin() const;	/**	 * Return an iterator to the point after the last element in the list,	 * which effectively is a NULL pointer.	 */	iterator end() const;	/**	 * Add an element to the back of the list.	 * \param o A const reference to an object of type T	 */	void push_back(const T& o);	/**	 * Add a list element to the front of the list	 * \param o A const reference to an object of type T	 */	void push_front(const T& o);	/**	 * Insert an item in the list before the item pointed to by the specified iterator.	 * \param i An iterator pointing to the item to insert before	 * \param o The item to insert before iterator i	 */	void insertBefore(iterator& i, const T& o);	/**	 * Insert an item in the list after the item pointed to by the specified iterator.	 * \param i An iterator pointing to the item to insert after	 * \param o The item to insert after iterator i	 */	void insertAfter(iterator& i, const T& o);	/**	 * Erase the element at this iterator.	 * \param i A const reference to an iterator object	 */	void erase(iterator& i);	/**	 * Erase a list element.	 * \param pos The position of the element to erase 	 */	void erase(unsigned int pos);};} // namespace util#endif

class IMBase{    // class definition ^^};util::list<IMBase*> IMBase::activeList;		///< The list of active objects (with ref_count > 0)util::list<IMBase*> IMBase::deadList;		///< The list of dead objects (with ref_count == 0)