Using std::string

[Victor Hannak]

I am taking a program written in Borland C++ Builder 4 and converting the
non-GUI related code to be generic c++ that can run anywhere. My main issue
at this point is dealing with the string classes used in this program. All
strings in this program are of the Borland AnsiString class. I would like
to convert them over to use std::string.

In order to keep from breaking the original program, I was hoping to use
std::string everywhere except the GUI class. In the GUI class (which is
still a BCB4 GUI), I was hoping to do some translation from std::string to
AnsiString to maintain compatibility with the visual components.

So 2 questions:

1) When moving a string from the std::string datatype to the AnsiString
datatype, is the only way to do it to copy character by character from one
datatype to the other? (I have never used the std::string class before)

2) Throughout the code, there are AnsiString variables declared with the
keyword "String". Is there a way I can set up an alias so that anytime the
compiler sees "String", it uses the std::string class (i.e. "string"
lower-case) instead? (I think the operators/methods are pretty much
compatible between the two, but correct me if I am wrong)

Thanks,

Vic

[Mike Wahler]

Ron Natalie <ro*@sensor.com > wrote in message
news:3f******** *************** @news.newshosti ng.com...

"Mike Wahler" <mk******@mkwah ler.net> wrote in message news:4i******** *********@newsr ead4.news.pas.e arthlink.net...

std::istringstr eam iss;
iss >> f;

The above fails (backwards from what the user wanted anyhow)
std::ostringstr eam oss;
oss << f;

Oops, yes, sorry about that.

-Mike

[Duane Hebert]

1) When moving a string from the std::string datatype to the AnsiString
datatype, is the only way to do it to copy character by character from one
datatype to the other? (I have never used the std::string class before)
AnsiString has a ctor that takes a char* so you can do

std::string Flarn("whatever ");
AnsiString Spoo(Flarn.c_st r());

2) Throughout the code, there are AnsiString variables declared with the
keyword "String". Is there a way I can set up an alias so that anytime the compiler sees "String", it uses the std::string class (i.e. "string"
lower-case) instead? (I think the operators/methods are pretty much
compatible between the two, but correct me if I am wrong)

String is a typedef for AnsiString. (or is it that AnsiString is a typedef
for String...)

There are some differences between
std::string and AnsiString that you need to know.

AnsiString is a Delphi construct and is 1 based. BCB4 allows you to access
the first character at index 0
but this doesn't work after BCB5.

AnsiString's c_str() doesn't return a const char* so you can modify the
String via
its c_str() function.

Also, BCB4's STL implementation is pretty old. BCB5 used Rogue Wave for
it's
STL which was pretty buggy. BCB6 uses STLPort which seems much better.

At any rate, you'd get a lot more information at one of Borland's newsgroups

Try the server newsgroups.borl and.com and look for
borland.public. cppbuilder.lang uage.cpp
There are a few people there that understand both Borland stuff and STL
stuff.

HTH

[John Harrison]

"Victor Hannak" <vi***********@ nospam.kodak.co m> wrote in message
news:bj******** **@news.kodak.c om...

Use an ostringstream for this kind of conversion.

float tmp = 5.0;
ostringstream oss;
oss << tmp;
string my_string = oss.str();

Great suggestions...t hat's exactly the info I needed... but one more
question...

I have taken the above code and made it into a function:

string str(float In) {
ostrstream oss;
oss << In;
return(oss.str( ));
}

Just noticed you made a crucial change to my suggestion, you've used
ostrstream instead of ostringstream.

ostrstream is not recommended, but if you insist you need this code

string str(float In)
{
ostrstream oss;
oss << In << ends;
char* tmp = oss.str();
string Out(tmp);
delete[] tmp;
return Out;
}

ostrstream predates the string class, its based on C null terminated strings
(that's what ends is for, it adds the null terminator, and that's why you
have to delete[] the memory when you're done).

Use ostringstream if it is available to you.

john

[Rolf Magnus]

Dave Vandervies wrote:

In article <bj**********@n ews.kodak.com>,
Victor Hannak <vi***********@ nospam.kodak.co m> wrote:

string str(float In) {
ostrstream oss;
oss << In;
return(oss.str( ));
}

[...]

So I _could_ replicate/overload the str() function for each type of
data
that I would want to potentially print out. But is there a way to
make it generic so that it doesn't matter what data type I am passing
in? (Since ultimately it is limited to what ostrstream can accept)

This looks to me like a good place for a template:

template <class T> std::string str(T in)
{
ostringstream os;
os<<in;
return os.str();
}

/*Use like this:*/
WriteGUI("An int: "+str(my_in t));
WriteGUI("A double: "+str(my_double ));
WriteGUI("A user-defined type: "+str(my_user_d efined_type));
I'd probably try inlining it, too, though I'm not sure that would make
a noticeable difference in either speed or size.
dave
(Still working on the jump from C to C++, so any comments on my code
would be welcome)

You should use a const reference for the parameter:

template <class T> std::string str(const T& in)

With this, the object itself is used, not a copy of it. This makes a
difference if copying takes a long time or your class isn't copyable at
all.