atoi()

[Christopher Benson-Manica]

What is the preferred C++ alternative to C's atoi(), if there is one?

--
Christopher Benson-Manica | I *should* know what I'm talking about - if I
ataru(at)cyberspace.org | don't, I need to know. Flames welcome.

[Jonathan Turkanis]

"Christopher Benson-Manica" <at***@nospam.cyberspace.org> wrote in
message news:bu**********@chessie.cirr.com...

What is the preferred C++ alternative to C's atoi(), if there is one?
--
Christopher Benson-Manica | I *should* know what I'm talking about - if I ataru(at)cyberspace.org | don't, I need to know. Flames welcome.

The standard alternative is to construct a stringstream and read its
data into an int using >>. See also
http://www.boost.org/libs/conversion/lexical_cast.htm.

Jonathan

[Christopher Benson-Manica]

Jonathan Turkanis <te******@kangaroologic.com> spoke thus:

The standard alternative is to construct a stringstream and read its
data into an int using >>.

You would recommend such an approach in the following situation?

#include <cstdlib>

int main( int argc, char *argv[] )
{
int count=0;
if( argc > 1 ) {
count=atoi( argv[1] ); // <- worth setting up a stringstream?
}
return EXIT_SUCCESS;
}

--
Christopher Benson-Manica | I *should* know what I'm talking about - if I
ataru(at)cyberspace.org | don't, I need to know. Flames welcome.

[Kevin Goodsell]

Christopher Benson-Manica wrote:

Jonathan Turkanis <te******@kangaroologic.com> spoke thus:

The standard alternative is to construct a stringstream and read its
data into an int using >>.

You would recommend such an approach in the following situation?

#include <cstdlib>

int main( int argc, char *argv[] )
{
int count=0;
if( argc > 1 ) {
count=atoi( argv[1] ); // <- worth setting up a stringstream?

You forgot std::.
}
return EXIT_SUCCESS;
}

Well, atoi() doesn't allow much in the way of error detection &
recovery. It silently invokes undefined behavior on overflow, if I
recall correctly. I'd recommend using either the stringstream method or
possibly strtol() or a related function - whichever you think is
appropriate for the situation.

-Kevin
--
My email address is valid, but changes periodically.
To contact me please use the address from a recent posting.

[Jonathan Turkanis]

"Christopher Benson-Manica" <at***@nospam.cyberspace.org> wrote in
message news:bu**********@chessie.cirr.com...

Jonathan Turkanis <te******@kangaroologic.com> spoke thus:

The standard alternative is to construct a stringstream and read its data into an int using >>.

You would recommend such an approach in the following situation?

#include <cstdlib>

int main( int argc, char *argv[] )
{
int count=0;
if( argc > 1 ) {
count=atoi( argv[1] ); // <- worth setting up a stringstream?
}
return EXIT_SUCCESS;
}

int main( int argc, char *argv[] )
{
int count=0;
if( argc > 1 && (std::stringstream(argv[1]) >> count) )
/* ... */
}
return EXIT_SUCCESS;
}

There is a certain overhead to using a stringstream or stringbuf:
constuction of a locale, and depending on the implementation,
initialization of a number of member pointers and possibly a
synchronization construct. So its not appropriate always. It is,
however, the 'standard C++ alternative.'

Jonathan

[Ron Natalie]

"Christopher Benson-Manica" <at***@nospam.cyberspace.org> wrote in message news:bu**********@chessie.cirr.com...

What is the preferred C++ alternative to C's atoi(), if there is one?

I won't even use atoi in C. There are input conditions that cause it to
invoke undefined behavior. strtol is much better behaved.

[Norbert Riedlin]

"Christopher Benson-Manica" <at***@nospam.cyberspace.org> schrieb im
Newsbeitrag news:bu**********@chessie.cirr.com...

Jonathan Turkanis <te******@kangaroologic.com> spoke thus:

#include <cstdlib>

int main( int argc, char *argv[] )
{
int count=0;
if( argc > 1 ) {
count=atoi( argv[1] ); // <- worth setting up a stringstream?
}
return EXIT_SUCCESS;
}

What is the difference?

#include <boost/lexical_cast.hpp> // #include <cstdlib>

int main( int argc, char *argv[] )
{
int count=0;
if( argc > 1 ) {
count = boost::lexical_cast<int>(argv[1]); // count=atoi( argv[1] );
}
// return EXIT_SUCCESS;
}

