🚀 go-pugleaf

In article <6021@alice.uUCp> bs@alice.UucP (Bjarne Stroustrup) writes:

>Maybe there ought to be a separate function ``unsig()'' like the ``oct()''
>and ``hex()'' functions, but currently there is not.

I think that adding arguments to existing functions would be better
than adding functions. i.e.

	hex(0xFFFFFFFF, 0, UNSIGNED) 

would produce "FFFFFFFF", but

	hex(0xFFFFFFFF, 0, SIGNED) would produce

"-1".  I prefer this solution to adding functions, since it can be 
general, and can be used with oct, and dec, and any new functions
people think up. SIGNED and UNSIGNED can be implemented in several
ways, and would be defined in stream.h.   This solution also allows
each function to choose what its default would be.  I imagine dec()
having a default of SIGNED, whereas hex(), and oct() would have 
UNSIGNED as default.
 
By the way, the current inplementation of dec() will not print the 
most negative long integer correctly on a 2's complement machine.
(The first thing the code does is to change a negative argument into
a positive one, and set a sign flag.  This is a big lose on a 2's
complement machine!)

Also, the second argument to str() does NOT truncate the string
the way the other functions do.  If the string is too long it
just overflows, and makes it as long as it has to be (which is
what an argument of 0 does).  I definitely consider this a bug.
Do you consider it feature?


-- 
Jim \/\/illiams
jim@mimsy.umd.edu
umcp-cs!jim.UUCP

In article <6021@alice.uUCp> bs@alice.UUCP writes:
>The general problem of which this problem with unsigned is a symptom is that
>C++'s resolution mechanism for overloaded functions cannot distinguish an
>``unsigned'' from an ``int''. For example, if one could declare
>
>	overload f(unsigned), f(int);
>
>which function would f(-1) call? which one would f(1) call? why?

From K&R, pg. 180 (Stroustrup has identical wording on pg. 246):

   A decimal constant whose value exceeds the largest signed integer is
   taken to be "long"; an octal or hexadecimal constant which exceeds the
   largest unsigned integer is likewise taken to be "long"; otherwise
   integer constants are taken to be "int".

Therefore, both "1" and "-1" are of type "int", and both "f(1)" and "f(-1)"
should invoke "f(int)".  If you want to invoke the other function using a
constant argument, try e.g. "f((unsigned) 1)".

There may be some point allowing a terminal "u" (or "U") to specify an
unsigned constant, so that "1u" would be of type "unsigned int"; but as
the example shows, this is not strictly necessary.

Frank Adams                           ihnp4!philabs!pwa-b!mmintl!franka
Multimate International    52 Oakland Ave North    E. Hartford, CT 06108

> There may be some point allowing a terminal "u" (or "U") to specify an
> unsigned constant, so that "1u" would be of type "unsigned int"...

There's definitely a point in allowing that - ANSI C compatibility.  From
the May 1, 1986 draft, p. 23:

	   The type of an integer constant is the first of the
	corresponding list in which its value can be represented.
	Unsuffixed decimal: "int", "long int", "unsigned long int";
	unsuffixed octal or hexadecimal: "int", "unsigned int",
	"long int", "unsigned long int"; suffixed by the letter "u"
	or "U": "unsigned int", "unsigned long int"; suffixed by the
	letter "l" or "L": "long int", "unsigned long int";
	suffixed by both the letters "u" or "U" and "l" or "L":
	"unsigned long int".
-- 
	Guy Harris
	{ihnp4, decvax, seismo, decwrl, ...}!sun!guy
	guy@sun.com (or guy@sun.arpa)