This post demonstrates how to count the number of 0s and 1s in the binary representation of an integer using inline assembly in a C++ program. This is an excellent example of bit-level operations using low-level assembly instructions.

#include<iostream.h>
#include<conio.h>

void main()
{
    int ip, n0, n1;
    cout << "\n Enter Input:";
    cin >> ip;

    asm {
        mov ax, ip       // Move input number into AX register
        mov bx, 00h      // Initialize BX (zero counter) to 0
        mov cx, 10h      // Set CX as loop counter (16 iterations for 16 bits)
        mov dx, 00h      // Initialize DX (one counter) to 0
    }

up:
    asm {
        rol ax, 1        // Rotate AX left by 1 bit (MSB to LSB)
        jc one           // If carry flag is set, it's a 1 (go to one)
        inc bx           // Otherwise, increment zero counter
        jmp nxt          // Jump to nxt
    }
one:
    asm {
        inc dx           // Increment one counter
    }
nxt:
    asm {
        dec cx           // Decrement loop counter
        jnz up           // If CX not zero, repeat loop
        mov n0, bx       // Move final zero count to n0
        mov n1, dx       // Move final one count to n1
    }

    cout << "\n No of zeros:" << n0;
    cout << "\n No of ones:" << n1;
    getch();
}

Understanding the Code

Variable Declarations

• int ip → Stores the user input.
• int n0, n1 → Used to store the number of 0s and 1s, respectively.

User Input

• Prompts the user to enter a number, which is stored in ip.

Inline Assembly Instructions Explanation (8086)

• mov ax, ip → Moves the value of ip into register AX.
• mov bx, 00h → Initializes BX register (used to count zeros) to 0.
• mov cx, 10h → Initializes CX with 0x10 (16 decimal), the number of bits to check.
• mov dx, 00h → Initializes DX register (used to count ones) to 0.

Loop Logic

• rol ax, 1 → Rotates AX register left by 1 bit. The MSB becomes the LSB, and the previous MSB is stored in the carry flag (CF).
• jc one → Jumps to label one if the carry flag is set, indicating a 1.
• inc bx → Increments BX register if the current bit is 0.
• jmp nxt → Jumps to label nxt to continue looping.
• inc dx → Increments DX register if the current bit is 1.
• dec cx → Decrements the loop counter.
• jnz up → Jumps back to the label up if CX is not zero.
• mov n0, bx → Moves the zero count from BX to variable n0.
• mov n1, dx → Moves the one count from DX to variable n1.

Output Display

Outputs the number of zeros and ones in the binary representation of the input number..

Output

Enter Input:12
No of zeros:14
No of ones:2

Output Explanation

If you enter 12, its binary representation is 0000 0000 0000 1100. Out of the 16 bits, 14 are 0s and 2 are 1s. The program successfully counts each using inline assembly and displays the result.