Определить, какой символ наиболее редко встречается в заданном массиве(шаблоны) - C++

#include <iostream>
#include <conio.h>
using namespace std;
typedef int T;
class VECTOR
{
    public:
       int n;
       T *A;
       VECTOR(int n);
       ~VECTOR();
       VECTOR(VECTOR & what);
       void Set(int j, T value);
       int GetSize();
       float Get(int t);
       int Check(int value,VECTOR what);
       void Print();
       void Counting(VECTOR what);
};
 
 
 VECTOR::VECTOR(int _n)
    {
        n=_n;
        A= new T[n];
            if(A==NULL) 
                {
                    cout << "Недостаточно памяти\n";
                    exit(1);
                }
            for(int i=0;i<n;i++)
                {
                    A[i]=0;
                }
    }
 
 VECTOR::~VECTOR()
    {
        if (A)
            delete[] A;
    }
 
 VECTOR::VECTOR(VECTOR & what) 
    {
        n = what.n;
        A = new T[n];
        for(int i = 0; i < n; i++)
            A[i] = what.A[i];
    };
 
 int VECTOR::GetSize() 
    {   
        return n;
    }
 
 float VECTOR::Get(int t) 
    {
        return A[t];
    }
 
 int VECTOR::Check(int value,VECTOR what)
    {
        int flag1;
        flag1=0;
        for(int j=0; j<what.GetSize();j++)
            {
                if(what.Get(j)==value)
                    {
                        flag1++;
                    }
            }
                if(flag1==0)
                    {
                        cout<<"\n Введенный элемент не может содержаться массиве!";
                        cout<<"\n Массив должен содержать следующие элементы:";
                        what.Print();
                        return 1;
                        _getch();
                    }
        return 0; 
 
    }
 
 void VECTOR::Set(int j, T value)
    {
        if(j<GetSize())   
            {
                A[j]=value;
            }
        else
            {
                cout<<"Вы вышли за пределы выделенной для программы памяти!!!";
                cout<<"\nПрограмма завершает свою работу!!!";
                _getch();
                exit(0);
            }
    }
 
 void VECTOR::Print()
    {
        cout << "[";    
        for(int i=0;i<n;i++)
            {
               cout << " "<<A[i];
            };
        cout << "]";    
    };
 
 void VECTOR::Counting(VECTOR what)
    {
        int schet,result, min;
        VECTOR count(what.GetSize());
        Print();
        what.Print();
        for (int i=0; i<what.GetSize();i++)
            {
                schet=0;
                for(int j=0; j<GetSize();j++)
                    {
                        if(A[j]==what.Get(i))
                            {
                                schet++;
                            }
                    }
                count.Set(i, schet);
            }       
        min=what.GetSize()-1;
        for(int j=0;j<what.GetSize();j++)
            {
                if((count.Get(j)!=0)&&(count.Get(j)<min))
                    {
                        min=count.Get(j);
                        result=j;
                    }
            }
        cout<<"\nЧисло "<< result <<" встречается реже остальных: "<<min<<" раз.";
 }

#include <iostream>
#include <conio.h>
#include <clocale>
#include "VECTOR.h"
using namespace std;
 
int main()
{
    setlocale(LC_CTYPE,"Russian");
    int n, input,in_elem;
    VECTOR Check_Arr(7);
        cout << "Введите элементы проверочного массива: ";
        cout << "\nА= [ ";
        for(int i = 0; i < 7; i++)
            {
                cin>>in_elem;
                Check_Arr.Set(i,in_elem);
            }
        cout << "]";
        do
            {
                cout << "Введите размерность массива: ";
                cin >> n; 
            }
        while(n <= 0); // Проверка корректности ввода
    VECTOR V(n);
    cout << "\nВведите элементы массива А: ";
    for(int i = 0; i < n; i++)
        {
            do
                {
                    cout << "\nВведите [" << i << "] элемент: ";
                    cin >> in_elem;
                    input=V.Check(in_elem,Check_Arr);//проверка, чтоб вводимый массив 
                }                        //состоял из нужных нам элементов
            while(input==1);
            V.Set(i,in_elem);
        }
    V.Counting(Check_Arr);
    _getch();
    return 0;
}

#include <stdexcept>
#include <string>
#include <sstream>
#include <utility>
 
using namespace std;
 
template <class T>
class TVector
{
   protected:
      int n;
      T* A;
 
   public:
      // TODO: Исключение в конструкторе вещь не благодарное
      //       но если хотите проверять new ...
      TVector(int n) throw (std::runtime_error);
      TVector(const TVector& what) throw (std::runtime_error);
 
      ~TVector();
      void Set(int index, T value) throw (std::runtime_error);
      int GetSize() const;
      T Get(int t) const throw (std::runtime_error);
      int Check(T value, TVector what) const throw (std::runtime_error);
      std::string AsString() const;
      std::pair<T, int> Counting(const TVector& what) const;
};
 
