Вызвать конструктор базового класса позже (не в списке инициализаторов) в C++

Есть ли способ, которым я могу просто вызвать его позже, вместо того, чтобы вызывать его в списке инициализаторов?

Нет, ты не можешь. Конструктор базового класса должен быть вызван в списке инициализаторов, и он должен быть вызван первым.

На самом деле, если вы его здесь не укажете, компилятор просто неявно добавит вызов.

Я считаю, что это можно сделать на Java и C#, но я не уверен в C++.

Ни C#, ни Java этого не допускают.

Однако вы можете вызвать метод в качестве аргумента вызова конструктора базового класса. Затем это обрабатывается перед конструктором:

class Derived {
public:
    Derived() : Base(some_function()) { }

private:
    static int some_function() { return 42; }
};

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

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

class my_dirty_little_secret {
  // friend class the_class;
public: 
  my_dirty_little_secret(const std::string& str)
  {
    // however that calculates x, y, and z from str I wouldn't know
  }
  int x;
  std::string y;
  float z;
};

class the_class : private my_dirty_little_secret // must be first, see ctor
                , public the_other_base_class {
  public:
    the_class(const std::string str)
      : my_dirty_little_secret(str)
      , the_other_base_class(x, y, z)
    {
    }
  // ...
};

Класс my_dirty_little_secret является частной базой, поэтому пользователи the_class не могут его использовать, все его материалы также являются частными, с явной дружбой, предоставляющей доступ к нему только the_class. Однако, поскольку он указан первым в списке базовых классов, он будет надежно сконструирован до the_other_base_class, поэтому все, что он вычислит, может быть использовано для его инициализации.
Хороший комментарий в списке базовых классов, надеюсь, не даст другим нарушить работу путем рефакторинга. .

ИМХО, я не думаю, что можно отложить вызов конструктора базового класса так, как вы упомянули.

Вау, мы все когда-то были молодыми. Этот ответ не сработает, поэтому не используйте его. Контент оставлен для исторических целей.

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

class Base
{
public:
    Base()
    {
        Initialize();
    }
protected:
    virtual void Initialize()
    {
        //do initialization;
    }
};

class Derived : Base
{
public:

    Derived() : Base()
    {
    }
protected:
    virtual void Initialize()
    {
        //Do my initialization
        //call base
        Base::Initialize();
    }
};

Другой вариант, основанный на предложении @Konrad, состоит в том, чтобы иметь статический метод для создания объекта, например:

class Derived {
public:
    Derived(int p1, int p2, int p3) : Base(p1, p2) { }

    static Derived* CreateDerived(int p3) { return new Derived(42, 314, p3); }
};

Я нашел это полезным при расширении класса из библиотеки и наличии нескольких параметров для переопределения. Вы даже можете сделать конструктор приватным.

struct base{
   base(int x){}
};

struct derived : base{
   derived(int x) : base(x){}
};

Именно так конструкторы базового класса вызываются в C++ из списка инициализации производного класса.