Before learning the C macro, you should know about C preprocessor directives in C language. In this post, you can clearly understand the following

• what preprocess commands are available in C?
• How do you declare the preprocessor command.?
• what is a macro?
• What is the macro syntax?
• how to declare the macro?
• how to assign the macro value?
• how can use the macro function in c.

Here your answer, if you have any doubts please post in doubts about C Preprocessor and Macros.

C program structure model explanation

Incremental and Decremental Operators

• S++; // ++, as it is single machine instruction (INC) internally.(recommended)
• S = S+1; // ++, as it wil take two machine cycle internally.(not recommended)

Example:

Code:

#include<stdio.h>
int main()
{
	int a=5, b=6;
	printf("A : %d \n", a);
	printf("B : %d \n\n", b);
	int c = a++ + ++b;
	printf("A : %d \n", a);
	printf("B : %d \n\n", b);

	printf("C : %d \n", c);
	printf("A : %d \n", a);
	printf("C : %d \n", c);
	return 0;
}

Output:

A : 5
B : 6
A : 6
B : 7
C : 12
A : 6
B : 7

Relational Operator

Code-1:

#include <stdio.h>

int main()
{
	int y;
	int x = y ==10; //int x = y == y; or int x = y ;  
	printf("%d",x);
	
	return 0;
}


//Output : 0

Code-2:

#include<stdlib.h>
 
int main()
{
	int x =10;
	x ==10;
	printf("%d",x);
      return 0;
}
//Output : 1

Boolean Operator

• == Equal
• != Not equal
• > Greater than
• >= Greater than or equal
• < Less than
• <= Less than or equal
• && Logical AND
• || Logical OR
• ! Logical NOT

Conditional operators (Ternary Operator)

syntax : expression 1 ? expression 2 : expression 3;

• Rule
  • if expression 1 is true then expression 2 is executed
  • else expression 1 is false then expression 3 is executed
• Advantage : Using ?: reduce the number of line codes and improve the performance of application.
• Example Invalid:In this below example this is an error in this line i>45? return(*P): return (*q); We cannot use return keyword in the terenary operators.

  #include<stdio.h>
  int check (int, int);
  
  int main()
  {
      int c;
      c = check(10, 20);
      printf("c=%d\n", c);
      return 0;
  }
  int check(int i, int j)
  {
      int *p, *q;
      p=&i;
      q=&j;
      i>=45 ? return(*p): return(*q);
  }

• Example Valid : In this below example a is lesser than b . so the b value

  a= 5;
  b=7;
  a>b?a:b;

• More examples :
  • Find largest number among 3 numbers using ternary operator

Associativity

Associativity is only needed when the operators in an expression have the same precedence. Usually + and – have the same precedence.

Consider the expression 7 – 4 + 2. The result could be either (7 – 4) + 2 = 5 or 7 – (4 + 2) = 1. The former result corresponds to the case when + and – are left-associative, the latter to when + and – are right-associative.

Usually, the addition, subtraction, multiplication, and division operators are left-associative, while the exponentiation, assignment, and conditional operators are right-associative. To prevent cases where operands would be associated with two operators or no operator at all, operators with the same precedence must have the same associativity.

BIT Operations

How do find the status of a particular bit is SET or NOT?

#include <stdio.h>

int main(void)
{
  //How to find the status of a particular bit is SET or NOT?
    int value = 5;
    int n = 2;
    if (value & (1 << (n - 1)))
        printf("SET");
    else
        printf("NOT SET");

    return 0;
}

Print the Multiplication of the given N number?

#include <stdio.h>
#define N 4
int main()
{
    
    printf("Method-1: 1*%d = %d\n",N,(N));
    printf("Method-1: 2*%d = %d\n",N,(N<<1));
    printf("Method-1: 3*%d = %d\n",N,(N<<1)+N);
    printf("Method-2: 3*%d = %d\n",N,(N<<2)-N);
    printf("Method-1: 4*%d = %d\n",N,(N<<2));
    printf("Method-1: 5*%d = %d\n",N,(N<<2)+N);
    printf("Method-1: 8*%d = %d\n",N,(N<<3));
    printf("Method-1: 9*%d = %d\n",N,(N<<3)+N);
    printf("Method-1: 10*%d = %d\n",N,(N<<3)+(N<<1));
    printf("Method-1: 15*%d = %d\n",N,(N<<4)-N);
    printf("Method-1: 16*%d = %d\n",N,(N<<4));
    printf("Method-1: 40*%d = %d\n",N,(N<<5)+(N<<3));
    return 0;
}

