Convert an integer to a string? Plan B?

[Steven T. Hatton]

http://public.research.att.com/~bs/b...#int-to-string

Is there no C library function that will take an int and convert it to its
ascii representation? The example Bjarne shows in his faq is not extremely
convenient.
--
NOUN:1. Money or property bequeathed to another by will. 2. Something handed
down from an ancestor or a predecessor or from the past: a legacy of
religious freedom. ETYMOLOGY: MidE legacie, office of a deputy, from OF,
from ML legatia, from L legare, to depute, bequeath. www.bartleby.com/61/

[Kai-Uwe Bux]

Roland Pibinger wrote:

On 11 Mar 2006 14:19:21 -0800, an**@servocomm. freeserve.co.uk wrote:

Pete Becker wrote:

But in general, low level functions should report errors in-channel,
because once you've added the overhead of throwing exceptions you can't
get rid of it. Applications that don't use exceptions shouldn't have to
pay for them.

I put them in because I do use them. If an empty string is returned
that is an error and must be acknowledged as such rather than ignored,
which is what happens IMO all to often if it can be ignored.

Actually, the conversion from int to string cannot fail because all
bit combinations in an int result in a valid value.

[snip]

Clause [3.9.1/1] makes that guarantee for unsigned character types. For the
type int, however, I think no such guarantee is made in the standard.
Best

Kai-Uwe Bux

[andy]

Daniel T. wrote:

In article <44************ **@news.utanet. at>,
rp*****@yahoo.c om (Roland Pibinger) wrote:

On Sat, 11 Mar 2006 11:11:57 -0500, Pete Becker <pe********@acm .org>
wrote:

Daniel T. wrote:
> So, what is the "appropriat e test" to ensure that a buffer is not
> overrun?

Here's a proposal for a simple, efficient, and safe conversion
function:

#include <stdio.h>
#include <string>

inline std::string& itostr (int i, std::string& out) {
std::string::va lue_type buf[128];
int len = snprintf(buf, sizeof(buf), "%d", i);

if (len > 0 && size_t (len) < sizeof (buf)) {
out.assign(buf, std::string::si ze_type (len));
} else {
out.clear();
}
return out;
}

Why put a 128 char buffer on the stack when string already has one
imbedded in it...

string& itostr( int i, string& result )
{
result.clear();
if ( i == INT_MIN ) {
result += "-2147483648";
}
else if ( i == 0 ) {
result = '0';
}
else {
string::size_ty pe pos = 0;
if ( i < 0 ) {
result = '-';
i = -i;
pos = 1;
}
while ( i > 0 ) {
result.insert( pos, 1, char( '0' + i % 10 ) );
i /= 10;
}
}
return result;
}

string itostr( int i ) {
string result;
itostr( i, result );
return result;
}

Hmm ... Maybe somebody ought to test all these functions and see which
has the best features on grounds of speed, stack/heap used and also
reliability (IOW likelihood of failure or data corruption). Maybe even
the original stringstream wouldnt do too bad then ?

Then it should be not too difficult to write a standardisation proposal
.. I guess it has to be called itostr though!

regards
Andy Little

[andy]

Daniel T. wrote:
[...]

result += "-2147483648";
}

BTW Thats not portable of course. You might be able to use BOOST
Preprocessor to stringize INT_MIN.:

http://www.boost.org/libs/preprocess...stringize.html

Anyway if that doesnt work I'm sure there would be some way to do it.

regards
Andy Little

[Roland Pibinger]

On 11 Mar 2006 16:50:04 -0800, an**@servocomm. freeserve.co.uk wrote:

In that case things are much simpler. Now I added a traits class for
the format string so potentially extending the useage to other integer
types, though it seems sprintf is a bit limited to signed and unsigned
int only..whatever. ..

#include <cstdio>
#include <limits>
#include <string>
#include <boost/utility/enable_if.hpp>
#include <boost/type_traits/is_integral.hpp >

....

Ahem, wasn't a simple solution desired?

[andy]

Roland Pibinger wrote:

Andy Little wrote

#include <cstdio>
#include <limits>
#include <string>
#include <boost/utility/enable_if.hpp>
#include <boost/type_traits/is_integral.hpp > ...

Ahem, wasn't a simple solution desired?

I like to use enable_if. It improves (IMO) the error message if I
passed a double rather than a int for example. So it makes my life a
bit simpler. However its not in the C++ standard I guess Try code
below re that ----->

BTW It would also be useful to template param the string char_type then
wrap sprintf/swprintf in a functor and select based on the char_type.
Then the function would be even simpler wouldnt it .... ;-)

regards
Andy Little

-----------------------
#include <cstdio>
#include <limits>
#include <string>

// comment/uncomment to check difference in error messages
#define USE_ENABLE_IF

#ifdef USE_ENABLE_IF
#include <boost/utility/enable_if.hpp>
#include <boost/type_traits/is_integral.hpp >
#endif

template <typename IntegerType>
struct format;

template <>
struct format<int>{
static const char* specifier(){ret urn "%d";}
};
template <>
struct format<unsigned int>{
static const char* specifier(){ret urn "%u";}
};

template <typename IntegerType>
inline
#ifdef USE_ENABLE_IF
typename boost::enable_i f<
boost::is_integ ral<IntegerType >,
std::string&::type

#else
std::string&
#endif
itostr (IntegerType i, std::string& out)
{
std::string::va lue_type buf[
std::numeric_li mits<IntegerTyp e>::digits10 + 3
];
std::string::si ze_type len
= std::sprintf(bu f, format<IntegerT ype>::specifier (), i);
out.assign(buf, len);
return out;
}