Why should one _not_ use lexical_cast in this/any case? Ok, to
have the same result here you had to surround the cast by a try
block, catching the appropriate boost::bad_lexical_cast but...

In my opinion, lexical_cast is to be preferred in _any_ realistical
case. In not realistical cases, noone cares.

Bye

Norbert

[Jonathan Turkanis]

"Norbert Riedlin" <no*************@t-online.de> wrote in message
news:bu*************@news.t-online.com...

"Christopher Benson-Manica" <at***@nospam.cyberspace.org> schrieb im
Newsbeitrag news:bu**********@chessie.cirr.com...

Jonathan Turkanis <te******@kangaroologic.com> spoke thus:

#include <cstdlib>

int main( int argc, char *argv[] )
{
int count=0;
if( argc > 1 ) {
count=atoi( argv[1] ); // <- worth setting up a stringstream?
}
return EXIT_SUCCESS;
}

What is the difference?

#include <boost/lexical_cast.hpp> // #include <cstdlib>

int main( int argc, char *argv[] )
{
int count=0;
if( argc > 1 ) {
count = boost::lexical_cast<int>(argv[1]); // count=atoi(

argv[1] ); }
// return EXIT_SUCCESS;
}

Why should one _not_ use lexical_cast in this/any case? Ok, to
have the same result here you had to surround the cast by a try
block, catching the appropriate boost::bad_lexical_cast but...

In my opinion, lexical_cast is to be preferred in _any_ realistical
case. In not realistical cases, noone cares.

Do we disagree on anything? I mentioned the 'standard C++ alternative'
as well as boost::lexical cast; I did not express any preference.

Jonathan

[Norbert Riedlin]

"Jonathan Turkanis" <te******@kangaroologic.com> schrieb im Newsbeitrag
news:bu************@ID-216073.news.uni-berlin.de...

"Norbert Riedlin" <no*************@t-online.de> wrote in message
news:bu*************@news.t-online.com...

"Christopher Benson-Manica" <at***@nospam.cyberspace.org> schrieb im
Newsbeitrag news:bu**********@chessie.cirr.com...

Do we disagree on anything? I mentioned the 'standard C++ alternative'
as well as boost::lexical cast; I did not express any preference.

Jonathan

Not at all. If you look closer, I was relying to Christopher's post. I
should have
been more careful cutting the posting though...

Bye

Norbert

[Peter Koch Larsen]

"Norbert Riedlin" <no*************@t-online.de> skrev i en meddelelse
news:bu*************@news.t-online.com...

"Christopher Benson-Manica" <at***@nospam.cyberspace.org> schrieb im
Newsbeitrag news:bu**********@chessie.cirr.com...

Jonathan Turkanis <te******@kangaroologic.com> spoke thus:

#include <cstdlib>

int main( int argc, char *argv[] )
{
int count=0;
if( argc > 1 ) {
count=atoi( argv[1] ); // <- worth setting up a stringstream?
}
return EXIT_SUCCESS;
}

What is the difference?

#include <boost/lexical_cast.hpp> // #include <cstdlib>

int main( int argc, char *argv[] )
{
int count=0;
if( argc > 1 ) {
count = boost::lexical_cast<int>(argv[1]); // count=atoi( argv[1] );
}
// return EXIT_SUCCESS;
}

Why should one _not_ use lexical_cast in this/any case? Ok, to
have the same result here you had to surround the cast by a try
block, catching the appropriate boost::bad_lexical_cast but...

In my opinion, lexical_cast is to be preferred in _any_ realistical
case. In not realistical cases, noone cares.

Bye

Norbert

While I would agree with you in the general case, there could be cases where
avoiding streams would better be avoided. One example is when you write a
program where you are concerned about its footprint: if that program only
uses streams this one place, it does justify using an alternative approach.

Kind regards
Peter

[Nick Hounsome]

"Christopher Benson-Manica" <at***@nospam.cyberspace.org> wrote in message
news:bu**********@chessie.cirr.com...

What is the preferred C++ alternative to C's atoi(), if there is one?

- std::atoi is standard C++
- std::strtol is also standard C and standard C++ and is superior in every
respect ( IMHO atoi should be deprecated ).
- You could use an istrstream but why bother?
- I can think of no good reason to use an istringstream if you have a char*.

- as far as I am aware there is no stream equivalent of the strtol ability
to read numbers in decimal,octal or hex

