FEBRUARY 19, 2025

UNDERSTANDING
LOOPS, QUALIFIERS AND MODIFIERS IN C LANGUAGE

VAMSI KRISHNA VAKA

What is a Loop?
A loop in C is a control structure that allows repetitive execution of a block of code as long as a
specified condition is met. Loops help reduce redundancy and make the program more efficient.

Why Do We Use Loops?

• To avoid code repetition.

• To execute a block of code multiple times based on a condition.

• To iterate through arrays, lists, or perform calculations.

• To implement logic such as searching, sorting, and mathematical operations.

Types of Loops in C

C provides three types of loops:

1. for Loop (Entry-controlled loop)

2. while Loop (Entry-controlled loop)

3. do-while Loop (Exit-controlled loop)

1. for Loop

The for loop is an entry-controlled loop, meaning the condition is checked before execution.

Syntax:

for(initialization; condition; update)

// Code to be executed

• Initialization: Executed once before the loop starts.

• Condition: The loop executes as long as this condition is true.

• Update: Executed after each iteration.

Example: Print numbers from 1 to 5

#include <stdio.h>
int main()
{
for(int i = 1; i <= 5; i++)
{
printf("%d\n", i);
}
return 0;
}
Output:

2. while Loop

The while loop is an entry-controlled loop that executes as long as the condition is true.

Syntax:

while(condition)

// Code to be executed

• The loop starts only if the condition is true.

• If the condition is false initially, the loop does not execute.

Example: Print numbers from 1 to 5

#include <stdio.h>
int main()
{
int i = 1;
while(i <= 5)
{
printf("%d\n", i);
i++;
}
return 0;
}

Output:

5
3. do-while Loop

The do-while loop is an exit-controlled loop, meaning the loop body executes at least once, even if
the condition is false.

Syntax:

do

// Code to be executed

} while(condition);

Example: Print numbers from 1 to 5

#include <stdio.h>
int main()
{
int i = 1;
do
{
printf("%d\n", i);
i++;
} while(i <= 5);
return 0;
}
Output:

Loop Variations
1. Infinite Loops

o A loop runs indefinitely if the condition is always true.

o Example:

while(1)

printf("This is an infinite loop\n");

}
 2. Nested Loops

o A loop inside another loop.

o Example:

for(int i = 1; i <= 3; i++)

for(int j = 1; j <= 2; j++)

printf("i = %d, j = %d\n", i, j);

o Output:

i = 1, j = 1

i = 1, j = 2

i = 2, j = 1

i = 2, j = 2

i = 3, j = 1

i = 3, j = 2

Jumping Statements:
Jumping statements in C are used to transfer control from one part of the program to another. These
include:

1. break

2. continue

3. goto

4. return

1. break Statement

The break statement is used to exit a loop or switch statement prematurely.

Syntax:

break;

Example 1: Breaking a Loop

#include <stdio.h>
int main()
{
for(int i = 1; i <= 10; i++)
{
if(i == 5)
{
break; // Exits the loop when i == 5
}
printf("%d ", i);
}
return 0;
}
Output:

1234

Explanation:

• The loop runs from 1 to 10, but when i == 5, the break statement terminates the loop.

Problem 1: Stop Printing at a Certain Value

Code:

#include <stdio.h>
int main()
{
for (int i = 1; i <= 10; i++)
{
if (i == 6)
{
break; // Exit loop when i == 6
}
printf("%d ", i);
}
return 0;
}
Output:

12345

Explanation:

• The loop runs from 1 to 10, but when i == 6, break terminates the loop.

Problem 2: Find the First Even Number

Code:

#include <stdio.h>
int main()
{
int arr[] = {1, 3, 5, 7, 8, 9, 11};
int size = sizeof(arr) / sizeof(arr[0]);
for (int i = 0; i < size; i++)
{
 if (arr[i] % 2 == 0)
{
printf("First even number: %d\n", arr[i]);
break; // Stop after finding the first even number
}
}
return 0;
}
Output:

First even number: 8

Problem 3: Printing Stars but Stopping at a Certain Row

Code:

#include <stdio.h>
int main()
{
for (int i = 1; i <= 5; i++)
{
for (int j = 1; j <= i; j++)
{
printf("* ");
if (j == 3)
break; // Stop printing stars when 3rd column is reached
}
printf("\n");
}
return 0;
}

Output:

**

***

***

***

2. continue Statement

The continue statement is used to skip the current iteration and move to the next iteration of the
loop.

Syntax:

continue;

Example 2: Skipping a Number

