#include <stdio.h>
int main()
{
  //!showMemory()
int a =5;
printf("Memory address of variable a is: %p",&a);
return 0;
}

int*ip;/* pointer to an integer */
double*dp;/* pointer to a double */
float*fp;/* pointer to a float */
char*ch /* pointer to a character */

#include <stdio.h>
int main ()
{
  //!showMemory()
int a = 5; /* variable declaration */
int *ip; /* pointer variable declaration */
ip = &a; /* store address of "a" in pointer variable*/
printf("Address of a variable: %p\n", &a );
/* address stored in pointer variable */
printf("Address stored in ip variable: %p\n", ip );
return 0;
}

#include <stdio.h>
int main ()
{
  //!showMemory()

int a = 5;
int *ip;
ip = &a;
/* access the value using the pointer */
printf("Value of *ip variable: %d\n", *ip );
return 0;
}

#include <stdio.h>

int main()
{
  int num= 10;
  int *ptr= &num;
  *ptr= 20;
  
  int **ptr1= &ptr; 
  **ptr1= 30;
  printf("Number: %d\n", num);
  return 0;
}

#include <stdio.h>
#include <string.h>

int main() {
    char food1[] = "Pizza";
    char food2[] = "Burger";
    char food3[] = "Sushi";
    char food4[] = "Pasta";
    char food5[] = "Ice Cream";

    char* ptr;

    ptr = food1;
    printf("Food 1: %s\n", food1);
    strncpy(ptr, "Spam", sizeof(food1) - 1); 

    ptr = food2;
    printf("Food 2: %s\n", food2);
    strncpy(ptr, "Steak", sizeof(food2) - 1); 
    printf("Food 2 (Updated): %s\n", food2);

    ptr = food3;
    printf("Food 3: %s\n", food3);
    strncpy(ptr, "Pizza", sizeof(food3) - 1); 
    printf("Food 3 (Updated): %s\n", food3);
    
    ptr = food4;
    printf("Food 4: %s\n", food4);
    strncpy(ptr, "Curry", sizeof(food4) - 1); 
    printf("Food 4 (Updated): %s\n", food4);
    
    ptr = food5;
    printf("Food 5: %s\n", food5);
    strncpy(ptr, "Donut", sizeof(food5) - 1); 
    printf("Food 5 (Updated): %s\n", food5);

    return 0;
}

#include <stdio.h>
 
void func1(int *pNum) {
   *pNum = 5;
   return;
}
 
int main () 
{
   //!showMemory()
 
   int num = 1;
 
   printf("Before passing: %d\n", num );
 
   func1( &num );
 
   printf("After passing: %d\n", num );
 
   return 0;
}

#include <stdio.h>
#include <string.h>
 
// Define a structure to represent a person
struct Person {
    char name[10];
    char behavior[12];
    struct Person* pointer1;
    struct Person* pointer2;
};
 
void report(struct Person* person) {
    printf("%s reports:\n", person->name);
    printf("%s is %s\n", person->pointer1->name, person->pointer1->behavior);
    printf("%s is %s\n", person->pointer2->name, person->pointer2->behavior);
    printf("\n");
}
 
int main() {
    // Create three persons
    struct Person person1, person2, person3;
 
    // Assign names to each person
    strcpy(person1.name, "Person 1");
    strcpy(person2.name, "Person 2");
    strcpy(person3.name, "Person 3");
 
    // Initialize real behaviors for each person
    strcpy(person1.behavior, "Industrious");
    strcpy(person2.behavior, "Expert");
    strcpy(person3.behavior, "Creative");
 
    // Point each person to the other two persons
    person1.pointer1 = &person2;
    person1.pointer2 = &person3;
 
    person2.pointer1 = &person1;
    person2.pointer2 = &person3;
 
    person3.pointer1 = &person1;
    person3.pointer2 = &person2;
 
    // Report on behaviors
    report(&person1);
    report(&person2);
    report(&person3);
 
    return 0;
}

#include <stdio.h>