OutPut

Method-1: 1*4 = 4
Method-1: 2*4 = 8
Method-1: 3*4 = 12
Method-2: 3*4 = 12
Method-1: 4*4 = 16
Method-1: 5*4 = 20
Method-1: 8*4 = 32
Method-1: 9*4 = 36
Method-1: 10*4 = 40
Method-1: 15*4 = 60
Method-1: 16*4 = 64
Method-1: 40*4 = 160


...Program finished with exit code 0
Press ENTER to exit console.

NEXT

C Structure is the group of heterogeneous data structure which can store data of different data types or Structure is a collection of variables of different types under a single name. 

In the case of array, we can store the data of same data type but what if we have to save data of different data type in structure. Can use single structure name for  more type of data in structure and union. Storage area is not reserved by the compiler to structure definition.

• Keyword struct  is used for creating a structure.
• Structure is a user defined data structure.

C Structure Syntax

struct tag_filed_name 
{
    data_type_1 member_1;
    data_type_2 member_2
    .
    .
    .
    data_type_N member_N
}

How to create a structure?

‘struct’ keyword is used to create a structure. Following is an example.

struct address
{
   char name[50];
   char street[100];
   char city[50];
   char state[20];
   int pin;
};

Rules

• Use declare semicolon };at end of structure. (Don’t forget the semicolon in  the ending line.)
• Referencing structure members : struct_var-name . member_variable
• A structure variable can be assigned to other using =, but cannot be compared with other using ==
• In Structure bit cant set in float variable.
• Bit-fields are only part of structs or unions because that’s what the C standard allows

static members can’t allowed in structure

• In C, struct and union types, we cannot have static members.
• In C++, struct types are allowed to have static members, but in union cannot have static members in C++ also.
• The Below C program output is compilation error.

#include<stdio.h>
struct st
{
    int x;
    static int y;
};
 
int main()
{
    printf("%d", sizeof(struct st));
    return 0;
}

How to declare structure variables?

Way 1:

struct struct_name
{
    data_type member_1;
    data_type member_2;
}var_1, var_2;

Way 2 : struct struct_name var_1, var_2;

struct struct_name
 var_1, var_2;

How to initialize structure members?

Note: Structure elements cannot be initialized. When we declare a structure or union, we actually declare a new data type suitable for our purpose. By default, structure member init with a NULL value. It means Zero.

static struct structure_name var-name = 
{
        var_1, var_2,...var_n
};

So we cannot initialize values as it is not a variable declaration but a data type declaration. The below program output is Compilation error.

#include‹stdio.h›
int main()
{
    struct site
    {
        char name[] = "ArunEworld";
        int no_of_pages = 20;
    };
    struct site *ptr;
    printf("%d ", ptr->no_of_pages);
    printf("%s", ptr->name);
    getchar();
    return 0;
}

In a school, we need to store data like name, roll no, address and percentage. But we are able to store only one data type at a time. So, C programming provides a structure data type that can store data of different types such as integer, float, character, etc. In the case of the above school, we can initialize structure as (refer below example)

struct info
{
    char name [10];
    int roll_no;
    char address [10];
    float per;
};

Read/write in Structure variables

• . (colon) is the member of a structure
• -> (arrow) is the member of a POINTED TO structure
• x -> y and (*x).y are both the same

When to user ->  (arrow) operator.?

• When the structure/union variable is a pointer variable, we use the arrow operator to access structure/union elements.

What is a self-referential structure?

• We call a structure containing the same structure pointer variable as its element a self-referential structure.

Nested structure [structure with structure]

• We refer to a structure containing an element of another structure as its member.

