Board index » cppbuilder » Signed unsigned conversion

2005-11-08 04:30:29 AM
cppbuilder66
I've got a long number that I'm trying to selectively convert to signed or
unsigned values. The problem I'm having is that casting doesn't seem to
work. I've got my code listed below, any help would be appreciated.
char charTemp;
long longRtn;
long ConvertNum( String strType, long longValue)
{
strcpy(&charTemp, strType.SubString(0, 1).c_str()); //Get the first
character
switch (UpCase(charTemp))
{
case 'U': //Unsigned desired
longRtn = static_cast<unsigned long>(longValue);
break;
case 'S': //Signed desired
longRtn = static_cast<signed long>(longValue);
break;
default:
longRtn = -1;
break;
}//end switch
return longRtn;
}
 

On Mon, 7 Nov 2005 13:30:29 -0700, Jeff wrote:
/always/ returning the default implementation (signed or unsigned,
which differs for different compilers) for long. That is, even though
longRtn is /always/ signed if your implementation defaults to signed,
or unsigned if your implementation defaults to unsigned. With BCB the
default is signed, so you'll always get the signed value.
something more like this might be better:
template <typename T, typename U>T aconvert(U value)
{
T ret;
ret = static_cast<T>( value);
return ret;
}
but even with your code it's unnecessary to do the UpperCase call,
switch(strType[1])
{
case 'u' : case 'U' : // whatever
break;
case 'l' : case 'L': // whatever
break;
default: break;
}
--
liz
 

Your function returns a signed long. No matter what the cast is the result
is placed into that value (the value of the variable 'longRtn').
Note that the bit pattern for a long and an unsigned long are identical.
The code you show is confusing as it seems to have no function. What are
you really trying to achieve with it? Show something in the source code
which calls the function, something which is sensitive to if it is a signed
vs an unsigned long.
. Ed

{smallsort}

I'm trying to have a function which will selectively return a signed or
unsigned representation of the number.
That is, I'd like to pass in 'S' and 65535 and have it return -1. Or pass
in U and -1 and have it return 65535.
Thanks,
Jeff
"Ed Mulroy" < XXXX@XXXXX.COM >wrote in message

"Jeff" < XXXX@XXXXX.COM >writes:
[Just some remarks that I haven't seen in this thread.]
fact, two char objects are written, including the terminating 0. Since
charTemp can only hold one, the program has undefined behavior.
What's wrong with the obvious
?
perfectly valid return value for some input.
Why not
- using assert() to abort the program if strType[0] has an unexpected
value, or
- throw an exception in that case, or
- change strType's type to bool or an appropriate enumeration type
 

On Mon, 7 Nov 2005 14:41:55 -0700, Jeff wrote:
--
liz
 

"Jeff" < XXXX@XXXXX.COM >wrote in message
you implicitally. So why do you need a function for it?
Also, in your example, 65535 is the same value for both 'signed long' and
'unsigned long'. Remember that a 'long' is a 32-bit value, and 65535 is a
valid 32-bit value for both signed and unsigned types. The kind of behavior
that you describe would have to be applied to a 'short' instead of a 'long',
ie:
signed short s_value = 65535; // s_value becomes -1
unsigned short u_value = -1; // u_value becomes 65535
signed short s_value2 = -1;
unsigned short u_value2 = static_cast<unsigned short>(s_value2); //
u_value2 becomes 65535
s_value2 = static_cast<signed short>(u_value2); // s_value becomes -1
Gambit
 

Casting is what I've done in the code I pasted, this doesn't work.
"liz" < XXXX@XXXXX.COM >wrote in message

On Mon, 7 Nov 2005 16:19:34 -0700, Jeff wrote:
are you really trying to do? The bit representation will be the same
whether it's signed or unsigned.
Why do you need signed (or unsigned)?
--
liz
 

"Jeff" < XXXX@XXXXX.COM >wrote in message
to you why - your function is always returning the same type of value
regardless of any casting, and your casting is using the wrong sized data
type for what you are trying to accomplish anyway.
Gambit
 

liz wrote:
defined (7.1.5.2)
I think you might be confusing it with char, where char is a distinct
type from both signed and unsigned char, and it is
implementation-defined whether it is a signed or unsigned type.
[Similarly for wchar_t, although it is even less clear what type is
'shadows']
--
AlisdairM(TeamB)
 

On 8 Nov 2005 03:34:36 -0700, Alisdair Meredith [TeamB] wrote:
--
liz
 

The problem is I have to return a signed variable, but I need to convert a
signed negative number into it's signed positive equivalent. For example,
with a -1 pass in, it should return 65535 and vice versa; both of which are
passed back in a signed variable.
"Remy Lebeau (TeamB)" < XXXX@XXXXX.COM >wrote in message

"Jeff" < XXXX@XXXXX.COM >wrote in message
both 'signed' and 'unsigned' long types. The only way to convert 65535
to -1 is if the function works with 16-bit values instead of 32-bit values.
In which case, the C++ language already handles thee conversion for you, so
you don't need a function.
conversions in the first place? You've been asked several timees now to
provide more details and a real example, but you have not provided them yet.
Gambit
 

*See comments below:
"Remy Lebeau (TeamB)" < XXXX@XXXXX.COM >wrote in message
program which *contains a scripting engine. The script expects a signed
value, and it's code that I *cannot change. This scripting program is used
to talk to custom hardware.
numbers which *are in two's complement representative unsigned form. I'm
trying to find a way to *translate these two's complement representative
unsigned numbers into their signed *representative equivalents so that I can
use them in straight forward math functions.
internal product *which contains intellectual property, and I can't divulge
every part of the code.