#include <stdio.h>

int main() {
   // printf() displays the string inside quotation
   printf("Hello, World!\n");
   return 0;
}

#include<stdio.h>
#include<stdlib.h>
 
int main() 
{
      int count, num;
      printf("Ten Random Numbers:\t"); 
      for(count = 1; count <= 10; count++) 
      {
            num = rand() % 100;
            printf("%d\t", num);
      } 
      printf("\n");
      return 0;
}

#include <stdio.h>

int main()
{
    int testInteger = 5;
    printf("Number = %d\n", testInteger);
    return 0;
}

#include <stdio.h>

int main()
{
    float number1 = 13.5;
    double number2 = 12.4;

    printf("number1 = %f\n", number1);
    printf("number2 = %lf\n", number2);
    return 0;
}

#include <stdio.h>

int main()
{
    char chr = 'a';    
    printf("character = %c\n", chr);  
    return 0;
} 

#include <stdio.h>

int main()
{
    int testInteger;
    printf("Enter an integer: ");
    scanf("%d", &testInteger);  
    printf("Number = %d\n",testInteger);
    return 0;
}

int digit = 42;

#include <stdio.h>
int main() {
   int digit = 42;

   /* the memory-address where the variable digit is saved */
   printf("The memory-address of digit = %d.\n", &digit);

   /* getting the content itself again throughout pointer */
   printf("The value of digit = %d.\n", *(&digit));

   return 0;
}

int* pointer1;           /* can save an address, where a value with type Integer is saved */
int *pointer2;           /* you can use space before or after asterisk */
int * pointer3;          /* also possible as notation, depending on the code-style defined */
int *pointer4, *pointer5; /* definition of two pointers */
int *pointer6, number;    /* definition of one pointer and a variable with type Integer */

int variable = 0;
int array[10];
int *pointer;
int *pointer2;
pointer = &variable;     /* with address-operator */
pointer = array;         /* with array, done without ampersand as not needed and handled internally from C */
pointer = pointer2;      /* with another pointer */
pointer = NULL;          /* with NULL (predefined keyword in syntax) */

int variable = 0; /* definition of a variable with type Integer, including initialization */
int *pointer = &variable; /* definition of a variable for a pointer with type Integer, including initialization */
printf("%p", (void*)&variable); /* output of the adress for the variable, depends on implementation for example this would result in hexadecimal output */

int variable = 3;
int *pointer = &variable; /* this is NOT the content-operator */
printf("%d", *&variable); /* output value "3" */
printf("%d", *pointer); /* output, value "3" */

* pointer = 5;
printf("%d", *pointer); /* output, value "5" */
* pointer = *pointer + 1;
printf("%d", *pointer); /* output, value "6" */

int *pointer;
pointer = NULL;

* pointer = 0;  /* error */

pointer = malloc( sizeof(*pointer) );
if ( pointer == NULL )
  puts("error while reserving memory");

#define NULL 0
#define NULL 0L
#define NULL (void *) 0

char character;
char *pointer = &character;
printf("%p\n", pointer);   /* output is for example the address 0019FF01 */
pointer = pointer + 1;
printf("%p\n", pointer);   /* output would be therefore 0019FF02 */

int number;
int *pointer = &number;
printf("%p\n", pointer); /* output would be some memory-address, for example 0019FF01 */
pointer = pointer + 2;
printf("%p\n", pointer); /* corresponding with the mentioned above: output would therefore here 0019FF09, meaning 0019FF01 plus 4 multiplied with 2 */

pointer += 5; /* pointer = pointer + 5 */
pointer++; /* pointer = pointer + 1 */

char *string = "hello";
char *pointer = &string;
char *pointer2 = pointer + 2;
ptrdiff_t difference;
difference = pointer2 - pointer;
printf("%d\n", difference);     /* result is here the difference in bytes, here "2" */

int *pointer = malloc(sizeof(int));  /* pointer at the start of a reserved memory-area at runtime, memory for one value of type Integer */

