C - Changing the value of a variable outside of a function by passing pointers

Question

I have an assignment in C to implement a abstract data type STACK. The nature of the data type requires key structure that needs to have memory allocated. My problem is that my instructor insists, for now, for the initialization function to take in a pointer to the key structure. The init() function will do nothing more than allocate the memory necessary for the structure and set a field to zero, but the pointer that is passed in needs to be assigned that memory location.

I can't think of a way to do this without either having the function return a pointer, or to pass in a 2-star pointer - both of which are not allowed. I know The function prototype must be (where stackT* is a pointer to the key STACK data structure):

    void init(stackT* stack);

I came up with this and it works fine:

    void init(stackT** stack){
        *stack = (stackT*) malloc(sizeof(stack));
        (*stack)->count = 0;
        return;
    }

But it does not abide by the restrictions of the assignment.

---

tl;dr version:

Basically, how can I pass in the address of my original pointer to the STACK data structure (&stackPtr) into a function that takes one-star pointers as arguments and not get a pointer-type warning? Further, once you change the arguments to (stackT* stack) the below code does not work, even though I am passing the same thing either way - this is where my problem is.

I thought it is REQUIRED to have the argument as a 2-star pointer if you intend to pass in a pointer to a pointer .. the compiler must know what it is dealing with when you dereference a pointer.

At any rate, I am not sure how to do this given the restrictions. In my opinion this is only making it unnecessarily more difficult.

Answer 1

I believe, as pointed out in a comment, that you're missing the intention.

I think the idea is that the "root" stackT instance should be a well-known structure, so that you can declare one locally. Then you call init() to set up the actual stack described by the stackT instance:

int push_four(void)
{
  stackT my_stack;

  init(&my_stack);
  push(&my_stack, 1);
  push(&my_stack, 2);
  push(&my_stack, 3);
  push(&my_stack, 4);
}

The above assumes that the stack stores integers, i.e. the allocation inside init() should be something like:

void init(stackT *stack)
{
  stack->items = malloc(64 * sizeof *items);
  stack->count = 0;
}

And this, in turn, assumes a declaration like:

typedef struct {
  int *items;
  size_t count;
} stackT;

Of course, the default maximum depth (64) should be a parameter to init(), you must check (but not cast!) the return value of malloc(), and so on.

Answer 2

Typically when you have complex structures then there is a control struct and that one will have a pointer to the real memory.

Example:

struct stack_control_s {
    void * memory;
    size_t memory_size;
    size_t current_size;
};

Then you would pass a pointer to the control structure to your initialiser and make it do the real work;

#define STACK_MIN_SIZE 0x100
int stack_init(struct stack_control_s * stack) {
    memset(stack, 0, sizeof(*stack));

    stack->memory = calloc(STACK_MIN_SIZE, 1);

    if (!stack->memory)
        return -1; //error

    stack->memory_size = STACK_MIN_SIZE;

    return 0; // all good
}

Here is a slightly modified header for a generic C list that I once made. I have added to macros to make it useable as a stack. Maybe this will give you some inspirations:

list_t.h

Use:

list_t(char) mylist;
list_init(&mylist);

list_push(&mylist, 'A');

printf("%c\n", list_pop(&mylist));

Answer 3

Probably it is not the best solution, but you can define your stack globally.

In this case it will look like a:

stackT G_stack;
....

void init(stackT* stack){
    stack->count = 0;
    return;
}

int main() {
    .....
    init(&G_stack);
    .....
}

In this case you don't need to change prototype.

Answer 4

This assignes the pointer the address of the definition of STACK and passes the pointer to be initialized (using a single * :)... Will this work for you?

#include <ansi_c.h>  
typedef struct  {
    int count;
} COUNT;

typedef struct  {
    COUNT count;
    int *element1;
    int *element2;
    int address;
} STACK;

STACK stack, *pStack;

void InitStack(STACK *iS);

int main(void)
{    //This is how I think you will meet the 
     //criteria you are talking about (single *)
    pStack = &stack; //assigning address of stack to pointer

    InitStack(pStack);
    //pStack->address == pStack
    return 0;
}

void InitStack(STACK *iS)
{
    iS->count.count = 0;
    iS->address = (int)iS; //assigning address of stack to member of struct
    iS->element1 = calloc(10, sizeof(int));
    iS->element2 = calloc(10, sizeof(int));
}