convert int to string without using standard library (stdio.h)

Keith Thompson · *nix forums Guru Joined: 28 Feb 2005 Posts: 5173

websnarf@gmail.com writes:

neutron*star · *nix forums Guru Joined: 21 Feb 2005 Posts: 2039

websnarf@gmail.com said:

<reasonable arguments snipped>

websnarf@gmail.com · *nix forums Guru Wannabe Joined: 26 Jul 2005 Posts: 249

Mark McIntyre wrote:

Mark McIntyre · *nix forums Guru Joined: 16 Feb 2005 Posts: 1564

On 19 Jul 2006 18:35:01 -0700, in comp.lang.c , websnarf@gmail.com
wrote:

websnarf@gmail.com · *nix forums Guru Wannabe Joined: 26 Jul 2005 Posts: 249

Mark McIntyre wrote:

Mark McIntyre · *nix forums Guru Joined: 16 Feb 2005 Posts: 1564

On 18 Jul 2006 15:32:37 -0700, in comp.lang.c , websnarf@gmail.com
wrote:

websnarf@gmail.com · *nix forums Guru Wannabe Joined: 26 Jul 2005 Posts: 249

ceeques wrote:

Morris Dovey · *nix forums addict Joined: 22 Jun 2005 Posts: 90

ceeques (in 1153272522.516660.83020@s13g2000cwa.googlegroups.com)
said:

| I am actually dealing with unsigned integer and unsigned short.
| Does it make the situtaion easier to deal with?. Also, if my
| integer is represented in hex values does it change anything?..

Using unsigned types does make it easier. As Eric pointed out, the
function I posted has a problem with the largest negative number -
and by using only unsigned integer types you avoid that problem (and
eliminate the need to deal with taking the absolute value, output of
the sign character, and need for another pointer to char. The code can
be shortened to:

char *itos(char *s,unsigned i)
{ unsigned t = i;
do ++s; while (t /= 10);
*s = '\0';
do *--s = '0' + i % 10; while (i /= 10);
return s;
}

The conversion to hexadecimal digits is slightly different; since you
can use >> and & operations instead of / and % operations; and use the
digit values to retrieve digit characters from an array of 16 chars.
Since it's common to display leading zeros with hex numbers, you may
elect to eliminate the first do{}while loop.

The suggestion to download a public domain version of sprintf() is not
a bad idea. On one embedded project, we started with a public domain
version and removed all the features/formats we didn't want to
minimize the memory footprint.

--
Morris Dovey
DeSoto Solar
DeSoto, Iowa USA
http://www.iedu.com/DeSoto

ceeques · *nix forums beginner Joined: 17 Jul 2006 Posts: 3

Thanks all for replying once again.

Morris Dovey wrote:
The OP is involved in a situation involving a lot of

websnarf@gmail.com · *nix forums Guru Wannabe Joined: 26 Jul 2005 Posts: 249

Mark McIntyre wrote:

Herbert Rosenau · *nix forums Guru Wannabe Joined: 06 Jan 2006 Posts: 101

On Mon, 17 Jul 2006 22:06:51 UTC, "ceeques" <cquestions@gmail.com>
wrote:

Morris Dovey · *nix forums addict Joined: 22 Jun 2005 Posts: 90

Eric Sosman (in 1153233525.240054@news1nwk) said:

| Morris Dovey wrote On 07/18/06 10:07,:
|| Eric Sosman (in acKdnZlwuLw2WiHZnZ2dnUVZ_uydnZ2d@comcast.com) said:
||
||| Something's strange: On my machine this works most of
||| the time, but once it gave "-./,),(-*,(" as the digit string.
||| Any idea why? (The value of i was negative and large when
||| the peculiar output occurred: -2147483648, to be precise.)
||
|| Interesting indeed. Could it have been a problem with the target
|| string area not being large enough to contain the result string?
|| Even at the boundary point where i = -i might produce a problem, I
|| would still expect to see an initial sequence of digits.
||
|| The problem value is 0xFFFFFFFF80000000 - so there might be a
|| problem with division of the largest int value if your int size is
|| 32.
||
|| It is strange.
|
| Not so very strange, actually (I was attempting irony,
| but apparently only achieved rust-y ...). The problem is
| that INT_MIN may have no corresponding positive int value,
| so the computation of `-INT_MIN' overflows. What happens
| next is up to the implementation, but on two's complement
| systems it is often the case that `-INT_MIN' produces the
| value INT_MIN all over again. If this happens, `i = -i'
| in the code above does not produce a positive value; `i'
| will still be large and negative.
|
| The next piece of the puzzle depends on the behavior
| of the modulus operator with negative numbers. In C90, it
| is conceivable that you could get lucky: `-13 % 10' could
| produce 7 as a result, if `-13 / 10' produces -2. But C90
| also allows `-13 % 10' to produce -3 and `-13 / 10' to
| produce -1. C99 tightened the rules to *require* the latter,
| in part for consistency with other languages and in part
| because practically every implementation already did it that
| way anyhow. So it's almost a sure bet that `negative % 10'
| produces a remainder somewhere between -9 and 0.
|
| The weird characters I reported happen to have (on my
| system) encodings that lie just before that of the digit '0'.
| Strangeness explained.
|
| To make a long story short: "Emit a minus sign and then
| convert the absolute value" is *not* a reliable strategy
| for converting integers to digit strings.

I recognized the irony; but was paying closer attention to the
context. The OP is involved in a situation involving a lot of
judgement calls to resolve trade-offs, as illustrated by the decision
to not use printf(). If this boundary value problem is significant in
his judgement, he will need to determine appropriate mods (use
unsigned types, promote to wider type within the function, etc); but
can use the code provided as a starting point.

From where I sit (blissfully ignorant of his project context) all I
can meaningfully offer is the starting point...

--
Morris Dovey
DeSoto Solar
DeSoto, Iowa USA
http://www.iedu.com/DeSoto

Mark McIntyre · *nix forums Guru Joined: 16 Feb 2005 Posts: 1564

On 18 Jul 2006 06:54:54 -0700, in comp.lang.c , websnarf@gmail.com
wrote:

Eric Sosman · *nix forums Guru Joined: 21 Feb 2005 Posts: 1246

Morris Dovey wrote On 07/18/06 10:07,:

Morris Dovey · *nix forums addict Joined: 22 Jun 2005 Posts: 90

Eric Sosman (in acKdnZlwuLw2WiHZnZ2dnUVZ_uydnZ2d@comcast.com) said:

| Morris Dovey wrote:
|
|| char *itos(char *s,int i)
|| { char *r = s;
|| int t;
|| if (i < 0)
|| { i = -i;
|| *s++ = '-';
|| }
|| t = i;
|| do ++s; while (t /= 10);
|| *s = '\0';
|| do *--s = '0' + i % 10; while (i /= 10);
|| return r;
|| }
||
|| Will convert i to a properly terminated digit string beginning at s
|| and will prepend a '-' if the value of i is less than zero. It will
|| return a pointer to the start of the string.
|
| Something's strange: On my machine this works most of
| the time, but once it gave "-./,),(-*,(" as the digit string.
| Any idea why? (The value of i was negative and large when
| the peculiar output occurred: -2147483648, to be precise.)

Interesting indeed. Could it have been a problem with the target
string area not being large enough to contain the result string? Even
at the boundary point where i = -i might produce a problem, I would
still expect to see an initial sequence of digits.

The problem value is 0xFFFFFFFF80000000 - so there might be a problem
with division of the largest int value if your int size is 32.

It is strange.

--
Morris Dovey
DeSoto Solar
DeSoto, Iowa USA
http://www.iedu.com/DeSoto

Google