... usage of pointer ...
pointer[0] = 1;
printf("%d", pointer[0]);
* pointer = 2;
printf("%d", *pointer);

free(pointer);    /* get memory free */

... after free() the usage of the pointer will be no longer stable and foreseeable, undefined results incoming when doing that ...

void function(int *pointer) {
    *pointer = 1; /* the value for concurrent memory is overwritten with "1" */
}
int main() {
    int number = 0;
    function(&number); /* using variable as parameter */
    printf("%d\n", number); /* output will be "1" */
}

#include <limits.h>
#include <stdio.h>
#include <stdlib.h>
struct Stack {
     int top;
     unsigned capacity;
     int* array;
};
struct Stack* createStack(unsigned capacity)
{
     struct Stack* stack = (struct Stack*)malloc(sizeof(struct Stack));
     stack->capacity = capacity;
     stack->top = -1;
     stack->array = (int*)malloc(stack->capacity * sizeof(int));
     return stack;
}
int isFull(struct Stack* stack)
{
     return stack->top == stack->capacity - 1;
}
int isEmpty(struct Stack* stack)
{
     return stack->top == -1;
}
void push(struct Stack* stack, int item)
{
     if (isFull(stack))
     return;
     stack->array[++stack->top] = item;
     printf("%d pushed to stack\n", item);
}
int pop(struct Stack* stack)
{
      if (isEmpty(stack))
      return INT_MIN;
      return stack->array[stack->top--];
}
int main()
{
      struct Stack* stack = createStack(100);
      push(stack, 11);
      push(stack, 12);
      push(stack, 33);
      printf("%d popped from stack\n", pop(stack));
      printf("%d popped from stack\n", pop(stack));
      printf("%d popped from stack\n", pop(stack));
      return 0;
}

#include <limits.h>
#include <stdio.h>
#include <stdlib.h>

/*
    definining struct
*/
struct Stack {
     int top;
     unsigned capacity;
     int* array;
};

/*
    function "createStack"
    parameter:
              unsigned numeric capacity - absolute maximum of possible entries within stack

    This functions is creating the initial data-structure with holding a maximum of entries (capacity).
    Returns the structure as pointer towards the predefined datatype.
*/
struct Stack* createStack(unsigned capacity)
{
     struct Stack* stack = (struct Stack*)malloc(sizeof(struct Stack));
     stack->capacity = capacity;
     stack->top = -1;
     stack->array = (int*)malloc(stack->capacity * sizeof(int));
     return stack;
}

/*
    function "isFull"
    parameter:
              pointer for datatype stack

    This function is checking if the defined stack is full.
*/
int isFull(struct Stack* stack)
{
     return stack->top == stack->capacity - 1;
}

/*
    function "isEmpty"
    parameter:
              pointer for datatype stack

    This function is checking if the defined stack is just empty. 
*/
int isEmpty(struct Stack* stack)
{
     return stack->top == -1;
}

/*
    function "push"
    parameter:
              pointer for datatype stack
              item to be pushed into the stack as numeric

    This function pushes a new element / item within the stack on top.
*/
void push(struct Stack* stack, int item)
{
     if (isFull(stack)) return;
     stack->array[++stack->top] = item;
     printf("%d pushed to stack\n", item);
}

/*
    function "pop"
    parameter:
              pointer for datatype stack

    This function removes the last element to be find on top of the data-structure.
*/
int pop(struct Stack* stack)
{
      if (isEmpty(stack)) return INT_MIN;
      return stack->array[stack->top--];
}

int main()
{
      // defining a new pointer with given datatype and create this with possible 100 entries
      struct Stack* stack = createStack(100);

      // adding new elements
      push(stack, 11);
      push(stack, 12);
      push(stack, 33);

      // removing elements, last one added as first to be removed
      printf("%d popped from stack\n", pop(stack));
      printf("%d popped from stack\n", pop(stack));
      printf("%d popped from stack\n", pop(stack));
      return 0;
}