Does 'this' pointer in bind C++ really matters?

Question

I am trying to experiment bind in C++. Basically I have two class - Invokee. The invokee class registers a test handler that needs to be invoked upon some callbacks. The method here is -

 void RegisterTestHandler(int id, TestFunction handler, std::string summary, std::string details);

Similarly, I have another method that actually invokes what has been registered -

void callHandler(int id);

Another class Test which has a function that needs to be invoked on callHandler.

unsigned int globalReset(int val);

In the main function, I am doing the nullptr for the second parameter in the bind. However, it still works and I don't get any crashes. Is it something working because of the compiler optimisation or undefined behaviour or it is something to do with bind concept.

Here is the entire experimental code.

// main.cpp

#include <iostream>
#include "test.h"
#include "invokee.h"
#include <memory>
#include <functional>

// beautify using clang-format in Vscode.


int main(int argc, char **argv)
{
    auto *invokeTest = new Invokee();
    Test *test = new Test();

    std::string summary = "global reset summary";
    std::string details = "global reset details";

    //Basically there are two object from different class - InvokeTest --> does the registration of the handler.
    // Now the InvokeTest has to call the member function of class object - Test.
    // ?? How it can do - it can do using bind - basically, the this pointer of Test class is available to invokeTest
    // therefore invokeTest can simply invoke the member function of test object.
    // until the test point is valid, it can use it to invoke the method of it ?? --> Is it really correct?

    delete(test);  //experiment deleted the test pointer.
    test= nullptr;  // explicity set to nullptr
    // still it works?? how come ??

    invokeTest->RegisterTestHandler(1, std::bind(&Test::globalReset, test, std::placeholders::_1), summary, details);
    invokeTest->callHandler(1);

    

    return 0;
}

Here is the invokee.cpp -

#include "invokee.h"

void Invokee::RegisterTestHandler(int id, TestFunction handler, std::string summary, std::string details)
{

    this->handlers[id] = handler;
    this->summary[id] = summary;
    this->details[id] = details;
}

void Invokee::callHandler(int id)
{
    auto handler = handlers.find(id);
    if (handler != handlers.end())
    {
        std::cout << "Found the handler --" << std::endl;
        handler->second(1);
    }
}

Here is the test.cpp

#include <iostream>
#include "test.h"

unsigned int Test::globalReset(int val)
{

    std::cout << "global Reset invoked" << std::endl;
    return 0;
}