// Function to swap values using pointers
void swap(int *x, int *y) {
    int temp = *x;
    *x = *y;
    *y = temp;
}

int main() {
    // Declare an array with a null terminator
    int arr[] = {1, 2, 3, 4, 5, '\0'};

    // Declare variables
    int a = 10;
    int b = 20;
    int *ptr_a, *ptr_b;

    // Initialize pointers
    ptr_a = &a;
    ptr_b = &b;

    // Print array using pointers and ptr++
    printf("Array elements using ptr++:\n");
    int *ptr_arr = arr;
    while (*ptr_arr != '\0') {
        printf("%d ", *ptr_arr);
        ptr_arr++;
    }

    // Reset pointer to the first element
    ptr_arr = arr;

    // Print array using pointers and ptr--
    printf("\nArray elements using ptr--:\n");
    while (ptr_arr >= arr) {
        printf("%d ", *ptr_arr);
        ptr_arr--;
    }

    // Update array element using pointer
    *(arr + 2) = 99;

    // Print updated array
    printf("\nArray after update:\n");
    for (int i = 0; i < 5; ++i) {
        printf("%d ", arr[i]);
    }

    // Use function to swap values
    printf("\n\nBefore swapping:\n");
    printf("Value of a: %d\n", *ptr_a);
    printf("Value of b: %d\n", *ptr_b);

    swap(ptr_a, ptr_b);

    printf("After swapping:\n");
    printf("Value of a: %d\n", *ptr_a);
    printf("Value of b: %d\n", *ptr_b);

    // Pointer to pointer
    int c = 30;
    int *ptr_c = &c;
    int **ptr_to_ptr_c = &ptr_c;

    printf("\nPointer to pointer example:\n");
    printf("Value of c: %d\n", **ptr_to_ptr_c);

    return 0;
}

#include<stdio.h>  
void change(int num) {    
    printf("Before adding value inside function num=%d \n",num);    
    num=num+100;    
    printf("After adding value inside function num=%d \n", num);    
} 
    
int main() {    
    int x=100;    
    printf("Before function call x=%d \n", x);    
    change(x);//passing value in function    
    printf("After function call x=%d \n", x);    
return 0;  
}    

#include<stdio.h>  
void change(int *num) {    
    printf("Before adding value inside function num=%d \n",*num);    
    (*num) += 100;    
    printf("After adding value inside function num=%d \n", *num);    
}      
int main() {    
    int x=100;    
    printf("Before function call x=%d \n", x);    
    change(&x);//passing reference in function    
    printf("After function call x=%d \n", x);    
return 0;  
}   

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

int main() {
  //!showMemory()
  char *dynamic_var;
  
  dynamic_var = (char *)malloc(200 * sizeof(char));
  
  if (dynamic_var == NULL) {
    printf("Couldn't able to allocate requested memory\n");
  } else {
    char text[30] = "Dynamically allocated string.";
    int length = 0;
    
    while (text[length] != '\0') {
      dynamic_var[length] = text[length];
      length++;
    }
    
    dynamic_var[length] = '\0'; // Null-terminate the string
  }
  
  printf("%s\n", dynamic_var);
  
  free(dynamic_var);
  
  return 0;
}

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

int main() {
    //!showMemory()
    int *dynamic_var;
    int n, i;
    printf("How many numbers will you store? ");
    scanf("%d", &n);

    dynamic_var = (int *)malloc(n * sizeof(int));
    if (dynamic_var == NULL) {
        printf("Couldn't allocate requested memory\n");
    } else {
        // Read dynamically allocated values
        for (i = 0; i < n; i++) {
            printf("Enter number %d: ", i + 1);
            scanf("%d", &dynamic_var[i]);
        }
    }

    // Printing dynamically allocated values
    for (i = 0; i < n; i++) {
        printf("Number %d = %d\n", i + 1, dynamic_var[i]);
    }

    free(dynamic_var);

    return 0;
}

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
 
