for loop initialization failure

Question

I am trying to set index for the for loop to go over a char array. For some reason when I go to debug mode I see the variable i (I use it as index in the for loop) initialized to 0 and the step is i++ instead of i--.

Using ddd debugger on ubuntu.

I tried to set i to a constant and failed.

Answer 1

As mentioned in the top comments, there are a number of issues ...

1. You have UB (undefined behavior). You're going one beyond the end. Try changing for (i = num_bits; i >= 1; i--) into for (i = num_bits - 1; i >= 1; i--)
2. You are using big-endian for the input numbers but little-endian for the sum.
3. The a and b vectors use ascii values (e.g. '0'-'1') instead of binary (e.g. 0x00-0x01). And, the sum vector uses binary. These should match.
4. pow(2*Bin_Rep_sum[i],i) is wrong. Do you want: Bin_Rep_sum[i] * pow(2,i)??? Actually, this is still wrong

---

Because the code was posted as an image, and was missing some key elements, I had to completely restructure the code. It corrects all of the aforementioned issues:

#include <stdio.h>
#include <string.h>

typedef unsigned int u32;

#define BITS_PER_BYTE       8
#define BITV_SIZE_INP       (sizeof(u32) * BITS_PER_BYTE)
#define BITV_SIZE_CARRY     (BITV_SIZE_INP + 1)
typedef unsigned char bitv[BITV_SIZE_CARRY];

// uint_to_binary -- convert integer to bit vector
// RETURNS: leftmost one bit(?)
int
uint_to_binary(u32 x,bitv bin)
{

    memset(bin,0,BITV_SIZE_CARRY);

    int bit = 0;

    // store digits from right-to-left (LSB to MSB)
    for (;  x != 0;  x >>= 1, ++bit)
        bin[bit] = x & 1;

    return bit;
}

// my_add -- convert integers to bit vectors and compute bit vector sum
u32
my_add(u32 a,u32 b,bitv bin_sum)
{

    // convert a to bit vector
    bitv bin_a;
    uint_to_binary(a,bin_a);

    // convert b to bit vector
    bitv bin_b;
    uint_to_binary(b,bin_b);

    // zero out the sum
    uint_to_binary(0,bin_sum);

    u32 carry = 0;
    int bit = 0;

    for (;  bit < BITV_SIZE_INP;  ++bit) {
        // get the current digits
        u32 a = bin_a[bit];
        u32 b = bin_b[bit];

        // get the sum of the two numbers plus the carry in
        u32 sum = (a + b) + carry;

        // store the current digit
        bin_sum[bit] = sum & 1;

        // get carry out (for next round)
        carry = sum >> 1;
    }

    // store the final carry out
    bin_sum[bit] = carry;

    return carry;
}

// putbit -- output a single bit
void
putbit(u32 bit)
{
    bit = bit ? '1' : '0';
    fputc(bit,stdout);
}

// my_print -- print a bit vector
void
my_print(bitv bin)
{
    int bit = BITV_SIZE_CARRY - 1;

    putbit(bin[bit]);
    fputc('+',stdout);

    for (bit -= 1;  bit >= 0;  --bit)
        putbit(bin[bit]);
}

// dotest -- show an integer number
void
intshow(u32 x,const char *sym)
{

    putbit(0);
    fputc('+',stdout);

    for (int bit = BITV_SIZE_INP - 1;  bit >= 0;  --bit)
        putbit((x >> bit) & 1);

    printf(" %8.8X %s\n",x,sym);
}

// dotest -- test a single addition
void
dotest(u32 a,u32 b)
{
    u32 sum = a + b;

    // show the original input numbers
    intshow(a,"a");
    intshow(b,"b");
    intshow(sum,"sum");

    // get the sum
    bitv bin_sum;
    my_add(a,b,bin_sum);

    // show the bit vector sum
    my_print(bin_sum);
    printf(" bin_sum\n");

    printf("\n");
}

int
main(void)
{

    dotest(1,2);
    dotest(2,2);
    dotest(3,7);
    dotest(0xFFFFFFFE,1);
    dotest(0xFFFFFFFF,1);
    dotest(0xFFFFFFFF,0xFFFFFFFF);

    return 0;
}

---

Here is the test program output:

0+00000000000000000000000000000001 00000001 a
0+00000000000000000000000000000010 00000002 b
0+00000000000000000000000000000011 00000003 sum
0+00000000000000000000000000000011 bin_sum

0+00000000000000000000000000000010 00000002 a
0+00000000000000000000000000000010 00000002 b
0+00000000000000000000000000000100 00000004 sum
0+00000000000000000000000000000100 bin_sum

0+00000000000000000000000000000011 00000003 a
0+00000000000000000000000000000111 00000007 b
0+00000000000000000000000000001010 0000000A sum
0+00000000000000000000000000001010 bin_sum

0+11111111111111111111111111111110 FFFFFFFE a
0+00000000000000000000000000000001 00000001 b
0+11111111111111111111111111111111 FFFFFFFF sum
0+11111111111111111111111111111111 bin_sum

0+11111111111111111111111111111111 FFFFFFFF a
0+00000000000000000000000000000001 00000001 b
0+00000000000000000000000000000000 00000000 sum
1+00000000000000000000000000000000 bin_sum

0+11111111111111111111111111111111 FFFFFFFF a
0+11111111111111111111111111111111 FFFFFFFF b
0+11111111111111111111111111111110 FFFFFFFE sum
1+11111111111111111111111111111110 bin_sum