В последовательности из n произвольных чисел подсчитать количество нулей

#include <iostream>
#include <vector>
#include <memory>
 
template<typename T>
class Vector :public std::vector<T>
{
public:
    typedef T ValueType;
    enum Constants
    {
        ValueModule = 100
    };
};
 
template<typename T>
class Input
{
public:
    virtual void action(size_t _count, T& _array) = 0;
    virtual ~Input() {}
};
 
template<typename T>
class RandInput: public Input<T>
{
public:
    void action(size_t _count, T& _array)
    {
        for (size_t x = 0; x < _count; x++)
        {
            typename T::ValueType value = std::rand() % (int)T::ValueModule;
            _array.push_back(value);
        }
    }
};
 
template<typename T>
class UserInput: public Input<T>
{
public:
    void action(size_t _count, T& _array)
    {
        std::cout << "input " << _count << " numbers: ";
        for (size_t y = 0; y < _count;)
        {
            typename T::ValueType value;
            std::cin >> value;
            if (std::cin.fail())
            {
                std::cin.clear();
                std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
                std::cout << std::endl << "input " << (_count-y) << " numbers: ";
                continue;
            }
            _array.push_back(value);
            ++y;
        }
        std::cout << std::endl << "...array complete." << std::endl;
    }
};
 
template<typename T>
class Task
{
public:
    void run(const T& _array)
    {
        size_t zeroCount = 0;
        for (size_t y = 0; y < _array.size(); ++y)
        {
            if (!_array[y])
                ++zeroCount;
        }
        std::cout << "For array: ";
        print(_array);
        std::cout << std::endl << "Found " << zeroCount << " elements." << std::endl;
    }
};
 
template<typename T>
void print(const T& _array)
{
    bool useSeparator = false;
    for (size_t y = 0; y < _array.size(); y++)
    {
        if (useSeparator) std::cout << ", ";
        else useSeparator = true;
        std::cout << _array[y];
    }
}
 
template<typename T>
class SelectSizeAndInput
{
public:
    typedef Vector<T> TVector;
private:
    std::vector<std::unique_ptr<Input<TVector>>> inputs;
public:
    enum Constants{
        Rand = 0x0,
        User = 0x1,
    };
    
    SelectSizeAndInput()
    {
        inputs.push_back(std::make_unique<RandInput<TVector>>());
        inputs.push_back(std::make_unique<UserInput<TVector>>());
    }
 
    void fill(size_t _count, Vector<T>& _array)
    {
        
        size_t mode = 0;
        char ch = 0;
 
        bool repeat = false;
        do{
            std::cout << "Required user input? (Y/N): ";
            std::cin >> ch;
            repeat = false;
            switch (ch)
            {
            case 'Y': mode = (size_t)User; break;
            case 'N': break;
            default:
                repeat = true;
                continue;
            }
            std::cin.clear();
        } while (repeat);
 
        inputs.at(mode)->action(_count, _array);
    }
 
    void run()
    {
        TVector array;
        std::cout << "Array elements count (number required (1; +infinity)): ";
        size_t count = 0;
        while (!count)
        {
            std::cin >> count;
            if (std::cin.fail())
            {
                std::cin.clear();
                std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
                std::cout << std::endl << "Array elements count (number required (1; +infinity)): ";
            }
        }
        std::cout << std::endl;
        
        fill(count, array);
 
        Task<TVector>().run(array);
    }
};
 
int main()
{
    SelectSizeAndInput<int> app;
    app.run();
 
    std::cout << "app done." << std::endl;
#ifdef WIN32
    system("pause");
#endif
}