Описать класс, реализующий простой динамический массив из целых чисел

#include <iostream>
using namespace std;
class Massiv
{
    int* mas;
    int pos;
public:
    Massiv():pos(0)
    {
        mas=new int[100];
    }
    ~Massiv()
    {
        delete[] mas;
    }
    void PushMass(int value)
    {
        if(pos>100) cout<<"Выход ща границы массива!!!"<<endl;
        else
        {
            mas[pos]=value;
            pos++;
        }
    }
    void PopMass(int position)
    {
        if(position<0 || position>100) cout<<"Введите корректный индекс!!!"<<endl;
        else cout<<mas[position]<<endl;
    }
    void ShowMass()
    {
        for(int i=0;i<pos;i++)
            cout<<mas[i]<<" ";
        cout<<endl;
    }
};
int main()
{
    setlocale(LC_ALL, ".1251");
    Massiv mass;
    mass.PushMass(2);
    mass.PushMass(-4);
    mass.PushMass(16);
    mass.ShowMass();
    mass.PopMass(1);
    system("pause");
    return 0;
}

std::vector

#include <iostream>
#include <cstring>
 
 
class ClArray
{
    private :
        int *Data;
         int arrSize;
 
    public:
        ClArray();  
        ClArray( int );
        ~ClArray();
        ClArray( const ClArray& t );
 
    public:
        int getSize() const;  //  размер 
        void Add( const int  val );// добавление в конец 
 
        void Insert( const  int pos, const int  val );  // добавление в указ. позицию 
 
        int IndexOf( const int val );   //  возвращает индекс 
        int LastIndexOf( const int val ); //  возвращает последний  индекс 
    
    public:
        int &operator[](  int ind );
        ClArray &operator= ( const ClArray &t );
        friend std::istream & operator >> ( std::istream & is,  ClArray & a );
        friend std::ostream & operator << ( std::ostream & to, const ClArray & a );
    
};
 
 
ClArray::~ClArray()
    {
        delete[] Data;
        Data = 0;   
    }
 
ClArray::ClArray() :
        arrSize ( 10 )
{
        Data = new int[ arrSize ];
         if ( Data == 0 )
             {
                 std::cerr << "Can't allocate memory!!";
                    exit ( -1 );
             }
        memset ( Data , 0, arrSize * sizeof( int )  );
}
 
ClArray::ClArray( int arr_size ) :
          arrSize ( arr_size )
    {
         Data = new int[ arrSize ];
          if ( Data == 0 )
             {
                 std::cerr << "Can't allocate memory!!";
                    exit ( -1 );
             }
         memset ( Data , 0, arrSize * sizeof( int )  );
    }
 
            ClArray::ClArray( const ClArray& t )
    {       
           if ( this == &t )
               return ;
                      
             Data = new int [ t.arrSize ];
 
              if ( Data == 0 )
             {
                 std::cerr << "Can't allocate memory!!";
                    exit ( -1 );
             }
 
             memcpy ( Data, t.Data , t.arrSize * sizeof( int ) );
             arrSize = t.arrSize;
    }
 
 
int ClArray::getSize() const
    {
        return ( arrSize ); 
    }
    
void ClArray::Add( const int val )
    {
         // создаем промежуточный массив 
         int *tmp = new int [ arrSize ];
          if ( tmp == 0 )
             {
                 std::cerr << "Can't allocate memory!!";
                    exit ( -1 );
             }
         memcpy ( tmp, Data , arrSize * sizeof( int ) );// копируем в него данные 
         delete [] Data;  // удалим данные 
 
         Data = new int [ arrSize + 1 ]; // создаем новые данные + новый елемент который добавили 
          if ( Data == 0 )
             {
                 std::cerr << "Can't allocate memory!!";
                    exit ( -1 );
             }
 
         for (  int  i = 0; i < arrSize; ++i )  //  копируем  данные в нов. массив  
             *( Data + i ) = *( tmp + i ) ;    
 
              *( Data + arrSize ) = val;    // допишем значение в последний эл-мент 
 
         delete []tmp;// удалим промежуточный массив 
         tmp = 0;
 
         arrSize++;  // увеличим размер  массива на 1 
 
    }
 
