Simple Stack Implementation in C This is my implementation of the stack data type in C language. It is static meaning it does not grow in size. Any suggestions or feedback would be much appreciated.

#include &lt;stdio.h&gt;
#define MAXSTACKLENGTH 6
#define true 1
#define false 0

struct stk{
    char content[MAXSTACKLENGTH];
    int top;
};

typedef struct stk stack;

int size(stack *s)
{
    return s-&gt;top;
}

int isEmpty(stack *s)
{
    if (size(s) &lt;= -1)
    {
        return true;
    }
    else if (size(s) &gt; -1)
    {
        return false;
    }
}

int isFull(stack *s) {
    if (size(s) == (MAXSTACKLENGTH-1))
    {
        return true;
    }
    else {
        return false;
    }
}

char peek(stack *s)
{
    if (isEmpty(s) == true)
    {
        printf("Can't peek: Stack is empty!\n");
        return '\0';
    }
    else {
        return s-&gt;content[s-&gt;top];
    }
}

void push(stack *s, char element)
{
    if (isFull(s) == true)
    {
        printf("Cant push: Stack is full!\n");
    }
    else {
        s-&gt;top++;
        s-&gt;content[s-&gt;top] = element;
    }
}

void pop(stack *s)
{
    if (isEmpty(s) == true) {
        printf("Cant pop: Stack is empty!\n");
    }
    else {
        s-&gt;top--;
    }
}

void input_push(stack *s)
{
    char c;
    printf("Enter a character&gt; ");
    scanf(" %c", &amp;c);

    push(s, c);
}

void print_stack(stack *s)
{
    if (isEmpty(s)) {
        printf("Stack is empty!\n");
    }
    else {
        int i = s-&gt;top;

        for (i; i &gt; -1; i--)
        {
            printf("%c\n", s-&gt;content[i]);
        }

        printf("\n");
    }
}

void pause()
{
    char c;
    printf("Enter any character to continue.\n");
    scanf(" %c", &amp;c);
}

int main()
{
    printf("SimpleStack! v1\n");

    stack mystack;
    mystack.top = -1; //Empty

    int run = true;
    int choice = 0;

    while (run)
    {
        if (isFull(&amp;mystack))
        {
            printf("Warning -&gt; Stack is full\n");
        }
        if (isEmpty(&amp;mystack))
        {
            printf("Warning -&gt; Stack is empty\n");
        }
        printf("1 -&gt; Push\n");
        printf("2 -&gt; Pop\n");
        printf("3 -&gt; Peek\n");
        printf("4 -&gt; Print Stack\n");
        printf("5 -&gt; Exit\n");

        printf("Enter choice&gt; ");
        scanf("%d", &amp;choice);

        switch (choice) {
            case 1:
                input_push(&amp;mystack);

                break;
            case 2:
                pop(&amp;mystack);

                break;
            case 3:
                printf("%c\n", peek(&amp;mystack));
                pause();
                break;
            case 4:
                print_stack(&amp;mystack);
                pause();
                break;
            case 5:
                printf("Goodbye!\n");
                run = false;

                break;
            default:
                printf("Invalid choice.\n");

                break;
        }

        system("clear");
    }

    return 0;
}
It looks good. Here are a few things you can add to it or change:


You don't have to define true/false yourself. It's unfortunate that bool is not a built-in type in C, but the Standard C Library at least provides an #include file that gives  you those definitions in a portable way. So you can #include &lt;stdbool.h&gt; and it will define the type bool and true/false constants.
You can combine the structure declaration + typedef into the same declaration:

typedef struct stk 
{
    char content[MAXSTACKLENGTH];
    int top;
} stack;


Most C programs you'll find use this more compact notation of typedef struct.
You can simplify statements like this and others:


int isEmpty(stack *s)
{
    if (size(s) &lt;= -1)
    {
        return true;
    }
    else if (size(s) &gt; -1)
    {
        return false;
    }
}



By simply returning the condition:

int isEmpty(stack *s)
{
    return size(s) &lt;= -1;
}


The result of a comparison is always a boolean, so it can be returned directly if the function also returns true/false. This is another pattern that you will see used a lot. It makes code more concise.
Comparing against true/false in a conditional is not very usual:


if (isFull(s) == true)



You gave good descriptive names to your functions, so you can just test them like this:

if (isFull(s)) { ...


And to test if not full, the more usual way is to apply the ! (logical not) operator:

if (!isFull(s)) { ... // Reads "if not isFull"

size() currently return -1 for an empty stack. That's unusual. It doesn't make sense for a size to be negative. I'd expect an empty stack to have size 0. You should change that.
I suggest having a init_stack() function that sets the expected initial invariants when a new stack is declared. Better than having to remember to manually set top to -1, for example.
Since you already have a custom pause() function, you don't have to use system("pause"). The latter is non-portable and not recommended for use in real-life programs due to security risk it might incur. Best if you avoid it.
A minor nitpick, you're mixing different styles of curly brace positioning. Some are on the same line as the parent conditional, some are on their own line. This creates a break in your style, which is a little annoying. It would be nice if you kept them consistent, independent of which style you decide for.