#ifndef _BOUNDARR_H_ #define _BOUNDARR_H_ /* * This class implements an array with user-specified bounds. Subscripting * is done with a at() function, and subscripts are bounds-checked. * Objects of this class may not be copied. */ #include <iostream> #include <string> #include <stdexcept> #include <memory> #include <algorithm> template <typename T> class BoundArr { public: // Create a new array of the given dimensions BoundArr(int low, int high): m_space(new T[high-low+1]), m_low(low), m_high(high) { } // Convenience for conventional creation. BoundArr(int size): m_space(new T[size]), m_low(0), m_high(size-1) { } // Create an array as a copy of another. BoundArr(const BoundArr &other) = delete; // Perform an array assignment. Delete our space, then make us a // copy of other. BoundArr & operator=(const BoundArr &other) = delete; // Find out how large this is. int low() const { return m_low; } int high() const { return m_high; } int size() const { return m_high - m_low + 1; } // Subscript the array. The two versions are allowed, and will // be chosen based on the context of use. T &at(int subs) { return m_space[offset(subs)]; } T const &at(int subs) const { return m_space[offset(subs)]; } // Print the array to the stream. void print(std::ostream &out) const; private: std::shared_ptr<T[]> m_space; // Actual storage space for the array. int m_low, m_high; // Bounds // Check the bounds, throw if out, then int offset(int sub) const; }; // Check that the sub is in range, and throw if it is not. Otherwise, // return the sub adjusted to an offset for subscripting the base array. template <typename T> int BoundArr<T>::offset(int sub) const { if(sub < m_low || m_high < sub) throw std::range_error("Bounds: sub " + std::to_string(sub) + " outside " + std::to_string(m_low) + ".." + std::to_string(m_high)); return sub - m_low; } // Array printer template <typename T> void BoundArr<T>::print(std::ostream &out) const { out << "<" << m_low << "|"; for(int n = 0; n < size(); ++n) { out << " " << m_space[n]; } out << " |" << m_high << ">"; } // This exports the printing function to standard streams by defining // the meaning of << on a stream and a BoundArr to be running the print // method on the array to the stream. template <typename T> inline std::ostream & operator<<(std::ostream &strm, const BoundArr<T> &arr) { arr.print(strm); return strm; } #endif