Boolean class using shared referenced memory
I'm sorry to be so straightforward: This is madness! Your code seems to indicate a sincere lack of several language features.

Pointer to const

You define MEM to be of type uint8_t*, but it actually points to  values of const uint8_t. To account for this difference you cast the const away in both constructors. If you'd ever (accidentally) write to the memory MEM points to, undefined behavior might ensue. So it should be at least of type uint8_t const *.

Memory leak in constructor

As you have suspected, your code leaks memory. Both constructors assign new uint8_t to MEM before overwriting it directly afterwards. Now there is no way to reference the values created on the heap with new. Both allocations are not necessary since MEM always points to one of the two static variables. Therefore you should also not try to delete them once Zeroth goes out of scope.

Since we are at the constructor: why do you accept an 32bit integer as argument when all you care about is one bit and all your internal values are stored in an uint8_t? I also find it unintuitive to treat all the even numbers as false, and all the odd ones as true (this is basically a consequence of your bit mask). Often all values except 0 are treated as truthy values (exempt of this rule are exit codes, where 0 is usually seen as success).

isPresent/isNotPresent

Those functions do not even compile on a 64bit platform, since the completely unnecessary cast to int narrows the bidwidth of the pointer type from 64bit to 32bit. Apart from that, there is a whole lot of other weird things going on here.

Let's try to break this down:

(int)&amp;(*this-&gt;MEM)


this-&gt;MEM is a pointer. You then for whatever reason decided to dereference (*this-&gt;MEM) it to get the value it's pointing to. After that, you take the address of the value (&amp;(*this-&gt;MEM)), which should be the same as this-&gt;MEM. And if all of this weren't enough, you then try to cram the address into an int ((int)&amp;(*this-&gt;MEM)).

Same procedure for the value you try to compare it with:

(int)&amp;Zeroth::UnitSet


You have the value Zeroth::UnitSet, take the address of it &amp;Zeroth::UnitSet and then try to cram this address into a 32bit integer.

You get the same effect using

bool isPresent() const { return &amp;Zeroth::UnitSet == this-&gt;MEM; }
bool isNotPresent() const { return &amp;Zeroth::NullSet == this-&gt;MEM; }


without all this madness.

Memory footprint

The internal state of your class is represented by a pointer to a const uint8_t. As I have already tried to tell you in the comments, the size of the pointer is 32bit or 64bit depending on which type of architecture your compiler tries to target. This 4 to 8 times larger than the 8bit you would need to store the value. If you stick with the value, there are far less possibilities to shoot yourself in the foot.

class ZerothVal {

public:
    ZerothVal() = default;  // see https://en.cppreference.com/w/cpp/language/default_constructor

    ZerothVal(uint8_t VAL) {
        val = (VAL &amp; 0x1 ? ZerothVal::UnitSet : ZerothVal::NullSet);
    }

    bool isPresent() const { return val == ZerothVal::UnitSet; }
    bool isNotPresent() const { return val == ZerothVal::NullSet; }

    friend std::ostream&amp; operator&lt;&lt;(std::ostream&amp; os, const ZerothVal&amp; data);

private:
    const uint8_t NullSet = 0;
    const uint8_t UnitSet = 1;

    uint8_t val = ZerothVal::NullSet;
};

std::ostream&amp; operator&lt;&lt;(std::ostream&amp; os, const ZerothVal&amp; data) {
    return os &lt;&lt; (data.isPresent() ? 'T' : 'F');
}


Operator support

Since you'd like to implement some kind of bool value, I'd highly recommend implementing the Safe Bool Idiom. For you that would mean that you have to implement operator bool() for your class (see this SO post for an explanation).