Is code a safe thread?

    I customize operator new to create my own definition.
m_out_of_memory is a global variable of class Test. m_out_of_memory
can be set to true or false inside operator new function before Test()
is called to construct three data members: a, b, c.
    If m_out_of_memory is to be true, then Test() is not called and all
data members cannot be initialized.
    My one question is =96 is thread safe? What happen if two main
functions are running on two threads at the same time while accessing
m_out_of_memory?
    First thread will report out of memory before second thread will skip
to initialize data members. Can you please confirm that it never
happened as long as thread safety is taken care?
    Or=85is m_out_of_memory stored in separate memory on each thread and is
never shared?
    I choose this method to avoid using exception.

class Test
{
public:
    Test() : a( 1 ), b( 2 ), c( 3 ) {
    }

    ~Test() {
    }

    bool Is_Sufficient_Memory() const {
        return ( m_out_of_memory == false ) ? true : false;
    }

    void* operator new( size_t size ) {
        void* p = malloc( size );

        m_out_of_memory = ( p == 0 ) ? true : false;

        return p;
    }

    void operator delete( void* memory ) {
        free( memory );
    }

    void Set_abc( int _a, int _b, int _c ) {
        a = _a; b = _b; c = _c;
    }

private:
    static bool m_out_of_memory;
    int a;
    int b;
    int c;
};

bool Test::m_out_of_memory = false;

int main()
{
    Test* T = new Test();

    if( T->Is_Sufficient_Memory()) {
        T->Set_abc( 10, 20, 30 );
        delete T;
    }

    return 0;
}