------------------------------------------------------------------------------
MC logo
Generalized Safe Array
[^] CSc 220 Home
------------------------------------------------------------------------------
[Introduction] [Boolean and Control] [Functions] [Arrays and Pointers] [Dynamic Arrays] [Array Errors] [Command Array] [Standard Containers] [Structs and Classes] [Automatic Pointer] [Multi-File Programs] [Copying Objects] [Templates] [Inheritance] [Plain C I/O] [Type Odds And Ends] [Plain C Strings] [File I/O]
[Template Functions] [Template Generalized Stack] [Template Generalized Stack Driver] [Array Template Stack] [Array Template Test Driver] [Generalized Safe Array] [Safe Array Demo] [Vector Iterator Demo]
gensafearr.h
#ifndef _GENSAFEARR_H_
#define _GENSAFEARR_H_

#include <iostream>
#include <stdexcept>
using namespace std;

template <typename T>
class SafeArr {
public:
        // Create a new array of the given size.
        SafeArr(int asize) { 
                m_size = asize;
                m_space = new T[asize]; 
        }

        // Create an array as a copy of another.
        SafeArr(const SafeArr &other) { 
                copyin(other);
        }

        // Clean up.
        ~SafeArr() { delete [] m_space; }

        // Find out how large this is.
        int size() const { return m_size; }

        // Perform an array assignment.  Delete our space, then make us a
        // copy of other.
        SafeArr & operator=(const SafeArr &other)
        {
                delete [] m_space;
                copyin(other);
                return *this;
        }

        // Store into the array, or print an error message and don't 
        // change the aray.
        void store(int pos, const T &tostore);

        // Fetch from pos, or, if pos is out of bounds, print a message
        // and return 0.
        const T & fetch(int pos) const;

        // Print the array to the stream.
        void print(ostream &out) const;

private:
        T *m_space;     // Actual storage space for the array.
        int m_size;     // Size of the array.

        // Make us a copy of the other array.  Allocates m_space of
        // the same size, then copies the contents of other.m_size into it,
        // and copies m_size.
        void copyin(const SafeArr &other);
};

// Make us a copy of the other array.  Allocates m_space of the same size, then
// copies the contents of other.m_size into it, and copies m_size.
template <typename T>
void SafeArr<T>::copyin(const SafeArr<T> &other)
{
        m_space = new int[other.m_size];
        m_size = other.m_size;
        for(int m = 0; m < m_size; ++m)
                m_space[m] = other.m_space[m];
}

// Store into the array, or print an error message and don't 
// change the aray.
template <typename T>
void SafeArr<T>::store(int pos, const T &tostore)

        if(pos < m_size && pos >= 0)
                m_space[pos] = tostore;
        else 
                throw range_error("Store out of bounds"); 
}

// Fetch from pos, or, if pos is out of bounds, print a message
// and return 0.
template <typename T>
const T & SafeArr<T>::fetch(int pos) const

        if(pos < m_size && pos >= 0)
                return m_space[pos];
        else
                throw range_error("Fetch out of bounds"); 
}

// Array printer
template <typename T>
void SafeArr<T>::print(ostream &out) const
{
        for(int n = 0; n < m_size; ++n) {
                out << m_space[n];
                if(n < m_size-1) out << " ";
        }
}

template <typename T>
inline ostream & operator<<(ostream &strm, const SafeArr<T> &arr) 
{
        arr.print(strm);
        return strm;
}

#endif