Каково практическое использование указателей на функции-члены?

Есть много практических применений. Мне на ум приходит следующее:

Предположим, что основная функция, такая как ниже (соответственно определенные myfoo и MFN)

void dosomething(myfoo &m, MFN f){   // m could also be passed by reference to 
                                     // const
   m.*f();
}

Такая функция при наличии указателя на функции-члены становится открытой для расширения и закрытой для модификации (OCP < / а>)

Также обратитесь к идиоме Safe bool, которая разумно использует указатель на элементы.

По той же причине, по которой вы используете любой указатель на функцию: вы можете использовать произвольную программную логику для установки переменной указателя на функцию перед ее вызовом. Вы можете использовать переключатель, if / else, передать его в функцию, что угодно.

РЕДАКТИРОВАТЬ:

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

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

#include <iostream>

class MemberDemo;
typedef void (MemberDemo::*MemberDemoPtr)();

class MemberDemo
{
    public:
    void test1();
    void test2();

    private:
    void test1_internal();
    void test2_internal();
    void do_with_setup_teardown(MemberDemoPtr p);
};

void MemberDemo::test1()
{
    do_with_setup_teardown(&MemberDemo::test1_internal);
}

void MemberDemo::test2()
{
    do_with_setup_teardown(&MemberDemo::test2_internal);
}

void MemberDemo::test1_internal()
{
    std::cout << "Test1" << std::endl;
}

void MemberDemo::test2_internal()
{
    std::cout << "Test2" << std::endl;
}

void MemberDemo::do_with_setup_teardown(MemberDemoPtr mem_ptr)
{
    std::cout << "Setup" << std::endl;
    (this->*mem_ptr)();
    std::cout << "Teardown" << std::endl;
}

int main()
{
    MemberDemo m;
    m.test1();
    m.test2();
}

Мой вопрос основан на следующем: если у вас есть экземпляр, почему бы не вызвать функцию-член напрямую [?]

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

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

Я считаю, что настоящая полезность указателей на функции-члены проявляется, когда вы смотрите на конструкцию более высокого уровня, такую ​​как boost::bind(). Это позволит вам обернуть вызов функции как объект, который позже может быть привязан к конкретному экземпляру объекта, а затем передан как копируемый объект. Это действительно мощная идиома, позволяющая использовать отложенные обратные вызовы, делегаты и сложные операции с предикатами. См. Несколько примеров в моем предыдущем посте:

https://stackoverflow.com/questions/1596139/hidden-features-and-dark-corners-of-stl/1596626#1596626

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

Одно из распространенных применений - алгоритмы. В std :: for_each мы можем захотеть вызвать функцию-член класса каждого члена нашей коллекции. Мы также можем захотеть вызвать функцию-член нашего собственного класса для каждого члена коллекции - для последнего требуется boost :: bind, первое может быть выполнено с помощью семейства классов STL mem_fun (если у нас нет коллекция shared_ptr, и в этом случае нам также нужно усилить :: bind). Мы также могли бы использовать функцию-член в качестве предиката в определенных алгоритмах поиска или сортировки. (Это избавляет нас от необходимости писать собственный класс, который перегружает operator () для вызова члена нашего класса, мы просто передаем его напрямую в boost :: bind).

Другое использование, как я уже упоминал, - это обратные вызовы, часто в коде, управляемом событиями. Когда операция завершена, нам нужен метод нашего класса, вызываемый для обработки завершения. Часто это можно обернуть в функтор boost :: bind. В этом случае мы должны быть очень осторожны, чтобы правильно управлять временем жизни этих объектов и их поточной безопасностью (тем более, что отладка может быть очень сложной, если что-то пойдет не так). Тем не менее, это еще раз может избавить нас от написания большого количества кода-оболочки.

Лучшее использование указателей на функции-члены - разорвать зависимости.

Хорошим примером, когда требуется указатель на функцию-член, является шаблон подписчика / издателя:

http://en.wikipedia.org/wiki/Publish/subscribe

На мой взгляд, указатели на функции-члены не очень полезны для среднего программиста в их необработанном виде. OTOH, конструкции типа ::std::tr1::function, которые объединяют указатели функций-членов вместе с указателем на объект, над которым они должны работать, чрезвычайно полезны.

Конечно ::std::tr1::function очень сложно. Итак, я приведу вам простой пример, который вы бы фактически не использовали на практике, если бы у вас было ::std::tr1::function в наличии:

// Button.hpp
#include <memory>

class Button {
 public:
   Button(/* stuff */) : hdlr_(0), myhandler_(false) { }
   ~Button() {
      // stuff
      if (myhandler_) {
         delete hdlr_;
      }
   }
   class PressedHandler {
    public:
      virtual ~PressedHandler() = 0;

      virtual void buttonPushed(Button *button) = 0;
   };

   // ... lots of stuff

   // This stores a pointer to the handler, but will not manage the
   // storage.  You are responsible for making sure the handler stays
   // around as long as the Button object.
   void setHandler(const PressedHandler &hdlr) {
      hdlr_ = &hdlr;
      myhandler_ = false;
   }

   // This stores a pointer to an object that Button does not manage.  You
   // are responsible for making sure this object stays around until Button
   // goes away.
   template <class T>
   inline void setHandlerFunc(T &dest, void (T::*pushed)(Button *));

 private:
   const PressedHandler *hdlr_;
   bool myhandler_;

   template <class T>
   class PressedHandlerT : public Button::PressedHandler {
    public:
      typedef void (T::*hdlrfuncptr_t)(Button *);

      PressedHandlerT(T *ob, hdlrfuncptr_t hdlr) : ob_(ob), func_(hdlr) { }
      virtual ~PressedHandlerT() {}

