Re: ambiguous types: want automatic conversion

From:

"Ron AF Greve" <ron@localhost>

Newsgroups:

comp.lang.c++

Date:

Fri, 21 Sep 2007 00:40:02 +0200

Message-ID:

<46f2f6c2$0$243$e4fe514c@news.xs4all.nl>

Hi,

"Markus Dehmann" <markus.dehmann@gmail.com> wrote in message
news:1190327211.987359.227480@g4g2000hsf.googlegroups.com...

I think this is a question about automatic type conversion, but I
didn't find the answer after googling for these words ...

I have a class called Value (source see below) which can hold an int
or a string:
Value i(23);
Value s("blah");

Now I want an implicit conversion that automatically returns the
correct type, even in a context like this:
std::cout << i; // works
std::cout << s; // doesn't work: "Not an int" exception thrown

I think this should be feasible because the object knows what to
return (it was constructed with the certain type, although that's only
at runtime, not compile time ...). Of course, I could have an
asString(), or an asInt() method in the class, but I want to avoid
that as it seems redundant. I also don't want to use external (non-
std) packages like boost.

Thanks for any help! The class I have so far is this:

class Value {
   std::string stringValue;
   int intValue;
   bool isString;
   bool isInt;
public:
   Value(std::string s) : isString(true), isInt(false),
stringValue(s) {}
   Value(int i) : isString(false), isInt(true), intValue(i) {}
   operator std::string (){
     if(!isString){throw std::runtime_error("Not a string");}
     return stringValue;
   }
   operator int (){
     if(!isInt){throw std::runtime_error("Not an int");}
     return intValue;
   }
};

Yes that is possible. Just create a friend function like in my own variant
class
//------------------------ Header----------------------
class UVar
{
friend std::ostream& operator<<( std::ostream& Output, const UVar& Var );
};

std::ostream& operator<<( std::ostream& Output, const UVar& Var );
//-----------------Source
std::ostream& operator<<( std::ostream& Output, const UVar& Var )
{
Var.Print( Output );

return Output;
}

void UVar::Print( ostream& Output ) const
{

switch( Type )
{
  case eNull:
   Output << "Null";
   break;
   case eLong:
   Output << Long;
   break;
  case eDouble:
   Output << Double;
   break;
  case eString:
   Output << *reinterpret_cast<const std::string*>( String );
   break;
  case eMap:;
   {
     Output << "Map : ";

      const map<UVar*,UVar*, UFindVar> Map1 =
*reinterpret_cast<map<UVar*,UVar*, UFindVar> const *const>( Map );

    for( map<UVar*,UVar*, UFindVar>::const_iterator VarIter = Map1.begin();
VarIter != Map1.end(); ++VarIter )
    {
     Output << "Key(" << VarIter->first->type_name() << ") = " <<
*VarIter->first << "> Value{ " << VarIter->second->type_name() << ") = <"
<< *VarIter->second << ">";
    }
   }
   break;
  case eSRefPtr:
   Output << "Object Classname = " << (
*reinterpret_cast<MSRefPtr<ISerialize>const*>( SRefPtr ) ?
(*reinterpret_cast<MSRefPtr<ISerialize>const*>( SRefPtr ) )->GetClassname()
: string( "SRefPtr is null" ) );
   break;
  case eWRefPtr:
   Output << "Object Classname = " << (
*reinterpret_cast<MWRefPtr<ISerialize>const*>( WRefPtr ) ?
(*reinterpret_cast<MWRefPtr<ISerialize>const*>( WRefPtr ) )->GetClassname()
: string( "WRefPtr is null" ) );
   break;
  case eKey:
   Output << "MKey " << *reinterpret_cast<MKey const *>( KeyStroke );
   break;
  default:
   Channel << Chan1 << "Unknown type in UVar type = " << static_cast<int>(
Type ) << End;
   throw CInfoException( "Unknown type" );
}
}

Regards, Ron AF Greve

http://www.InformationSuperHighway.eu