Вы можете использовать dynamic_cast, если вектор содержит указатели Animal.

vector <Animal *> stuff;

for(int i=0;i<stuff.size();i++) {
    Dog *pDog = dynamic_cast <Dog *> (stuff[i]);
    if (pDog) {
        // do whatever with the dog
    }

    Cat *pCat = dynamic_cast <Cat *> (stuff[i]);
    if (pCat) {
        // and so on
    }
}

но вы должны знать, что это, как правило, не лучшая практика. Вы должны попытаться работать с полиморфизмом, а не против него. Другими словами, попробуйте написать виртуальную функцию Animal, которую Dog и Cat переопределяют, и пусть компилятор автоматически вызовет нужную функцию.

(Кроме того, dynamic_cast относительно медленный, поэтому слишком большое их количество снизит производительность; в то время как вызов виртуальной функции обычно представляет собой всего лишь одну инструкцию.)

Вы уверены, что хотите это сделать? То, что вы собираетесь сделать, прямо противоположно полиморфизму, а полиморфизм - лучшее, что есть в объектно-ориентированном программировании.

Грубо говоря: ничего не делайте если вы животное собака; пусть иерархия Животных знает, что делать, если одним из ее объектов является Собака! :)

Для этого можно использовать оператор typeid, например

if (typeid(stuff[i].getClass())==typeid(Dog))

Однако этого нельзя поймать, если это производный класс от Dog. Для этого можно использовать dynamic_cast. Однако любое использование typeid или dynamic_cast часто указывает на конструктивный недостаток. Обычно вам не нужно знать, какие у вас производные типы, и, вероятно, есть способ лучше, который включает полиморфизм. Однако сложно дать правильный совет без реального примера.

Как отмечали другие, вам не следует использовать ни typeid, ни оператор dynamic_cast, чтобы получить динамический тип того, на что указывает ваш указатель. виртуальные функции были созданы, чтобы избежать такого рода неприятностей.

В любом случае, вот что вы делаете, если вы В самом деле хотите это сделать (обратите внимание, что разыменование итератора даст вам Animal*. Так что, если вы сделаете **it, вы получите Animal&):

for(std::vector<Animal*>::iterator it = v.begin(); it != v.end(); ++it) {
    if (typeid(**it) == typeid(Dog)) {
        // it's a dog
    } else if (typeid(**it) == typeid(Cat)) {
        // it's a cat
    }
}

Обратите внимание, что вы можете применить оператор typeid и к самим типам, как показано выше. Для этого не нужно создавать объект. Также обратите внимание, что метод typeid не работает, если вы передадите ему указатель, например typeid(*it). Используя его таким образом, вы получите только typeid(Animal*), который бесполезен.

Аналогично, dynamic_cast можно использовать:

for(std::vector<Animal*>::iterator it = v.begin(); it != v.end(); ++it) {
    if (Dog * dog = dynamic_cast<Dog*>(*it)) {
        // it's a dog (or inherited from it). use the pointer
    } else if (Cat * cat = dynamic_cast<Cat*>(*it)) {
        // it's a cat (or inherited from it). use the pointer. 
    }
}

Обратите внимание, что в обоих случаях ваш тип Animal должен быть полиморфным. Это означает, что он должен иметь или унаследовать хотя бы одну виртуальную функцию.

Если вам действительно нужен уровень приложения для идентификации собак и не-собак, вам следует избегать использования RTTI (dynamic_cast и typeid) и сделать это знание явным в иерархии классов.

for (size_t i = 0; i != v.size(); ++i) {
    if (v[i]->isDog()) { v->cleanupPoop(); }
}

Есть некоторые незначительные преимущества в производительности, но основное преимущество заключается в демонстрации необходимого поведения в интерфейсе вашего класса программистам по обслуживанию. RTTI (будучи столь же ограниченным) не должен требоваться для функционирования иерархии классов.

Теперь, наряду с тем, что говорили другие люди, вполне вероятно, что функцию isDog() можно реорганизовать во что-то, что не требует предварительного знания всей иерархии (например, needsPoopCleanup()). Как и все остальные, вы теряете преимущества полиморфизма, если логика вашего приложения так или иначе выполняется в зависимости от типа объекта.

с использованием виртуальных функций:

Как указывали другие ответы, использования виртуальных функций часто бывает достаточно, и это образ мышления "C++". Вот пример использования виртуальных функций:

#include<iostream>
#include<vector>
using namespace std;

/////////////

class Animal {
  public:
    virtual void move() { cout << "animal just moved" << endl; }
};
class Dog : public Animal {
  public:
    void move() { cout << "dog just moved" << endl; }
};
class Cat : public Animal {
  public:
    void move() { cout << "cat just moved" << endl; }
};

void doSomethingWithAnimal(Animal *a) {
  a->move();
}

/////////////

int main() {
  vector<Animal*> vec;
  vector<Animal*>::iterator it;

  Animal *a = new Animal;
  Dog *d = new Dog;
  Cat *c = new Cat;

  vec.push_back(a);
  vec.push_back(d);
  vec.push_back(c);

  it = vec.begin();

  while( it != vec.end() ) {
    doSomethingWithAnimal(*it);

    it++;
  }

  return 0;
}

Если этого будет недостаточно, то другие уже опубликовали ответы, которые фактически используют условную логику вместо полимеризованной логики.

Принятый ответ правильный, но вы должны знать, что есть еще один вариант, о котором не упоминалось. У вас может быть виртуальная функция в классе Animal с именем «type ()», которая может возвращать int или строку (или любой сопоставимый тип).

Так например:

class Animal {
    /*...*/
public:
    virtual std::string type() const { return "animal"; }
};

class Dog: public Animal{
    /*...*/
public:
    virtual std::string type() const { return "dog"; }
};

class Cat: public Animal{
    /*...*/
public:
    virtual std::string type() const { return "cat"; }
};

Таким образом, вы могли просто сделать:

if (array[i]->type() == "dog") { }

Функция типа может возвращать что угодно (int, уникальный для каждого производного типа, тоже будет работать, но строки лучше иллюстрируют это).

Просто еще один вариант.