expected unqualified-id before '}' error on LinkedArray

[newbcoding]

I'm trying to create a header for my LinkedArray class and I keep getting this error.. I can't pinpoint the issue, so any help would be great. Usually when it's this type of error, it's just a small thing I'm missing that would fix the code, I'm hoping that is the case here!

#include <vector>

using namespace std;

template <class myUnit>
class LinkedArray
{
public:
    template<typename T>
    struct Node
    {
        T data;
        Node *here;
        int key;
        bool inUse;
        Node():data(T()), key(-1), inUse(false), here(NULL){}
    };

    static myUnit dummy;

    /// end here

    LinkedArray();
    virtual ~LinkedArray();
    LinkedArray(const LinkedArray<myUnit> & copy);
    myUnit operator[](int index) const;
    myUnit & operator[](int index);
    int CAPACITY() const {return CAP;}
    int Size() const {return size;}
    bool containsKey(int index) const;
    void DeleteKey(int index);
    void Clear();
    vector<int> Keys() const;

private:

    Node<myUnit> * begin;
    Node<myUnit> * end;
    int CAP;
    int size;
    void del();
    void Copy(const LinkedArray<myUnit> & copy);

};


template <class myUnit>
myUnit LinkedArray<myUnit>::dummy = myUnit();

template<typename myUnit>
LinkedArray<myUnit>::LinkedArray()
    :begin(NULL), end(NULL), CAP(0), size(0){}

template <typename myUnit>
LinkedArray<myUnit>::LinkedArray (const LinkedArray<myUnit> & copy)
    :begin(NULL), end(NULL), CAP(0), size(0){ Copy(copy);}

template <class myUnit>
LinkedArray<myUnit>::~LinkedArray(){del();}

template <class myUnit>
LinkedArray<myUnit> & LinkedArray<myUnit>::operator=( const LinkedArray<myUnit> & copy )
{
  if( this != &copy )
    {
        del();
        Copy(copy);
    }
  return *this;
}

template <typename myUnit>
myUnit LinkedArray<myUnit>::operator[](int index) const
{
    if (index < 0 || index > CAP)
        return dummy;

    Node<myUnit> *const prePtr = &begin;
    while ( *prePtr != NULL && (*prePtr)->key < index)
        prePtr = &((*prePtr)->next);
    if ( *prePtr == NULL)
        return dummy;
    else if ( (*prePtr)->key > index)
        return dummy;
    else
        return (*prePtr)->data;
}

template <class myUnit>
{
    if (index < 0)
        return dummy;
    if (index >= CAP)
    {
        if (end == NULL) begin = end = new Node<myUnit>;
        else
        {
            end->next = new Node<myUnit>;
            end = end-> next;
        }
        end->key = index;
        end->inUse = true;
        size++
        CAP = index+1;
        return end->data;
    }
    Node<myUnit> ** prePtr = &begin;
    while ( (*prePtr) != NULL && (*prePtr)->key < index)
        prePtr = &((*prePtr)-> next);

    Node<myUnit> *aNode = NULL;
    if ( (*prePtr)->key > index)
    {
        aNode = new Node<myUnit>
        aNode->key= index;
        aNode->next = *prePtr;
        *prePtr = aNode;
    }
    else
    {
        aNode = *prePtr;
    }
    if ( aNode->inUse == false)
    {
        size++;
        aNode -> inUse = true;
    }
    return aNode->data;
}

template <typename myUnit>
void LinkedArray<myUnit>::Copy (const LinkedArray<myUnit> & copy)
{
    Node<myUnit> * cPtr = copy.begin;
    Node<myUnit> * iPtr = NULL;
    while (cPtr != NULL);
    {
        if (cPtr == copy.begin)
        {
            begin = new Node<myUnit>;
            iPtr = begin;
        }
        else
        {
            iPtr -> next = new Node<myUnit>;
            iPtr = iPtr -> next;
        }
        iPtr->dats=cPtr->data;
        iPtr->inUse = cPtr->inUse;
        iPtr->key = cPtr->key;
        if (cPtr == copy.end)
            end = iPtr;
        cPtr = cPtr->next;
    }
    size = copy.size;
    CAPACITY = copy.CAP;
}

template <class myUnit>
bool LinkedArray<myUnit>::containsKey(int index) const
{
    if (index <0 || index>= CAP)
        return false;
    Node<myUnit> const *nPtr = begin;
    while (nPtr != NULL && nPtr->key < index)
        nPtr = nPtr->next;
    if (nPtr != NULL)
        if (nPtr->key == index)
        if (nPtr->inUse==true)
        return true;
    return false;
}

template <typename myUnit>
void LinkedArray<myUnit>::DeleteKey(int index)
{
    if (index >= 0 && index < CAP)
    {
        Node<myUnit> *nPtr = begin;
        while(nPtr != NULL && nPtr->key < index)
            nPtr = nPtr->next;
        if (nPtr != NULL && nPtr->key == index)
        {
            if (nPtr->inUse == true)
                size--;
            nPtr->inUse = false;
        }
    }
}


template <typename myUnit>
void LinkedArray<myUnit>::del()
{
    Node<myUnit> * point = begin;
    while (begin!=NULL)
    {
        begin = begin->next;
        delete point;
        point = begin;
    }
    begin = end = NULL;
    CAP = size = 0;
}

template <class myUnit>
void LinkedArray<myUnit>::Clear()
{
    Node<myUnit> * nPtr = begin;
    while (nPtr!=NULL)
    {
        nPtr -> inUse = false;
        nPtr = nPtr -> next;
    }
    size = 0;
}

Thanks for any help you can provide CPLUSPLUS forums!

[gunnerfunner]

template <class myUnit>
{

lines 89-90 what is this - a template class / struct / function? you left that out
btw I'm getting another error over here:

63|error: no 'LinkedArray<myUnit>& LinkedArray<myUnit>::operator=(const LinkedArray<myUnit>&)' member function declared in class 'LinkedArray<myUnit>'|

perhaps this dropped out during copy/paste