Ошибка компоновщика

[ISergeyN]

Пробуй так (пример..)

file list_iterator.h

#ifndef list_iterator_h__
#define list_iterator_h__

template<typename T, typename item , typename f_list >
class list_iterator{
public:
	list_iterator(): cur(0) { }
	list_iterator(item *rhs): cur(rhs) { }

	list_iterator& operator ++()    { cur = cur->next; return *this; }
	list_iterator& operator --()    { cur = cur->prev; return *this; }
	list_iterator  operator ++(int) { list_iterator tmp = *this; cur = cur->next; return tmp; }
	list_iterator  operator --(int) { list_iterator tmp = *this; cur = cur->prev; return tmp; }

	list_iterator& operator +=(int num)
	{
		if(num > 0)
		{
			while (num-- && this->cur != 0) ++(*this);
		}
		else
		{
			while(num++ && this->cur != 0) --(*this);
		}
		return *this;
	}

	list_iterator  operator + (int num) const { list_iterator tmp = *this; return tmp += num; }
	list_iterator& operator -=(int num) const { return (*this)+=(-num); }
	list_iterator  operator - (int num) const { return (*this)+ (-num); }

	bool operator ==(const list_iterator& rhs) const { return cur == rhs.cur; }
	bool operator !=(const list_iterator& rhs) const { return cur != rhs.cur; }

	T & operator * () { return  cur->data; }
	T * operator ->() { return &cur->data; }
private:
	item *cur;
	friend f_list;
};

#endif // list_iterator_h__

file list.h

#ifndef list_h__
#define list_h__

#include "list_iterator.h"

template <typename T>
class list_item{
public:
	list_item() : next(0),prev(0) {};

	list_item *next;
	list_item *prev;
	T data;
};


template<typename T, typename _item = list_item<T> >
class list{
public:
	typedef typename _item item;
	typedef typename list_iterator<T, _item, list > iterator;


	list():first(0),last(0),count(0) {};
	list(const list<T> &rhs): first(0),last(0),count(0){ *this = rhs; }
	~list();


	void operator = (const list<T, _item>& rhs);
	unsigned size();
	void clear();
	bool empty() const;
	void push_back(const T& element);
	void push_front(const T& element);

	iterator begin();
	iterator end();

	iterator getLast();

	void insert_after(const iterator& it,  const T& element);
	void insert_before(const iterator& it, const T& element);

	iterator erase(iterator& it);
private:
	item *first;
	item *last;
	unsigned count;
};

#include "list.hpp"

#endif // list_h__

[ISergeyN]

file list.hpp

template <typename T, typename _item>
list<T, _item>::~list(){
	clear();
}

template <typename T, typename _item>
void list<T, _item>::operator = (const list<T, _item>& rhs){
	if(&rhs == this){
		return;
	}

	clear();

	item* node = rhs.first;
	while(node){
		push_back(node->data);
		node = node->next;
	}
}

template <typename T, typename _item>
unsigned list<T, _item>::size() {
	return count;
}

template <typename T, typename _item>
void list<T, _item>::clear(){
	while(first)
	{
		item * next = first->next;
		delete first;
		first = next;
	}

	last = 0;
	count = 0;
}

template <typename T, typename _item>
bool list<T, _item>::empty() const{
	return (first == 0);
}

template <typename T, typename _item>
void list<T, _item>::push_back(const T& element){
	item* node = new item;
	node->data = element;

	++count;

	if (first == 0)
		first = node;

	node->prev = last;

	if (last != 0)
		last->next = node;

	last = node;
}

template <typename T, typename _item>
void list<T, _item>::push_front(const T& element)
{
	item* node = new item;
	node->data = element;

	++count;

	if (first == 0)
	{
		last = node;
		first = node;
	}
	else
	{
		node->next = first;
		first->prev = node;
		first = node;
	}
}

template <typename T, typename _item>
typename list<T, _item>::iterator list<T, _item>::begin(){
	return iterator(first);
}

template <typename T, typename _item>
typename list<T, _item>::iterator list<T, _item>::end(){
	return iterator(0);
}

template <typename T, typename _item>
typename list<T, _item>::iterator list<T, _item>::getLast(){
	return iterator(last);
}

template <typename T, typename _item>
void list<T, _item>::insert_after(const typename list<T, _item>::iterator& it, const T& element){
	item* node = new item;
	node->data  = element;

	node->next = it.cur->next;

	if (it.cur->next)
		it.cur->next->prev = node;

	node->prev = it.cur;
	it.cur->next = node;
	++count;

	if (it.cur == last)
		last = node;
}

template<typename T, typename _item> 
void list<T, _item>::insert_before(const typename list<T, _item>::iterator& it, const T& element){
	item* node = new item;
	node->data = element;

	node->prev = it.cur->prev;

	if (it.cur->prev)
		it.cur->prev->next = node;

	node->next = it.cur;
	it.cur->prev = node;
	++count;

	if (it.cur == first)
		first = node;
}

template<typename T, typename _item> 
typename list<T, _item>::iterator list<T, _item>::erase(typename list<T, _item>::iterator& it){

	iterator returnIterator(it);
	++returnIterator;

	if(it.cur == first)
		first = it.cur->next;
	else
		it.cur->prev->next = it.cur->next;

	if(it.cur == last)
		last = it.cur->prev;
	else
		it.cur->next->prev = it.cur->prev;

	delete it.cur;
	it.cur = 0;
	--count;

	return returnIterator;
}

file main.cpp

#include <iostream>

#include "list.h"

int main(){
	list<int> ls;
	list<int>::iterator it;

	for(int i = 1; i <= 10; ++i)
		ls.push_back(i);

	it = ls.begin();

	for(; it != ls.end(); ++it)
		std::cout << *it << ' ';

	std::cout << std::endl;
	return 0;
}

Сообщение от Результат

1 2 3 4 5 6 7 8 9 10
Для продолжения нажмите любую клавишу . . .