457,750 Members | 977 Online Need help? Post your question and get tips & solutions from a community of 457,750 IT Pros & Developers. It's quick & easy.

# Conversion rules between unsigned operands and signed operand

 P: n/a Hi All, I am trying to undestand "Type Conversions" from K&R book.I am not able to understand the bellow mentioned text "Conversion rules are more complicated when unsigned operands are involved. The problem is that comparisons between signed and unsigned values are machine- dependent, because they depend on the sizes of the various integer types. For example, suppose that int is 16 bits and long is 32 bits. Then -1L < 1U, because 1U, which is an unsigned int, is promoted to a signed long. But -1L 1UL because -1L is promoted to unsigned long and thus appears to be a large positive number" To understand it i wrote a small code #include int main(void) { signed long sl = -5; unsigned long ul= 5; if (sl>ul) { printf("\n -5 is greater than 5\n"); } else { printf("-5 is less than 5 \n"); } return 0; } OP is -5 is greater than 5 Could anybody help me to understand the conversion rules when unsigned operands are involved ? Regards, Somenath Jul 23 '07 #1
7 Replies

 P: n/a somenath wrote: > Hi All, I am trying to undestand "Type Conversions" from K&R book.I am not able to understand the bellow mentioned text "Conversion rules are more complicated when unsigned operands are involved. The problem is that comparisons between signed and unsigned values are machine- dependent, because they depend on the sizes of the various integer types. For example, suppose that int is 16 bits and long is 32 bits. Then -1L < 1U, because 1U, which is an unsigned int, is promoted to a signed long. But -1L 1UL because -1L is promoted to unsigned long and thus appears to be a large positive number" To understand it i wrote a small code #include int main(void) { signed long sl = -5; unsigned long ul= 5; if (sl>ul) { printf("\n -5 is greater than 5\n"); } else { printf("-5 is less than 5 \n"); } return 0; } OP is -5 is greater than 5 Could anybody help me to understand the conversion rules when unsigned operands are involved ? "rank" is the missing word here. To compare two expressions, they must be converted to the same type. The rule for comparing two exressions is simple, and signed or unsigned types do not form any exceptions to this rule: The lower ranking type is converted to the higher ranking type. The above text about comparisons being machine dependent because of sizes, is wrong. For example, suppose that int and long are both 32 bits. Then -1L < 1U, because 1U, which is an unsigned int, is *converted* (not promoted) to a signed long, and it has absolutely nothing to do with whether or not int and long are the same size. "Integer promotions" on the other hand, which are distinct from the kind of conversions performed on an operand of a relational operator, are dependent upon whether or not type int can represent all the positive values of the lower ranking type. N869 6.3.1 Arithmetic operands 6.3.1.1 Boolean, characters, and integers [#1] Every integer type has an integer conversion rank defined as follows: -- No two signed integer types shall have the same rank, even if they have the same representation. -- The rank of a signed integer type shall be greater than the rank of any signed integer type with less precision. -- The rank of long long int shall be greater than the rank of long int, which shall be greater than the rank of int, which shall be greater than the rank of short int, which shall be greater than the rank of signed char. -- The rank of any unsigned integer type shall equal the rank of the corresponding signed integer type, if any. -- The rank of any standard integer type shall be greater than the rank of any extended integer type with the same width. -- The rank of char shall equal the rank of signed char and unsigned char. -- The rank of _Bool shall be less than the rank of all other standard integer types. -- The rank of any enumerated type shall equal the rank of the compatible integer type (see 6.7.2.2). -- The rank of any extended signed integer type relative to another extended signed integer type with the same precision is implementation-defined, but still subject to the other rules for determining the integer conversion rank. -- For all integer types T1, T2, and T3, if T1 has greater rank than T2 and T2 has greater rank than T3, then T1 has greater rank than T3. /* BEGIN new.c */ #include #include int main(void) { signed long sl = -5; unsigned u = 5; if (sl u) { puts("-5 is greater than 5"); } else { puts("-5 is less than 5"); } printf("LONG_MAX is %ld\n", LONG_MAX); printf("UINT_MAX is %u \n", UINT_MAX); return 0; } /* END new.c */ On my machine the output of new.c is: -5 is greater than 5 LONG_MAX is 2147483647 UINT_MAX is 4294967295 The unsigned type is converted to the long signed type, even though on my machine, they have the same size and number of bits. -- pete Jul 23 '07 #2

 P: n/a On Jul 23, 12:37 pm, pete int main(void) { signed long sl = -5; unsigned long ul= 5; if (sl>ul) { printf("\n -5 is greater than 5\n"); } else { printf("-5 is less than 5 \n"); } return 0; } OP is -5 is greater than 5 Could anybody help me to understand the conversion rules when unsigned operands are involved ? "rank" is the missing word here. To compare two expressions, they must be converted to the same type. The rule for comparing two exressions is simple, and signed or unsigned types do not form any exceptions to this rule: The lower ranking type is converted to the higher ranking type. The above text about comparisons being machine dependent because of sizes, is wrong. For example, suppose that int and long are both 32 bits. Then -1L < 1U, because 1U, which is an unsigned int, is *converted* (not promoted) to a signed long, and it has absolutely nothing to do with whether or not int and long are the same size. "Integer promotions" on the other hand, which are distinct from the kind of conversions performed on an operand of a relational operator, are dependent upon whether or not type int can represent all the positive values of the lower ranking type. N869 6.3.1 Arithmetic operands 6.3.1.1 Boolean, characters, and integers [#1] Every integer type has an integer conversion rank defined as follows: -- No two signed integer types shall have the same rank, even if they have the same representation. -- The rank of a signed integer type shall be greater than the rank of any signed integer type with less precision. -- The rank of long long int shall be greater than the rank of long int, which shall be greater than the rank of int, which shall be greater than the rank of short int, which shall be greater than the rank of signed char. -- The rank of any unsigned integer type shall equal the rank of the corresponding signed integer type, if any. -- The rank of any standard integer type shall be greater than the rank of any extended integer type with the same width. -- The rank of char shall equal the rank of signed char and unsigned char. -- The rank of _Bool shall be less than the rank of all other standard integer types. -- The rank of any enumerated type shall equal the rank of the compatible integer type (see 6.7.2.2). -- The rank of any extended signed integer type relative to another extended signed integer type with the same precision is implementation-defined, but still subject to the other rules for determining the integer conversion rank. -- For all integer types T1, T2, and T3, if T1 has greater rank than T2 and T2 has greater rank than T3, then T1 has greater rank than T3. /* BEGIN new.c */ #include #include int main(void) { signed long sl = -5; unsigned u = 5; if (sl u) { puts("-5 is greater than 5"); } else { puts("-5 is less than 5"); } printf("LONG_MAX is %ld\n", LONG_MAX); printf("UINT_MAX is %u \n", UINT_MAX); return 0; } /* END new.c */ On my machine the output of new.c is: -5 is greater than 5 LONG_MAX is 2147483647 UINT_MAX is 4294967295 The unsigned type is converted to the long signed type, even though on my machine, they have the same size and number of bits. Hi Pete, Many thanks for this information. But i am still not able to understand the comparision. As par my signed long has higher rank than unsigned int . so "u" will be converted to Signed long .Does it mean the value of "u" which is 5 will be converted to -5 ? Even then how "if (sl u)" is true ? Regards, Somenath Jul 24 '07 #3

 P: n/a somenath wrote: > On Jul 23, 12:37 pm, pete int main(void) { signed long sl = -5; unsigned long ul= 5; if (sl>ul) { printf("\n -5 is greater than 5\n"); } else { printf("-5 is less than 5 \n"); } return 0; } OP is -5 is greater than 5 Could anybody help me to understand the conversion rules when unsigned operands are involved ? "rank" is the missing word here. To compare two expressions, they must be converted to the same type. The rule for comparing two exressions is simple, and signed or unsigned types do not form any exceptions to this rule: The lower ranking type is converted to the higher ranking type. The above text about comparisons being machine dependent because of sizes, is wrong. For example, suppose that int and long are both 32 bits. Then -1L < 1U, because 1U, which is an unsigned int, is *converted* (not promoted) to a signed long, and it has absolutely nothing to do with whether or not int and long are the same size. "Integer promotions" on the other hand, which are distinct from the kind of conversions performed on an operand of a relational operator, are dependent upon whether or not type int can represent all the positive values of the lower ranking type. N869 6.3.1 Arithmetic operands 6.3.1.1 Boolean, characters, and integers [#1] Every integer type has an integer conversion rank defined as follows: -- No two signed integer types shall have the same rank, even if they have the same representation. -- The rank of a signed integer type shall be greater than the rank of any signed integer type with less precision. -- The rank of long long int shall be greater than the rank of long int, which shall be greater than the rank of int, which shall be greater than the rank of short int, which shall be greater than the rank of signed char. -- The rank of any unsigned integer type shall equal the rank of the corresponding signed integer type, if any. -- The rank of any standard integer type shall be greater than the rank of any extended integer type with the same width. -- The rank of char shall equal the rank of signed char and unsigned char. -- The rank of _Bool shall be less than the rank of all other standard integer types. -- The rank of any enumerated type shall equal the rank of the compatible integer type (see 6.7.2.2). -- The rank of any extended signed integer type relative to another extended signed integer type with the same precision is implementation-defined, but still subject to the other rules for determining the integer conversion rank. -- For all integer types T1, T2, and T3, if T1 has greater rank than T2 and T2 has greater rank than T3, then T1 has greater rank than T3. /* BEGIN new.c */ #include #include int main(void) { signed long sl = -5; unsigned u = 5; if (sl u) { puts("-5 is greater than 5"); } else { puts("-5 is less than 5"); } printf("LONG_MAX is %ld\n", LONG_MAX); printf("UINT_MAX is %u \n", UINT_MAX); return 0; } /* END new.c */ On my machine the output of new.c is: -5 is greater than 5 LONG_MAX is 2147483647 UINT_MAX is 4294967295 The unsigned type is converted to the long signed type, even though on my machine, they have the same size and number of bits. Hi Pete, Many thanks for this information. But i am still not able to understand the comparision. As par my signed long has higher rank than unsigned int . so "u" will be converted to Signed long .Does it mean the value of "u" which is 5 will be converted to -5 ? Even then how "if (sl u)" is true ? The answer is simple: I was wrong. The rules are more complicated. Both sl and u get converted to type long unsigned in the above expression on my machine. The reason is because on my machine, signed long can't represent the entire range of unsigned values. The conversion in question, is called "the usual arithmetic conversions". N869 6.3.1.8 Usual arithmetic conversions [#1] Many operators that expect operands of arithmetic type cause conversions and yield result types in a similar way. The purpose is to determine a common real type for the operands and result. For the specified operands, each operand is converted, without change of type domain, to a type whose corresponding real type is the common real type. Unless explicitly stated otherwise, the common real type is also the corresponding real type of the result, whose type domain is the type domain of the operands if they are the same, and complex otherwise. This pattern is called the usual arithmetic conversions: First, if the corresponding real type of either operand is long double, the other operand is converted, without change of type domain, to a type whose corresponding real type is long double. Otherwise, if the corresponding real type of either operand is double, the other operand is converted, without change of type domain, to a type whose corresponding real type is double. Otherwise, if the corresponding real type of either operand is float, the other operand is converted, without change of type domain, to a type whose corresponding real type is float. Otherwise, the integer promotions are performed on both operands. Then the following rules are applied to the promoted operands: If both operands have the same type, then no further conversion is needed. Otherwise, if both operands have signed integer types or both have unsigned integer types, the operand with the type of lesser integer conversion rank is converted to the type of the operand with greater rank. Otherwise, if the operand that has unsigned integer type has rank greater or equal to the rank of the type of the other operand, then the operand with signed integer type is converted to the type of the operand with unsigned integer type. Otherwise, if the type of the operand with signed integer type can represent all of the values of the type of the operand with unsigned integer type, then the operand with unsigned integer type is converted to the type of the operand with signed integer type. Otherwise, both operands are converted to the unsigned integer type corresponding to the type of the operand with signed integer type. -- pete Jul 25 '07 #4

 P: n/a On Jul 25, 8:35 am, pete int main(void) { signed long sl = -5; unsigned long ul= 5; if (sl>ul) { printf("\n -5 is greater than 5\n"); } else { printf("-5 is less than 5 \n"); } return 0; } OP is -5 is greater than 5 Could anybody help me to understand the conversion rules when unsigned operands are involved ? "rank" is the missing word here. To compare two expressions, they must be converted to the same type. The rule for comparing two exressions is simple, and signed or unsigned types do not form any exceptions to this rule: The lower ranking type is converted to the higher ranking type. The above text about comparisons being machine dependent because of sizes, is wrong. For example, suppose that int and long are both 32 bits. Then -1L < 1U, because 1U, which is an unsigned int, is *converted* (not promoted) to a signed long, and it has absolutely nothing to do with whether or not int and long are the same size. "Integer promotions" on the other hand, which are distinct from the kind of conversions performed on an operand of a relational operator, are dependent upon whether or not type int can represent all the positive values of the lower ranking type. N869 6.3.1 Arithmetic operands 6.3.1.1 Boolean, characters, and integers [#1] Every integer type has an integer conversion rank defined as follows: -- No two signed integer types shall have the same rank, even if they have the same representation. -- The rank of a signed integer type shall be greater than the rank of any signed integer type with less precision. -- The rank of long long int shall be greater than the rank of long int, which shall be greater than the rank of int, which shall be greater than the rank of short int, which shall be greater than the rank of signed char. -- The rank of any unsigned integer type shall equal the rank of the corresponding signed integer type, if any. -- The rank of any standard integer type shall be greater than the rank of any extended integer type with the same width. -- The rank of char shall equal the rank of signed char and unsigned char. -- The rank of _Bool shall be less than the rank of all other standard integer types. -- The rank of any enumerated type shall equal the rank of the compatible integer type (see 6.7.2.2). -- The rank of any extended signed integer type relative to another extended signed integer type with the same precision is implementation-defined, but still subject to the other rules for determining the integer conversion rank. -- For all integer types T1, T2, and T3, if T1 has greater rank than T2 and T2 has greater rank than T3, then T1 has greater rank than T3. /* BEGIN new.c */ #include #include int main(void) { signed long sl = -5; unsigned u = 5; if (sl u) { puts("-5 is greater than 5"); } else { puts("-5 is less than 5"); } printf("LONG_MAX is %ld\n", LONG_MAX); printf("UINT_MAX is %u \n", UINT_MAX); return 0; } /* END new.c */ On my machine the output of new.c is: -5 is greater than 5 LONG_MAX is 2147483647 UINT_MAX is 4294967295 The unsigned type is converted to the long signed type, even though on my machine, they have the same size and number of bits. Hi Pete, Many thanks for this information. But i am still not able to understand the comparision. As par my signed long has higher rank than unsigned int . so "u" will be converted to Signed long .Does it mean the value of "u" which is 5 will be converted to -5 ? Even then how "if (sl u)" is true ? The answer is simple: I was wrong. The rules are more complicated. Both sl and u get converted to type long unsigned in the But does it mean -5 will be converted to 5 ? Even then how "if (sl u)" is true ? Jul 25 '07 #5

 P: n/a On Jul 25, 8:35 am, pete int main(void) { signed long sl = -5; unsigned long ul= 5; if (sl>ul) { printf("\n -5 is greater than 5\n"); } else { printf("-5 is less than 5 \n"); } return 0; } OP is -5 is greater than 5 Could anybody help me to understand the conversion rules when unsigned operands are involved ? "rank" is the missing word here. To compare two expressions, they must be converted to the same type. The rule for comparing two exressions is simple, and signed or unsigned types do not form any exceptions to this rule: The lower ranking type is converted to the higher ranking type. The above text about comparisons being machine dependent because of sizes, is wrong. For example, suppose that int and long are both 32 bits. Then -1L < 1U, because 1U, which is an unsigned int, is *converted* (not promoted) to a signed long, and it has absolutely nothing to do with whether or not int and long are the same size. "Integer promotions" on the other hand, which are distinct from the kind of conversions performed on an operand of a relational operator, are dependent upon whether or not type int can represent all the positive values of the lower ranking type. N869 6.3.1 Arithmetic operands 6.3.1.1 Boolean, characters, and integers [#1] Every integer type has an integer conversion rank defined as follows: -- No two signed integer types shall have the same rank, even if they have the same representation. -- The rank of a signed integer type shall be greater than the rank of any signed integer type with less precision. -- The rank of long long int shall be greater than the rank of long int, which shall be greater than the rank of int, which shall be greater than the rank of short int, which shall be greater than the rank of signed char. -- The rank of any unsigned integer type shall equal the rank of the corresponding signed integer type, if any. -- The rank of any standard integer type shall be greater than the rank of any extended integer type with the same width. -- The rank of char shall equal the rank of signed char and unsigned char. -- The rank of _Bool shall be less than the rank of all other standard integer types. -- The rank of any enumerated type shall equal the rank of the compatible integer type (see 6.7.2.2). -- The rank of any extended signed integer type relative to another extended signed integer type with the same precision is implementation-defined, but still subject to the other rules for determining the integer conversion rank. -- For all integer types T1, T2, and T3, if T1 has greater rank than T2 and T2 has greater rank than T3, then T1 has greater rank than T3. /* BEGIN new.c */ #include #include int main(void) { signed long sl = -5; unsigned u = 5; if (sl u) { puts("-5 is greater than 5"); } else { puts("-5 is less than 5"); } printf("LONG_MAX is %ld\n", LONG_MAX); printf("UINT_MAX is %u \n", UINT_MAX); return 0; } /* END new.c */ On my machine the output of new.c is: -5 is greater than 5 LONG_MAX is 2147483647 UINT_MAX is 4294967295 The unsigned type is converted to the long signed type, even though on my machine, they have the same size and number of bits. Hi Pete, Many thanks for this information. But i am still not able to understand the comparision. As par my signed long has higher rank than unsigned int . so "u" will be converted to Signed long .Does it mean the value of "u" which is 5 will be converted to -5 ? Even then how "if (sl u)" is true ? The answer is simple: I was wrong. The rules are more complicated. Both sl and u get converted to type long unsigned in the But does it mean -5 will be converted to 5 ? Even then how "if (sl u)" is true ? Jul 25 '07 #6

 P: n/a somenath wrote: > On Jul 25, 8:35 am, pete int main(void) { signed long sl = -5; unsigned long ul= 5; if (sl>ul) { printf("\n -5 is greater than 5\n"); } else { printf("-5 is less than 5 \n"); } return 0; } OP is -5 is greater than 5 Could anybody help me to understand the conversion rules when unsigned operands are involved ? "rank" is the missing word here. To compare two expressions, they must be converted to the same type. The rule for comparing two exressions is simple, and signed or unsigned types do not form any exceptions to this rule: The lower ranking type is converted to the higher ranking type. The above text about comparisons being machine dependent because of sizes, is wrong. For example, suppose that int and long are both 32 bits. Then -1L < 1U, because 1U, which is an unsigned int, is *converted* (not promoted) to a signed long, and it has absolutely nothing to do with whether or not int and long are the same size. "Integer promotions" on the other hand, which are distinct from the kind of conversions performed on an operand of a relational operator, are dependent upon whether or not type int can represent all the positive values of the lower ranking type. N869 6.3.1 Arithmetic operands 6.3.1.1 Boolean, characters, and integers [#1] Every integer type has an integer conversion rank defined as follows: -- No two signed integer types shall have the same rank, even if they have the same representation. -- The rank of a signed integer type shall be greater than the rank of any signed integer type with less precision. -- The rank of long long int shall be greater than the rank of long int, which shall be greater than the rank of int, which shall be greater than the rank of short int, which shall be greater than the rank of signed char. -- The rank of any unsigned integer type shall equal the rank of the corresponding signed integer type, if any. -- The rank of any standard integer type shall be greater than the rank of any extended integer type with the same width. -- The rank of char shall equal the rank of signed char and unsigned char. -- The rank of _Bool shall be less than the rank of all other standard integer types. -- The rank of any enumerated type shall equal the rank of the compatible integer type (see 6.7.2.2). -- The rank of any extended signed integer type relative to another extended signed integer type with the same precision is implementation-defined, but still subject to the other rules for determining the integer conversion rank. -- For all integer types T1, T2, and T3, if T1 has greater rank than T2 and T2 has greater rank than T3, then T1 has greater rank than T3. /* BEGIN new.c */ #include #include int main(void) { signed long sl = -5; unsigned u = 5; if (sl u) { puts("-5 is greater than 5"); } else { puts("-5 is less than 5"); } printf("LONG_MAX is %ld\n", LONG_MAX); printf("UINT_MAX is %u \n", UINT_MAX); return 0; } /* END new.c */ On my machine the output of new.c is: -5 is greater than 5 LONG_MAX is 2147483647 UINT_MAX is 4294967295 The unsigned type is converted to the long signed type, even though on my machine, they have the same size and number of bits. Hi Pete, Many thanks for this information. But i am still not able to understand the comparision. As par my signed long has higher rank than unsigned int . so "u" will be converted to Signed long .Does it mean the value of "u" which is 5 will be converted to -5 ? Even then how "if (sl u)" is true ? The answer is simple: I was wrong. The rules are more complicated. Both sl and u get converted to type long unsigned in the But does it mean -5 will be converted to 5 ? No. The converted expression is equal to ((long unsigned)-5). Even then how "if (sl u)" is true ? The rule for converting a negative value to an unsigned integer type is to add (1 + UNSIGNED_INTEGER_TYPE_MAX) repeatedly to the negative value until it is not negative any more. -5 gets converted to 4294967291LU -- pete Jul 25 '07 #7

 P: n/a On Jul 25, 3:35 pm, pete int main(void) { signed long sl = -5; unsigned long ul= 5; if (sl>ul) { printf("\n -5 is greater than 5\n"); } else { printf("-5 is less than 5 \n"); } return 0; } OP is -5 is greater than 5 Could anybody help me to understand the conversion rules when unsigned operands are involved ? "rank" is the missing word here. To compare two expressions, they must be converted to the same type. The rule for comparing two exressions is simple, and signed or unsigned types do not form any exceptions to this rule: The lower ranking type is converted to the higher ranking type. The above text about comparisons being machine dependent because of sizes, is wrong. For example, suppose that int and long are both 32 bits. Then -1L < 1U, because 1U, which is an unsigned int, is *converted* (not promoted) to a signed long, and it has absolutely nothing to do with whether or not int and long are the same size. "Integer promotions" on the other hand, which are distinct from the kind of conversions performed on an operand of a relational operator, are dependent upon whether or not type int can represent all the positive values of the lower ranking type. N869 6.3.1 Arithmetic operands 6.3.1.1 Boolean, characters, and integers [#1] Every integer type has an integer conversion rank defined as follows: -- No two signed integer types shall have the same rank, even if they have the same representation. -- The rank of a signed integer type shall be greater than the rank of any signed integer type with less precision. -- The rank of long long int shall be greater than the rank of long int, which shall be greater than the rank of int, which shall be greater than the rank of short int, which shall be greater than the rank of signed char. -- The rank of any unsigned integer type shall equal the rank of the corresponding signed integer type, if any. -- The rank of any standard integer type shall be greater than the rank of any extended integer type with the same width. -- The rank of char shall equal the rank of signed char and unsigned char. -- The rank of _Bool shall be less than the rank of all other standard integer types. -- The rank of any enumerated type shall equal the rank of the compatible integer type (see 6.7.2.2). -- The rank of any extended signed integer type relative to another extended signed integer type with the same precision is implementation-defined, but still subject to the other rules for determining the integer conversion rank. -- For all integer types T1, T2, and T3, if T1 has greater rank than T2 and T2 has greater rank than T3, then T1 has greater rank than T3. /* BEGIN new.c */ #include #include int main(void) { signed long sl = -5; unsigned u = 5; if (sl u) { puts("-5 is greater than 5"); } else { puts("-5 is less than 5"); } printf("LONG_MAX is %ld\n", LONG_MAX); printf("UINT_MAX is %u \n", UINT_MAX); return 0; } /* END new.c */ On my machine the output of new.c is: -5 is greater than 5 LONG_MAX is 2147483647 UINT_MAX is 4294967295 The unsigned type is converted to the long signed type, even though on my machine, they have the same size and number of bits. Hi Pete, Many thanks for this information. But i am still not able to understand the comparision. As par my signed long has higher rank than unsigned int . so "u" will be converted to Signed long .Does it mean the value of "u" which is 5 will be converted to -5 ? Even then how "if (sl u)" is true ? The answer is simple: I was wrong. The rules are more complicated. Both sl and u get converted to type long unsigned in the But does it mean -5 will be converted to 5 ? No. The converted expression is equal to ((long unsigned)-5). Even then how "if (sl u)" is true ? The rule for converting a negative value to an unsigned integer type is to add (1 + UNSIGNED_INTEGER_TYPE_MAX) repeatedly to the negative value until it is not negative any more. -5 gets converted to 4294967291LU But is this rules applies to largest negative number such as -2147483648 ? then what will be the result when it is converted to unsigned integer type? Jul 30 '07 #8

### This discussion thread is closed

Replies have been disabled for this discussion. 