Thread: Size of Linked List

Code:

struct _Link
{
     int x;
     int y;
     struct _Link *next;
};
typedef struct _Link Link;

struct _LinkList
{
     int size;
     Link *head;
     Link *tail;
};
typedef struct _LinkList LinkList;

struct _Stack
{
    LinkList *l;
};
typedef struct _Stack Stack;


Stack* stack_init()
{
    Stack *s;
    LinkList *l;

    s = (Stack*)malloc(sizeof(Stack));
    s->l = (LinkList*)malloc(sizeof(LinkList));

    s->l->size =0;  
    s->l->head = NULL;
    s->l->tail = NULL;

    return s;
}


void stack_check()
{
   Stack *s;


   s = stack_init();

   if(s==0)
      printf("correct");
}

This is part of my project, I'm trying to get the size of the stack (which in this case should be 0) after initialization. After exiting the function, it returns an arbitrary value. Howcome?
Note, the linked list has already been initialized.
Any help will be greatly appreciated.

Can you post a bit more code, please?

Welcome to the forum.

The stack_init function returns the pointer to your new stack.
You don't attempt to "get the size" in the code you posted.
And you should be checking the that the return value from malloc is not NULL.

I've no idea, you need to provide a runnable test case which fails for you.

Code:

int main ( ) {
  Stack *s = stack_init();
  printf("Len=%d\n", s->l->size);
  return 0;  
}

I just added this and it works as expected.

> s = stack_init();
> if(s==0)
This isn't checking the size of your stack, it's checking whether you have a stack at all.

Check my code.

The code you added does -pretty much- what oogabooga said. Take a look at Salem's post, where he actually checks the size.

Are you sure you are ok with structs, or do you want a little revision in the very basics of structs?

Oh and a piece of advice. It is better some times to post your new code in your current post, not editing the old ones, because if the thread is big, people get easily lost. Aliens not. :P

You are welcome.

Functions in C (very short) can provide some info in pointers, but I do not have something that is devoted to pointers. You can see the link in my signature, if you want to search yourself.

That's the easy solution. And the when something is way too easy, it means that there is a tradeoff hiding back there.

When you have a small program of about 200 lines it's ok to use a global variable. You know that this is a global variable, etc.
When you start writing some bigger projects, you will see that even you get fooled by what it is a global variable and which variable does it shadows, etc.

Imagine what will happen, when your projects are read/modified by at least two people. You will protect the others from ruining the code, you will save time and you will avoid chaos.

One can easily say: "Well, ok, let me use global variables now and when the time for BIG projects comes up, I will stop using them.".
Let me give you an analogy to this:
Assume we have a runner, who when practicing, runs with his back turned to the direction he goes. Imagine how runners run and rotate that man by π (180 degrees), but let him run to the same direction.
His coach asks him, why do you do such thing? It's easier for me, because it's fun.
The coach tells him, that in the finals, he will have to run normally, like all the runners. And the runner says, well ok, let me run normally when the the finals come up.
When the finals come up, I do not think he is going to be ready for this.

Originally Posted by MutantJohn

Idk, I like globals for counts. Just modify it when you add or remove an element. Doesn't seem that bad or hard

What if you have multiple linked lists? You won't be able to reuse the structure and its associated functions because they are tied to the notion of a single linked list with a global count.

Originally Posted by MutantJohn

Another solution is to comtain an index for each element in the list, the front being 0, the next being 1...

This has a disadvantage in that adding or removing an element in the middle of the linked list would no longer be a constant time operation since the elements after the insertion/removal point must be re-indexed.