No init for const!

#include <iostream>
#include <stdexcept>
#include <string>
 
static struct default_init_tag_ {} default_init_tag;
 
template <typename T>
struct const_var
{
    template <typename V>
    const_var(V const & x) 
        : wasInit_(false) 
    {
        init(x);
    }
    const_var(const_var const & x) 
        : wasInit_(false)
    {
        if(x.wasInit())
        {
            init(x);
        }
    }
    const_var(default_init_tag_) 
        : wasInit_(false)
    {
        init();
    }
    const_var() 
        : wasInit_(false)
    { }
    
    const_var const & operator=(const_var const & x) const
    {
        if(this != &x && x.wasInit())
        {
            init(x);
        }
        return *this;
    }
    template <typename V>
    const_var const & operator=(V const & x) const
    {
        init(x);
        return *this;
    }
    template <typename V>
    const_var const & operator=(const_var<V> const & x) const
    {
        if(this != &x && x.wasInit())
        {
            init(x);
        }
        return *this;
    }
    const_var const & operator=(default_init_tag_) const
    {
        init();
        return *this;
    }
    
    operator T const &() const
    {
        if(wasInit_)
        {
            return var_.value;
        }
        throw std::logic_error("attempt to get the value from an uninitialized object");
    }
    
    ~const_var()
    {
        if(wasInit_)
        {
            var_.value.~T();
        }
    }
 
    bool wasInit() const
    {
        return wasInit_;
    }
    
private:
    template <typename ...Args>
    void init(Args const & ...v) const
    {
        if(!wasInit_)
        {
            ::new(&var_.value) T(v...);
            wasInit_ = true;
        }
        else
        {
            throw std::logic_error("re-initialization for a final object");
        }
    }
    
    mutable union storage
    {
        char data[sizeof(T)];
        T    value;
        
        storage()  {}
        ~storage() {}
        
    } var_;
    mutable bool wasInit_;
};
 
template <typename T>
using final = const const_var<T>;
 
int main()
{
    {
        final<std::string> a; // no init
        
        //std::string b1 = a; // get noninit value, error
        
        a = "test1"; // init
        
        std::string b2 = a; 
        
        std::cout << b2 << '\n';
        
        //a = "test"; // re-init, error
    }
    
    {
        final<std::string> a = "test2"; // init
        
        //a = "test"; // re-init, error
        
        std::string b1 = a;
        
        std::cout << b1 << '\n';        
    }
    
    {
        final<std::string> a = default_init_tag; // init default
        
    }
    
    {
        final<std::string> a; // no init
        
        a = default_init_tag; // init default
    }
}