Re: Is this class exception safe

Hi ,
I am trying to write a class that encapsulates a Union within it , I
intend the code to be exception safe.
can someone please review it and tell me if I have done the right
thing , are there any obvious memory leaks or bad design , inability
to cover most likely failure paths etc..?.

Thanks in advance
Digz
-------------------

#include<exception>
enum datatype { INVALID=-1, INTEGER=1, STRING, DOUBLE };

struct cacheSType
{
    private:
        union cacheUType
        {
            int i_;
            double d_;
            char* cptr_;
            cacheUType():d_(-999){}
            cacheUType(int i):i_(i){}
            cacheUType(double d):d_(d){}
            cacheUType(char* c):cptr_(c){}
        };
        typedef cacheUType unionType;
        datatype _data_t;
        unionType _cache_t;

    public:
        cacheSType():_data_t(INVALID){}
        cacheSType(int i): _data_t(INTEGER), _cache_t(i){}
        cacheSType(double d): _data_t(DOUBLE), _cache_t(d){}
        cacheSType(const char* c ): _data_t(STRING){
            try {
            _cache_t.cptr_ = new char[strlen(c) + 1 ];
            strcpy(_cache_t.cptr_, c);
            }
            catch( const std::bad_alloc &oom ){
                cerr << oom.what() << endl;
                throw;
            }
            catch(...) {
                throw;
            }
        }

        cacheSType( const cacheSType& rhs) {
            try {
                if ( rhs._data_t == STRING ) {
                    _cache_t.cptr_ = new
char[strlen(rhs._cache_t.cptr_) + 1];
                    strcpy(_cache_t.cptr_, rhs._cache_t.cptr_);
                }
                else {
                  _cache_t = rhs._cache_t;
                }
                _data_t = rhs._data_t;
            }
            catch( const std::bad_alloc &oom) {
                cerr << oom.what() << endl;
                throw;
            }
            catch(...) {
                throw;
            }
        }