#include <stdio.h>
int main()
{
for(int i = 1; i <= 10; i++)
{
if(i == 5)
{
continue; // Skips iteration when i == 5
}
printf("%d ", i);
}
return 0;
}
Output:

1 2 3 4 6 7 8 9 10

Explanation:

• When i == 5, the continue statement skips printing 5 and continues with the next iteration.

Problem 1: Skip Multiples of 3

Code:

#include <stdio.h>
int main()
{
for (int i = 1; i <= 10; i++)
{
if (i % 3 == 0)
{
continue; // Skip multiples of 3
}
printf("%d ", i);
}
return 0;
}

Output:

1 2 4 5 7 8 10

Problem 2: Skip 5 in a Pattern

Code:

#include <stdio.h>
int main()
{
for (int i = 1; i <= 10; i++)
{
if (i == 5)
{
continue; // Skip number 5
}
 printf("%d ", i);
}
return 0;
}

Output:

1 2 3 4 6 7 8 9 10

Problem 3: Print Odd Numbers Only

Code:

#include <stdio.h>
int main()
{
for (int i = 1; i <= 10; i++)
{
if (i % 2 == 0)
{
continue; // Skip even numbers
}
printf("%d ", i);
}
return 0;
}
Output:

13579

3. Goto Statement

The goto statement allows jumping to a labeled statement anywhere in the program. It is generally
discouraged as it makes code hard to debug, but sometimes useful for breaking deeply nested loops.

Syntax:

goto label;

...

label:

// Code to execute

1. Using goto to Exit a Loop

#include <stdio.h>
int main()
{
int i = 1;
while(i <= 10)
{
printf("%d ", i);
if(i == 5)
{
goto end; // Jump to the "end" label
}
i++;
}
end: // Label
printf("\nLoop terminated early using goto.\n");
return 0;
}
Output:

12345

Loop terminated early using goto.

Explanation:

• The loop runs normally but exits early when i == 5 using goto.

2. Using goto to Repeat a Block of Code

#include <stdio.h>
int main()
{
int num;
retry: // Label for re-entering the input step
printf("Enter a positive number: ");
scanf("%d", &num);
if(num < 0)
{
printf("Invalid input! Try again.\n");
goto retry; // Jump to "retry" label
}

printf("You entered: %d\n", num);

return 0;
}
Output:

Enter a positive number: -3

Invalid input! Try again.

Enter a positive number: 5

You entered: 5

Explanation:
 • If the user enters a negative number, the program jumps back to the retry label and asks for
input again.

Problem 1: Simple Jump

Code:

#include <stdio.h>
int main()
{
printf("Before goto\n");
goto jump;
printf("This won't be printed\n");
jump:
printf("After goto\n");
return 0;
}
Output:

Before goto

After goto

Problem 2: Retry Input Until Valid

Code:

#include <stdio.h>
int main()
{
int num;
retry:
printf("Enter a positive number: ");
scanf("%d", &num);
if (num < 0)
{
printf("Invalid! Try again.\n");
goto retry;
}
printf("You entered: %d\n", num);
return 0;
}

Problem 3: Loop Simulation Using goto

Code:

#include <stdio.h>
int main()
{
int i = 1;
loop:
if (i > 5) return 0;
 printf("%d ", i);
i++;
goto loop;
}
Output:

12345

4. return Statement

The return statement exits the function and optionally returns a value.

Example: Using return

#include <stdio.h>
void greet()
{
printf("Hello, ");
return; // Exits the function early
printf("World!"); // This line is never executed
}
int main()
{
greet();
return 0;
}
Output:

Hello,

Explanation: The return statement exits the function early, skipping the second printf.

Pattern Programs
1. Right-Angled Triangle

#include <stdio.h>

int main()

int n = 5;

for(int i = 1; i <= n; i++)

for(int j = 1; j <= i; j++)

printf("* ");
 }

printf("\n");

return 0;

Output:

**

***

****

*****

2. Inverted Right-Angled Triangle

#include <stdio.h>

int main()

int n = 5;

for(int i = n; i >= 1; i--)

for(int j = 1; j <= i; j++)

printf("* ");

printf("\n");

return 0;

Output:

*****

****

***
**

3. Pyramid Pattern

#include <stdio.h>

int main()

int n = 5;

for(int i = 1; i <= n; i++)

for(int j = i; j < n; j++)

printf(" ");

for(int k = 1; k <= (2*i - 1); k++)

printf("*");

printf("\n");

return 0;

Output:

***

*****

*******

*********

4. Number Triangle Pattern

#include <stdio.h>

int main()

int n = 5;

for(int i = 1; i <= n; i++)

