Вывести те названия фруктов, которые имеют наибольшее количество заданной буквы

#include<iostream>
#include<string>
using namespace std;
template<class T>
class Vectorr{
private:
    T*arrays;
    int size;
public:
    Vectorr(){ int size=0;
 
    } 
  void Fill(T object, int size){
if(size==0){
arrays=new T[size+1];
}
else {
T *copy=new T[size+1];
for(int i=0; i<size; i++){
copy[i]=arrays[i];
}
delete []arrays;
arrays=copy;
}
arrays[size]=object;
}
    void Counter(T *word, string a){
        T *p;
        int count =0;
            for(p=word; *p!="\0"; p++){
            if(*p==a)
                count++;
        }
                    
        cout<<count<<endl;
    }
    void output(int size){
for(int i=0; i<size; i++){
            cout<<arrays[i]<<endl;
        }
    }   
    
};
class Fruict{
private:
    char* b;
public:
    Fruict(){}
    Fruict(char *a){
        b=a;
    }
};
void main(){
    int m=5;
 
string* a=new string();
 
Vectorr <string> k;
int n=3;
for(int i=0; i<n; i++){
cin>>*a;
k.Fill(*a,i);
}
k.output(n);
for(int i=0; i<n; i++){
k.Counter(a,"an");
}
system ("pause");
}

#include <iostream>
#include <cstring>
#include <algorithm>
 
template<class T>
class Vectorr;
 
template<class T>
std::ostream& operator<<(std::ostream&, const Vectorr<T>&);
 
template<class T>
class Vectorr
{
private:
  T      *arrays;
  size_t  size;
  size_t  count;
public:
  Vectorr() : count{ 0 }, size{ 0 }, arrays{nullptr} {}
 
  Vectorr(Vectorr&& vec)
    : size{vec.size}, count{vec.count}, arrays{vec.arrays}
    {
      vec.arrays = nullptr;
      vec.size = 0;
      vec.count = 0;
    }
 
  ~Vectorr() { if (arrays) delete[] arrays; }
 
  Vectorr& operator=(Vectorr&& vec)
    {
      delete[] arrays;
      arrays = vec.arrays;
      size = vec.size;
      count = vec.count;
      vec.count = 0;
      vec.size = 0;
      vec.arrays = nullptr;
      return *this;
    }
 
  T operator[](size_t index) const
    {
      return arrays[index];
    }
  void push_back(const T& t)
    {
      if (count == size)
      {
        if (!count) count++;
        count *= 2;
        T *temp = new T[count];
        std::copy(arrays, arrays + size, temp);
        delete[] arrays;
        arrays = temp;
      }
      arrays[size++] = t;
    }
 
   size_t getSize() const { return size; }
 
   friend std::ostream& operator<< <T>(std::ostream& os, const Vectorr<T>& vec);
 };
 
template<class T>
 std::ostream& operator<<(std::ostream& os, const Vectorr<T>& vec)
 {
   for (size_t i = 0; i < vec.size; ++i)
   {
     os << "\t\t" << vec.arrays[i] << '\n';
   }
   return os;
 }
 
 class Fruict
 {
 private:
   char* b;
   size_t size;
   void setName(const char* str)
     {
       size = strlen(str);
       delete[] b;
       b = new char[size + 1];
       std::copy(str, str + size, b);
       b[size] = '\0';
     }
 public:
   Fruict() : size{0}, b{nullptr} {}
   Fruict(const char *a)
     {
       size = strlen(a);
       b = new char[size + 1];
       std::copy(a, a + size, b);
       b[size] = '\0';
     }
   Fruict(const Fruict& f)
    : size{f.size}, b{ new char[size + 1]}
    {
      std::copy(f.b, f.b + size, b);
      b[size] = '\0';
    }
  ~Fruict() { if (b) delete[] b; }
  Fruict& operator=(const Fruict& f)
    {
      size = f.size;
      delete[] b;
      b = new char[size + 1];
      std::copy(f.b, f.b + size, b);
      b[size] = '\0';
      return *this;
    }
  bool search(const char ch) const
    {
      for (size_t i = 0; i < size; ++i)
        if (b[i] == ch) return true;
      return false;
    }
  operator bool()
   {
      return b ? true : false;
    }
  friend std::istream& operator>>(std::istream& is, Fruict& fruict);
  friend std::ostream& operator<<(std::ostream& os, const Fruict& fruict);
};
 
std::istream& operator>>(std::istream& is, Fruict& fruict)
{
  std::string name;
  is >> name;
  fruict.setName(name.c_str());
  return is;
}
 
std::ostream& operator<<(std::ostream& os, const Fruict& fruict) { return os << fruict.b; }
 
template<class T>
Vectorr<T> fill(std::istream& is)
{
  Vectorr<T> vectorr;
  for(Fruict f; is >> f;) vectorr.push_back(f);
  return vectorr;
}
 
template<class T>
Vectorr<T> find(const Vectorr<T>& vec, const char ch)
{
  Vectorr<Fruict> temp;
  size_t sz = vec.getSize();
  for (size_t i = 0; i < sz; ++i)
  {
    Fruict f = vec[i];
    if (f.search(ch)) temp.push_back(f);
  }
  return temp;
}
 
int main()
{
  Vectorr<Fruict> k = fill<Fruict>(std::cin);
 
  std::cout << "\nVectorr<Fruict> k -->\n"<< k << std::endl;
 
  Vectorr<Fruict> f = find<>(k, 'a');
  std::cout << "\nVectorr<Fruict> f -->\n" << f << std::endl;
 
  std::cin.get();
 
  return 0;
}