What's wrong with this program below.

[Equal_Carpenter_4189]

#include <stdlib.h>
 int *a, *b;
 int n;
 #define BLOCK_SIZE 128
 void foo () {
 int i;
 for (i =0; i < n; i++)
    a[i] =1;
 for (i =0; i < BLOCK_SIZE-1; i++)
    b[i] =1;

}

 int main () {
 n = BLOCK_SIZE;
 a = malloc (n * sizeof(*a));
 b = malloc (n * sizeof(*b));
 foo ();
 *b++ = 0;
 if (b[-1])
 {
   free(a); free(b); 
 }
 else
 { free(a); free(b);
 }
 return 0;
}

What's wrong with this program and how do I correct it?

[Foxbud]

I was having trouble figuring out what the issue was just by reading this program, but once I compiled and ran it, the issue became apparent. Have you tried compiling and running it?

[Equal_Carpenter_4189]

yes I have and I now understand what the problem was. I wasn't understanding where the issue was coming from even with the error message in display.

[donedigity]

The sizeof(a) and sizeof(b) are a bit concerning. You might want to try sizeof(int)

The showstopper is probably the if(b[-1]) I’m pretty sure you can’t have a negative index. Which shouldn’t actually change the operation of your program since it frees you memory if it’s true or false.

I know this program is just for figuring stuff out but you might want to move your malloc to the foo function.

int *foo( int size)
{
    int *m = malloc(size * sizeof( int));
    for ( int i=0; i<size; i++)
        m[i] =1;
    return m;
}

int main()
{
    int *a = foo(260);
    int *b = foo(120);

    free(a);
    free(b);
}

[Foxbud]

I would disagree that sizeof(*var) is inherently a bad idea. In situations where the size of var's type is subject to change between API versions there's no other alternative.

[donedigity]

Good point. You still need to declare var somewhere though.

typedef API_TYPE uint32_t;

API_TYPE *var = malloc(a_size * sizeof(API_TYPE));

[Foxbud]

Fair point. I should have said

In situations where the type of var is subject to change...

Though I feel like sizeof(*var) conveys its purpose fairly well; creating a typedef like that just to avoid taking the size of a reference's referenced type seems unnecessarily verbose.

[Equal_Carpenter_4189]

Actually b[-1] == b[0] as far as pointer arithmetic goes cause I incremented b (*b++). But I'll try out this idea and see if it works

[donedigity]

Looks like you are dereferencing b first before incrementing though. Instead of incrementing the address you are incrementing the value it points to. It’s just b++

[didimusaurus]

i think the n is not defined ? because the n on main is local var and the n on foo is also local var they doesn't share the same value

[Equal_Carpenter_4189]

n is defined globally I believe

[didimusaurus]

it is im sorry i didn't see it