Callback. Так ли используется на практике?

#include <iostream>
 
using namespace std;
 
// Тип-Указатель на некую функцию
typedef void(*ClbFunc)(int, int);
 
// Некая функция, которая дожна быть вызвана
void TestFunc(int a, int b)
{
    cout << "Func is called!" << endl; 
    cout << a  << " + " << b << " = " << a + b << endl << endl;
}
 
// Некий класс, который будет генерировать "событие", 
// чтобы вызвать некую функцию извне
class TestCallback
{
public:
    TestCallback();
    void CallTheFunc(int a, int b);
    void SetCallBack(ClbFunc a);
private:
    // указатель на функцуию, которым будем оперировать внутри класса
    ClbFunc func;
};
 
TestCallback::TestCallback()
{
    func = NULL;
}
 
void TestCallback::SetCallBack(ClbFunc a)
{
    func = a;
}
 
void TestCallback::CallTheFunc(int a, int b)
{
    if (func != NULL && a == b)
        func(a, b); 
}
 
int main()
{
    TestCallback *t = new TestCallback;
 
    t->SetCallBack(TestFunc);
 
    t->CallTheFunc(10, 12);
    t->CallTheFunc(20, 20);
    t->CallTheFunc(50, 43);
    t->CallTheFunc(7, 7);
    t->CallTheFunc(12, 2485);
 
    system("pause");
    return 0;
}

t->CallTheFunc(10, 12);
t->CallTheFunc(20, 20);
t->CallTheFunc(50, 43);
t->CallTheFunc(7, 7);
t->CallTheFunc(12, 2485);

#include <iostream>
#include <vector>
#include <string>
#include <map>
#include <algorithm>
 
class EventSystem
{
public:
    typedef void(*fun)();    
    
    inline void subscribeEvent( const std :: string eventName, fun f )
    {
        auto event = _events.find( eventName );
        if( event != _events.end() )
            event -> second.push_back( f );
        else
        {
            std :: vector<fun> v;
            v.push_back( f );
            _events.insert( std :: pair<std :: string, std :: vector<fun>>( eventName, v ) );
        }
    }
    
    inline void unsubscribeEvent( const std :: string eventName, fun f )
    {
        auto event = _events.find( eventName );
        if( event != _events.end() )
        {
            auto handler = std :: find( event -> second.begin(), event -> second.end(), f );
            event -> second.erase( handler );
        }
    }
    
    inline void invokeEvent( const std :: string eventName )
    {
        auto event = _events.find( eventName );
        if( event != _events.end() )  
        {
            for( const auto& f : event -> second )
                f();
        }
    }
    
private:
    std :: map<std :: string, std :: vector<fun>> _events;
};
 
 
void fun1()
{
    std :: cout << "Invoked fun1" << std :: endl;
}
void fun2()
{
    std :: cout << "Invoked fun2" << std :: endl;
}
void fun3()
{
    std :: cout << "Invoked fun3" << std :: endl;
}
void fun4()
{
    std :: cout << "Invoked fun4" << std :: endl;
}
void fun5()
{
    std :: cout << "Invoked fun5" << std :: endl;
}
void fun6()
{
    std :: cout << "Invoked fun6" << std :: endl;
}
 
int main()
{
    EventSystem eventSystem;
    
    // Подписываем два хендлера на событие Event1
    eventSystem.subscribeEvent( "Event1", fun1 );
    eventSystem.subscribeEvent( "Event1", fun2 );
    
    // Подписываем два хендлера на событие Event2
    eventSystem.subscribeEvent( "Event2", fun3 );
    eventSystem.subscribeEvent( "Event2", fun4 );
    
    // Подписываем два хендлера на событие Event3
    eventSystem.subscribeEvent( "Event3", fun5 );
    eventSystem.subscribeEvent( "Event3", fun6 );   
    
    eventSystem.invokeEvent( "Event2" );                // Вызываем событие Event2
    eventSystem.unsubscribeEvent( "Event2", fun4 );     // Отписываем хендлер от события Event2
    eventSystem.invokeEvent( "Event2" );                // Снова вызываем Event2
    
    eventSystem.invokeEvent( "Event1" );                // Вызываем событие Event1
    
    eventSystem.invokeEvent( "Event3" );                // Вызываем событие Event3  
}

// Тип-Указатель на некую функцию
typedef void(_stdcall * ClbFunc)(int, int, void *);