Как мне вызвать метод базового класса с помощью указателя на функцию-член?

Question

Это связано с моей нитью Member Указатели функций и наследование на allegro.cchere.

См. Тему на allegro.cc для примеров кода.

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

Итак, мой вопрос в том, какие альтернативы существуют? Lambdas были предложены, но я не уверен, как это реализовать, поскольку у меня мало опыта работы с C++ 11 или C++ 14. Идеи приветствуются.

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

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

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

В общем, что я хочу в псевдо C++ код следующим образом:

void TextDecorator::SetFlagState(bool state , void (WidgetBase::*StateSetter)(bool)) { 
    if (basic_text_widget) { 
     (basic_text_widget->WidgetBase::*StateSetter)(state); 
    } 
    (text_widget_layout->WidgetBase::->*StateSetter)(state); 
    (this->WidgetDecoratorBase::->*StateSetter)(state); 
} 

Что бы тогда позвольте мне сделать настройки мое состояние вызовов в TextDecorator ясной и краткой, который будет называться так:

void TextDecorator::SetEnabledState(bool state) { 
    SetFlagState(state , SetEnabledState); 
} 

, где SetEnabledState является одной из функций виртуального состояния в моем классе WidgetBase.

Пожалуйста, оставляйте предложения только для возможных путей его реализации. Должен быть чистый лаконичный способ сделать это на C++.

Answer 1

Простейшим решением является небольшой рефакторинг вашего базового класса. Вместо того, чтобы:

class Base { 

public: 

    virtual void foo() 
    { 
      // The base implementation of foo(). 
    } 
}; 

Замените его:

class Base { 

public: 

    virtual void foo() 
    { 
      foo_base(); 
    } 

    void foo_base() 
    { 
      // base class implementation of foo. 
    } 
}; 

код замены 100% логически эквивалентны. Но теперь вы можете получить указатель на метод foo_base() и вызвать его непосредственно без особых трудностей.

Answer 2

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

Насколько я знаю, вы не можете этого сделать.
Указатель не несет с собой достаточной информации.
Вызов функции-члена с помощью указателя на функцию-члена - это как прямой вызов.
Я подозреваю, что не существует сопоставления с такими вещами, как this->B::f() (обратите внимание, что (this->B::*ptr)() не является допустимым синтаксисом).

Итак, мой вопрос в том, какие альтернативы существуют? Lambdas были предложены, но я не знаю, как это реализовать.

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

#include<iostream> 
#include<utility> 

struct B { 
    virtual void f() { std::cout << "B" << std::endl; } 
}; 

struct D: B { 
    void f() override { std::cout << "D" << std::endl; } 

    template<typename F> 
    void g(F &&f) { std::forward<F>(f)(*this); } 
}; 

int main() { 
    D d; 
    d.g([](auto &i){ i.B::f(); }); 
} 

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

---

В соответствии с комментариями, я добавляю более подробную информацию.

Давайте посмотрим над этим:

template<typename F> 
void g(F &&f) { std::forward<F>(f)(*this); } 

В этом случае g шаблон функции, которая принимает вызываемый объект. && рядом с f есть потому, что f является ссылкой для пересылки и может использоваться для привязки либо к ссылке lvalue, либо к ссылке rvalue.
Я предлагаю прочитать статью Мейерса this, когда он также предложил условия универсальные ссылки для того же.
std::forward служит для пересылки переменной, сохраняя точно ее тип. Обратите внимание, что переменная с типом rvalue ссылкой на будет ссылкой на lvalue в контексте g в противном случае.
В приведенной выше статье объясняется более подробно.

Теперь рассмотрим следующую строку кода:

d.g([](auto &i){ i.B::f(); }); 

Мы вызывающую g с использованием универсального лямбда в качестве аргумента.
Это не строго необходимо, мы могли бы использовать вместо этого:

d.g([](D &i){ i.B::f(); }); 

Помимо того факта, что тип выводится, идея заключается в том, что мы получаем экземпляр класса, который является производным от B и мы называем реализация f от B на этом экземпляре.
Кому нужна такая ссылка?
Назад к предыдущему сниппето:

template<typename F> 
void g(F &&f) { std::forward<F>(f)(*this); } 

Nite что здесь призывает f (то есть наша лямбда) с использованием *this в качестве аргумента (он формирует ссылку на объект типа D).

Это все.