Как сделать контейнер, который содержит указатели любого типа

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

class pointer_wrapper_base
{
public:
  virtual void delete_pointee()=0;
protected:
  void *m_ptr;
};

template<class T>
class pointer_wrapper: public pointer_wrapper_base
{
public:
  pointer_wrapper(T *ptr_) {m_ptr=ptr_;}
  virtual void delete_pointee()
  {
    delete (T*)m_ptr;
  }
};

Если у вас есть этот класс, вы можете использовать, например, поливариантный класс, который похож на класс вариантов, но все различные варианты имеют общий базовый класс. У меня есть реализация, если хотите посмотреть: https://sourceforge.net/p/spinxengine/code/HEAD/tree/sxp_src/core/utils.h (ищите poly_pod_variant):

  std::vector<poly_pod_variant<pointer_wrapper_base> > x;
  x.push_back(pointer_wrapper<Cat>(new(Cat)));
  x[0]->delete_pointee();

Или, если у вас все в порядке с динамическим распределением для оберток, вы, конечно, можете просто хранить указатели на pointer_wrap_base в векторе, например.

std::vector<std::unique_ptr<pointer_wrapper_base> > x;
x.push_back(std::unique_ptr<pointer_wrapper_base>(new(pointer_wrapper<Cat>)(new Cat)));
x[0]->delete_pointee();

Попробуйте использовать некоторые классы Boost, такие как boost::any, https://www.boost.org/doc/libs/1_55_0/doc/html/any.html и их пример кода, https://www.boost.org/doc/libs/1_55_0/doc/html/any/s02.html

В качестве альтернативы, посмотрите на вариант Boost.

В общем, изучайте Boost. Это поразит вас и ускорит вашу разработку на C++.

C++ имеет статическую систему типов. Это означает, что типы всех выражений должны быть известны во время компиляции. Решение вашей проблемы зависит от того, что вы собираетесь делать с объектами.

Вариант 1: пусть Cat и Dog будут производными от класса

Это имеет смысл, если все объекты имеют общий интерфейс и если вы можете сделать их производными от класса.

std::vector<std::unique_ptr<Animal>> vec; // good practice - automatically manage 
                                          // dynamically allocated elements with
                                          // std::unique_ptr

vec.push_back(std::make_unique<Dog>()); // or vec.emplace_back(new Dog());
vec.push_back(std::make_unique<Cat>()); // or vec.emplace_back(new Cat());

std::cout << *v[0];

Вариант 2: boost::any

Это имеет смысл, если типы не связаны. Например, вы храните int и объекты вашего класса. Очевидно, вы не можете сделать int производным от вашего класса. Таким образом, вы используете boost::any для сохранения, а затем возвращаете его к типу объекта. Исключение типа boost::bad_any_cast выдается, если вы приводите к несвязанному типу.

std::vector<boost::any> vec;
vec.push_back(Dog());
vec.push_back(25);

std::cout << boost::any_cast<int>(vec[1]);

А также указатели. Решение «Я хочу правильно управлять своей памятью»: «Не используйте new и delete». Вот инструменты, которые помогут вам в этом, в произвольном порядке:

• std::string вместо строк с завершающим нулем
• std::vector<T> вместо new T[]
• std::unique_ptr<T> вместо необработанных указателей на полиморфные объекты
• ...или std::shared_ptr<T>, если вы поделитесь ими

cout ‹‹ * ((Собака *)v[0]);

Я предполагаю, что ваш класс Dog является строковым, иначе вы получите ошибку другого типа, но ваша проблема преобразования типа должна быть решена путем приведения типа (Dog *).