Re: 'Weak type' class
Simon wrote:
Hi,
I want to create a weak type class, (not sure if this is the correct term).
By weak type I mean,
MyVar x = 5; // (an int)
MyVar y = "37"; // (a string)
MyVar z = x + y; // == 42
and the opposite would also be true.
std::string sZ = z; // == "42"
int iZ = z; // == 42
float fZ = z; // == 42.f
Would there already be a class, (on code project or something), that
would achieve what I am trying to do?
I would hate to have to re-invent the wheel :).
Many thanks
Simon
Well, I tried to write such a class, as an exercise in curiosity. But the result reveals many of the weaknesses in what you are
requesting. There are many issues to consider, such as rounding and precision, or what type to return when adding a MyVar to a
string, etc.
Here is the class I created. Good luck:
#include <tchar.h>
#include <string>
class MyVar
{
public:
MyVar() : m_dVal( 0.0 ) {}
MyVar( const MyVar & Var ) : m_dVal( Var.m_dVal ) {}
MyVar( char cVal ) : m_dVal( cVal ) {}
MyVar( short sVal ) : m_dVal( sVal ) {}
MyVar( int sVal ) : m_dVal( sVal ) {}
MyVar( long lVal ) : m_dVal( lVal ) {}
MyVar( __int64 llVal ) : m_dVal( static_cast<double>(llVal) ) {}
MyVar( unsigned char cVal ) : m_dVal( cVal ) {}
MyVar( unsigned short sVal ) : m_dVal( sVal ) {}
MyVar( unsigned int sVal ) : m_dVal( sVal ) {}
MyVar( unsigned long lVal ) : m_dVal( lVal ) {}
MyVar( unsigned __int64 llVal ) : m_dVal( static_cast<double>(llVal) ) {}
MyVar( double dVal ) : m_dVal( dVal ) {}
MyVar( bool bVal ) : m_dVal( bVal ? 1.0 : 0.0 ) {}
MyVar( LPCTSTR pszVal ) : m_dVal( _tstof( pszVal ) ) {}
MyVar( std::string & strVal ) : m_dVal( _tstof( strVal.c_str() ) ) {}
~MyVar() {}
MyVar & operator =( const MyVar & Var ) { m_dVal = Var.m_dVal ; return *this ; }
MyVar & operator =( char cVal ) { m_dVal = cVal ; return *this ; }
MyVar & operator =( short sVal ) { m_dVal = sVal ; return *this ; }
MyVar & operator =( int sVal ) { m_dVal = sVal ; return *this ; }
MyVar & operator =( long lVal ) { m_dVal = lVal ; return *this ; }
MyVar & operator =( __int64 llVal ) { m_dVal = static_cast<double>(llVal) ; return *this ; }
MyVar & operator =( unsigned char cVal ) { m_dVal = cVal ; return *this ; }
MyVar & operator =( unsigned short sVal ) { m_dVal = sVal ; return *this ; }
MyVar & operator =( unsigned int sVal ) { m_dVal = sVal ; return *this ; }
MyVar & operator =( unsigned long lVal ) { m_dVal = lVal ; return *this ; }
MyVar & operator =( unsigned __int64 llVal ) { m_dVal = static_cast<double>(llVal) ; return *this ; }
MyVar & operator =( double dVal ) { m_dVal = dVal ; return *this ; }
MyVar & operator =( bool bVal ) { m_dVal = bVal ? 1.0 : 0.0 ; return *this ; }
MyVar & operator =( LPCTSTR pszVal ) { m_dVal = _tstof( pszVal ) ; return *this ; }
MyVar & operator =( std::string & strVal ) { m_dVal = _tstof( strVal.c_str() ) ; return *this ; }
double operator +( const MyVar & Var ) { return m_dVal + Var.m_dVal ; }
double operator +( LPCTSTR pszVal ) { return m_dVal + _tstof( pszVal ) ; }
double operator +( std::string & strVal ) { return m_dVal + _tstof( strVal.c_str() ) ; }
double operator -( const MyVar & Var ) { return m_dVal - Var.m_dVal ; }
double operator -( LPCTSTR pszVal ) { return m_dVal - _tstof( pszVal ) ; }
double operator -( std::string & strVal ) { return m_dVal - _tstof( strVal.c_str() ) ; }
double operator *( const MyVar & Var ) { return m_dVal * Var.m_dVal ; }
double operator *( LPCTSTR pszVal ) { return m_dVal * _tstof( pszVal ) ; }
double operator *( std::string & strVal ) { return m_dVal * _tstof( strVal.c_str() ) ; }
double operator /( const MyVar & Var ) { return m_dVal / Var.m_dVal ; }
double operator /( LPCTSTR pszVal ) { return m_dVal / _tstof( pszVal ) ; }
double operator /( std::string & strVal ) { return m_dVal / _tstof( strVal.c_str() ) ; }
operator char() const { return static_cast<char>(floor(m_dVal + 0.5)) ; }
operator short() const { return static_cast<short>(floor(m_dVal + 0.5)) ; }
operator int() const { return static_cast<int>(floor(m_dVal + 0.5)) ; }
operator long() const { return static_cast<long>(floor(m_dVal + 0.5)) ; }
operator __int64() const { return static_cast<__int64>(floor(m_dVal + 0.5)) ; }
operator unsigned char() const { return static_cast<unsigned char>(floor(m_dVal + 0.5)) ; }
operator unsigned short() const { return static_cast<unsigned short>(floor(m_dVal + 0.5)) ; }
operator unsigned int() const { return static_cast<unsigned int>(floor(m_dVal + 0.5)) ; }
operator unsigned long() const { return static_cast<unsigned long>(floor(m_dVal + 0.5)) ; }
operator unsigned __int64() const { return static_cast<unsigned __int64>(floor(m_dVal + 0.5)) ; }
operator float() const { return static_cast<float>(m_dVal) ; }
operator double() const { return m_dVal ; }
operator bool() const { return (m_dVal != 0.0) ; }
operator LPCTSTR() const
{
if ( _gcvt_s( szBuf, m_dVal, 5 ) == 0 )
return szBuf ;
else
return _T("") ;
}
operator std::string() const
{
std::string str;
if ( _gcvt_s( szBuf, m_dVal, 5 ) == 0 )
str = szBuf ;
else
str = _T("") ;
return str;
}
private:
double m_dVal;
mutable TCHAR szBuf[_CVTBUFSIZE];
};
double operator +( LPCTSTR pszVal, MyVar & rVar ) { return _tstof( pszVal ) + static_cast<double>(rVar) ; }
double operator +( std::string & strVal, MyVar & rVar ) { return _tstof( strVal.c_str() ) + static_cast<double>(rVar) ; }
double operator -( LPCTSTR pszVal, MyVar & rVar ) { return _tstof( pszVal ) - static_cast<double>(rVar) ; }
double operator -( std::string & strVal, MyVar & rVar ) { return _tstof( strVal.c_str() ) - static_cast<double>(rVar) ; }
double operator *( LPCTSTR pszVal, MyVar & rVar ) { return _tstof( pszVal ) * static_cast<double>(rVar) ; }
double operator *( std::string & strVal, MyVar & rVar ) { return _tstof( strVal.c_str() ) * static_cast<double>(rVar) ; }
double operator /( LPCTSTR pszVal, MyVar & rVar ) { return _tstof( pszVal ) / static_cast<double>(rVar) ; }
double operator /( std::string & strVal, MyVar & rVar ) { return _tstof( strVal.c_str() ) / static_cast<double>(rVar) ; }