std::string sprintf

[Frank Neuhaus]

Hey
Iam occaisonally using something like
char buffer[1024];
sprinf(buffer,"Hello test %d %s",someint,somestring);

Is there any _convenient_ and buffer overflow secure equivalent for that
using std::string?
Thanks

[Mike Wahler]

"Frank Neuhaus" <fn******@uni-koblenz.de> wrote in message
news:di**********@cache.uni-koblenz.de...

Hey
Iam occaisonally using something like
char buffer[1024];
sprinf(buffer,"Hello test %d %s",someint,somestring);

Is there any _convenient_ and buffer overflow secure equivalent for that
using std::string?

Look up 'std::ostringstream'

-Mike

[Victor Bazarov]

Frank Neuhaus wrote:

Hey
Hey yourself
Iam occaisonally using something like
char buffer[1024];
sprinf(buffer,"Hello test %d %s",someint,somestring);

Is there any _convenient_ and buffer overflow secure equivalent for that
using std::string?

There is a snprintf, IIRC...

Generally speaking, the only reasonable way I know is

std::ostringstream os;
os << "Hello test " << someint << ' ' << somestring;
std::string buffer(os.str());

// here 'buffer' has the string

V

[Matthias Kaeppler]

Frank Neuhaus wrote:

Iam occaisonally using something like
char buffer[1024];
sprinf(buffer,"Hello test %d %s",someint,somestring);

Is there any _convenient_ and buffer overflow secure equivalent for that
using std::string?

Boost.Format has printf-style formatting by overloading operator%. It
still doesn't feel very printf-ish to me though. What you do, basically,
is create a formatter object which has an internal stream buffer holding
the formatted sequence. You can then take its string value and assign it
to a std::string.

Example:

std::string s;
s = str( format(" %d %d ") % 11 % 22 );

See http://www.boost.org/libs/format/index.html for more examples.

--
Matthias Kaeppler | Tel: [phone]
Gerhart-Hauptmann-Str. 16a | Mob: [phone]
D-67663 Kaiserslautern | E-Mail: matthias at finitestate dot org

[Default User]

Frank Neuhaus wrote:

Hey
Iam occaisonally using something like
char buffer[1024];
sprinf(buffer,"Hello test %d %s",someint,somestring);

Is there any convenient and buffer overflow secure equivalent for
that using std::string? Thanks

http://www.parashift.com/c++-faq-lit...es.html#faq-39.
1
Brian
--
Please quote enough of the previous message for context. To do so from
Google, click "show options" and use the Reply shown in the expanded
header.

[Marcus Kwok]

Frank Neuhaus wrote:

Hey
Iam occaisonally using something like
char buffer[1024];
sprinf(buffer,"Hello test %d %s",someint,somestring);

Is there any convenient and buffer overflow secure equivalent for
that using std::string? Thanks

Default User <de***********@yahoo.com> wrote: http://www.parashift.com/c++-faq-lit...es.html#faq-39.
1

Link should be all on one line:

http://www.parashift.com/c++-faq-lit....html#faq-39.1

--
Marcus Kwok

[Frank Neuhaus]

Thanks for all suggestions
ostringstream looks like the most reasonable method for my case ;)
Gonna look into that

"Frank Neuhaus" <fn******@uni-koblenz.de> schrieb im Newsbeitrag
news:di**********@cache.uni-koblenz.de...

Hey
Iam occaisonally using something like
char buffer[1024];
sprinf(buffer,"Hello test %d %s",someint,somestring);

Is there any _convenient_ and buffer overflow secure equivalent for that
using std::string?
Thanks

[wenmang]

I am read the example in your link, and I have a question about
efficiency of following code:

inline std::string stringify(double x)
{
std::ostringstream o;
if (!(o << x))
throw BadConversion("stringify(double)");
return o.str();
}

how expensive to create std::ostringstream o again and again by calling
stringify() compared to sprintf() C function call?

[John Harrison]

we*****@yahoo.com wrote:

I am read the example in your link, and I have a question about
efficiency of following code:

inline std::string stringify(double x)
{
std::ostringstream o;
if (!(o << x))
throw BadConversion("stringify(double)");
return o.str();
}

how expensive to create std::ostringstream o again and again by calling
stringify() compared to sprintf() C function call?

sprintf is much cheaper than ostringstream *except* when you get a
buffer overflow, when it is much, much, much more expensive.

john

[Default User]

Marcus Kwok wrote:

Link should be all on one line:

One of the few bad quirks of XanaNews is wrapping long URLs.

Brian

[Default User]

John Harrison wrote:

we*****@yahoo.com wrote:

I am read the example in your link, and I have a question about
efficiency of following code:

inline std::string stringify(double x)
{
std::ostringstream o;
if (!(o << x))
throw BadConversion("stringify(double)");
return o.str();
}

how expensive to create std::ostringstream o again and again by
calling stringify() compared to sprintf() C function call?

sprintf is much cheaper than ostringstream except when you get a
buffer overflow, when it is much, much, much more expensive.

And the original request specifically asked:

"Is there any convenient and buffer overflow secure equivalent for that
using std::string?"

He already had an sprintf() solution.

Brian

[Jacques Labuschagne]

we*****@yahoo.com wrote:

I am read the example in your link, and I have a question about
efficiency of following code:

inline std::string stringify(double x)
{
std::ostringstream o;
if (!(o << x))
throw BadConversion("stringify(double)");
return o.str();
}

how expensive to create std::ostringstream o again and again by calling
stringify() compared to sprintf() C function call?

On my system the actual conversion is roughly as fast as through
sprintf, but the cost of creating and destroying a stringstream for each
conversion triples the time taken.
I've always used stringstream for the general form of my "stringify"
equivalent and then specialised the numeric versions to use snprintf.

Jacques.