Есть ли способ определить тип объекта?

Если вы собираетесь оставить метод doSomething как есть, это то, что называется множественная отправка и в настоящее время НЕ поддерживается C++.

Если бы это была виртуальная функция-член BaseClass, то да, это был бы полиморфизм мельницы С++ для объекта, для которого он вызывается, но он все равно НЕ вывел бы автоматически тип аргумента.

Чтобы обойти это, вы можете сделать что-то вроде того, что предлагается в предыдущей ссылке.

void collideWith(Thing& other) {
     // dynamic_cast to a pointer type returns NULL if the cast fails
     // (dynamic_cast to a reference type would throw an exception on failure)
     if (Asteroid* asteroid = dynamic_cast<Asteroid*>(&other)) {
         // handle Asteroid-Asteroid collision
     } else if (Spaceship* spaceship = dynamic_cast<Spaceship*>(&other)) {
         // handle Asteroid-Spaceship collision
     } else {
         // default collision handling here
     }
 }

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

ВАЖНО: как указывает @WhozCraig, ваш вектор должен содержать указатели, чтобы избежать Object-Slicing и сделать весь этот вопрос спорным.

Хорошо, да, вы должны использовать полиморфизм, как указано выше. Если ваша функция должна обрабатывать 2 объекта, это становится чрезвычайно сложным.

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

class DerivedA;
class DerivedB;
class DerivedC;

class BaseClass
{
 public:
     virtual ~BaseClass();

     virtual void doSomethingWithBase( BaseClass & b2 ) = 0;
     virtual void doSomethingWithDerivedA( DerivedA & da ) = 0;
     virtual void doSomethingWithDerivedB( DerivedB & db ) = 0;
     virtual void doSomethingWithDerivedC( DerivedC & dc ) = 0;
};

class DerivedA : public BaseClass
{
   public:

      void doSomethingWithBase( BaseClass & b2 )
      {
           b2.doSomethingWithDerivedA( *this );
      }

      void doSomethingWithDerivedA( DerivedA & da )
      {
           // implement for two DerivedA objects
      }

      void doSomethingWithDerivedB( DerivedB & db )
      {
           // implement for an A and B
      }

      void doSomethingWithDerivedC( DerivedC & dc )
      {
          // implement for an A and C
      }
 };

 // implement DerivedB to call doSomethingWithDerivedB on its parameter
 // implement DerivedC to call doSomethingWithDerivedC on its parameter.

Вы поняли идею. Откуда вы звоните, вам не нужно знать, какие два типа у вас есть, и вам никогда не нужно искать это на самом деле. Но если вы когда-нибудь добавите больше реализаций, у вас будет много кода для редактирования, и вы можете подумать о какой-то таблице поиска.

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

  class BaseClass
  {
      public:
         virtual int id() const = 0;
  };

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