模板容器类及迭代器的实现二（基于链表）

节点类头文件node.h：

#ifndef MAIN_WTF_NODE1_H

#define MAIN_WTF_NODE1_H

#include <cstdlib>

namespace main_wtf_6B

{
template<class Item>
class node
{
public:
typedef Item value_type;
node(const Item& init_data = Item(),node* init_link = NULL)
{
data_field = init_data;
link_field = init_link;
}

void set_data(const Item& new_data)
{
data_field = new_data;
}

void set_link(node* new_link)
{
link_field = new_link;
}

Item data() const
{
return data_field;
}

const node* link() const
{
return link_field;
}

node* link()
{
return link_field;
}

private:
Item data_field;
node* link_field;
};
template<class Item>
std::size_t list_length(const node<Item>* head_ptr);

template<class Item>
void list_head_insert(node<Item>*& head_ptr,const Item& entry);
template<class Item>
void list_insert(node<Item>*& previous,const Item& entry);
template<class NodePtr,class Item>
NodePtr list_search(NodePtr head_ptr,const Item& target);

template<class Item>
void list_head_remove(node<Item>*& head_ptr);
template<class Item>
void list_remove(node<Item>* previous_ptr);
template<class Item>
void list_clear(node<Item>*& head_ptr);
template<class NodePtr>
NodePtr list_locate(NodePtr head_ptr,std::size_t position);
template<class Item>
void list_copy(const node<Item>* source_ptr,node<Item>*& head_ptr,node<Item>*& tail_ptr);

template <class Item>
class node_iterator: public std::iterator<std::forward_iterator_tag,Item>
{
public:
node_iterator(node<Item>* init = NULL)
{ current = init; }

Item& operator*() const
{ return current->data(); }

node_iterator& operator++()
{
current = current->link();
return *this;
}
node_iterator& operator++(int)
{
node_iterator original(current);
current = current->link();
return original;
}
bool operator ==(const node_iterator other) const
{ return current == other.current; }

bool operator !=(const node_iterator other) const
{ return current != other.current;}
private:
node<Item>* current;
};

template <class Item>
class const_node_iterator: public std::iterator<std::forward_iterator_tag,Item>
{
public:
const_node_iterator(node<Item>* init = NULL)
{ current = init; }

Item& operator*() const
{ return current->data(); }

const_node_iterator& operator++()
{
current = current->link();
return *this;
}
const_node_iterator& operator++(int)
{
const_node_iterator original(current);
current = current->link();
return original;
}
bool operator ==(const const_node_iterator other) const
{ return current == other.current; }

bool operator !=(const const_node_iterator other) const
{ return current != other.current;}
private:
const node<Item>* current;
};

}

#include "node.template"

#endif

节点类实现文件node.template：

#include"node2.h"

namespace main_wtf_6B

{

template<class Item>

std::size_t list_length(const node<Item>* head_ptr)

{
size_t answer = 0;
const node<Item>* cursor;
for(cursor = head_ptr; cursor != NULL; cursor = cursor->link())
{
++answer;
}
return answer;

}

template<class Item>

void list_head_insert(node<Item>*& head_ptr,const Item& entry)

{
head_ptr = new node<Item>(entry,head_ptr);

}

template<class Item>

void list_insert(node<Item>*& previous,const Item& entry)

{
node<Item>* insert_ptr;

insert_ptr = new node<Item>;
insert_ptr->set_data(entry);
insert_ptr->set_link(previous->link());
previous->set_link(insert_ptr);

}

template<class NodePtr,class Item>

NodePtr list_search(NodePtr head_ptr,const Item& target)

{
NodePtr cursor;
for(cursor = head_ptr;cursor != NULL;cursor = cursor->link())
if(target == cursor->data())
return cursor;
return NULL;

}

/*

const node<Item>* list_search(const node<Item>* head_ptr,const node<Item>::value_type& target)

{
const node<Item>* cursor;
for(cursor = head_ptr;cursor != NULL;cursor = cursor->link())
if(target == cursor->data())
return cursor;
return NULL;

}

*/

template<class Item>

void list_head_remove(node<Item>*& head_ptr)

{
node<Item>* remove_ptr;
remove_ptr = head_ptr;
head_ptr = head_ptr->link();
delete remove_ptr;

}

template<class Item>

void list_remove(node<Item>* previous_ptr)

{
node<Item>* remove_ptr;
remove_ptr = previous_ptr->link();
previous_ptr->set_link(remove_ptr->link());
delete remove_ptr;

}

template<class Item>

void list_clear(node<Item>*& head_ptr)

{
while(head_ptr != NULL)
list_head_remove(head_ptr);

}

template<class Item>

void list_copy(const node<Item>* source_ptr,node<Item>*& head_ptr,node<Item>*& tail_ptr)

{
head_ptr = NULL;
tail_ptr = NULL;

if(source_ptr == NULL)
return;

list_head_insert(head_ptr,source_ptr->data());
tail_ptr = head_ptr;

source_ptr = source_ptr->link();
while(source_ptr != NULL)
{
list_insert(tail_ptr,source_ptr->data());
tail_ptr = tail_ptr->link();
source_ptr = source_ptr->link();
}

}

template<class NodePtr>

NodePtr list_locate(NodePtr head_ptr,std::size_t position)

{

NodePtr cursor;
cursor = head_ptr;

for(std::size_t i=1;(i<position) && (cursor != NULL);i++)
cursor = cursor->link();
return cursor;

}

}

