HTML Java script MYSQL programmers dev. .(elmo)

You can actually define your template class inside a .template file rather than a .cpp file. Whoever is saying you can only define it inside a header file is wrong. This is something that works all the way back to c++ 98.

Don't forget to have your compiler treat your .template file as a c++ file to keep the intelli sense.

Here is an example of this for a dynamic array class.


    #ifndef dynarray_h
    #define dynarray_h

    #include <iostream>

    template <class T>
    class DynArray{
        int capacity_;
        int size_;
        T* data;
    public:
        explicit DynArray(int size = 0, int capacity=2);
        DynArray(const DynArray& d1);
        ~DynArray();
        T& operator[]( const int index);
        void operator=(const DynArray<T>& d1);
        int size();

        int capacity();
        void clear();

        void push_back(int n);

        void pop_back();
        T& at(const int n);
        T& back();
        T& front();
    };

    #include "dynarray.template" // this is how you get the header file

    #endif

Now inside you .template file you define your functions just how you normally would.

    template <class T>
    DynArray<T>::DynArray(int size, int capacity){
        if (capacity >= size){
            this->size_ = size;
            this->capacity_ = capacity;
            data = new T[capacity];
        }
        //    for (int i = 0; i < size; ++i) {
        //        data[i] = 0;
        //    }
    }

    template <class T>
    DynArray<T>::DynArray(const DynArray& d1){
        //clear();
        //delete [] data;
        std::cout << "copy" << std::endl;
        this->size_ = d1.size_;
        this->capacity_ = d1.capacity_;
        data = new T[capacity()];
        for(int i = 0; i < size(); ++i){
            data[i] = d1.data[i];
        }
    }

    template <class T>
    DynArray<T>::~DynArray(){
        delete [] data;
    }

    template <class T>
    T& DynArray<T>::operator[]( const int index){
        return at(index);
    }

    template <class T>
    void DynArray<T>::operator=(const DynArray<T>& d1){
        if (this->size() > 0) {
            clear();
        }
        std::cout << "assign" << std::endl;
        this->size_ = d1.size_;
        this->capacity_ = d1.capacity_;
        data = new T[capacity()];
        for(int i = 0; i < size(); ++i){
            data[i] = d1.data[i];
        }

        //delete [] d1.data;
    }

    template <class T>
    int DynArray<T>::size(){
        return size_;
    }

    template <class T>
    int DynArray<T>::capacity(){
        return capacity_;
    }

    template <class T>
    void DynArray<T>::clear(){
        for( int i = 0; i < size(); ++i){
            data[i] = 0;
        }
        size_ = 0;
        capacity_ = 2;
    }

    template <class T>
    void DynArray<T>::push_back(int n){
        if (size() >= capacity()) {
            std::cout << "grow" << std::endl;
            //redo the array
            T* copy = new T[capacity_ + 40];
            for (int i = 0; i < size(); ++i) {
                copy[i] = data[i];
            }

            delete [] data;
            data = new T[ capacity_ * 2];
            for (int i = 0; i < capacity() * 2; ++i) {
                data[i] = copy[i];
            }
            delete [] copy;
            capacity_ *= 2;
        }
        data[size()] = n;
        ++size_;
    }

    template <class T>
    void DynArray<T>::pop_back(){
        data[size()-1] = 0;
        --size_;
    }

    template <class T>
    T& DynArray<T>::at(const int n){
        if (n >= size()) {
            throw std::runtime_error("invalid index");
        }
        return data[n];
    }

    template <class T>
    T& DynArray<T>::back(){
        if (size() == 0) {
            throw std::runtime_error("vector is empty");
        }
        return data[size()-1];
    }

    template <class T>
    T& DynArray<T>::front(){
        if (size() == 0) {
            throw std::runtime_error("vector is empty");
        }
        return data[0];
        }


      enoslay.elmo@yahoo.com.ph