template 
const int OneDGrid::kDefaultSize;

template 
OneDGrid::OneDGrid(int inSize) : mSize(inSize)
{
    mElems = new T[mSize];
}

template 
OneDGrid::OneDGrid(const OneDGrid& src)
{
    copyFrom(src);
}

template 
OneDGrid::~OneDGrid()
{
    delete [] mElems;
}

template 
void OneDGrid::copyFrom(const OneDGrid& src)
{
    mSize = src.mSize;
    mElems = new T[mSize];

    for (int i = 0; i < mSize; i++) {
        mElems[i] = src.mElems[i];
    }
}

template 
OneDGrid& OneDGrid::operator=(const OneDGrid& rhs)
{
    // check for self-assignment
    if (this == &rhs) {
        return (*this);
    }

    // free the old memory
    delete [] mElems;

    // copy the new memory
    copyFrom(rhs);
    return (*this);
}

template 
void OneDGrid::resize(int newSize)
{
    T* newElems = new T[newSize]; // Allocate the new array of the new size

    // Handle the new size being smaller or bigger than the old size
    for (int i = 0; i < newSize && i < mSize; i++) {
        // Copy the elements from the old array to the new one
        newElems[i] = mElems[i];
    }
    mSize = newSize; // store the new size
    delete [] mElems; // free the memory for the old array
    mElems = newElems; // Store the pointer to the new array
}

template 
T& OneDGrid::operator[](int x)
{
    return (mElems[x]);
}

template 
const T& OneDGrid::operator[](int x) const
{
    return (mElems[x]);
}