Возможно ли переопределение методов объекта? С++

Как упомянул @Jarod42 в комментариях, я бы добавил участника std::function или другого вызываемого участника. Как пример (Годболт)

#include <functional>
#include <iostream>
#include <utility>

class Object {
public:
   Object(std::function<int(int)> do_work) : do_work_(std::move(do_work)) {}

   int DoWork(int i) { return do_work_(i); }

private:
   std::function<int(int)> do_work_;
};

int main() {
  Object obj1{[](int i){ return i + 1;}};
  std::cout << obj1.DoWork(1) << '\n';

  Object obj2{[](int i){ return i - 1;}};
  std::cout << obj2.DoWork(1) << '\n';
}

Вы можете видеть, что DoWork вызывает вызываемый объект, и каждый экземпляр класса Object может свободно определять, что это за работа.

Нет, члены функции не являются данными в C++, поэтому их нельзя изменять отдельно для каждого объекта. Нет obj->Foo(); есть только Object::Foo(), который получает скрытый параметр this, указывающий на *obj.

Если вам нужно разрешить пользователю вашего класса настраивать поведение класса, у вас есть два основных варианта:

1. Используйте в классе функцию-член (возможно, чистую) virtual и позвольте пользователям создавать новый дочерний класс из вашего класса:

class Object {
public:
    virtual void Foo() {
        // do something
    }
};

class DerivedObject {
public:
    void Foo() override {
        // Do something else
    }
};

int main() {
    Object* obj = new DerivedObject();
    obj->Foo(); // will call DerivedObject::Foo()
}

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

2. Используйте член функционального объекта:

class Object {
public:
    Object(std::function<void(Object*)> foo)
        : foo_{std::move(foo)}
    {}

    Object()
        : foo_{[](Object* self) { /* do something */ }}
    {}

    void Foo() {
        foo_(this);
    }

private:
    std::function<void(Object*)> foo_;
};

int main() {
    Object o{[](Object* self) {
        // do something else
    }};
    o.Foo();
}

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