Example : School Data Base

The below example explains many things about the structure

• This below code is the best example for structure array.

/*********************************
Date: 2016-06-04
Authur: Arun
********************************/

#include <stdio.h>
#include <stdint.h>

//The structure used to store the school student details
typedef struct student_Details
{
    uint8_t     Roll_no; 
    const char* studnt_Name;
    uint8_t    Tamil;
    uint8_t    English;
    uint8_t    Maths;
    uint8_t    Science;
    uint8_t    SocialScience;
    
}student_Details;

// Already declared structure can initialize, throw here.
static student_Details Entry[]=
{
  {1, "Arun", 0, 0, 0, 0, 0},
  {2, "Jhon", 0, 0, 0, 0, 0},
  {3, "Raja", 0, 0, 0, 0, 0},
  {4, "Gaurav", 0, 0, 0, 0, 0},
  {5, "Smith", 0, 0, 0, 0, 0},
  {6, "Jothi", 0, 0, 0, 0, 0},
};


//Printing the structure array
void printStudentDetails()
{
    printf("\n\r Total No of stundets : %ld", sizeof(Entry)/sizeof(student_Details));
    
    uint8_t i=0, No_of_students = sizeof(Entry)/sizeof(student_Details);
    
    printf("\n _________________________________________________________");
    printf("\n | ID | Name \t | S1 \t | S2 \t| S3 \t| S4 \t| S5 \t |");
    printf("\n _________________________________________________________");
    while(No_of_students != i)
    {
        printf("\n\r | %d | %s \t | %d \t | %d \t | %d \t | %d \t | %d \t | ",
        Entry[i].Roll_no, 
        Entry[i].studnt_Name, 
        Entry[i].Tamil,
        Entry[i].English,
        Entry[i].Maths,
        Entry[i].Science,
        Entry[i].SocialScience);
        
        i++;
    }
    printf("\n _________________________________________________________");
}

void UpdateStudentRecord(int Rn,int Sb, int Mrk)
{
    if(Sb == 1)     Entry[Rn-1].Tamil= Mrk;
    else if(Sb == 2) Entry[Rn-1].English= Mrk;
    else if(Sb == 3) Entry[Rn-1].Maths= Mrk;
    else if(Sb == 4) Entry[Rn-1].Science= Mrk;
    else if(Sb == 5) Entry[Rn-1].SocialScience= Mrk;
}

void PrintHelperMenu()
{
    printf("\n helper Menu ");
    printf("\n 1 - Print Student record");
    printf("\n 2 - Update the Student Only One subject mark Mark");
}

void helperMenu()
{
    int scanValue;
    
    PrintHelperMenu();
    
    while(1)
    {
        printf("\n");
        
        scanf("%d",&scanValue);
        
        if(scanValue == 2 )
        {
            int Rn,Sb,Mrk;
            
            printf("\n 1 - Tamil, 2 - English, 3 - Maths, 4 - Science, 5 - Social Science.");
            
            printf("\n Enter the Roll No, Subject and Mark : ");
            
            scanf("%d%d%d",&Rn, &Sb, &Mrk);
            
            UpdateStudentRecord(Rn,Sb,Mrk);
            
            printStudentDetails();
            
            PrintHelperMenu();
        }
        else if( scanValue == 1)
        {
            printStudentDetails();
            
            PrintHelperMenu();
        }
    }
}

int main()
{
    helperMenu();
    return 0;
}

Structure Padding

During struct memory allocation, the system adds empty bytes based on the controller/processor type (8/16/32/64 bit), which can lead to memory issues when working with large arrays of data.

Structure Packing

Reduce the amount of memory that your application requires by packing data into structures. This is especially important if you need to store and access large arrays of data.

pack() function can be use to packing the structure memory.

• Syntax: #pragma pack(parameters)
• Parameters: 1 – Aligns structure members on 1-byte boundaries, or on their natural alignment boundary, whichever is less.
• Parameters: 2 – Aligns structure members on 2-byte boundaries, or on their natural alignment boundary, whichever is less.
• Parameters: 4 – Aligns structure members on 4-byte boundaries, or on their natural alignment boundary, whichever is less.
• Parameters: 8 – Reserved for possible future use.
• Parameters: 16 – Reserved for possible future use.