#include <iostream>
int main()
{
std::string str;
itostr(1.,str);
}

regards
Andy Little

[Roland Pibinger]

On Sun, 12 Mar 2006 03:58:25 GMT, "Daniel T."
<po********@ear thlink.net> wrote:

Why put a 128 char buffer on the stack when string already has one
imbedded in it...
because it costs nothing. But I probably change it to
std::string::va lue_type buf[3 * sizeof(int) + 1];
string& itostr( int i, string& result )
{
result.clear();
this may delete the internal buffer for some string implementations
if ( i == INT_MIN ) {
result += "-2147483648";
}
else if ( i == 0 ) {
result = '0';
}
else {
string::size_ty pe pos = 0;
if ( i < 0 ) {
result = '-';
i = -i;
pos = 1;
}
while ( i > 0 ) {
result.insert( pos, 1, char( '0' + i % 10 ) );
this may cause string reallocations for some string implementations
(IIRC even some professional implementations )
i /= 10;
}
}
return result;
}

With the *printf functions you can format the string output. An
extended version of the above function could offer output format
alternatives to users. Not as format string but in a safe way.

Best wishes,
Roland Pibinger

[Pete Becker]

an**@servocomm. freeserve.co.uk wrote:

Daniel T. wrote:
[...]

result += "-2147483648";
}

BTW Thats not portable of course. You might be able to use BOOST
Preprocessor to stringize INT_MIN.:

You're looking for a string that converts to the minimum representable
value?

#define XSTR(x) #x
#define STR(x) XSTR(x)
STR(INT_MIN)

But note that on some implementations , INT_MIN is defined more like
(-2147483657-1).

--

Pete Becker
Roundhouse Consulting, Ltd.

[andy]

Pete Becker wrote:

an**@servocomm. freeserve.co.uk wrote:

Daniel T. wrote:
[...]

result += "-2147483648";
}

BTW Thats not portable of course. You might be able to use BOOST
Preprocessor to stringize INT_MIN.:

You're looking for a string that converts to the minimum representable
value?

#define XSTR(x) #x
#define STR(x) XSTR(x)
STR(INT_MIN)

But note that on some implementations , INT_MIN is defined more like
(-2147483657-1).

hmm..IIRC Its you that started us on this rocky road, further up this
thread. Now look where its ended up using nested macros!

OK How about this... just to initalise that value:

#include <sstream>
#include <iostream>
#include <string>

std::string
int_min_init()
{
std::ostringstr eam s;
s << INT_MIN;
return s.str();
}
std::string const & int_min()
{
static std::string const& str = int_min_init();
return str;
}

// now use
result += int_min();

See .. I can still get an ostringstream in somewhere... :-)

regards
Andy Little

[Daniel T.]

In article <44************ **@news.utanet. at>,
rp*****@yahoo.c om (Roland Pibinger) wrote:

On Sun, 12 Mar 2006 03:58:25 GMT, "Daniel T."
<po********@ear thlink.net> wrote:

Why put a 128 char buffer on the stack when string already has one
imbedded in it...

because it costs nothing. But I probably change it to
std::string::va lue_type buf[3 * sizeof(int) + 1];

string& itostr( int i, string& result )
{
result.clear();

this may delete the internal buffer for some string implementations

Then change the line to:
result.reserve( numeric_limits< float>::digits1 0 + 2 );

or some such. But then you have a problem with "result = ..." calls
below because they *may* reduce the size of the internal buffer thus
defeating the reserve call.

if ( i == INT_MIN ) {
result += "-2147483648";
}
else if ( i == 0 ) {
result = '0';
}
else {
string::size_ty pe pos = 0;
if ( i < 0 ) {
result = '-';
i = -i;
pos = 1;
}
while ( i > 0 ) {
result.insert( pos, 1, char( '0' + i % 10 ) );

this may cause string reallocations for some string implementations
(IIRC even some professional implementations )

i /= 10;
}
}
return result;
}

With the *printf functions you can format the string output. An
extended version of the above function could offer output format
alternatives to users. Not as format string but in a safe way.

But then your right back to using something very much like stringstream
which Mr. Becker (and apparently only Mr Becker) finds "too expensive".
--
Magic depends on tradition and belief. It does not welcome observation,
nor does it profit by experiment. On the other hand, science is based
on experience; it is open to correction by observation and experiment.

[Daniel T.]

In article <11************ *********@i39g2 000cwa.googlegr oups.com>,
an**@servocomm. freeserve.co.uk wrote:

Hmm ... Maybe somebody ought to test all these functions and see which
has the best features on grounds of speed, stack/heap used and also
reliability (IOW likelihood of failure or data corruption). Maybe even
the original stringstream wouldnt do too bad then ?

Then it should be not too difficult to write a standardisation proposal
. I guess it has to be called itostr though!

I don't think itostr is a good name. Personally, I like
lexical_cast<Ty pe>. As in:

template < typename T, typename U >
T lexical_cast( const U& u ) {
std::stringstre am ss;
T t;
if ( !( ss << u && ss >> t ) ) throw std::bad_cast() ;
return t;
}

template < >
std::string lexical_cast<st d::string>( const int& u ) {
// do whatever you think is "least expensive" here Pete.
}
--
Magic depends on tradition and belief. It does not welcome observation,
nor does it profit by experiment. On the other hand, science is based
on experience; it is open to correction by observation and experiment.