June 24, 2021


TriStudy Provide Free Online Tutorials about Programming languages,Digital Marketing, web designing, online earning, web hosting, WordPress etc

C-for loop in C programming.

C-for loop in C programming

A circle is utilized for executing a square of articulations more than once until a given condition returns bogus.

C-for loop in C programming.

C program For circle .

This is one of the most habitually utilized circle in C programming. Punctuation of for circle:

for (introduction; condition test; augmentation or decrement)


/Statements to be executed more than once

Step 1: First initialization happens and the counter variable gets initialized.
Step 2: In the second step the condition is checked, where the counter variable is tested for the given condition, if the condition returns true then the C statements inside the body of for loop gets executed, if the condition returns false then the for loop gets terminated and the control comes out of the loop.
Step 3: After successful execution of statements inside the body of loop, the counter variable is incremented or decremented, depending on the operation (++ or –).

Example of For loop


int main()
int i;
for (i=1; i<=3; i++)
printf(“%d\n”, i);
return 0;

Different types of for circle in C

I am utilizing variable num as the counter in all the accompanying models –

1) Here rather than num++, I’m utilizing num=num+1 which is same as num++. for (num=10; num<20; num=num+1)

2) Initialization part can be skipped from circle as demonstrated as follows, the counter factor is pronounced before the circle. int num=10; for (;num<20;num++)

Note: Even however we can skip instatement part yet semicolon (;) before condition is must, without which you will get arrangement mistake.

3) Like instatement, you can likewise skirt the addition part as we did beneath. For this situation semicolon (;) is should after condition rationale. For this situation the augmentation or decrement part is done inside the circle.

for (num=10; num<20; )





4) This is likewise conceivable. The counter factor is introduced before the circle and augmented inside the circle.

int num=10;

for (;num<20;)





5) As referenced over, the counter factor can be decremented too. In the underneath model the variable gets decremented each time the circle runs until the condition num>10 returns bogus.

for(num=20; num>10; num- – )

Settled For Loop in C

Settling of circle is likewise conceivable. Lets take a guide to get this:


int primary()


for (int i=0; i<2; i++)


for (int j=0; j<4; j++)


printf(“%d, %d\n”,i ,j);



return 0;



0, 0

0, 1

0, 2

0, 3

1, 0

1, 1

1, 2

1, 3

In the above model we have a for circle inside another for circle, this is called settling of circles. One of the model where we use settled for circle is Two dimensional cluster.

Numerous introduction inside for Loop in C

We can have numerous introduction in the for circle as demonstrated as follows.

for (i=1,j=1;i<10 && j<10; i++, j++)

What’s the contrast between above for circle and a basic for circle?

  1. It is instating two factors. Note: both are isolated by comma (,).
  2. It has two test conditions consolidated utilizing AND (&&) consistent administrator. Note: You can’t utilize numerous test conditions isolated by comma, you should utilize sensible administrator, for example, && or || to join conditions.
  3. It has two factors in increase part. Note: Should be isolated by comma.

Case of for circle with different test conditions


int fundamental()


int i,j;

for (i=1,j=1 ; i<3 || j<5; i++,j++)


printf(“%d, %d\n”,i ,j);


return 0;

A for circle is a reiteration control structure that enables you to proficiently compose a circle that requirements to execute a particular number of times.

Linguistic structure

The linguistic structure of a for circle in C programming language is −

for ( init; condition; increase ) {



Here is the progression of control in a ‘for’ circle −

The init step is executed solitary once. This progression enables you to pronounce and instate any circle control factors. You are not required to put an announcement here, up to a semicolon shows up.

Next, the condition is assessed. In the event that it is valid, the body of the circle is executed. In the event that it is bogus, the body of the circle doesn’t execute and the progression of control bounces to the following proclamation soon after the ‘for’ circle.

After the body of the ‘for’ circle executes, the progression of control hops back up to the addition explanation. This announcement enables you to refresh any circle control factors. This announcement can be left clear, up to a semicolon shows up after the condition.

The condition is presently assessed once more. On the off chance that it is valid, the circle executes and the procedure rehashes itself (assortment of circle, at that point increase step, and afterward again condition). After the condition turns out to be bogus, the ‘for’ circle ends.

Model Live Demo .


int fundamental () {

int a;

/* for circle execution */

for( a = 10; a < 20; a = a + 1 ){

printf(“value of a: %d\n”, a);


return 0;


At the point when the above code is gathered and executed, it delivers the accompanying outcome −

estimation of a: 10

estimation of a: 11

estimation of a: 12

estimation of a: 13

estimation of a: 14

estimation of a: 15

estimation of a: 16

estimation of a: 17

estimation of a: 18

estimation of a: 19

Utilizing Loops

In Loop, the announcement should be composed just once and the circle will be executed multiple times as demonstrated as follows.

In PC programming, a circle is an arrangement of guidelines that is rehashed until a specific condition is come to. An activity is done, for example, getting a thing of information and evolving it, and afterward some condition is checked, for example, regardless of whether a counter has arrived at an endorsed number. Counter not Reached: If the counter has not arrived at the ideal number, the following guidance in the arrangement comes back to the principal guidance in the succession and rehash it.

Counter came to: If the condition has been come to, the following guidance “fails to work out” to the following consecutive guidance or branches outside the circle.

There are for the most part two kinds of circles:

Passage Controlled circles: In this kind of circles the test condition is tried before entering the circle body. For Loop and keeping in mind that Loop are section controlled circles. Exit Controlled Loops: In this kind of circles the test condition is tried or assessed toward the finish of circle body. In this way, the circle body will execute atleast once, independent of whether the test condition is valid or bogus. do – while circle is exit controlled circle.

for Loop.

A for circle is a redundancy control structure which enables us to compose a circle that is executed a particular number of times. The circle empowers us to perform n number of steps together in one line.

Linguistic structure:

for (introduction expr; test expr; update expr)


/body of the circle

/articulations we need to execute


In for circle, a circle variable is utilized to control the circle. First introduce this circle variable to some esteem, at that point check whether this variable is not exactly or more noteworthy than counter esteem. In the event that announcement is valid, at that point circle body is executed and circle variable gets refreshed . Steps are rehashed till leave condition comes. Instatement Expression: In this articulation we need to introduce the circle counter to some esteem. for instance: int i=1;

Test Expression: In this articulation we need to test the condition. In the event that the condition assesses to genuine, at that point we will execute the collection of circle and go to refresh articulation else we will exit from the for circle. For instance: I <= 10; Update Expression: After executing circle body this articulation increases/decrements the circle variable by some worth. for instance: i++;

for more visir regularly www.tristudy.com/