• Pack() function : Reference Link
• Reference Link

Memory allocation in C refers to the process of reserving memory space during the execution of a program for storing variables or data structures. There are mainly two types of memory allocation in C: stack allocation and heap allocation.

Stack Allocation:

• Stack allocation is the default method for allocating memory for local variables within functions.
• Memory allocated on the stack is automatically managed by the compiler.
• Variables allocated on the stack have a fixed size and are deallocated when they go out of scope, typically when the function exits.
• Stack memory is limited and generally smaller than heap memory.

Heap Allocation:

• Heap allocation involves dynamically allocating memory during runtime from the heap, which is a larger pool of memory managed by the operating system.
• Memory allocated on the heap must be explicitly requested and released by the programmer using functions like malloc(), calloc(), realloc(), and free().
• Heap memory allows for dynamic data structures like linked lists, trees, and dynamic arrays.
• Improper use of heap memory can lead to memory leaks or memory fragmentation.

Common memory allocation functions in C:

• malloc(size_t size): Allocates a block of memory of specified size in bytes and returns a pointer to the allocated memory.
• calloc(size_t num, size_t size): Allocates an array of elements initialized to zero, with the total size equal to num * size bytes, and returns a pointer to the allocated memory.
• realloc(void* ptr, size_t size): Resizes the previously allocated memory block pointed to by ptr to the new size specified by size. It may move the memory block to a new location, and the contents of the original block may be copied to the new block.
• free(void* ptr): Releases the memory block previously allocated by malloc, calloc, or realloc.

Proper memory management is crucial in C programming to prevent memory leaks, segmentation faults, and other memory-related issues. It’s essential to allocate memory dynamically only when necessary and deallocate it when no longer needed to ensure efficient memory usage.

Static Memory allocation

In the case of static memory allocation, memory is allocated at compile time and memory can’t be increased while executing the program. It is used in the array

Dynamic memory allocation

In the case of dynamic memory allocation, memory is allocated at run time and memory can be increased while executing the program. It is used in the linked list.

The following functions are used in Dynamic memory allocation

• malloc() – allocates a single block of requested memory. It has garbage value initially.
• calloc()  – allocates multiple blocks of requested memory. It initially initializes all bytes to zero.
• realloc() – reallocates the memory occupied by malloc()  or calloc()  functions.
• free()      – free the dynamically allocated memory.

Stack grows upwards or downwards

Write a C code to check whether a stack grows upwards or downwards

void main()
{
	int i=2;
	int j=3;
	
	if(&i > &j)
	{
		printf("stack grown downwards");
	}
	else
	{
		printf("stack grows upwards");
	}
}

Memory Layout & Storage Type understanding

char *getString()
{
   char *str = "Nice test for strings";
   return str;
}
 
int main()
{
   printf("%s", getString());
   getchar();
   return 0;
}

Output: “Nice test for strings”
Explanations:

• The above program works because string constants are stored in Data Section (not in Stack Section). So, when getString returns *str is not lost.
• string constants are stored in Data Section (not in Stack Section)
• static variable and is stored in Data Section,
• array variables are stored in Stack Section

It is very difficult to define more variables’ names when using more data.  So can create a array to solve this difficult(single variable name and more data). If the index of the array size is exceeded, the program will crash. But the modern compilers will take care of this kind of errors. We cannot initialize the size of array dynamically. Constant expression is required. This tutorial about “C Array”

Array Rules

• only store the same data types in array structures
• Arrays are always passed by reference
• Array list should be end expression with semicolon  ; . Otherwise it will show the error.
•  
• What is Base address of array??  Eg : a[10] = {0,1,2,3,4,5,6,7,8,9};     // The starting address of the array is called as the base address of the array. Consider the address of the array starts from 101. Here the variable 0(Zero) address is the base address and the base address of the array is 101.
• When we pass an array as a function argument, the base address of the array will be passed.
• Array three types
  1. One Dimensional Array
  2. Two Dimensional Array and
  3.  Multi Dimensional Array

