Цепочка методов метод производного класса после вызова метода базового класса

Question

С классом и производной, как показано ниже, есть ли способ для методов базовых классов возвращать ссылку на объект производного типа вместо его собственного типа, так что синтаксически я могу связать методы вместе?

Предположим, что объект A имеет методы a1,a2 и производная AD добавляет метод ad1 как можно сделать правильную цепочку методов AD_instance.a1().a2().ad1();?

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

class AsyncWorker() {
pthread_t worker;
public:
  AsyncWorker();
  void *worker_run();
  AsyncWorker& Detach() { /*code*/ return *this;  }
  AsyncWorker& Start()  {
     pthread_create(&worker, NULL, &AsyncWorker::worker_helper, this);
     return *this;
  }
  static void *worker_helper(void *context) {
    return ((AsyncWorker *)context)->worker_run();
  }

};

class workerA : public AsyncWorker {
public: 
  int a;
  workerA(int i) { a = i; }
  void* worker_run() { ++a; sleep(1); }
  workerA& other_method_i_want_to_chain() { return *this };
};

Прикован как то так.

workerA A(0);
A.Start().Detach().other_method_i_want_to_chain();

Answer 1

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

class workerA {
    // ...
    workerA& Start() {
        this->AsyncWorker::Start();
        return *this;
    }
    workerA& Detach() {
        this->AsyncWorker::Detach();
        return *this;
    }
    // ...
 };

Answer 2

Надеюсь, что это делает проблему немного яснее для вас.

#include <iostream>

struct Base
{
   virtual Base& foo() = 0;
};

struct Derived : Base
{
   virtual Derived& foo()
   {
      std::cout << "Came to Derived::foo()\n";
      return *this;
   }

   void bar()
   {
      std::cout << "Came to Derived::bar()\n";
   }

};

int main()
{
   Derived derived;
   derived.foo().bar(); // OK. From the interface of Derived, foo()
                        // returns a Derived&.
   Base& base = derived;
   base.foo().bar();    // Not OK. From the interface of Base, foo()
                        // returns a Base&.

   return 0;
}