counting number of base and derived classes pointers

[vdxnc0]

I have to write a function to count number of pointers to objects of base class and number of pointers to objects of derived class that are stored in array.
I already know how to do it using RTTI.
But I really do not have an idea how to do it outside the classes.
I would really appreciate some help.
That's how my classes and small piece of function look like:

class IntVector
{

    int* tab;
    int size;
    int* _useCount;


public:
    const int max = 7;

    IntVector(int s) : tab(new int[s]), size(s), _useCount(new int)
    {
        if (s <= 0 || s > max)
            throw Size(s);
        else
        {
            size = s;
            tab = new int;
        }
    }

    IntVector(const IntVector& src) : tab(src.tab), size(src.size), _useCount(src._useCount)
    {
        (*_useCount)++;
    }

    class Range
    {
        int index;
    public:
        int getIndex() { return index; };
        Range(int i) : index(i) { }
    };

    class Size
    {
        int id;
    public:
        int getIndex() { return id; };
        Size(int i) : id(i) { }
    };



    int& operator[](int i)
    {
        if (i >= 0 && i < size)
            return tab[i];
        else
            throw Range(i);
    }

    virtual ~IntVector()
    {
        if (--(*_useCount) == 0)
        {
            delete[] tab;
            delete _useCount;
        }
    }
};

class StringIntVector : IntVector
{
    int* _useCount;
    int* tab;
    int size;

public:

    StringIntVector(int s) : IntVector(s), tab(new int[s]), size(s), _useCount(new int)
    {
        if (s <= 0 || s > max)
        {
            throw Size(s);
        }
        else
        {
            size = s;
            tab = new int;
        }
    }

    StringIntVector(const StringIntVector& src) : IntVector(src), tab(src.tab), size(src.size), _useCount(src._useCount)
    {
        (*_useCount)++;
    }

    int& operator[](string s)
    {
        int s_s = s.length();
        if (s_s < size)
            return tab[s_s];
        else
            throw Range(s_s);
    }
};

bool count(IntVector* source[], int n, int& base, int& derived)
{
    IntVector* vec();

    for (int i = 0; i < n; i++)
    {

        if (???)
        {
            base++;
        }
        else
        {
            derived++;
        }
    }

    if ((base + derived) == n)
        return true;
    else
        return false;
}
}

[ne555]

class Foo{
public:
   virtual ~Foo() = default;
};

class Bar: public Foo{
};


int count_bar(Foo * array[], int size){
   int result = 0;
   for(int K=0; K<size; ++K)
      if(dynamic_cast<Bar*>(array[K]))
         ++result;
   return result;
}