Exercising the SparseArray class template for an array of arrays - C++ template
C++ examples for template:template class
Description
Exercising the SparseArray class template for an array of arrays
Demo Code
#include <string> #include <iostream> #include <memory> using std::string; template<typename T> class SparseArray { class Node;//from w ww.ja v a2s .c o m using PNode = std::shared_ptr < Node >; private: PNode pFirst; // Pointer to first element node PNode pLast; // Pointer to last element node public: SparseArray() = default; // Constructor SparseArray(const SparseArray& array); // Copy constructor SparseArray& operator=(const SparseArray& array); // Assignment operator T& operator[](int index); // Subscript SparseArray bool element_exists(int index); // Return true if element exists void show(); // display array elements void insert(T* pObj); // Insert an element after the last private: // Node class definition class Node { public: int index {}; // Index of element T* pObject; // Address of object PNode pNext; // Pointer to next node PNode pPrevious; // Pointer to previous node Node(int newIndex) : index(newIndex), pObject(new T) {} // Constructor Node(const Node& node) : index(node.index), pObject(new T(*node.pObject)) {} // Copy constructor ~Node(){ delete pObject; } // Destructor }; }; // Copy constructor template template<typename T> SparseArray<T>::SparseArray(const SparseArray& array) { if (array.pFirst) { // If there is a first element pLast = pFirst = std::make_shared<Node>(*array.pFirst); // Duplicate it PNode pTemp; PNode pCurrent {array.pFirst}; while (pCurrent = pCurrent->pNext) { // Duplicate any further nodes pTemp = pLast; // Save the address of the last pLast = std::make_shared<Node>(*pCurrent); // Make the new one the last pTemp->pNext = pLast; // Set the next pointer of old last pLast->pPrevious = pTemp; // Set previous pointer of new last } } } // Assignment operator template template<typename T> SparseArray<T>& SparseArray<T>::operator=(const SparseArray& array) { if (this == &array) // Check for rhs same as lhs return *this; PNode pCurrent; if (array.pFirst) { pLast = pFirst = std::make_shared<Node>(*array.pFirst); Node* pTemp; pCurrent = array.pFirst; while (pCurrent = pCurrent->pNext) { pTemp = pLast; pLast = std::make_shared<Node>(*pCurrent); pTemp->pNext = pLast; pLast->pPrevious = pTemp; pTemp = pLast; } } return *this; } // Subscript operator for non-const objects template<typename T> T& SparseArray<T>::operator[](int index) { // Search the list for a node corresponding to index PNode pCurrent {pFirst}; while (pCurrent) { if (pCurrent->index == index) return *pCurrent->pObject; if (pCurrent->index > index) break; pCurrent = pCurrent->pNext; } PNode pNode = std::make_shared<Node>(index); pNode->pObject = new T; if (pCurrent) // If its not the end of the list we must insert the element { if (pCurrent->pPrevious) // If current has a previous node just insert the new node { pCurrent->pPrevious->pNext = pNode; pNode->pPrevious = pCurrent->pPrevious; pCurrent->pPrevious = pNode; pNode->pNext = pCurrent; } else // Current must be the first so add new node as first { pNode->pNext = pCurrent; pCurrent->pPrevious = pNode; pFirst = pNode; } } else { // We must append the element if (pLast) { pLast->pNext = pNode; pNode->pPrevious = pLast; pLast = pNode; } else pFirst = pLast = pNode; } return *pNode->pObject; // Return the new element } // Display the elements of a SparseArray template<typename T> void SparseArray<T>::show() { PNode pCurrent {pFirst}; while (pCurrent) { std::cout << "\n[" << std::setw(2) << pCurrent->index << "] = " << *pCurrent->pObject; pCurrent = pCurrent->pNext; } std::cout << std::endl; } // Test for existence of element at index template<typename T> bool SparseArray<T>::element_exists(int index) { PNode p {pFirst}; while (p) { if (p->index == index) return true; p = p->pNext; } return false; } // Insert an element after the last template<typename T> void SparseArray<T>::insert(T* pObj) { PNode pNode; if (pLast) // If there is a last element add the new one after it { pNode = std::make_shared<Node>(pLast->index + 1); pLast->pNext = pNode; pNode->pPrevious = pLast; pLast = pNode; } else // Otherwise the new one is the first pFirst = pLast = pNode = std::make_shared<Node>(0); if (pObj) // If there is an object pNode->pObject = new T(*pObj); // Create a duplicate else pNode->pObject = new T; // Otherwise, create a default T } int main() { string text; // Stores input prose or poem std::cout << "\nEnter a poem or prose over one or more lines." << "Terminate the input with #:\n"; getline(std::cin, text, '#'); SparseArray< SparseArray<string> > arrays; // Sparse array of arrays of strings string letters {"ABCDEFGHIJKLMNOPQRSTUVWXYZ"}; // Extract words and store in the appropriate list string word; // Stores a word string separators {" \n\t,.\"?!;:"}; // Separators between words int start {}; // Start of a word int end {}; // separator position after a word while (string::npos != (start = text.find_first_not_of(separators, start))) { end = text.find_first_of(separators, start + 1); word = text.substr(start, end - start); arrays[letters.find(toupper(word[0]))].insert(&word); start = end; } // List the words in order 5 to a line const int perline {5}; int count {}; // Word counter int j {}; for (int i {}; i < 26; ++i) { if (!arrays.element_exists(i)) continue; j = 0; count = 0; while ((word = arrays[i][j++]).length()) { std::cout << word << ' '; if (!(++count % perline)) std::cout << std::endl; } std::cout << std::endl; } std::cout << std::endl; }
Result