int main()
{
char *dynamic_var;
 
dynamic_var = (char*)malloc( 30 * sizeof(char) );
 
if( dynamic_var== NULL )
{
printf("Couldn't able to allocate requested memory\n");
}
else
{
strcpy( dynamic_var,"Dynamically allocated string.");
}
printf("%s\n", dynamic_var );
 
free(dynamic_var);
 
return 0;
}

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
 
int main()
{
char *dynamic_var;
 
dynamic_var =(char*)calloc( 200 , sizeof(char) );
 
if( dynamic_var== NULL )
{
printf("Couldn't able to allocate requested memory\n");
}
else
{
strcpy( dynamic_var,"Dynamically allocated string.");
}
printf("%s\n", dynamic_var );
 
free(dynamic_var);
 
return 0;
}

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
 
int main()
{
char *dynamic_var;
//allocate
dynamic_var = (char*)malloc( 30 * sizeof(char) );
 
if( dynamic_var== NULL )
{
printf("Couldn't able to allocate requested memory\n");
}
else
{
strcpy( dynamic_var,"Dynamically allocated string.");
}
printf("%s\n", dynamic_var );
 
//reallocate
dynamic_var = (char* )realloc( dynamic_var, 60 * sizeof(char) );
 
if( dynamic_var== NULL )
{
printf("Couldn't able to allocate requested memory\n ");
}
else
{
strcat( dynamic_var,"With more reallocated content");
}
printf("%s\n", dynamic_var );
 
free(dynamic_var);
 
return 0;
}

#include <stdio.h>
#include <stdlib.h>
int main(){
int *dynamic_var ,i,n1,n2;
printf("Enter size of array: ");
scanf("%d",&n1);
 
dynamic_var =(int*)malloc(n1*sizeof(int));
 
printf("Address of previously allocated memory: ");
 
for(i=0;i<n1;++i)
printf("%u\t",dynamic_var +i);
 
printf("\nEnter new size of array: ");
scanf("%d",&n2);
 
dynamic_var =realloc(dynamic_var ,n2);
 
for(i=0;i<n2;++i)
printf("%u\t",dynamic_var +i);
return 0;
}

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
 
int main()
{
    char *dynamic_var;
 
    // Step 1: Allocate memory using malloc
    dynamic_var = (char*)malloc(30 * sizeof(char));
   
    if (dynamic_var == NULL)
    {
        printf("Couldn't allocate requested memory with malloc\n");
        return 1; // Exit the program if allocation fails
    }
   
    // Copy a string into the malloc allocated memory
    strcpy(dynamic_var, "Dynamically allocated string.");
    printf("Using malloc: %s\n", dynamic_var);
 
    // Step 2: Allocate new memory using calloc
    char *calloc_var = (char*)calloc(30, sizeof(char)); // Allocate with calloc
   
    if (calloc_var == NULL)
    {
        printf("Couldn't allocate requested memory with calloc\n");
        return 1; // Exit the program if allocation fails
    }
 
    // Copy the string from malloc_var to calloc_var
    strcpy(calloc_var, dynamic_var);
    printf("Using calloc: %s\n", calloc_var);
 
    // Step 3: Reallocate memory using realloc
    char *realloc_var = (char*)realloc(calloc_var, 60 * sizeof(char)); // Resize memory with realloc
 
    if (realloc_var == NULL)
    {
        printf("Couldn't reallocate requested memory\n");
        free(calloc_var);
        return 1; // Exit the program if reallocation fails
    }
 
    // Copy the string again and add more content to the reallocated memory
    strcat(realloc_var, " With more reallocated content");
    printf("After realloc: %s\n", realloc_var);
 
    // Free all allocated memory
    free(realloc_var);
    // realloc_var is free. So no data will display.
   //printf("After Free Realloc: %s\n", realloc_var);
    free(dynamic_var);
    // dynamic_var is free. So no data will display.
   //printf("After Free Malloc: %s\n", dynamic_var);
   
   
    return 0;
}