One Dimensional Array

When declare one index value is called One dimensional array

Syntax: 

data_type array_name [ size];

• data_type  – What kind of array data type
• array_name  – name of the array
• size  – array size

Syntax Declaration:

• int a[100];  //Data type- int (2Byte), array_name – ‘a’, size – 100, Memory Occupies- 200 byte (100×2).
• float s [50];  //Data type- float(4byte), array_name – ‘s’, size – 50, Memory Occupies- 200 byte (50×4).
• char name[15];  // Data type- char(1byte), array_name – “name”, size – 15, Memory Occupies- 15 byte (15×1).

Declaration : int a[100];

• Reading : for(i=0; i<100; i++) scanf(“%d”, &a[i]);
  
• Writing : for(i=0; i<100; i++) printf(“%d”, a[i]);
• Memory Representation :

Array initialization Syntax :

Synatx:  data_type array_name [size] = {list_of_values}; 

Examples

• static int age [3] = {10,20,30};  //its means – a[0]=10; a[1]=20; a[3]=30;
• static float salary[] = {1000,2200,3300};  //salary[0]=1000; salary[2]=3300;
• static char a[10] = “ArunEworld”;  //its means – a[0]=’A’; a[1]=’r’; like… a[9]=’d’;

Array initialization with Zero:

When an automatic array is partially initialized, the remaining elements are initialized to 0.

Example-1:

#include<stdio.h>
int main()
{
    int awe[2];
    printf("%d, %d, %d, %d, %d, %d, %d, %d\n", awe[0], awe[1], awe[2], awe[3], awe[4], awe[5], awe[6], awe[7]);
    return 0;
}

/* Output:     0, 0, 0, 0, -467742907, 32525, 0, 0 */

Example-2:

#include<stdio.h>
int main()
{
    int awe[3]={1,2,3};
    printf("%d, %d, %d, %d, %d, %d, %d, %d\n", awe[0], awe[1], awe[2], awe[3], awe[4], awe[5], awe[6], awe[7]);
    return 0;
}

/* Output:     1, 2, 3, 0, 0, -2036674747, 32587, 0 */

Accessing the Array Element

#include<stdio.h>

int main()
{
    int arr_aew[2]={10,2};
    printf("%d\n", 1[arr_aew]);
    return 0;
}

/* Output: 2 */

Other Example Programs

Check this below examples list in this Links

• C program to Find Smallest & Largest Number of N numbers in Array.c
• C program to Ascending Order of N numbers in Array.c
• C program to Descending Order of N numbers in Array.c
• C program to fine Largest Number and Position of N numbers in Array.c
• C program to Find Mean and Standard Deviation in Array Element.c

Two Dimensional Array

• When declare two index value is called two dimensional array
• Two dimensional arrays can consider as a table. size_1 is row size and size_2 is column size.

Syntax: data_type array_name [ size_1] [size_2];

1. • data_type  – What kind of array data type
   • array_name  – name of the array
   • size_1 , size_2 – two dimensional array size

Syntax Declaration:

• • int a[100] [20];  //Data type- int (2Byte), array_name – ‘a’, size_1(row) – 100,size_2(column)-20, Memory Occupies- 200 byte (100×2).

Declaration : int a[10][15];

Reading : for(i=0; i<10; i++) for(j=0; j<15; j++) scanf(“%d”, &a[i][j]); 

Writing : for(i=0; i<10; i++) for(j=0; j<15; j++) printf(“%d”, a[i][j]); 

• Memory Representation :

Array initialization Syntax : data_type array_name [size_1] [size_2] = {v1, v2,…..vn}; 

Examples

