Can someone help fix this program to work in visual studios in c++? Thank you so much

//node2.h

#ifndef MAIN_SAVITCH_NODE2_H #define MAIN_SAVITCH_NODE2_H #include // Provides NULL and size_t #include // Provides iterator and forward_iterator_tag

namespace main_savitch_6B { template 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; } Item& data() { return data_field; } node* link() { return link_field; } void set_data(const Item& new_data) { data_field = new_data; } void set_link(node* new_link) { link_field = new_link; } const Item& data() const { return data_field; } const node* link() const { return link_field; } private: Item data_field; node *link_field; };

template void list_clear(node*& head_ptr);

template void list_copy (const node* source_ptr, node*& head_ptr, node*& tail_ptr);

template void list_head_insert(node*& head_ptr, const Item& entry);

template void list_head_remove(node*& head_ptr);

template void list_insert(node* previous_ptr, const Item& entry);

template std::size_t list_length(const node* head_ptr);

template NodePtr list_locate(NodePtr head_ptr, SizeType position);

template void list_remove(node* previous_ptr);

template NodePtr list_search(NodePtr head_ptr, const Item& target);

template class node_iterator : public std::iterator { public: node_iterator(node* initial = NULL) { current = initial; } Item& operator *() const { return current->data(); } node_iterator& operator ++() // Prefix ++ { current = current->link(); return *this; } node_iterator operator ++(int) // Postfix ++ { 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* current; };

template class const_node_iterator : public std::iterator { public: const_node_iterator(const node* initial = NULL) { current = initial; } const Item& operator *() const { return current->data(); } const_node_iterator& operator ++() // Prefix ++ { current = current->link(); return *this; } const_node_iterator operator ++(int) // Postfix ++ { 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* current; }; }

#include "node2.template" #endif

//node2.template

#include "stdafx.h" #include // Provides assert #include // Provides NULL and size_t

namespace main_savitch_6B { template void list_clear(node*& head_ptr) // Library facilities used: cstdlib { while (head_ptr != NULL) list_head_remove(head_ptr); }

template void list_copy( const node* source_ptr, node*& head_ptr, node*& tail_ptr ) // Library facilities used: cstdlib { head_ptr = NULL; tail_ptr = NULL;

// Handle the case of the empty list if (source_ptr == NULL) return;

// Make the head node for the newly created list, and put data in it list_head_insert(head_ptr, source_ptr->data( )); tail_ptr = head_ptr; // Copy rest of the nodes one at a time, adding at the tail of new list 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 void list_head_insert(node*& head_ptr, const Item& entry) { head_ptr = new node(entry, head_ptr); }

template void list_head_remove(node*& head_ptr) { node *remove_ptr;

remove_ptr = head_ptr; head_ptr = head_ptr->link( ); delete remove_ptr; }

template void list_insert(node* previous_ptr, const Item& entry) { node *insert_ptr; insert_ptr = new node(entry, previous_ptr->link( )); previous_ptr->set_link(insert_ptr); }

template std::size_t list_length(const node* head_ptr) // Library facilities used: cstdlib { const node *cursor; std::size_t answer; answer = 0; for (cursor = head_ptr; cursor != NULL; cursor = cursor->link( )) ++answer; return answer; }

template NodePtr list_locate(NodePtr head_ptr, SizeType position) // Library facilities used: cassert, cstdlib { NodePtr cursor; SizeType i; assert(0 < position); cursor = head_ptr; for (i = 1; (i < position) && (cursor != NULL); ++i) cursor = cursor->link( ); return cursor; }

template void list_remove(node* previous_ptr) { node *remove_ptr;

remove_ptr = previous_ptr->link( ); previous_ptr->set_link(remove_ptr->link( )); delete remove_ptr; }

template NodePtr list_search(NodePtr head_ptr, const Item& target) // Library facilities used: cstdlib { NodePtr cursor; for (cursor = head_ptr; cursor != NULL; cursor = cursor->link( )) if (target == cursor->data( )) return cursor; return NULL; } }

//table2.h

#ifndef TABLE2_H #define TABLE2_H #include #include "node2.h"

namespace main_savitch_12B { template class table { public: static const std::size_t TABLE_SIZE = 811; table(); table(const table& source); ~table(); void insert(const RecordType& entry); void remove(int key); void operator =(const table& source); void find(int key, bool& found, RecordType& result) const; bool is_present(int key) const; std::size_t size() const { return total_records; }

private: main_savitch_6B::node *data[TABLE_SIZE]; std::size_t total_records; std::size_t hash(int key) const; }; } #include "table2.template" #endif

//table2.template

using namespace main_savitch_12B; template table::table() { total_records = 0; }

template table::table(const table& source) { copy(source.data, source.data + total_records, data); total_records = source.total_records; }

template table::~table() { }

template void table::insert(const RecordType &entry) { assert(entry.key >= 0); size_t index = hash(entry.key); if (!is_present(entry.key)) { data[index].push_back(entry); ++total_records; } else { for (typename list::iterator i = data[index].begin(); i != data[index].end(); ++i) { if (i->key == entry.key) { *i = entry; break; } } } }

template void table::remove(int key) { if (is_present(key)) { int index = hash(key); for (typename list::iterator i = data[index].begin(); i != data[index].end(); ++i) { if (i->key == key) { data[index].erase(i); --total_records; return; } } } }

template void table::operator =(const table &source) { if (this != &source) { copy(source.data, source.data + total_records, data); total_records = source.total_records; } }

template void table::find(int key, bool &found, RecordType &result) const { size_t index = hash(key); for (typename list::const_iterator i = data[index].begin(); i != data[index].end() ; i++) { if (key == i->key) { found = true; result = *i; return; } } found = false; }

template bool table::is_present(int key) const { size_t index = hash(key); for (typename list::const_iterator i = data[index].begin(); i != data[index].end() ; i++) { if (key == i->key) { return true; } } return false; }

template size_t table::hash(int key) const { return (key % TABLE_SIZE); }

//testlab2.cpp

using namespace main_savitch_12B; template table::table() { total_records = 0; }

template table::table(const table& source) { copy(source.data, source.data + total_records, data); total_records = source.total_records; }

template table::~table() { }

template void table::insert(const RecordType &entry) { assert(entry.key >= 0); size_t index = hash(entry.key); if (!is_present(entry.key)) { data[index].push_back(entry); ++total_records; } else { for (typename list::iterator i = data[index].begin(); i != data[index].end(); ++i) { if (i->key == entry.key) { *i = entry; break; } } } }

template void table::remove(int key) { if (is_present(key)) { int index = hash(key); for (typename list::iterator i = data[index].begin(); i != data[index].end(); ++i) { if (i->key == key) { data[index].erase(i); --total_records; return; } } } }

template void table::operator =(const table &source) { if (this != &source) { copy(source.data, source.data + total_records, data); total_records = source.total_records; } }

template void table::find(int key, bool &found, RecordType &result) const { size_t index = hash(key); for (typename list::const_iterator i = data[index].begin(); i != data[index].end() ; i++) { if (key == i->key) { found = true; result = *i; return; } } found = false; }

template bool table::is_present(int key) const { size_t index = hash(key); for (typename list::const_iterator i = data[index].begin(); i != data[index].end() ; i++) { if (key == i->key) { return true; } } return false; }

template size_t table::hash(int key) const { return (key % TABLE_SIZE); }