Realloc with an array of pointers in a struct

I think your declarations are wrong. The following line assumes that ptr points to some memory when in fact it has not been initialized at all!

var->ptr[0] = &a;

If your compiler supports it, shouldn't it be more like this instead:

typedef struct{
    int size;
    int* ptr[0];
}foo;

Otherwise, change ptr[0] to ptr[1], and adjust your calculations based on the fact that the structure already includes one element.

Note: Once you write to a wrong address, the result is undefined. You have a problem there but it only happens to show up in one case. The problem is still there in both cases.

The problem is that you are not assigning ptr to point at anything, so it points to random memory, and any access of ptr[index] is undefined behavior.

Changing the declaration of ptr like Jonathan's answer suggested is the safest option, eg:

typedef struct{
    int size;
    int* ptr[1]; // or 0 if your compiler supports it
}foo;

int main()
{
    foo *var;

    var = malloc(offsetof(foo, ptr));
    if (var) {
        var->size = 0;
        ...
    }

    foo *newvar = realloc(var, offsetof(foo, ptr) + (2 * sizeof(int*)));
    if (newvar) {
        var = newvar;
        var->size = 2;

        int a = 3, b = 6;

        var->ptr[0] = &a; // <-- OK!
        var->ptr[1] = &b; // <-- OK!

        printf("%d %d\n", *(var->ptr[0]), *(var->ptr[1]));
    }

    free(var);
    return 0;
}

But, if for whatever reason, you can't change the declaration of ptr (foo is used with an existing API, for instance), then you can do this instead:

typedef struct{
    int size;
    int **ptr;
}foo;

int main()
{
    foo *var = malloc(sizeof(foo));
    if (var) {
        var->size = 0;
        var->ptr = NULL; // <-- add this!
        ...
    }

    foo *newvar = realloc(var, sizeof(foo) + (2 * sizeof(int*)));
    if (newvar) {
        var = newvar;
        var->size = 2;
        var->ptr = (int**)(var + 1); // <-- add this!

        int a = 3, b = 6;

        var->ptr[0] = &a; // <-- OK!
        var->ptr[1] = &b; // <-- OK!

        printf("%d %d\n", *(var->ptr[0]), *(var->ptr[1]));
    }

    free(var);
    return 0;
}

In this latter case, make sure you do the same ptr assignment every time you want to (re)allocate var. I would wrap that logic in a set of helper functions, eg:

typedef struct{
    int size;
    int **ptr;
}foo;

foo* createFoo(int size)
{
    foo *var = malloc(sizeof(foo) + (size * sizeof(int*)));
    if (var) {
        var->size = size;
        var->ptr = (int**)(var + 1);
    }
    return var;
}

foo* resizeFoo(foo **var, int newSize)
{
    foo *newvar = realloc(*var, sizeof(foo) + (newSize * sizeof(int*)));
    if (newvar) {
        newvar->size = newSize;
        newvar->ptr = (int**)(newvar + 1);
        *var = newvar;
    }
    return newvar;
}

int main()
{
    foo *var = createFoo(0);
    ...

    if (resizeFoo(&var, 2)) {
        int a = 3, b = 6;

        var->ptr[0] = &a; // <-- OK!
        var->ptr[1] = &b; // <-- OK!

        printf("%d %d\n", *(var->ptr[0]), *(var->ptr[1]));
    }

    free(var);
    return 0;
}

You need to fix the struct:

typedef struct{
    int size;
    int *ptr;
}foo;

And the code:

 var = malloc(sizeof(foo));
 var->ptr = malloc(2 * sizeof(int));

 int a = 3, b = 6;
 // store a and b in array, not their addresses
 var->ptr[0] = a;
 var->ptr[1] = b;

Assuming you want 2 entries in the array. And of course, ignoring the fact that I am not testing the result of malloc().

If you want to resize the array, just realloc var->ptr instead of var.

In Visual Studio, Windows 10, both of your examples doesn't work. This is because the struct is uninitialized in both situations.

The arrow operation:

foo->bar

is a shorthand write for:

(*foo).bar

Therefore, if "foo" struct variable is uninitialized, depending on the compiler, the pointer inside your struct will point to a random location in memory.

So, when you used the arrow operator as such:

var->ptr[0] = &a;

What you did was:

(*var).ptr[0] = &a;

So, basically, you tried to write the address of "a", into a location in memory, that you shouldn't have accessed. This is why you are getting a segmentation fault.

However, if you instead have initialized it:

int goodmemorylocation = 0;
var->ptr = &goodmemorylocation; // You change the location of your pointer to an accessible location in memory

Then your code works for both cases, in my system.

Perhaps, in your system, the first example that you used malloc, somehow points to a correct address in your memory. This is why it works.