Как избежать использования разрушенной переменной?

#include <iostream>
#include <mutex>
 
void log(const char* s);
 
class A {
public:
    A() { }
    ~A() { log("~A"); }
} a;
 
class B {
public:
    B() { log("B"); }
    ~B() { }
} b;
 
void log(const char* s) {
    static std::shared_ptr<std::mutex> m = std::make_shared<std::mutex>();
    std::unique_lock<std::mutex> lock(*m);
    std::cout << s << "\n";
}
 
 
int main() {
    return 0;
}

// pch.hpp (предварительно скомпилированный заголовок)
#include "glob_init.hpp"

// glob_init.hpp
 
// Подключение данного хедера приводит к инициализации
// всех глобальных точек доступа
static auto state  = glob::initialize();

#include "logger.hpp"
#include "thread_pool.hpp"
#include "singleton.hpp"
 
// glob_init.сpp
namespace glob
{
    struct initial
    {
        // Здесь указываем порядок вызова глобальных точек доступа        
        initial()
        {
            log("started");        // Запускаем логгер
            thread::pool::start(); // Запускаем пул потоков
            singleton::get();      // Запускаем ещё что нибудь
        }
    };
    
    const int initialize()
    {
        static initial obj;
        return OK;
    }
}

// main.cpp
 
// Делать явный  #include "logger.hpp" больше не нужно
 
int main()
{
    // Можно сразу использовать
    log("hello word");
}

int main()
{
    auto logger = std::make_shared<my_logger>(...);
    A a(logger);
    B b(logger);
}

#include <iostream>
 
struct my_app
{
    A a;
    B b;
 
    void run()
    {
        // здесь всё то, что хотели реализовать в main
    }
};
 
// для глобального доступа
// просто теперь к A и B мы обращаемся не напрямую,
// а вот так: app->a, app->b
my_app* app;
 
int main()
{
    app = new my_app;
    app->run();
    // при delete A и B уже уничтожаются,
    // но в их деструкторах можно смело вызывать функцию log
    // так как статический объект, созданный в функции log все еще не уничтожен
    // потому что main не закончился еще
    delete app;
}