[C++] Classe generica - template

[riemann_01]

Ciao a tutti!
Ho scritto una classe generica che definisce, in modo piuttosto semplice, un vettore.
Nel processo di compilazione ricevo il seguente errore:

$ g++ -o vector vector.cpp
vector.h:58: error: expected constructor, destructor, or type conversion before ‘vector’
vector.h:64: error: expected constructor, destructor, or type conversion before ‘vector’

Per quale motivo? Non riesco a venire a capo.

Ecco il codice:

// file: vector.h

#include <iostream>

template <class T>
class vector {
public:
        explicit vector(int);
        vector(const T[],int);
        vector(const vector<T>&);
        ~vector();
    typedef T* iterator;
    iterator begin() const;
    iterator end() const;
        T& operator[](int);
    vector<T>& operator=(const vector<T>&);
private:
        int size;
        T* s;
};

template <class T>
vector<T>::vector(int dim = 10) : size(dim)
{
        assert(dim > 0);
        s = new T[size];
        assert(s != 0);
}

template <class T>
vector<T>::vector(const T a[], int dim)
{
        assert(dim > 0);
        size = dim;
        s = new T[size];
        assert(s != 0);
        for (int i = 0; i < size; ++i)
                s[i] = a[i];
}

template <class T>
vector<T>::vector(const vector<T>& v)
{
        size = v.size;
        s = new T[size];
        assert(s != 0);
        for (int i = 0; i < size; ++i)
                s[i] = v.s[i];
}

template <class T>
vector<T>::~vector()
{
        delete []s;
}

template <class T>
iterator vector<T>::begin() const
{
        return s;
}

template <class T>
iterator vector<T>::end() const
{
        return (s + size);
}

template <class T>
T& vector<T>::operator[](int i)
{
        assert(i > 0 && i < size);
        return s[i];
}

template <class T>
vector<T>& vector<T>::operator=(const vector<T>& v)
{
        assert(size == v.size);
        for (int i = 0; i < size; ++i)
                s[i] = v.s[i];
        return *this;
}

// file: vector.cpp

#include "vector.h"

int main()
{
        vector<int> v1;
        vector<double> v2;
}

Ringrazio in anticipo chiunque possa darmi indicazioni utili a riguardo!

[riemann_01]

Mi rispondo da solo.
Occorre aggiungere la keyword typename per risolvere l'ambiguita' rilevata dal compilatore.

template <class T>
typename vector<T>::iterator vector<T>::begin() const
{
        return s;
}

template <class T>
typename vector<T>::iterator vector<T>::end() const
{
        return (s + size);
}