do not understand why I cannot free an array - c

Question

Again with the memory allocation...
I don't seem to understand why my call to free is not working on the array in the object. It makes sense to me, but I get a segmentation fault. All I would like is to free the min_array and the array in the stack in the minStackFree function. Does anyone understand why this could be happening?
#include<stdio.h>
#include<stdlib.h>
typedef struct {
int * array;
int array_idx; // is 'top'
int * min_array;
int min_idx;
} MinStack;
MinStack * minStackCreate() {
MinStack * obj = malloc(sizeof(MinStack*));
//initialize the stacks
obj->array = malloc(10000*sizeof(int*));
obj->min_array = malloc(10000*sizeof(int*));
//initialize the index
obj->array_idx = -1;
obj->min_idx = -1;
}
void minStackFree(MinStack* obj) {
free(obj->min_array); // ************PROBLEM
free(obj->array); // ************PROBLEM
free(obj); // OK
}

Answer 1

It is not a matter of if malloc() will fail returning NULL, it is a matter of when. You must always validate EVERY allocation. Otherwise you risk Undefined Behavior (and likely a SegFault) if you fail to catch the allocation failure. A simple check is all that is needed, e.g.
#define ARRSZ 10000 /* if you need a constant, #define one (or more) */
MinStack *minStackCreate (void) {
MinStack *obj = malloc (sizeof *obj); /* use dereference pointer for typesize */
if (!obj) { /* validate EVERY allocation */
perror ("malloc-obj");
return NULL;
}
obj->array = malloc (ARRSZ * sizeof *obj->array); /* dereference pointer for typesize */
if (!obj->array) { /* validate EVERY allocation */
perror ("malloc-obj->array");
free (obj); /* free prior allocaitons */
return NULL;
}
obj->min_array = malloc (ARRSZ * sizeof *obj->min_array); /* ditto */
if (!obj->min_array) { /* ditto */
perror ("malloc-obj->min_array");
free (obj->array); /* free prior allocaitons */
free (obj);
return NULL;
}
//initialize the index
obj->array_idx = -1;
obj->min_idx = -1;
return obj; /* return allocated pointer */
}
As #chux-ReinstateMonica points out, with multiple allocations in your function, should an allocation fail, you must free the memory allocated in the function prior to the point of failure, before returning NULL to avoid a memory leak. Once NULL is returned, you would have no way to reach the allocations that occurred prior to the point of failure.
Don't use Magic-Numbers (e.g. 10000) in your code. If you need a constant, #define one, or use a global enum for the same purpose. That way if your needs change, you have one single location to update and the change is seen throughout your code.
Readability. The '*' dereference operator goes with the variable not the type. Why? Readability:
int* a, b, c;
most certainly does not declare 3-pointers to int, writing
int *a, b, c;
makes it abundantly clear that a single pointer to int and two integers are being declared.
Use the dereferenced pointer to set typesize. If you do that, you will never get the typesize wrong, e.g.
MinStack *obj = malloc (sizeof *obj);
and
obj->array = malloc (ARRSZ * sizeof *obj->array);
obj->min_array = malloc (ARRSZ * sizeof *obj->min_array);
While simple structs with the declaration in front of you may be easy to set the sizeof(type), when you are 1000 lines down in your code using complex types, things will not be so easy and it is easy to guess wrong.
With those changes, and returning obj on success or NULL on failure from minStackCreate() and the remainder compiles without warning.

Answer 2

It appears the issue was I needed to change:
MinStack * obj = malloc(sizeof(MinStack*));
//initialize the stacks
obj->array = malloc(10000*sizeof(int*));
obj->min_array = malloc(10000*sizeof(int*));
to
MinStack * obj = malloc(sizeof(MinStack));
//initialize the stacks
obj->array = malloc(10000*sizeof(int));
obj->min_array = malloc(10000*sizeof(int));
return obj;