      virtual void buttonPushed(Button *button) { (ob_->*func_)(button); }

    private:
      T * const ob_;
      const hdlrfuncptr_t func_;
   };
};

template <class T>
inline void Button::setHandlerFunc(T &dest, void (T::*pushed)(Button *))
{
   PressedHandler *newhandler = new PressedHandlerT<T>(&dest, pushed);
   if (myhandler_) {
      delete hdlr_;
   }
   hdlr_ = newhandler;
   myhandler_ = true;
}

// UseButton.cpp
#include "Button.hpp"
#include <memory>

class NoiseMaker {
 public:
   NoiseMaker();
   void squee(Button *b);
   void hiss(Button *b);
   void boo(Button *b);

 private:
   typedef ::std::auto_ptr<Button> buttonptr_t;
   const buttonptr_t squeebutton_, hissbutton_, boobutton_;
};


NoiseMaker::NoiseMaker()
     : squeebutton_(new Button), hissbutton_(new Button), boobutton_(new Button)
{
   squeebutton_->setHandlerFunc(*this, &NoiseMaker::squee);
   hissbutton_->setHandlerFunc(*this, &NoiseMaker::hiss);
   boobutton_->setHandlerFunc(*this, &NoiseMaker::boo);
}

Предполагая, что Button находится в библиотеке и не может быть изменен вами, мне было бы приятно увидеть, как вы реализуете это чисто с использованием виртуального базового класса, не прибегая к каким-либо конструкциям switch или if else if.

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

object.method();
pointer->method();

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

Чтобы лучше проиллюстрировать это, позвольте мне провести следующую простую аналогию. Допустим, у вас есть массив

int a[100];

Вы можете получить доступ к его элементам с фиксированным индексом времени компиляции

a[5]; a[8]; a[23];

В этом случае конкретные индексы жестко запрограммированы в вашу программу. Но вы также можете получить доступ к элементам массива с помощью индекса времени выполнения - целочисленной переменной i

a[i];

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

Вопрос, который вы задаете («поскольку у вас есть экземпляр, почему бы не вызвать функцию-член напрямую»), можно перевести в контекст этого массива. Вы в основном спрашиваете: «Зачем нам нужен доступ к переменному индексу a[i], когда у нас есть прямой доступ к константе времени компиляции, такой как a[1] и a[3]?» Надеюсь, вы знаете ответ на этот вопрос и понимаете ценность выбора конкретного элемента массива во время выполнения.

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

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

Не то, чем вы пользуетесь каждый день ...

Представьте на секунду, что у вас есть функция, которая может вызывать одну из нескольких различных функций в зависимости от переданных параметров.

Вы можете использовать гигантский оператор if / else if
Вы можете использовать оператор switch
Или вы можете использовать таблицу указателей функций (таблица переходов)

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

Однако все зависит от личных предпочтений. Оператор переключения и таблица переходов в любом случае соответствуют более или менее одному и тому же скомпилированному коду :)

Указатели участников + шаблоны = чистая победа.

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

or

template<typename TContainer,
         typename TProperty,
         typename TElement = decltype(*Container().begin())>
TProperty grand_total(TContainer& items, TProperty (TElement::*property)() const)
{
   TProperty accum = 0;
   for( auto it = items.begin(), end = items.end(); it != end; ++it) {
       accum += (it->*property)();
   }
   return accum;
}

auto ship_count = grand_total(invoice->lineItems, &LineItem::get_quantity);
auto sub_total = grand_total(invoice->lineItems, &LineItem::get_extended_total);
auto sales_tax = grand_total(invoice->lineItems, &LineItem::calculate_tax);

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

Это полностью упускает из виду суть. Здесь есть две независимые проблемы:

• какое действие предпринять позже
• на каком объекте выполнить это действие

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

ПРИМЕР

Допустим, у вас есть обезьяна, которая может целовать или щекотать людей. В 18:00 ваша программа должна освободить обезьяну и знать, кого обезьяна должна посетить, но около 15:00 ваш пользователь напечатает, какое действие следует предпринять.

Подход новичка

Итак, в 15:00 вы можете установить переменную "enum Action {Kiss, Tickle} action;", затем в 18:00 вы можете сделать что-то вроде "if (action == Kiss) monkey-> kiss (person); else monkey-> tickle (человек)".

Проблемы

Но это вводит дополнительный уровень кодирования (для поддержки этого введен тип Action - встроенные типы могут использоваться, но будут более подвержены ошибкам и менее значимы по своей сути). Затем - после определения того, какое действие следует предпринять в 15:00, в 18:00 вы должны повторно проконсультироваться с этим закодированным значением, чтобы решить, какое действие предпринять, для чего потребуется другое if / else или переключиться на закодированное значение. Все это неуклюже, многословно, медленно и подвержено ошибкам.

Указатели на функции-члены

Лучше использовать более специализированный варибал - указатель на функцию-член, который напрямую записывает, какое действие нужно выполнить в 18:00. Вот что такое указатель на функцию-член. Это установленный ранее селектор поцелуев или щекоток, создающий «состояние» для обезьяны - щекотка это или поцелуй, - которое можно использовать позже. Более поздний код просто вызывает любую заданную функцию, не задумываясь о ее возможностях и не имея каких-либо операторов if / else-if или switch.

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

Вернемся к этому. Итак, это хорошо, если вы примете решение о том, какое действие предпринять во время компиляции (то есть точка X в вашей программе, это определенно будет щекоткой). Указатели на функции предназначены для случаев, когда вы не уверены и хотите отделить настройку действий от их вызова.