//----------------------------------------------//
template <class T>
TVector<T>::TVector(int _n) throw (std::runtime_error)
{
   n = _n;
   A = new T[n];
   if (A == NULL)
   {
      throw std::runtime_error("Недостаточно памяти");
   }
   for (int i = 0; i < n; i++)
   {
      A[i] = 0;
   }
}
//----------------------------------------------//
template <class T>
TVector<T>::TVector(const TVector& what) throw (std::runtime_error)
{
   n = what.n;
   A = new T[n];
   if (A == NULL)
   {
      throw std::runtime_error("Недостаточно памяти");
   }
   for (int i = 0; i < n; i++)
   {
      A[i] = what.A[i];
   }
};
//----------------------------------------------//
template <class T>
TVector<T>::~TVector()
{
   if (A)
   {
      delete[] A;
   }
}
//----------------------------------------------//
template <class T>
int TVector<T>::GetSize() const
{
   return n;
}
//----------------------------------------------//
template <class T>
T TVector<T>::Get(int index) const throw (std::runtime_error)
{
   if (index >= n)
   {
      throw std::runtime_error("Выход за пределы массива");
   }
 
   return A[index];
}
//----------------------------------------------//
template <class T>
int TVector<T>::Check(T value, TVector what) const throw (std::runtime_error)
{
   int flag1;
   flag1 = 0;
   for (int j = 0; j < what.GetSize(); j++)
   {
      if (what.Get(j) == value)
      {
         flag1++;
      }
   }
   if (flag1 == 0)
   {
      std::stringstream ss;
      ss << "Введенный элемент не может содержаться в массиве!\n"
         << "Массив должен содержать следующие элементы: "
         << what.AsString();
      throw std::runtime_error(ss.str());
   }
 
   return 0;
}
//----------------------------------------------//
template <class T>
void TVector<T>::Set(int index, T value) throw (std::runtime_error)
{
   if (index < GetSize())
   {
      A[index] = value;
   }
   else
   {
      throw std::runtime_error("Вы вышли за пределы выделенной для программы памяти!!!\n"
                               "Программа завершает свою работу!!!");
   }
}
//----------------------------------------------//
template <class T>
std::string TVector<T>::AsString() const
{
   std::stringstream ss;
   ss << "[";
   for (int i = 0; i < n; i++)
   {
      ss << " " << A[i];
   };
   ss << "]";
 
   return ss.str();
};
//----------------------------------------------//
template <class T>
std::pair<T, int> TVector<T>::Counting(const TVector& what) const
{
   int schet = 0;
 
   TVector<int> count(what.GetSize());
 
   for (int i = 0; i < what.GetSize(); i++)
   {
      schet = 0;
      for (int j = 0; j < GetSize(); j++)
      {
         if (A[j] == what.Get(i))
         {
            schet++;
         }
      }
      count.Set(i, schet);
   }
 
   int min = 0;
   for (int j = 0; j < what.GetSize(); j++)
   {
      if (count.Get(j) < count.Get(min))
      {
         min = j;
      }
   }
 
   return std::pair<T, int>(what.Get(min), count.Get(min));
}
//----------------------------------------------//

#include <iostream>
#include <clocale>
 
#include "vector.h"
 
int main()
{
   ::setlocale(LC_CTYPE, "Russian");
 
   char in_elem = 0;
   TVector<char> Check_Arr(7);
 
   cout << "Введите элементы проверочного массива:\nА = ";
   for (int i = 0; i < Check_Arr.GetSize(); i++)
   {
      cin >> in_elem;
      try
      {
         Check_Arr.Set(i, in_elem);
      }
      catch (const std::runtime_error& error)
      {
         std::cerr << error.what() << std::endl;
         return 1;
      }
   }
 
   int n = 0;
   do
   {
      std::cout << "Введите размерность массива: ";
      cin >> n;
   }
   while (n <= 0);
 
   TVector<char> V(n);
   std::cout << "Введите элементы массива А: " << std::endl;
 
   int input = 0;
   for (int i = 0; i < V.GetSize(); i++)
   {
      do
      {
         cout << "Введите [" << i << "] элемент: ";
         cin >> in_elem;
         try
         {
            input = V.Check(in_elem, Check_Arr);
            V.Set(i, in_elem);
         }
         catch (const std::runtime_error& error)
         {
            std::cerr << error.what() << std::endl;
            // TODO: не хорошо, но тогда i-ый элемент будет равен 0
            --i;
         }
      }
      while (input == 1);
   }
 
   std::cout << "\n" << Check_Arr.AsString() << "\n"  << V.AsString() << std::endl;
 
   std::pair<char, int> result = V.Counting(Check_Arr);
 
   std::cout << "Значение \""<< result.first << "\" встречается реже остальных: "
             << result.second << " раз." << std::endl;
 
   return 0;
}