--
Christopher Benson-Manica | I *should* know what I'm talking about - if I
ataru(at)cyberspace.org | don't, I need to know. Flames welcome.

[Jeff Schwab]

Christopher Benson-Manica wrote:

What is the preferred C++ alternative to C's atoi(), if there is one?

I rolled my own alternative. The idea is this, but if you're looking
for an improvement over atoi, you might consider validating the pointer,
the base, and the digits.
template< typename N > // unsigned numeric type
N ato( char const* p, unsigned base =10 )
{
N result = N( );

while( *p )
{
result = result * base + ( *p <= '9' ? *p - '0' : *p - 'a' + 10 );
++p;
}

return result;
}

#include <iostream>

int main( int argc, char *argv[] )
{
if( argc > 1 )
{
unsigned base = 10;

if( argc > 2 )
{
base = ato< unsigned >( argv[ 2 ] );
}

std::cout << ato< int >( argv[ 1 ], base ) << '\n';
}
}

[Ron Natalie]

"Nick Hounsome" <nh***@blueyonder.co.uk> wrote in message news:zT****************@news-binary.blueyonder.co.uk...

- std::strtol is also standard C and standard C++ and is superior in every
respect ( IMHO atoi should be deprecated ).

In my opinion, it could just be fixed by requiring it to be defined as:
int atoi(const char* s) { return strtol(s, 0, 10); }

That is, change it from undefined behavior to implementation defined value on
overflow. C99 even includes the above snippet as the definition "except for error
behavior."

[Norbert Riedlin]

"Jeff Schwab" <je******@comcast.net> schrieb im Newsbeitrag
news:o5********************@comcast.com...

template< typename N > // unsigned numeric type
N ato( char const* p, unsigned base =10 )
{
N result = N( );

while( *p )
{
result = result * base + ( *p <= '9' ? *p - '0' : *p - 'a' + 10 );
++p;
}

return result;
}

You are asuming the ASCII character set? In EBCDIC '9' > 'a'.

Bye

Norbert

[Jeff Schwab]

Norbert Riedlin wrote:

"Jeff Schwab" <je******@comcast.net> schrieb im Newsbeitrag
news:o5********************@comcast.com...

template< typename N > // unsigned numeric type
N ato( char const* p, unsigned base =10 )
{
N result = N( );

while( *p )
{
result = result * base + ( *p <= '9' ? *p - '0' : *p - 'a' + 10 );
++p;
}

return result;
}

You are asuming the ASCII character set? In EBCDIC '9' > 'a'.

Bye

Norbert

No assumption, just a mistake. That should have said:

'0' <= *p && *p <= '9'

[Norbert Riedlin]

"Jeff Schwab" <je******@comcast.net> schrieb im Newsbeitrag
news:f-********************@comcast.com...

Norbert Riedlin wrote:

"Jeff Schwab" <je******@comcast.net> schrieb im Newsbeitrag
news:o5********************@comcast.com...

template< typename N > // unsigned numeric type
N ato( char const* p, unsigned base =10 )
{
N result = N( );

while( *p )
{
result = result * base + ( *p <= '9' ? *p - '0' : *p - 'a' + 10 );
++p;
}

return result;
}

You are asuming the ASCII character set? In EBCDIC '9' > 'a'.

No assumption, just a mistake. That should have said:

'0' <= *p && *p <= '9'

Ok, so you are asuming correct and all lowercase input?

Bye Norbert

[Jeff Schwab]

Norbert Riedlin wrote:

"Jeff Schwab" <je******@comcast.net> schrieb im Newsbeitrag
news:f-********************@comcast.com...

Norbert Riedlin wrote:

"Jeff Schwab" <je******@comcast.net> schrieb im Newsbeitrag
news:o5********************@comcast.com...
template< typename N > // unsigned numeric type
N ato( char const* p, unsigned base =10 )
{
N result = N( );

while( *p )
{
result = result * base + ( *p <= '9' ? *p - '0' : *p - 'a' + 10 );
++p;
}

return result;
}
You are asuming the ASCII character set? In EBCDIC '9' > 'a'.

No assumption, just a mistake. That should have said:

'0' <= *p && *p <= '9'

Ok, so you are asuming correct and all lowercase input?

Bye Norbert

Are you unable to read? Here's the part of my post you snipped.

"The idea is this, but if you're looking for an improvement over atoi,
you might consider validating the pointer, the base, and the digits."