C++, Вызов виртуального метода после завершения конструктора суперкласса

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

class IObject{
public:
    virtual void doWork() = 0;
    virtual void serialize() const = 0;
    virtual void deserialize()  = 0;
    virtual ~IObject(){}
};

Теперь сделаем шаблонного строителя:

class IObjectBuilder{
public:
    virtual IObject* build() const = 0;
    virtual ~IObjectBuilder(){}
};
template<class Object>
class ObjectBuilder : public IObjectBuilder{
public:
    Object* build() const{
        return new Object();
    }
};

Далее реализуем фабрику-синглтон, которая будет создавать объекты в зависимости от некого идентификатора:

class ObjectFactory{
    typedef std::unique_ptr<IObjectBuilder> BuilderPointer;
    typedef std::map<int, BuilderPointer> BilderMap;
    BilderMap _builders;
    ObjectFactory(){}
public:
    //Синглтон
    static ObjectFactory& instance(){
        static ObjectFactory instance;
        return instance;
    }
    //Регистрация типа в фабрике. 
    //Для успешной регистрации нужно:
    // 1) чтобы Object наследовал IObject
    // 2) У Object был енум или интовая константа с именем Rtti
    template<class Object>
    int reg(){
        int type = Object::Rtti;
        _builders[type].reset(new ObjectBuilder<Object>());
        return type;
    }
    //Создание объекта по типу
    IObject* build(int id) const{
        IObjectBuilder *builder = _findBuilder(id);
        if(!builder){
            return 0;
        }
        return builder->build();
    };
private:
    IObjectBuilder* _findBuilder(int id) const{
        BilderMap::const_iterator builder = _builders.find(id);
        if(builder == _builders.end()){
            return 0;
        }
        return builder->second.get();
    }
};

Вообщем-то на этом можно было бы остановиться. Просто регистрируем новые типы в фабрике, по мере того как они создаются, и горя не знаем. Но вы хотите чтобы все происходило автоматически. Для этого я бы использовал CRTP

Создаем абстрактный класс, который при создании первого объекта будет регистрировать тип наследника в фабрике:

template<class Derived>
class AbstractObject : public IObject{
public:
    AbstractObject(){
        static const int type = ObjectFactory::instance().reg<Derived>();
    }
};

Ну а теперь пример, как пользоваться всем этим зоопарком. Создаем пару наследников:

class ObjectA : public AbstractObject<ObjectA>{
public:
    enum{
        Rtti = 1
    };
    void doWork(){
        std::cout << "ObjectA::doWork\n";
    }
    void serialize() const{
        std::cout << "ObjectA::serialize\n";
    }
    void deserialize(){
        std::cout << "ObjectA::deserialize\n";
    }
};
class ObjectB : public AbstractObject<ObjectB>{
public:
    enum{
        Rtti = 2 
    };
    void doWork(){
        std::cout << "ObjectB::doWork\n";
    }
    void serialize() const{
        std::cout << "ObjectB::serialize\n";
    }
    void deserialize(){
        std::cout << "ObjectB::deserialize\n";
    }
};

И используем:

int main(){
    ObjectA a; //Важно. Тип автоматически регистриуется в фабрике при создании первого экземпляра
    ObjectB b;
    std::unique_ptr<IObject> object;
    object.reset(ObjectFactory::instance().build(ObjectA::Rtti));
    object->serialize();
    object->deserialize();
    object->doWork();
    object.reset(ObjectFactory::instance().build(ObjectB::Rtti));
    object->serialize();
    object->deserialize();
    object->doWork();
}

Полный пример

Можно сделать так: потребовать от потомков передачи в конструктор базового класса информации о своем типе и зарегистрировать этот тип в RequestBuilder:

#include <string>
#include <functional>
#include <memory>
using namespace std;
class RequestBase
{
public:
    virtual ~RequestBase() = 0;
    virtual void Serialize(class QDataStream &) = 0;
};
typedef unique_ptr<RequestBase> DeserializeRequest (QDataStream &);
struct RequestBuilder
{
    static void registerHandler(const string & name, DeserializeRequest deserialize)
    {
    }
};
template<class T>
class Request : public RequestBase
{
protected:
    Request()
    {
        RequestBuilder::registerHandler(typeid(T).name(), T::Deserialize);
    }
};
class Request1 : public Request<Request1>
{
public:
    void Serialize(class QDataStream &) override
    {
    }
    static unique_ptr<RequestBase> Deserialize(QDataStream &)
    {
        return make_unique<Request1>();
    }
};

Теперь каждый потомок обязан иметь Serialize и Deserialize.