DevBoy: делаем генератор сигналов

А как вы возьмёте указатель на не статическую функцию? В C++ вы не можете этого сделать.

А что бы работать с остальными им нужна ссылка или указатель на объект (а вот о такой возможности не говорят, да и в книжках прямого указания на это я не встречал).

С помощью std::bind. 2018 год на дворе, как никак.

Если реализуется взаимодействие между С и C++, то такие callbacks с void* opaque pointer являются наистандартнейшим решением.

в общем случае с++ должен сам убедиться, что в указателе именно экземпляр нужного класса. dynamic_cast для этого годится плохо, т.к. dynamic_cast лишь предоставляет «навигацию» по дереву наследования полиморфных классов, а тут на входе вовсе не класс, а указатель на нечто (void*) с которым dynamic_cast работать не должен (допускаю, что возможно какой-то компилятор по ошибке позволяет, но стандарт чётко это запрещает).

1) А как передать указатели на разные объекты в UiButton для последующей передачи в callback функцию? Я знаю только один такой способ — привести к единому типу.

class ICallback {
public:
// Можно использовать NVI при желании/по необходимости.
    void operator()(// Параметры функции) = 0;
};


class ApplicationCallbackWrapper : public ICallbackWrapper {
public:
    ApplicationCallbackWrapper (Application* i_application)
    : application_ {i_application} {
        /* 
            При необходимости - проверка указателя на nullptr. Если считается,
            что вызов может быть NOOP, то можно разрешить использование нулевого
            указателя.
        */
    }

    void operator()(// Параметры функции) override {
        if (!application_) {
            /*
                Можно добавить обработку по умолчанию. Например, вывод 
                предупреждения в режиме отладки.
            */

            return;
        }

        // Необходимая обработка аргументов функции.

        /*
            Будем считать, что существует одна нестатическая функция-член, 
            которую необходимо вызывать в функции обратного вызова. В случае, 
            если требуется вызывать различные функции, можно написать несколько
            подобных классов-обёрток - по одному на каждую функцию. Если выбор
            функции должен осуществляться на основе аргументов функции - 
            необходимо добавить соответствующую обработку и
        */
        application_->Callback(// Аргументы для вызова основной функции);
    }


private:
    /*
        Можно использовать std::weak_ptr, что позволит узнавать об удалении
        объекта. Использование данного подхода требует, чтобы время жизни
        объекта (*application_) контроллировалось std::shared_ptr, что 
        ограничивает возможность создания объектов ApplicationCallbackWrapper
        из функций-членов класса Application. Данное ограничение можно обойти 
        через использование интрузивного подсчёта ссылок.
    */
    Application* application_;
};


/*
    При желании можно использовать владеющий (std::unique_ptr, 
    std::shared_ptr если требуется использовать один объект обратного вызова 
    из нескольких объектов) либо не владеющий (std::weak_ptr) указатель.
    В примене простой указатель для описания общей идеи. Если объект UiButton 
    владеет функтором обратного вызова, и используется обычный указатель, то 
    следует удалить объект при задании нового функтора обратного вызова и в 
    деструкторе.
*/
UiButton::SetCallback (ICallback* i_callback) {
    if (!i_callback) {
        // Необходимая обработка.
    }

    // callback_ - переменая-член класса UiButton для хранения функтора обратного вызова
    callback_ = i_callback;
}


UiButton::SomeFunction (...) {
    // ...

    if (callback_) {
        (*callback_)(// Аргументы);
    }

    // ...
}


int main (...) {
    // Используются простый указатели для краткости
    Application* application = new Application{};

    UiButton* button = new UiButton{};

    button->SetCallback (new ApplicationCallbackWrapper{application});
}

class ApplicationCallbackWrapper {
    /*
        Такой же класс, как выше, но без наследования.
    */
};


class UiButton {
    using Callback = std::function <void()>;
    // ...
}


UiButton::SetCallback (UiButton::Callback i_callback) {
    if (!i_callback) {
        // Необходимая обработка.
    }

    // callback_ - переменая-член класса UiButton для хранения функтора обратного вызова
    callback_ = i_callback;
}


UiButton::SomeFunction (...) {
    // ...

    if (callback_) {
        callback (// Аргументы);
    }

    // ...
}


int main (...) {
    // Используются простый указатели для краткости
    Application* application = new Application{};

    UiButton* button = new UiButton{};

    button->SetCallback (ApplicationCallbackWrapper{application});

    /*
        Если можжно гарантировать, что время жизни application больше времени 
        жизни button, то можно использовать лямбда-функцию.
    */
    button->SetCallback ([application](// Параметры функции){
        // Использование application.
    });


    // Так тоже можно
    button->SetCallback (SomeFreeFunction);
}

Выше был пример, когда делали интерфейс нужного коллбека, передавали и вызывали. Как зачем? Это, собственно, та функция-член другого класса, которую мы хотим вызвать. Внутри метода func мы можем даже не знать, что это за метод. Мы можем вместо BaseFoo* использовать шаблон и даже не знать, что за класс. Такой подход применяется, к примеру, в std::thread. Я не стал писать пример с шаблоном, чтобы показать, что с полиморфизмом тоже работает.

#include <iostream>
using namespace std;

class Foo
{
public:
    void bar()
    {
        cout << "Foo::bar()\n";
    }
};

template<class T>
void func(T* ptr, void (T::*func)())
{
    (ptr->*func)();
}

int main()
{
    Foo foo;
    func(&foo, &Foo::bar);
    return 0;
}

Помимо уже заданных вопросов у меня есть ещё один: при чём тут Java?

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

Для чего Вы предлагаете использовать шаблоны?

Чтобы можно было передать указатель на функцию-член произвольного класса. Например, так реализовано в std::thread: https://stackoverflow.com/a/10673671