Могу я это упростить?

Полагаю, вы могли бы перегрузить оператор сложения.

Можете ли вы объяснить, чего вы этим пытаетесь достичь?

Это похоже на довольно плохой дизайн, разве у вас не может быть абстрактный класс («интерфейс C++»), такой как «Computable», который имеет чистую виртуальную функцию1, подкласс Computable для каждой реализации, а затем MyFunctionSet поддерживает набор Computable?

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

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

Чтобы ответить на ваш актуальный вопрос - я бы сделал addFunction шаблоном:

void addFunctions() {
    addFunction(&MyFunctionSet::function1);
}

Измените addFunction в базовом классе на это:

template<typename Derived>
void addFunction(void(Derived::*f)()) {
    myFunctions.push_back(static_cast<Function>(f));
}

Лучше использовать static_cast, потому что он скажет вам, действительно ли Derived не является производным от FunctionSet.

Итак, я склонен в некоторой степени не согласиться с Ури.

Если вы реализуете паттерн Observer, вам нужно иметь возможность сказать:

«Когда объект X выполняет Y, я хочу выполнить код Z».

Использование подхода, основанного исключительно на абстрактном классе, - не лучший способ сделать это. Требовать отдельный класс (особенно в C++) для каждого обработчика событий - это излишне. Если вы пришли с Java, они все так и делают. Однако в Java есть 2 функции, которые делают это лишь слегка раздражающим: анонимный класс и классы-члены «экземпляра». Это позволяет вам определять несколько обработчиков для нескольких событий в одном классе. Вы должны добавить к методам префикс "class {", но вы можете это сделать.

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

.NET использует делегаты для обработки событий, которые в основном представляют собой указатели на функции с типобезопасностью. Они делают код для обработки событий очень простым. Однако, в отличие от указателей функций в C++, делегат объединяет указатели функций-членов и указатели статических функций. По сути, он может каррировать параметр «this» любой функции-члена, оставляя указатели на функции, которые выглядят так же, как указатель статической функции. Это означает, что тип объекта, обрабатывающего событие, не является частью «интерфейса» события. Это делает его очень гибким.

Вы не можете сделать это напрямую, используя указатели функций-членов C++, потому что тип «this» в конечном итоге становится частью типа указателя функции, тем самым ограничивая ваши обработчики только появлением в текущем классе.

Лучшее решение для C++ - это их гибрид. Вам нужен такой общий интерфейс:

class EventHandler
{
public:
    virtual void Handle() = 0;
};

А затем реализация для таких функций-членов

template <class T>
class MemberFuncEventHandler : public EventHandler
{
public:


    MemberFuncEventHandler(T * pThis, void (T::*pFunc)()) : m_pThis(pThis), m_pFunc(pFunc)
    {
    }

    void Handle()
    {
        (m_pThis->*m_pFunc)();
    } 
private:
    T* m_pThis;
    void (T::*m_pFunc)();
};

template <class T>
EventHandler * Handler(T * pThis, void (T::*pFunc)())
{
    return new MemberFuncEventHandler<T>(pThis, pFunc);
}

Вы также можете аналогичным образом определить класс обработчика для статических методов. Тогда вы можете делать что-то вроде этого:

Handlers += Handler(obj, &(c1::foo));
Handlers += Handler(obj, &(c2::bar));
Handlers += Handler(blaa); // for static methods...

Если вы пытаетесь создать систему обратного вызова или что-то еще, я бы порекомендовал библиотеку Boost.Signals. По сути, он объединяет функции и вызывает группу функций по команде (как и любая другая библиотека сигналов), но он также предназначен для работы с Boost.Bind и Boost.Function, которые великолепны.

Пример:

using boost::function
using boost::bind
using boost::signal

void some_other_func();    

Foo a;
Bar b;

signal<void()> sig;

sig.connect(bind(&Foo::foo,&a));
sig.connect(bind(&Bar::bar,&b));
sig.connect(some_other_func);

sig(); // calls -> a.foo(), b.bar(), some_other_func()

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