int ClArray::IndexOf( const int val )
    {
        for (  int pos = 0; pos < arrSize; ++pos )
            {
                if ( val == *( Data + pos ) )
                return (  pos  );
            }
        return -1;
    }
 
    void ClArray::Insert( const  int pos, const int  val )
    {
            if ( pos < 0 || pos > ( arrSize - 1 ) ) 
                {
                    std::cerr << "Index out of range";
                    exit ( -1 );
                }
                arrSize++;
 
            int *tmp = new int [ arrSize ];
              if ( tmp == 0 )
             {
                 std::cerr << "Can't allocate memory!!";
                    exit ( -1 );
             }
            int i = 0, j = 0;
            while( i < pos ) 
                {
                     *( tmp + i ) = *( Data + i ) ;
                     i++;
                }
 
            *( tmp + pos ) = val; 
            j = i;
            i++; 
               
           while( i < ( arrSize ) ) 
                {
                     tmp[ i++ ] =  Data [ j++ ] ;
                }
           delete[] Data;
 
           Data = new int [ arrSize ];
             if ( Data == 0 )
             {
                 std::cerr << "Can't allocate memory!!";
                    exit ( -1 );
             }
           memcpy ( Data, tmp , arrSize * sizeof( int ) );
           delete []tmp;
           tmp = 0;
 
    }
 
 
    int ClArray::LastIndexOf ( const int val )
    {
        for ( int pos =  arrSize - 1 ; pos != -1 ; --pos )
            {
                if ( val == *( Data + pos ) )
                return (  pos  );
            }
        return -1;
    }
 
 
    int & ClArray::operator[](  int ind )// const
    {
        if ( ind > ( arrSize - 1 )  || ind < 0 )
        {
                std::cerr << "Index out of range";
                exit ( -1 );
        } 
        return ( Data[ ind ] );
    }
 
 
  ClArray &ClArray::operator= ( const ClArray &t )
    {
          if ( this != &t )
          {     
             delete[] Data;
             Data = new int [ t.arrSize ];
             if ( Data == 0 )
             {
                 std::cerr << "Can't allocate memory!!";
                    exit ( -1 );
             }
             memcpy ( Data, t.Data , t.arrSize * sizeof( int ) );
             arrSize = t.arrSize;
          }
          return *this;
    }
 
std::ostream & operator << ( std::ostream & to, const ClArray & a )
    {
        for ( int i = 0; i < a.arrSize; ++i )
 
          to << a.Data[ i ] << ' ';
          return to;
    }
 
std::istream & operator >> ( std::istream & is,  ClArray & a )
    {
        for ( int i = 0; i < a.arrSize; ++i )
          is >> a.Data[ i ];
          return is;
    }
 
 
int main()
{
    ClArray ma;
        ClArray mc( 3 );//  создаем массив на три э-та, по умолчанию заполнен нулями
    std::cout << "Enter a elements:\n";
    std::cin >> ma;  // Ввводим значения 
    std::cout << ma[ 9 ] << std::endl;  // Вывод 10-го э-та 
    ma.Add( 2 );  // добавление в конец 
    std::cout << ma;
    ClArray mb ( ma );// копируем 
    std::cout << std::endl << mb;
    mb.Insert( mb.IndexOf( 3 ), 99 );  // вставим число 99 перед первым элементом со значением 3
    std::cout << std::endl << mb;
 
    std::cout << std::endl;
 
    mb[ 10 ] = mb[ 1 ] + ma [ 1 ];
 
    std::cout << mb[ 10 ];
    
    return 0;
}

ClArray a = 10;

void func(const ClArray& x);
//...
func(10);

explicit
ClArray( int );