Как написать шаблон класса

[Suren]

Если у меня шаблон класса обязателно ли перед каждым методом написать template <class T> или template <typename T>

#include<iostream>
#include"Dinar.hpp"
#define _INDEX_CONTROL
#include<stdlib.h>
#include<cassert>
#include<iomanip>
DynamicArray::DynamicArray(int p_logicSize,int p_partSize)
{
        if(p_partSize<=0)
        {
                m_partSize=128;
        }
        else
                m_partSize=p_partSize;
        if (p_logicSize<=0)
        {
                m_logicSize=0;
        }
        else
        {
        m_logicSize=p_logicSize;
        m_realSize=(m_logicSize/m_partSize +1) *m_partSize;
        }
        if(m_logicSize>0)
        {
                m_array=new int [m_realSize];
        }
        else
        {
                m_array=NULL;
                m_realSize=0;
        }
}

DynamicArray::~DynamicArray()
{
        if (m_array !=NULL)
        delete [] m_array;
}

void DynamicArray::Reallocate(void)
{ 
        int *newArray;
        m_realSize +=m_partSize;
        newArray= new int [m_realSize];
        for (int k=0;k< m_logicSize; k++)
        {
                newArray[k] =m_array[k];
        }
        delete [] m_array;
        m_array = newArray;
}

int &DynamicArray::operator [] (int index)
{
#ifdef _INDEX_CONTROL
      assert (index > 0 && index <=m_logicSize);
#endif
        return m_array[index];
}

int DynamicArray:: Add( int value)
{
       // m_logicSize++;
        if (m_realSize ==m_logicSize)
       {
             Reallocate();
      }
      m_array [m_logicSize] =value;
      m_logicSize++;
        return m_logicSize;
}

int DynamicArray::Insert(int position, int value)
{
        assert ((position>=0)&&( position < m_logicSize));
                if(m_logicSize==m_realSize)
                {
                        m_realSize += m_partSize;
                        int *temp =new int [m_realSize];
                        for(int k=0; k<position;k++)
                                temp[k]=m_array[k];
                        temp[position]=value;
                        for (int i= position+1;i<m_logicSize;i++)
                                temp[i]= m_array[i-1];
                        delete [] m_array;
                        m_array=temp;
                }
        else
        {
                for (int k=m_logicSize; k>position;k--)
                        m_array[k] =m_array[k-1];
                m_array[position]=value;
        }
        m_logicSize++;
        return m_logicSize;
}

void DynamicArray::MergeSort(DynamicArray *secondArray)
{
        QuickSort(0, secondArray->GetSize());
        QuickSort(0,m_logicSize);
        DynamicArray *newArray=new DynamicArray;
        for (int i=0, j=0, k=0;k < m_logicSize+secondArray->GetSize();k++)
        {
        if (i==m_logicSize)
                {
                        newArray[k]=secondArray->m_array[j++];
                        continue;
                }
        if (j==secondArray->GetSize())
        {
                newArray[k]=m_array[i++];
                continue;
        }
        if (m_array[i]< secondArray->m_array[j])
        {
                newArray[k]=m_array[i++];
        }
        else
        {
                newArray[k]=secondArray->m_array[j++];
        }
        }
}
        

bool DynamicArray::Compare(DynamicArray *secondArray)
{
        if (m_logicSize==secondArray->m_logicSize)
        {
                for (int i=0;i<m_logicSize;i++)
                {
                        if (m_array[i]==secondArray->m_array[i]);
                                        return true;
                }
        }
                else 
                return false;
}

#include<iostream>
class DynamicArray
{
        public:
                DynamicArray(int p_logicSize=0, int p_partSize=128);
                ~DynamicArray();
                int Add(int value);
                int GetSize(){return m_logicSize;}
                int& operator [](int index); 
               int Insert (int position,int value);
               int GetElVal(int pos){return m_array[pos];}
               void PrintArray();
               void QuickSort(int p_left,int p_right);
               void Random(int m_logicSize);
               void Set(int value,int i,int j);
               int SearchByValue(int value);
               void InsertArray(DynamicArray *secondArray,int position);
               void MergeSort( DynamicArray *secondArray);
              int Delete(int dilElem);
             bool Compare (DynamicArray *secondArray); 

        private:
                int *newArray; 
                int *secondArray;
                int *m_array;
                int m_partSize;
                int m_logicSize;
                int m_realSize;
                void Reallocate(void);
};

Модератор: тег CODE

[Sazary]

Сообщение от Suren

обязателно ли перед каждым методом написать template <class T> или template <typename T>

Да, перед описанием каждой функции.

[Suren]

Я точно так и сделал перед каждым методом написал , но у меня не получился если не трудно не привидите пример на моем коде

[pu4koff]

template < class T >
class CMyArray
{
private:
  T *items;
public:
  CMyArray(int size);
  ~CMyArray();
};

template < class T>
CMyArray< T >::CMyArray(int size)
{
  items = new T[size];
}

template < class T >
CMyArray< T >::~CMyArray()
{
  delete[] items;
}

[Suren]

Огромое спасибо вам