5. Write a program in C language that dynamically allocates memory for a stack data structure and performs push and pop operations.

Real-Life Applications
Stacks are common in a variety of real-life applications.
Managing function calls
Stacks are used by the compiler interpreter to manage function calls, return addresses.
Word segmentation
Stacks help evaluate mathematical expressions by converting them to postposition or prefix characters.
Undo mechanism
Many applications use stacks to consume implementations that store and repeat previous states or actions.

Description of the program
Lets create a step by step C program that uses a stack data structure using dynamic memory allocation.
step 1: Define Stack Structure
To begin with we are able to begin by using defining the structure of the stack that this could include. Array for storing stack elements: An array might be used to store the elements in the stack. Track top of the stack: an integer variable value will reserve track of the top element inside the stack. Stack operation functions: we will generate functions to push (add) and pop (delete) elements or values from the stack.
step 2: Defining Stack Operations
we will then place into effect abilities to carry out the successive stack operations Initializing stack : This feature will set up the memory for the stack and initialize the values. Push: The characteristic of this function is to add a value on the top of the stack. Pop: This function removes top element from stack and return it from the stack. Functions: Additional functions are used to check whether the stack is full or empty and will display the contents.
Step 3: Dynamic memory allocation DMA
we will dynamically allocate memory to the stack array based on a input given by user to define the size of stack. This confirms that the stack can be dynamically resized as wished during this program execution.
step 4: User Interaction
Programmer or user will interact with the stack through using push and pop operations. This may be achieved using a menu driven interface that allow users to choose movements or actions and see the results immediately.
step 5: Output
we will provide an explanation for the predicted program outcome at every statements of the program. This can display how stack operations and memory management work and what users can predict while performing the program.
step 6: cleaning
Cleaning before exiting or leaving the program we will make sure that any dynamically allocated memory is accurately released. This step is necessary to prevent memory leaks which could lead inefficient use of memory sources and possible program failures.

#include<stdio.h>
#include<stdlib.h>
// Structure to represent a stack
struct Stack {
    int top;        // Index of the top element
    int capacity;   // Maximum capacity of the stack
    int *array;     // Array to store stack elements
};

// Function to create a stack of given capacity
struct Stack *createStack(int capacity) {
    struct Stack *stack = (struct Stack *)malloc(sizeof(struct Stack));
    if (!stack) {
        printf("Memory allocation error.\n");
        return NULL;
    }
    stack->capacity = capacity;
    stack->top = -1;    // Stack is initially empty
    stack->array = (int *)malloc(stack->capacity * sizeof(int));
    if (!stack->array) {
        printf("Memory allocation error.\n");
        free(stack);
        return NULL;
    }
    return stack;
}

// Function to check if the stack is full
int isFull(struct Stack *stack) {
    return stack->top == stack->capacity - 1;
}

// Function to check if the stack is empty
int isEmpty(struct Stack *stack) {
    return stack->top == -1;
}

// Function to add an element to the stack (push operation)
void push(struct Stack *stack, int item) {
    if (isFull(stack)) {
        printf("Stack Overflow.\n");
        return;
    }
    stack->array[++stack->top] = item;
    printf("%d pushed to stack.\n", item);
}

// Function to remove an element from the stack (pop operation)
int pop(struct Stack *stack) {
    if (isEmpty(stack)) {
        printf("Stack Underflow.\n");
        return -1;  // Return a sentinel value for error
    }
    return stack->array[stack->top--];
}

// Function to display the stack contents
void displayStack(struct Stack *stack) {
    if (isEmpty(stack)) {
        printf("Stack is empty.\n");
        return;
    }
    printf("Stack elements:\n");
    for (int i = 0; i <= stack->top; ++i) {
        printf("%d ", stack->array[i]);
    }
    printf("\n");
}

// Main function to demonstrate stack operations
int main() {
    int capacity, choice, item;
    printf("Enter the capacity of the stack: ");
    scanf("%d", &capacity);

    // Create a stack of given capacity
    struct Stack *stack = createStack(capacity);
    if (!stack) {
        printf("Failed to create stack. Exiting.\n");
        return -1;
    }

    while (1) {
        printf("\nStack Operations:\n");
        printf("1. Push\n");
        printf("2. Pop\n");
        printf("3. Display\n");
        printf("4. Exit\n");
        printf("Enter your choice: ");
        scanf("%d", &choice);

        switch (choice) {
            case 1:
                printf("Enter element to push: ");
                scanf("%d", &item);
                push(stack, item);
                break;
            case 2:
                item = pop(stack);
                if (item != -1)
                    printf("Popped element: %d\n", item);
                break;
            case 3:
                displayStack(stack);
                break;
            case 4:
                printf("Exiting program.\n");
                free(stack->array);   // Free allocated memory for stack array
                free(stack);          // Free allocated memory for stack structure
                exit(0);
            default:
                printf("Invalid choice. Please try again.\n");
        }
    }

    return 0;
}

Output
Enter the capacity of the stack: 5
Stack Operations:
1. Push
2. Pop
3. Display
4. Exit
Enter your choice: 1
Enter element to push: 10
10 pushed to stack.
Stack Operations:
1. Push
2. Pop
3. Display
4. Exit
Enter your choice: 1
Enter element to push: 20
20 pushed to stack.

Program Explanation
Understanding the output of this stack program is essential to understanding how stack operations work in exercise. Let us study the potential outputs that we might meet during the execution of this program.
1 The Initial Prompt
When you begin the program you will be asked to enter the capacity of the stack
Enter the capacity of the stack: 5
Once you enter the capacity of stack After entering the capacity the program builds a stack with the mentioned size.

2 Main Menu
Once the stack is created successfully the program create a menu for you to do stack operations. Stack Operations:
1. Push
2. Pop
3. Display
4. Exit
Enter your choice:
The menu remains appearing for each operations unless and until you choose to exit option.
3. Push Operation
if you choose push operation by entering 1 the program will ask the user to enter element to push on to the stack Enter element to push: 10
10 pushed to stack.
This confirms the message that the value 10 has been successfully added to the stack. In some cases if the stack is full you will see the following message
"Stack Overflow."
4.Pop Operation
Choose 2 for pop operation which will remove the top most element from the stack and display that element. Element Popped: 10
Output would be Stack Underflow if it does not have any elements or stack is empty.
5. Display Stack
Enter 3 to see or display all the existing items in the stack.
Stack Elements:
10 20 30
The output reveals each of the current available elements of the stack from bottom to top, and if there are no elements in the stack or it is empty, we get this message
Stack is empty.
6. Exiting the Program
Type in or select 4 to stop running this program.
Exit program.
Frees all memory spaces allocated to our program before exit thereby avoiding memory leakage.