C program to find two's compliment - c

Question

I came across a C code in a book to find the two's complement of a binary number. I wasn't familiar with the concept of one's and two's complement of a binary number so I did a thorough research and now understand a fair bit about the same. But I still have a few doubts about how the code works. The code is as follows (the comments were not there in the original code and have been added by me so that I could be corrected if it's wrong)-
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
void main()
{
char a[16]; /*declaring an array to hold the binary number string*/
int i, j, k, len; /*len is the length of the string*/
printf ("Enter a binary number: ");
gets (a); /*reads the input string*/
len= strlen(a); /*calculates length of string*/
for (k=0; a[k]!='\0';k++) /*to check if its a valid binary number or not*/
{
if (a[k] != '0' && a[k]!='1')
{
printf ("\nIncorrect Binary format...this program will quit");
exit(0);
}
}
for (i=len-1; a[i]!='1'; i--) /* An empty for loop*/
;
for (j=i-1; j>=0; j--) /*checks from right to left if the bit is 0 or 1*/
{
if (a[j]=='1')
a[j]= '0'; /*if the bit is 1, its converted to 0*/
else
a[j]= '1'; /*if the bit is 0, its converted to 1*/
}
printf ("\n2's compliment = %s", a);
}
The code works absolutely fine, but I have doubts how.
First, I don't exactly understand what the empty for loop does. Does it counts till we encounter the first zero from the right side?
Second, in the third and last for loop, we just flip the value of each bit from 1 to 0 and from 0 to 1. But we do that for the one's complement, not the two's complement, right? We need to add 1 to the one's complement to find two's complement. The code dosen't seems to be doing that anywhere. How does it works then?
Kindly clearify, thanks in advance.

Answer 1

First, I don't exactly understand what the empty for loop does.
It is to find the rightmost 1 and assigns it to i.
Second, in the third and last for loop, we just flip the value of each
bit from 1 to 0 and from 0 to 1.
It is to flip all bits starting index i-1.
I have learnt the trick in my microprocessors course. It is that start read bits from right to left until see first bit which is 1. Don't flip it. After that, flip all bits.
Let's try, 10110 -> 01010
Start from right.
Read 0, it's not 1. Go ahead,
Read 1, yes, we get first bit which is 1. Don't flip it.
Read 1, flip it. Now it is 0.
Read 0, flip it. Now it is 1.
Read 1, flip it. Now it is 0.
We get 01010
The logic of the program is exactly what I mention.

Answer 2

Normally to compute the two's complement, we change all the 1's to 0's and all the 0's to 1, and then add 1.
Let's look at the two's complement of 172, or binary 10101100:
10101100
01010011 /* change all 0's to 1's and 1's to 0's */
01010100 /* add one */
Notice that when we added 1, we changed some of the 1's back to 0's. In fact, everything that had been a 0 at the right edge of the original number stayed 0. And the rightmost 1 in the original number stayed 1. And it was only the 1's and 0's to the left of the rightmost 1 that actually got swapped.
And that's what the mystery loop in the original program does. It scans from the right, skipping over 0's until it finds the first 1, and it's only the digits to the left of that point that it actually swaps. The variable i ends up holding the position of the rightmost 1, and then the next loop, the one that actually does the swapping, starts at j = i - 1.
One more thing: Sorry to nag about this, and you may know it already, but you really shouldn't use the gets() function, not even in a little test program. It's a truly horrid, dangerous function.