• static int mark[3][2] = {60,70,80, 35,90,18};  //its means – a[0][0]=60; a[0][1]=70; a[0][3]=30; a[1][0]=35; a[1][1]=90; a[1][2]=18;
• static mark[3][2] = {{50},{0},{35};  //a[0][0]=50; a[0][1]=50; a[0][3]=0; a[1][0]=0; a[1][1]=35; a[1][2]=35;

Example Programs

• Two_dimensional_array_read_row_column.c
• Two_dimensional_array_print_row_column.c
• Matrix_transpose_using_two_dimensional_array.c
• Diagonal_elements_using_two_dimensional_array.c
• Sum_of_diagonal_elements_using_two_dimensional_array.c
• Sum_of_all_matrix_elements_using_two_dimensional_array.c
• Add_a_given_matrix_elements_using_two_dimensional_array.c
• Multiply_matrix_elements_using_two_dimensional_array.c
• Largest_and_smallest_elements_using_two_dimensional_array.c

Exercise

C Program to Find the Number of Elements in an Array

Method 1:

if you know then data type of the array then easily can find out the array elements one if its initialized using sifeof(variable or array name) predefined function.

/* * C Program to Find the Number of Elements in an Array */
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
int main()
{
    int array[] = {15, 50, 34, 20, 10, 79, 100};
    int n; 
    n = sizeof(array);
    printf("Size of the given array is %d\n", n/sizeof(int));
    return 0;
}

Method 2 :

if you don’t know then data type of the array then bit difficult to find out the array elements.

Find the size of array

#include <stdio.h>
int main()
{
  int size,i;
  printf("Enter the size of the array list");
 // scanf("%d",&size);
  int Arr[5]={88,97,65,43,77};
  size = 5;
   
  printf("\nBefore Array value\t:\t");
  for(i=0;i<size;i++)
    printf("%d\t",Arr[size]);
  /*
  for(i=0;i<size;i++)
  {
    if(Arr[size]>Arr[size+1])
      
  }
  */
  getchar();
  return 0;
}

Sum of the arrays 10 element

#include<stdio.h>
#include<conia.h>
int main()
{
	int num_array[10];
	int i,sum=0;
	int *ptr;
	printf("\n Enter 10 Elements")
	for(i=0; i<=10; i++)
		scanf("%d", num_array[i]);
	ptr = num_array;
	for(i=0; i<=10; i++)
	{
		sum = sum + *ptr;
		*ptr++;
	}
	printf("\n Sum of the arrays's 10 element : %d", sum);
	return 0;
}

NEXT

main()
{
    extern int x;  //Tells compiler that it is defined somewhere else
    printf("%d",x);   
}
int x=10;    //Global variable x

Extern Variable Initializer

Extern as global variable initializer

• The extern keyword variable can be initialize when its global

Example : External variable always initialize (Zero) ‘0’

#include "stdio.h"
extern int a;
main(){
    printf("a=%d",a);
    return 0;
}
int a;

/* Output : a=0 */

Example : variable initialize in  global variable

#include "stdio.h"
extern int a;
main(){
    printf("a=%d",a);
    return 0;
}
int a =5;

/* Output : a=5 */

Example :

#include <stdio.h> 
extern int a;
int main()
{
    void fun();
    printf("\n a=%d",a);
    fun();
    return 0;
}
int a=7;
    
void fun()
{
    printf("\n in fun a=%d",a);
}

/* Output : 
 a=7
 in fun a=7
*/

Example : variable initialize in  global variable

#include <stdio.h> 
extern int a=5;
int main()
{   
    printf("%d",a);
    return 0;
}

/* Output : 5*/
/* Explanation pritf function print a value as 5. */

Example : variable initialize in  global variable

#include <stdio.h> 
extern int a=5;
int main()
{
    void fun();
    printf("\n a=%d",a);
    fun();
    return 0;
}
int a;
    
void fun()
{
    printf("\n in fun a=%d",a);
}

/* Output : 
 a=5
 in fun a=5
*/

Example : Error while running Linker

#include <stdio.h> 
extern int a;
int main()
{
    printf("\na=%d",a);
    return 0;
}

/* Output : // Error */

/*
  Error[e46]: Undefined external "a" referred in main 
  Error while running Linker 
*/

Extern as local variable initializer

#include <stdio.h> 
int main()
{
  extern int a=5;
  printf("%d",a);
  return 0;
}

/* Output */
// Error[Pe2442]: an initializer is not allowed on a local declaration of an extern variable main.c