самое близкое, что вы можете сделать, это сначала полностью построить свой объект, а затем вызвать метод после:

template <typename T>
T construct_and_print()
{
  T obj;
  obj.PrintStartMessage();

  return obj;
}

int main()
{
    Derived derived = construct_and_print<Derived>();
}

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

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

вызов PrintStartMessage после построения MyBase

давайте предположим, что вы хотите сделать что-то вроде этого:

class MyBase {
public:
    virtual void PrintStartMessage() = 0;
    MyBase() {
        printf("Doing MyBase initialization...\n");
        PrintStartMessage(); // ⚠ UB: pure virtual function call ⚠
    }
};

class Derived : public MyBase {
public:
    virtual void PrintStartMessage() { printf("Starting Derived!!!\n"); }
};

желаемая трассировка выполнения будет:

Doing MyBase initialization...
Starting Derived!!!

но для этого и существуют конструкторы! Просто отбросьте виртуальную функцию и сделайте конструктор производного, чтобы выполнить эту работу!

class MyBase {
public:
    MyBase() { printf("Doing MyBase initialization...\n"); }
};

class Derived : public MyBase {
public:
    Derived() { printf("Starting Derived!!!\n"); }
};

выход, хорошо, чего мы ожидали бы:

Doing MyBase initialization...
Starting Derived!!!

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

вызов PrintStartMessage перед MyBase строительство

как сказано выше, если вы не называть PrintStartMessage до Derived был конструктор, вы не можете этого сделать, потому что еще нет

вы не должны называть virtual функция в конструкторе. период. Вам придется найти обходной путь, например, сделать PrintStartMessage неvirtual и явно помещая вызов в каждый конструктор.

Если PrintStartMessage() не является чистой виртуальной функцией, а обычной виртуальной функцией, компилятор не будет жаловаться на это. Однако вам все равно придется выяснить, почему производная версия PrintStartMessage() не вызывается.

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

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

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

#include <iostream>

class MyBase
{
public:
    virtual void UniqueCode() = 0;
    MyBase() {};
    void init(MyBase & other)
    {
      std::cout << "Shared Code before the unique code" << std::endl;
      other.UniqueCode();
      std::cout << "Shared Code after the unique code" << std::endl << std::endl;
    }
};

class FirstDerived : public MyBase
{
public:
    FirstDerived() : MyBase() { init(*this); };
    void  UniqueCode()
    {
      std::cout << "Code Unique to First Derived Class" << std::endl;
    }
private:
    using MyBase::init;
};

class SecondDerived : public MyBase
{
public:
    SecondDerived() : MyBase() { init(*this); };
    void  UniqueCode()
    {
      std::cout << "Code Unique to Second Derived Class" << std::endl;
    }
private:
    using MyBase::init;
};

int main()
{
    FirstDerived first;
    SecondDerived second;
}

выход:

 Shared Code before the unique code
 Code Unique to First Derived Class
 Shared Code after the unique code

 Shared Code before the unique code
 Code Unique to Second Derived Class
 Shared Code after the unique code