Question: I'm studying Data Structures, and I'm not getting why stacks and queues need to be declared like:

```
struct stack *Stack;

```

(forget about the `struct` syntax)

I mean, why it is always declared as a pointer?

Answer: 
They are not always declared like that!

In general, declaring a variable as a pointer is useful for later allocating it dynamically. This can be due to a couple of reasons:

* The variable is too big for the program stack
* You want to return that variable from a function

In your case, let's think of two different implementations of stack:

```
struct stack
{
    void *stuff[10000];
    int size;
};

```

This is a terrible implementation, but assuming you have one like this, then you'd most probably not want to put it on the program stack.

Alternatively, if you have:

```
struct stack
{
    void **stuff;
    int size;
    int mem_size;
};

```

You dynamically change the size of `stuff` anyway, so there is absolutely no harm in declaring a variable of type `struct stack` on the program stack, i.e. like this:

```
struct stack stack;

```

Unless, you'd want to return it from a function. For example:

```
struct stack *make_stack(int initial_size)
{
    struct stack *s;

    s = malloc(sizeof(*s));
    if (s == NULL)
        goto exit_no_mem;

    if (initial_size == 0)
        initial_size = 1;
    s->stuff = malloc(initial_size * sizeof(*s->stuff));
    if (s->stuff == NULL)
        goto exit_no_stuff_mem;

    s->size = 0;
    s->mem_size = initial_size;

    return s;
exit_no_stuff_mem:
    free(s);
exit_no_mem:
    return NULL;
}

```

Personally, though, I would have declared the function like this:

```
int make_stack(struct stack *s, int initial_size);

```

and allocate the `struct stack` on the program stack.
There's really no need to implement stacks and queues with pointers - others have already stated this fact clearly. Look at @JohnBode 's answer for how a stack can be perfectly implemented using arrays. The thing is that modelling certain data structures (such as stacks, queues and linked lists) using pointers, allows you to program them in a very efficient way in terms of both execution speed and memory consumption.

Usually an underlying array for holding a data structure is very good implementation choice if your use-cases require frequent random access to an element in the structure, given it's positional index (this is FAST with an array). However growing the structure past its initial capacity can be expensive AND you waste memory with the unused elements in the array. Insertion and deletion operations can also be very expensive since you may need to rearrange elements to either compact the structure or make space for the new elements.

Since a queue and a stack don't have this random-acess requirement and you don't insert or delete elements in the middle of them, it is a better implementation choice to dynamically allocate each individual element "on the fly", requesting memory when a new element is required (this is what malloc does), and freeing it as an element is deleted. This is fast and will consume no more memory than it is actually needed by your data structure.