Union, new placement, strict-aliasing, cross-platform

//Title of this code
//g++  4.8.2
 
#include <iostream>
#include <cassert>
 
#include <type_traits>
 
 
struct IResource
{ 
    virtual void Foo()const =0; 
};
 
struct Resource: IResource
{ 
    virtual void Foo()const { std::cout<<"[ Resource ] hello\n"; }
};
 
 
union Holder
{
private:
    static void dimmy(){}
    typedef void (*unspecified)();
    
    char       mBuf[sizeof(IResource)];
    IResource* mHelper;
    
public:
    
    Holder():mHelper(nullptr){}
    
    IResource& Get()
    { 
        assert( mHelper && "ERROR: Holder is empty" );
        
        //промежуточная переменная служит для предотвращения угрозы
        //dereferencing type-punned pointer will break strict-aliasing rules
        IResource* obj = reinterpret_cast<IResource*>(mBuf);
        return *obj;
    }
    
    
    // true, если пуст
    bool Empty()const 
        { return mHelper? false: true; }
    
    // true, если пуст
    bool operator !()const 
        { return Empty(); }
   
    // true, если ресурс захвачен
    operator unspecified()const 
        { return !Empty()? dimmy: nullptr; }
    
 
    template<class T> void Capture()
    {
        static_assert( std::is_base_of<IResource, T>::value,
            "ERROR: T MUST BE THE HEIR OF THE CLASS 'IHelper'");
        
        static_assert( sizeof(T) == sizeof(IResource),
            "ERROR: SIZE OF T MUST BE == sizeof(IHelper)");
        
        new (mBuf) T;
    }
    
    void Clear() { mHelper = nullptr; }
    
    void View()const
    {
        std::cout << "addr = " << mHelper << mHelper << " : ";
        for(char i: mBuf)
            std::cout<<(int)i<<" ";
        std::cout<<'\n';
    }
};
 
int main()
{
    std::cout << "Hello, world!\n";
    
    Holder holder;
    holder.View();
    
    std::cout<<"holder is empty ? (must be true) : "
        << !holder<<'\n';
    
    holder.Capture<Resource>();
    holder.View();
    
    std::cout<<"holder is empty ? (must be false) : "
        << !holder<<'\n';
 
    std::cout<<"access to the resource:\n";
    holder.Get().Foo();
    
    std::cout<<"clear...\n";
    holder.Clear();
    
    std::cout<<"holder is empty ? (must be true) : "
        << !holder<<'\n';
    
}

void Clear() { mHelper = nullptr; }

template<class T> void Capture()
{
  new (mBuf) T;
}