• C

# bitwise operator--complement

I want to use bitwise operator--complement on an integer array. Here is my code:

#include <stdio.h>
int number[100];
unsigned char temp[100],complement[100];

main()
{
number[1]=23;
/*type cast integer*/
temp[1]=(unsigned char)(number[1]);
/*use complement operator*/
complement[1]=~temp[1];
printf("u%",complement[1]);
return 0;
}

I didn't get the correct result,.Is there anything wrong?

Thanks, --km

###### Who is Participating?

Commented:
I feel that what ozo and fremsley said r correct.

that is change u% to %u, u will get the correct answer 232. If that is not the answer u r looking to, then u views r wrong.

Integer is of 2 bytes, when u assign an integer to a character, the character gets allocated the least significant byte. In integer 23, the 2 bytes r as follows

00000000 00010111

so the characters get the least significant byte 00010111. When u complement it the value will be 1110100, which is equivalent to 232 in decimal.

I hope u understood. If u want to take the complement of the whole integer, then the sign bit will be taken into account, and u will get a negative answer, since the sign bit gets complemented.
0

Commented:
kxm try this:
#include <stdio.h>
int number[100];
main()
{
number[1]=23;
printf("%d", ~number[1]);
}
0

Commented:
What result *are* you getting?
0

Commented:
changing "u%" to "%u" gets the correct result 232
0

Commented:
Ur program works correct:
23  = 00010111
232 = 11101000

0

Commented:
i guess 'u%' was just a typo.

complement[1] is of type unsigned char, so printf only pushes 8 significant bits as parameter on the stack; the '%u' tells printf to treat the parameter as an unsigned int (usually 32 significant bits). so try:

printf("%u", (unsigned int)(complement[i]));

0

Commented:
kxm, note that your code only converts the lo-byte of the integer.
0

Commented:
Note further that you shouldn't really muck about with the sign bit of a signed int.

If you're going to twiddle bits, do it on unsigned types.

Here's a safe bit-twiddler:

unsigned int bitwiseNot(unsigned int n)
{
return ~n;
}

Wow, that was a tough one. :-)

0

Commented:
An int is not necessarily two bytes. It's sizeof(int) bytes. Under Visual C++ 1.5, that gives you a value of 2. Under Visual C++ 5.0, it gives you a value of 4. On a Cray, sizeof(int) is 8.

Furthermore, bear in mind that bytes don't necessarily have 8 bits. They have /at least/ 8 bits. To find out how many bits per byte in your implementation, print out the value of CHAR_BIT (in <limits.h>). Of course, it's 99 chances out of 100 that it'll be 8! :-)

The problem with twiddling bits on an int is that you are assuming your representation is twos complement. On ones complement machines, you'll get a totally different result. Hence my earlier admonition.

I certainly agree that changing u% to %u is likely to result in more effective display of the result. <grin>
0

Author Commented:
Thanks
0
Question has a verified solution.

Are you are experiencing a similar issue? Get a personalized answer when you ask a related question.

Have a better answer? Share it in a comment.