Re: Is this the correct way to do this template?

From:

Kai-Uwe Bux <jkherciueh@gmx.net>

Newsgroups:

comp.lang.c++

Date:

Sat, 03 Jun 2006 14:50:28 -0400

Message-ID:

<1283mflrghr5e76@corp.supernews.com>

Jim Langston wrote:

"Kai-Uwe Bux" <jkherciueh@gmx.net> wrote in message
news:1283jn2thc3n315@corp.supernews.com...

Jim Langston wrote:

I have a template I call StrmConvert, which uses std::stringstream to
convert from any type to any other type that can be used by
stringstring. This is what it looks like:

template<typename T, typename F > T StrmConvert( F from )
{
    std::stringstream temp;
    temp << from;
    T to = T();
    temp >> to;
    return to;
}

[snip]

int main ()
{

std::cout << StrmConvert<std::string>( 123.45 ) << std::endl;

I fail to see what that buys you compared to

std::cout << 123.45 << std::endl;

Well, usually this would be used for outputing text using a graphical
call. Something like:
draw_text( x, y, "The value is: " + jml::StrmConvert( HPs ) );

The std::cout here was just done for my test since it gained me nothing to
bring in all my graphical code for a test.

Also note that the StrmConvert<> is broken with regard to float types:
conversion will not even remotely make a round-trip:

double x;
double y = StrmConvert<double>( x );

This will turn y into a 6-digit precission approximation (I think << has
a default precision like that). Usually that is not what you want.

Luckily for me, this is usually what I want. As I said, this is normally
used for simple output. Incidently, if I do need precision, is there
anyway I can fix it?

Yes, you would need to set the precision of the stringstream to the right
value. You could either have the template do that based upon the floating
type (partial specialization) or you pass a precision parameter as a second
argument and have it default to something reasonable.

Also note that operator<< and operator>> are not strict inverses for some
other types (e.g., std::string). Your cast may lead to surprising
results.

Please explain? I don't understand what you're saying here.

Well, I mistook your template for a cast. So I was concerned with code like:

  std::string s = "hello world!";
  std::string t = my_fancy_cast< std::string >( s );

Now, given the naive stringstream implementation, the string t will
be "hello" and not "hello world!".

Now that I know you just want to convert to std::string so that you can
output anything via some API that takes strings or C-Strings, what about:

  template< typename T >
  std::string any_to_string ( T const & obj ) {
    std::stringstream dummy;
    if ( !( dummy << obj ) ) {
      throw( std::runtime_error( "conversion to string failed" ) );
    }
    return dummy.str();
  }

or:

  template< typename T >
  std::string any_to_string ( T const & obj, unsigned short prec = 6 ) {
    std::stringstream dummy;
    if ( !( dummy << std::setprecision(prec) << obj ) ) {
      throw( std::runtime_error( "conversion to string failed" ) );
    }
    return dummy.str();
  }

Best

Kai-Uwe Bux