Files
.github
api-server
client
config
curriculum
docs
guide
arabic
chinese
english
3d
accessibility
agile
algorithms
android-development
angular
angularjs
apache
aspnet
bash
blender
blockchain
bootstrap
bsd-os
bulma
c
canvas
certifications
chef
clojure
cloud-development
computational-genomics
computer-hardware
computer-science
containers
cplusplus
arrays
c-stl-sets
casting
clean-code-guidelines
compilers
conditional-operator
do-while-loop
dynamic-memory-allocation
erase-remove
error-handling
file-handling
for-loop
functions
goto
if-else-statement
inline-functions
input-and-output
lists
loops
index.md
map
object-oriented-programming
overloading
preprocessors
queue
random-functions
range-for-loop
set
stack
stl-algorithms
switch-statements
terms-to-know-for-beginners
the-auto-feature
the-if-statement
tokens-operators
tokens-variables
vector
while-loop
index.md
csharp
css
d3
data-science-tools
design-patterns
designer-tools
developer-ethics
developer-tools
devops
docker
documentation
drupal
electron
elixir
elm
erlang
fsharp
game-development
gatsbyjs
git
go
groovy
haskell
hibernate
html
ionic
java
javascript
joomla
jquery
julia
kotlin
laravel
linux
logic
machine-learning
mathematics
meta
miscellaneous
mobile-app-development
mongodb
natural-language-processing
neovim
network-engineering
nginx
nodejs
optical-alignment
php
product-design
progressive-web-apps
puppet
python
r
react
react-native
redux
rest-api
robotics
rt-os
ruby
rust
sass
security
semantic-ui
software-engineering
sql
ssh
svg
svn
swift
terminal-commandline
tomcat
tools
typescript
typography
user-experience-design
user-experience-research
vagrant
vim
virtualbox
visual-design
voice
vue
vue-cli
web-augmented-reality
web-components
web-performance
web-virtual-reality
wordpress
working-in-tech
xml
portuguese
russian
spanish
mock-guide
tools
.editorconfig
.eslintignore
.eslintrc
.gitattributes
.gitignore
.node-inspectorrc
.prettierrc
.snyk
.travis.yml
.vcmrc
CODE_OF_CONDUCT.md
CONTRIBUTING.md
LICENSE.md
README(french).md
README.md
docker-compose-shared.yml
docker-compose.yml
lerna.json
netlify.toml
package-lock.json
package.json
sample.env
freeCodeCamp/guide/english/cplusplus/loops/index.md

116 lines
3.6 KiB
Markdown
Raw Normal View History

---
title: Loops
---
# Loops
## Introduction
2018-11-05 02:07:32 -07:00
Now let's discuss something known as loop. Suppose you want to print the even numbers from 1 to 1000 on the screen. One way
to do this is to write the following lines
``` c++
cout << 0 << endl;
cout << 2 << endl;
cout << 4 << endl;
....
....
....
cout << 1000 << endl;
```
But the problem with this approach is that you have to write the same line again and again. And if suppose you have to print
prime numbers from 1 to 1000 then this will be more hectic.
Therefore, in order to solve such problems loops are introduced.
There are different types of loop functions:
### While and do while loops
While and do while loops allow you to run the loop until a condition finishes.
2018-11-05 02:07:32 -07:00
The difference between While and Do while is that Do while loop always executes at least once.
The very use of Do while loop can be seen in the scenarios when the number of times that the loop will run depends upon the first iteration of the loop.
Here you can see an example:
``` c++
while (condition){
// Code that will execute while condition is true
}
do {
// Will execute once and until the condition is false
} while (condition);
```
### For loops
For loops are usually used when you know how many times the code will execute.
The flow can be seen in this [graph](https://www.tutorialspoint.com/cplusplus/images/cpp_for_loop.jpg).
They are declared this way:
``` c++
for ( initialize a variable; check a condition; increment the initialized variable ) {
//Code to execute
}
```
2018-11-05 02:07:32 -07:00
Let's write a program which will print numbers from 0 to 1000 including 1000 on the screen using a for loop.
``` c++
for (int i = 0;i<=1000;i++)
{
cout << i << endl;
}
```
When you execute this code in a c++ program numbers from 1 to 1000 will be printed.
2018-11-05 02:07:32 -07:00
Now let's discuss how the for loop works.
* You start a for loop by typing the keyword 'for'. It means you are starting a for loop
` for `
* Next you open and close a round bracket. In this brackets you write some conditions which will be discussed later
` for()`
2018-11-05 02:07:32 -07:00
* Inside the brackets first you write the initial condition i.e. the value from where the loop will start. Like in the
above program we write int i = 0
` for(int i = 0)`
* Then you write the semicolon and then condition until when the loop will be executed. In the above code you define
i < 1000. It means until value of i is less then 1000 execuete the loop.
` for(int i=0;i<=1000) `
* Then you define the incremented value that is how much i has to be incremented in each iteration. In the above code
we write i++. It means value of i will be incremented by 1 every time.
` for(int i=0;i<=1000;i++) `
* If there is only one statement inside the loop then the curly bracket is optional but its better to write loop code
within brackets so that you don't get confused.
``` c++
for(int i=0;i<=1000;i++)
{
}
```
* Then inside the loop you write what do you want to do. In the above program we output the value of i.
So, in this way the for loop works
If you want to print even numbers from 1 to 1000 then your program will look like this
``` c++
for (int i = 0;i<=1000;i=i+2)
{
cout << i << endl;
}
```
2018-11-05 02:07:32 -07:00
* The difference between the first program and second is the increment part. The rest of the code is the same. This program will print 0 and
then add 2 to it and print 2 on console and so on upto value of i becomes equal to 1000.
Our final program to print even numbers from 0 to 1000 will look like this.
``` c++
#include<iostream>
using namespace std;
int main()
{
for (int i = 0;i<=1000;i=i+2)
{
cout << i << endl;
}
return 0;
}
```