#ifndef LISTKEYVAL_HPP #define LISTKEYVAL_HPP #include "KeyVal.hpp" #include /********************************************************************* * This is an example header without any...

Solution/KeyVal.hpp
#ifndef KEYVAL_HPP
#define KEYVAL_HPP
#include
#include
/**
* @class KeyVal
*
* This class is an interface to a system that can
* arbitrarily track key/value pairs. The abiltiy to
* build an "associative array" will be invaluable
* to a coder
*
* An associative array allows the coder to fetch
* an object by using a key. This essentially makes
* a content addressable data structure.
*
* All derived classes must use this template verbatim
*
* Notes:
* 1. Objects that are used as keys in the table
* must have the less than operator defined.
* 2. KeyVal objects should be creatable on both the
* stack and the heap
* 3. KeyVal objects should be assignable and copy constructible
* and should make deep copies as appropriate
* 4. The forEach method should iterate over the structure in
* sorted order least to greatest according to key value
*/
template
class KeyVal
{
public:
/**
* @brief Insert an object
*
* This will place a COPY of the val object
* into the associative array
*
* @param key Key associated with value
* @param val Value which is stored at location key
*/
virtual void insert(const K &key,
const V &val){
    struct Node* new_node = (struct Node*) malloc(sizeof(struct Node));
new_node->data = new_data;
new_node->next = (*head_ref);
(*head_ref) = new_node;
                     }
/**
* @brief Remove an object from the associative array
*
* This will remove the key/value pair from the array
* If the key is not found, no action is taken
*
* @param key Key for which key/val pair is removed
*/
virtual void del(const K &key){
    if (*head_ref == NULL)
return;
struct Node* temp = *head_ref;

if (position == 0)
{
*head_ref = temp->next;
free(temp);
return;
}

for (int i=0; temp!=NULL && i temp = temp->next;

if (temp == NULL || temp->next == NULL)
return;

struct Node *next = temp->next->next;

free(temp->next);

temp->next = next;
}
/**
* @brief Get a pointer to value
*
* Given a key, a shared_ptr to a value is returned.
* note that if the key did not exist, then the returned
* ptr is not valid
*
* @param key Key for which value is returned
* @return ptr to value if key existed
*/
virtual std::shared_ptr get(const K &key){
    return head_ref[key];
}
/**
* @brief Execute callback for each entry
*
* Rather than force students to create an inner iterator class,
* this functiona allows a callback function to be executed for
* every item in the associative array. Note that callbacks should
* be called in order of keys sorted least to greatest
*
* Note that keys are passed by const ref; they cannot be changed, yet
* values are passed by non-const ref. They can be changed and that change
* should be reflected in the underlying data structure.
*
* @param callback Function to be called with each item in the associative array
*/
virtual void forEach(std::function callback){
     struct Node* ptr;
ptr = head;
while (ptr != NULL) {
cout<< ptr->data <<" ";
ptr = ptr->next;
}
};
#endif /* KEYVAL_HPP */
Solution/ListKeyVal.hpp
#ifndef LISTKEYVAL_HPP
#define LISTKEYVAL_HPP
#include "KeyVal.hpp"
#include
/*********************************************************************
* This is an example header without any implementation that you
* may find useful in your effort to create an associative array.
*
* You are not required to conform to this header in any way, you are
* only required to conform to the overall interface header provided
* in KeyVal.hpp.
*
* However, there are helpful hints contained here that may make both
* this PEX and future PEXes which build on the base interface easier
* for you to implement. A careful study of this architecture is
* highly recommended. *
********************************************************************/
//forward declaration
template
class ListKeyVal;
/**
* @class ListKeyValNode
*
* The purpose of this class is to store key value pairs in a sorted list.
* Note that all methods and members are private and only accessible by the
* friend class ListKeyVal.
*
* The reason that the ListKeyValNode class and the ListKeyVal class are
* separate is to make usage cleaner. We must be able to create ListKeyVal
* objects on the stack just as we...