容器类头文件bag.h：

#ifndef MAIN_WTF_GAB5_H

#define MAIN_WTF_GAB5_H

#include<cstdlib>

#include"node2.h"

namespace main_wtf_6B

{
template <class Item>
class bag
{
public:
typedef std::size_t size_type;
typedef Item value_type;
typedef node_iterator<Item> iterator;
typedef const_node_iterator<Item> const_iterator;

bag();
bag(const bag& source);
~bag();
size_type erase(const Item& target);
bool erase_one(const Item& target);
void insert(const Item& entry);
void operator +=(const bag& addend);
void operator = (const bag& source);
size_type size() const { return many_nodes; }
size_type count(const Item& target) const;
Item grab() const;

iterator begin()
{ return iterator(head_ptr); }
const_iterator begin() const
{ return const_iterator(head_ptr); }
iterator end()
{ return iterator(); }
iterator end() const
{ return const_iterator(); }
private:
node<Item>* head_ptr;
size_type many_nodes;
};

template<class Item>
bag<Item> operator +(const bag<Item>& b1,const bag<Item>& b2);

}

#include "bag5.template"

#endif

容器类实现文件bag.template:

#include"bag5.h"

#include<cassert>

namespace main_wtf_6B

{
template<class Item>
bag<Item>::bag()
{
head_ptr = NULL;
many_nodes = 0;
}
template<class Item>
bag<Item>::bag(const bag<Item>& source)
{
node* tail_ptr;
list_copy(source.head_ptr,head_ptr,tail_ptr);
many_nodes = source.many_nodes;
}

template<class Item>
void bag<Item>::operator=(const bag<Item>& source)
{
node* tail_ptr;

if(this == &source)
return;

list_clear(head_ptr);
many_nodes = 0;

list_copy(source.head_ptr,head_ptr,tail_ptr);
many_nodes = source.many_nodes;
}

template<class Item>
bag<Item>::~bag()
{
list_clear(head_ptr);
many_nodes = 0;
}

template<class Item>
bool bag<Item>::erase_one(const Item& target)
{
node<Item>* target_node;

target_node = list_search(head_ptr,target);
if(target_node == NULL)
return false;
target_node->set_data(head_ptr->data());
list_head_remove(head_ptr);
--many_nodes;
return true;
}

template<class Item>
std::size_t bag<Item>::erase(const Item& target)
{
bag<Item>::size_type answer = 0;
while(erase_one(target))
answer++;
return answer;
}

template<class Item>
void bag<Item>::insert(const Item& entry)
{
list_head_insert(head_ptr,entry);
many_nodes++;
}

template<class Item>
void bag<Item>::operator+=(const bag<Item>& addend)
{
node* cursor;
cursor = addend.head_ptr;
while(cursor != NULL)
{
list_head_insert(head_ptr,cursor->data());
cursor = cursor->link();
}
many_nodes += addend.many_nodes;
}

template<class Item>
std::size_t bag<Item>::count(const Item& target) const
{
size_type answer;
const node<Item>* cursor;

answer = 0;
cursor = list_search(cursor,target);
while(cursor != NULL)
{
++answer;
cursor = cursor->link();
cursor = list_search(cursor,target);
}
return answer;
}

template<class Item>
Item bag<Item>::grab() const
{
size_type i;
const node<Item>* cursor;

assert(size()>0);
i = (rand() % size()) +1;
cursor = list_locate(head_ptr,i);
return cursor->data();
}

template<class Item>
bag<Item> operator +(const bag<Item>& b1,const bag<Item>& b2)
{
bag<Item> answer;
answer += b1;
answer += b2;
return answer;
}

}