for(int j = 1; j <= i; j++)

printf("%d ", j);

printf("\n");

return 0;

Output:

12

123

1234

12345

Explanation:

• Outer loop (i) runs from 1 to n (5).

• Inner loop (j) prints numbers from 1 to i, forming the increasing triangle pattern.

5. Reverse Number Triangle

#include <stdio.h>

int main()

int n = 5;

for(int i = n; i >= 1; i--)

{
 for(int j = 1; j <= i; j++)

printf("%d ", j);

printf("\n");

return 0;

Output:

12345

1234

123

12

Explanation:

• Outer loop starts from n (5) and decreases.

• Inner loop prints numbers from 1 to i, creating a decreasing pattern.

6. Hollow Square Pattern

#include <stdio.h>

int main()

int n = 5;

for(int i = 1; i <= n; i++)

for(int j = 1; j <= n; j++)

if(i == 1 || i == n || j == 1 || j == n)

printf("* ");
 }

else

printf(" ");

printf("\n");

return 0;

Output:

*****

* *

* *

* *

*****

Explanation:

• Print * if on the first/last row or first/last column.

• Print space otherwise.

7. Diamond Pattern

#include <stdio.h>

int main()

int n = 5;

// Upper half of the diamond

for(int i = 1; i <= n; i++)

for(int j = i; j < n; j++)

printf(" ");
 }

for(int k = 1; k <= (2*i - 1); k++)

printf("*");

printf("\n");

// Lower half of the diamond

for(int i = n - 1; i >= 1; i--)

for(int j = n; j > i; j--)

printf(" ");

for(int k = 1; k <= (2*i - 1); k++)

printf("*");

printf("\n");

return 0;

output:

***

*****

*******

*********

*******

*****

***
 *

Explanation:

• The first loop prints the upper pyramid.

• The second loop prints the lower pyramid by reducing the row count.

Qualifiers and Modifiers

1. Type Qualifiers in C

Type qualifiers in C specify how a variable should be stored or accessed. They do not change the
data type but modify the behaviour of variables.

Types of Type Qualifiers

1. const - Declares a variable as read-only.

2. volatile - Prevents compiler optimizations on a variable.

1.1 const Qualifier

• The const qualifier makes a variable read-only.

• It must be initialized at the time of declaration.

• Syntax:

const int x = 10;

x = 20; // Error: assignment of read-only variable

1. const with Basic Variables

Example 1: Trying to Modify const Variable

#include <stdio.h>

int main()

const int x = 10;

x = 20; // Error: Cannot modify a const variable

printf("%d", x);

return 0;

Explanation: Since x is declared as const, modifying it is not allowed.

2. const with Pointers

Example 2: Pointer to const Integer

#include <stdio.h>

int main()

const int a = 5;

const int *ptr = &a; // Pointer to a constant integer

*ptr = 10; // Error: Cannot modify a const value through a pointer

printf("%d", a);

return 0;

Explanation: The pointer ptr can point to another integer, but cannot modify the value it points to.

Example 3: const Pointer to Integer (Constant Pointer)

#include <stdio.h>

int main()

int a = 10;

int b = 20;

int *const ptr = &a; // Constant pointer to an integer

ptr = &b; // Error: Cannot change the address of a constant pointer

*ptr = 30; // Allowed: Can modify the value at the address

printf("%d", a);

return 0;

Explanation: ptr is a constant pointer, so its address cannot be changed, but the value it points to
can be modified.

Example 4: const Pointer to const Integer

#include <stdio.h>
int main()

const int a = 10;

const int *const ptr = &a; // Constant pointer to a constant integer

*ptr = 20; // Error: Cannot modify the value

ptr = &b; // Error: Cannot change the address

printf("%d", a);

return 0;

Explanation:

• const int *const ptr → Cannot modify value, cannot change pointer.

3. const with Function Parameters

Example 5: Passing const to a Function

#include <stdio.h>
void modify(const int x)
{
x = 20; // Error: Cannot modify a const parameter
}
int main()
{
int num = 10;
modify(num);
return 0;
}
Explanation: A const parameter cannot be modified inside the function.

Example 6: Using const Pointer as Function Parameter

#include <stdio.h>
void printValue(const int *ptr)
{
*ptr = 100; // Error: Cannot modify a const value
printf("%d", *ptr);
}
int main()
{
int num = 10;
printValue(&num);
return 0;
}
Explanation: ptr is a pointer to const int, so the function cannot modify the value of num.
4. const with Arrays

Example 7: const Array Elements

#include <stdio.h>

int main()