#include<stdio.h>
int recursiveToThree(int n){
  printf("%d th\n", n + 1);
  if(n < 3){
      int r = recursiveToThree(n + 1);
      n = r;
  }
  return n;
}
int main(){
  int n = 0;//variable declaration

  n = recursiveToThree(0);//recursive function

  int arr[5] = {1, 2, 3};//array variable

  int* ptr = &arr[2];//pointer variable
  *ptr = 5;

  //dynamic memory allocation
  int* d_arry = malloc(sizeof(int) * 3);

  //two-dimensional dynamic array
  int* pd_arr[2];
  pd_arr[0] = malloc(sizeof(int) * 2);
  pd_arr[1] = malloc(sizeof(int) * 2);

  printf("Hello,world!\n");//standard output

  free(pd_arr[0]);//memory leak

  //File Output
  {
    FILE* fp=NULL;
    fp = fopen("PLIVET.txt", "w");
    fputs("PLIVET", fp);
    fclose(fp);
  }

  //File Input
  {
    FILE* fp=NULL;
    char buf[7];
    fp = fopen("PLIVET.txt", "r");
    while(fgets(buf,10,fp) != NULL) {
      printf("%s",buf);
    }
    fclose(fp);
  }
  return 0;
}

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

int main() {
    // Stack memory allocation
    int stackVar1 = 10;
    int stackVar2 = 20;
    int stackVar3 = 30;

    // Pointers pointing to stack variables
    int *ptr1 = &stackVar1;
    int *ptr2 = &stackVar2;
    int *ptr3 = &stackVar3;

    // Displaying stack memory values
    printf("Stack Variables:\n");
    printf("stackVar1 = %d, Address = %p\n", *ptr1, (void *)ptr1);
    printf("stackVar2 = %d, Address = %p\n", *ptr2, (void *)ptr2);
    printf("stackVar3 = %d, Address = %p\n", *ptr3, (void *)ptr3);

    // Heap memory allocation
    int *heapVar1 = (int *)malloc(sizeof(int));
    int *heapVar2 = (int *)malloc(sizeof(int));
    int *heapVar3 = (int *)malloc(sizeof(int));

    // Check if memory allocation was successful
    if (heapVar1 == NULL || heapVar2 == NULL || heapVar3 == NULL) {
        printf("Memory allocation failed\n");
        return 1; // Exit with an error code
    }

    // Assigning values to heap variables
    *heapVar1 = 40;
    *heapVar2 = 50;
    *heapVar3 = 60;

    // Displaying heap memory values
    printf("\nHeap Variables:\n");
    printf("heapVar1 = %d, Address = %p\n", *heapVar1, (void *)heapVar1);
    printf("heapVar2 = %d, Address = %p\n", *heapVar2, (void *)heapVar2);
    printf("heapVar3 = %d, Address = %p\n", *heapVar3, (void *)heapVar3);

    // Freeing heap memory
    free(heapVar1);
    free(heapVar2);
    free(heapVar3);

    return 0;
}

#include <stdio.h>
#include <stdlib.h>  // Include for malloc and free
 
int global_var = 10; // global variable but memory can not be freed
 
void Function() {
    int local_var = 20;
    printf("local_var in Function: %d\n", local_var);
}
 
int main() {
    int local_var = 30; 
    printf("local_var in main: %d\n", local_var);

    //local_var1 but memory can be freed using malloc
    int *local_var1 = (int*) malloc(4 * sizeof(int));  // Allocate memory for 4 integers
    
    if (local_var1 == NULL) {  // Always check if malloc succeeded
        printf("Memory allocation failed\n");
        return 1;  // Return a non-zero value to indicate failure
    }
 
    // Optionally initialize the allocated memory
    for (int i = 0; i < 4; i++) {
        local_var1[i] = i + 1;  // Initialize with some values
    }
 
    printf("global_var: %d\n", global_var);
    Function();
 
    // Print values from the allocated memory
    for (int i = 0; i < 4; i++) {
        printf("local_var1[%d]: %d\n", i, local_var1[i]);
    }
 
    free(local_var1);  // Free the allocated memory
    printf("local_var1 after freed in main: %d\n", local_var1); // gurbadge value will print because memory is free
    printf("global_var: %d\n", global_var);
    Function();
    return 0;
}