模版及模版类的继承

关于类模版最好将类声明和实现凡在同一个.h文件中,否则有些编译器不支持导致莫名其妙的编译错误.

 

模版基类:

 

#ifndef PFARRAY_H
#define PFARRAY_H

#include <iostream>

using namespace std;

namespace PFArraySavith
{
  template<typename T> class PFArray
 {
    public:
        PFArray();
       
        PFArray(int capacityValue);

        PFArray(const PFArray<T>& pfaObject);

        void addElement(T element);

        bool full() const;

        int getCapacity() const;

        int getNumberUsed() const;

        void emptyArray();

        T& operator[](int index);

        PFArray<T>& operator =(const PFArray<T>& rightSide);

        virtual ~PFArray();
    private:
        T *a;
        int capacity;
        int used;
 };
 
 
    template<typename T>
    PFArray<T>::PFArray():capacity(50),used(0)
    {
        a = new T[capacity];                                                       
    }
   
    template<typename T>
    PFArray<T>::PFArray(int size):capacity(size),used(0)
    {
        a = new T[capacity];                                                       
    }

    template<typename T>
    PFArray<T>::PFArray(const PFArray<T>& pfaObject):
               capacity(pfaObject.getCapacity),used(pfaObject.getNumberUsed())
    {                   
        a = new T[capacity];
        for (int i = 0; i < used; i++)
        {
            a[i] = pfaObject.a[i];
        }                                                       
    }
   
    template<typename T>
    void PFArray<T>::addElement(T element)
    {
        if (used >= capacity)
        {
            cout<<"已满"<<endl;
            exit(0);
        }
       
        a[used++] = element;
    }
   
    template<typename T>
    bool PFArray<T>::full() const
    {
        return capacity == used;
    }
   
    template<typename T>
    int PFArray<T>::getCapacity() const
    {
        return this->capacity;
    }
   
    template<typename T>
    int PFArray<T>::getNumberUsed() const
    {
        return used;
    }
   
    template<typename T>
    void PFArray<T>::emptyArray()
    {
        used = 0;
    }
   
    template<typename T>
    T& PFArray<T>::operator[](int index)
    {
        if (index >= used)
        {
            cout<<"下标超界"<<endl;
            exit(0);
        }   
        return a[index];
    }
   
    template<typename T>
    PFArray<T>& PFArray<T>::operator =(const PFArray<T>& rightSide)
    {
        if (capacity != rightSide.capacity)
        {
            delete[] a;
            a = new T[rightSide.capacity];
        }
       
        capacity = rightSide.capacity;
        used = rightSide.used;
        for (int i = 0; i < used; i++)
            a[i] = rightSide.a[i];
           
        return *this;                   
    }
     
    template<typename T>
    PFArray<T>::~PFArray()
    {
        delete[] a;
    }
}

#endif

  

---

 

模版继承类:

 

#ifndef PFARRAYBACK_H
#define PFARRAYBACK_H

 

#include "pfarray.h"

 

namespace PFArraySavith
{
    template<typename T>
    class PFArrayBack : public PFArray<T>
    {
        public:
            PFArrayBack();
           
            PFArrayBack(int capacityValue);
           
            PFArrayBack(const PFArrayBack<T>& object);
           
            void backup();
           
            void restore();
           
            PFArrayBack<T>& operator =(const PFArrayBack<T>& rightSide);
           
            virtual ~PFArrayBack();
           
        private:
            T* b;
            int usedB;
    };
   
    template<typename T>
    PFArrayBack<T>::PFArrayBack() :
                    PFArray<T>(),usedB(0)
    {
        b = new T[getCapacity()];
    }
   
    template<typename T>
    PFArrayBack<T>::PFArrayBack(int capacityValue) :
                    PFArray<T>(capacityValue),usedB(0)
    {
        b = new T[getCapacity()];
    }
   
    template<typename T>
    PFArrayBack<T>::PFArrayBack(const PFArrayBack& object) :
                    PFArray<T>(object),usedB(0)
    {
        b = new T[getCapacity()];
        usedB = object.getNumberUsed();
        for (int i = 0; i < usedB; i ++)
        {
            b[i] = object.b[i];
        }
    }
   
    template<typename T>
    void PFArrayBack<T>::backup()
    {
        usedB = getNumberUsed();
        for (int i = 0; i < usedB; i++)
            b[i] = operator[](i);
    }
   
    template<typename T>
    void PFArrayBack<T>::restore()
    {
        PFArray::emptyArray();
       
        for (int i = 0; i < usedB; i++)
        {
            addElement(b[i]);
        }
    }
   
    template<typename T>
    PFArrayBack<T>& PFArrayBack<T>::operator =(const PFArrayBack<T>& rightSide)
    {
        PFArray<T>::operator =(rightSide);
       
        if (getCapacity() != rightSide.getCapacity())
        {
            delete[] b;
            b = new T[rightSide.getCapacity()];
        }
       
        usedB = rightSide.usedB;
        for (int i = 0; i < usedB; i++)
            b[i] = rightSide.b[i];
           
        return *this;
    }
   
    template<typename T>
    PFArrayBack<T>::~PFArrayBack()
    {
        delete[] b;
    }
}

#endif