const int arr[] = {1, 2, 3, 4};

arr[0] = 10; // Error: Cannot modify a `const` array element

printf("%d", arr[0]);

return 0;

Explanation: Since arr is const, we cannot change its elements.

Example 8: const Pointer to Array

#include <stdio.h>

int main()

int arr[] = {1, 2, 3, 4};

const int *ptr = arr; // Pointer to `const` array

ptr[0] = 100; // Error: Cannot modify a `const` value

printf("%d", ptr[0]);

return 0;

Explanation: The pointer ptr cannot modify array elements.

5. const with Global Variables

Example 9: Global const Variable

#include <stdio.h>

const int x = 50; // Global const variable

void changeValue()

{
 x = 100; // Error: Cannot modify a global `const` variable

int main()

changeValue();

return 0;

Explanation: A const global variable cannot be modified inside or outside of main().

6. const in Structs

Example 11: const Struct Members

#include <stdio.h>
struct Data
{
const int value;
};
int main()
{
struct Data d1 = {100};
d1.value = 200; // Error: Cannot modify a `const` struct member
printf("%d", d1.value);
return 0;
}
Explanation: A const struct member cannot be modified.

1.2. volatile Qualifier

What is volatile in C?

The volatile keyword informs the compiler that a variable’s value can change at any time, preventing
the compiler from applying certain optimizations.

Why volatile is Needed?

When a variable is declared as volatile, the compiler must always read its value from memory instead
of optimizing it by storing it in a register.

Situations Where volatile is Necessary

1. Memory-Mapped Registers in Embedded Systems

2. Global Variables Modified by Interrupts

3. Shared Variables in Multi-Threading

 • Used in: Embedded systems, hardware registers, interrupt handlers, multi-threading.

• Syntax:

volatile int flag = 0;

Compiler Optimizations:

Compilers use various optimization techniques to improve performance and reduce code size by
eliminating unnecessary computations. However, these optimizations can sometimes change the
intended behavior of the program, especially when working with hardware registers, multi-threaded
applications, or memory-mapped devices.

Example 1:

#include <stdio.h>
volatile int flag = 0; // Can be modified by hardware
void check()
{
while (flag == 0)
{
// Loop will not be optimized
}
printf("Flag changed!\n");
}
int main()
{
check();
return 0;
}
• Example Problem:

// Why do we need volatile for hardware registers?

volatile int *status_register = (int *)0x40021000;

while ((*status_register & 0x01) == 0) {

// Wait for hardware event (without optimization)

2. Type Modifiers in C

Type modifiers are used to change the storage size and sign of basic data types.

Types of Type Modifiers

1. signed - Allows both positive and negative values (default for int).

2. unsigned - Allows only positive values.

3. short - Reduces memory size.

4. long - Increases memory size.

2.1 signed and unsigned Modifiers

• Signed Variables store positive and negative values.

• Unsigned Variables store only positive values (0 and above).

• Syntax:

signed int a = -5; // Default signed integer

unsigned int b = 10; // Only positive values

• Example:

#include <stdio.h>

int main()

signed int x = -10;

unsigned int y = 10;

printf("x = %d\n", x);

printf("y = %u\n", y);

return 0;

• Example Problem:

int main()

unsigned int x = -5; // Overflow: Interpreted as large positive number

printf("%u\n", x);

return 0;

2.2 short and long Modifiers

• short reduces memory usage, while long increases it.

• Syntax:

short int s = 100; // Uses 2 bytes

long int l = 100000; // Uses 4 or 8 bytes

Example:

#include <stdio.h>

int main()

short int s = 100;

long int l = 1000000;

printf("Short: %hd, Long: %ld\n", s, l);

return 0;

• Example Problem:

long int x = 2147483648; // Error: Out of range for int

Summary Table

Qualifier/Modifier Purpose Example

const Makes a variable read-only const int x = 5;

volatile Prevents compiler optimizations volatile int flag;

signed Allows negative and positive values signed int a = -5;

unsigned Only positive values unsigned int a = 10;

short Uses less memory short int a = 10;

long Uses more memory long int a = 100000;

Practice Problems

1. What is the output of this code?

int main()

const int x = 10;

int *ptr = (int *)&x;

*ptr = 20;

printf("x = %d\n", x);

 return 0;

o Will this compile? What happens?

2. Why is volatile important in embedded systems?

volatile int *status = (int *)0x4000;

while ((*status & 0x01) == 0) { }

o What happens if volatile is removed?

3. What is wrong with this code?

void modify(int *restrict p, int *q)

*p = *q; // May cause undefined behavior