Ders 5 - C++ Döngüler

10 Eyl 2017 · 12 dk okuma süresi

Döngüler, programlamanın olmazsa olmazlarındandır. Döngüler dilerseniz belli bir sayıda tekrar eder, dilerseniz belli bir koşul sağlandığı sürece devam eder. C++ dilinde 3 tane temel döngü tipi vardır. Bunlar;

  1. While Döngüsü
  2. Do While Döngüsü
  3. For Döngüsü

While Döngüsü

While döngüsünün kullanımı aşağıdaki gibidir.

while(koşul)
{
 Komut1;
 Komut2;
 Komut3;
 ...
}

while döngüsünde, while kelimesinden sonra gelen parantez içerisinde koşul ifadesi yer alır. Devamındaki süslü parantezlerle ayrılmış bölgeye döngü gövdesi denir. Bu bölgede tek bir komut olabileceği gibi birden çok komutta olabilir. while döngüsünde koşul sağlandığı sürece döngü gövdesindeki komutlar çalıştırılır.

Koşul kısmına 0 yazarsanız, bu koşulun sağlanmadığı anlamına gelir ve döngü çalışmaz. Aksi olarak da 1 yazarsak koşulun her zaman sağlandığı varsayılır ve döngü sonsuz döngüye dönüşür.

while döngüsünün örneğine geçelim. 0 ile 10 arasındaki sayıların ekrana alt alta yazdırılması:

#include "stdafx.h"
#include <iostream>

using namespace std;

int main()
{
 int i = 0;
 while(i<=10){
 cout<<i<<endl;
 i++;
 }

 system("pause");
 return 0;
}

Örnekte sayacımız olan i değerine ilk olarak 0 değerini atadık. Ardından i <= 10 koşuluna sahip olan while döngüsü çalışırken 0 <= 10 ifadesinin değerinin sağlanmasından ötürü döngümüz çalıştı ve döngünün içindeki kodlarla beraber sayının değeri ekrana yazılarak, i değişkenin değeri increment(++) operatörü ile arttırıldı ve ardından bu işlem, koşul  sağlandığı sürece devam etti. En son i değerimiz 11 olunca while döngüsündeki koşul 11<=10 oluyor ve koşul sağlanmadığı için döngü içerisindeki kod bloku çalıştırılmadan bir sonraki ifadeye geçiyor.

İç İçe While Döngüsü

Bir While döngüsü içerisinde birden çok while döngüsü olabilir.

while (koşul) {
	while (koşul)
	{
	 komut1;
	 komut2;
	 ...
	}
	komut3;
}

Üstteki kullanım şeklini bir örnek içerisinde inceleyelim:

#include "stdafx.h"
#include <iostream>

using namespace std;

int main()
{
  int i = 0, j;
  while (i <= 5)
  {
    j = 0;
    cout << "i";

    while (j <= 3)
    {
      cout << "j";
      j++;
    }
    i++;
    cout << endl;
  }

  system("pause");
  return 0;
}

Örneği dikkatli inceleyecek olursak; ikinci, yani içteki While döngüsünün 24 kez işlerken ilk döngünün 6 kere işlediğini göreceksiniz. İlk döngüdeki koşulumuz i<=5 ve i değişkeninin başlangıç değeri sıfırdır. Bu demek oluyor ki ilk döngü 6 kere dönecek. İkinci döngüde ise koşul j<=3 ve j değişkeninin de başlangıç değeri sıfırdır, dolayısıyla içteki döngü kendi başına 4 kere tekrar eder. Fakat ikinci döngü içte olduğu için, ilk döngünün tekrar sayısı olan 6 ile çarpılır ve içteki döngü toplamda 6 x 4 = 24 kez çalışmış olur.

Sonsuz Döngüler

Sonsuz döngüler koşulun daima sağlandığı durumlarda gerçekleşir. Örneğin, koşula yazılacak sıfırdan farklı sabit sayı yazıldığı durumunda koşul doğru kabul edilir ve döngü daima tekrar eder. Bunun dışında koşul bir değişkenin değerine bağlıyken değişkenin değeri döngü içerisinde değiştirilmezse ve koşul sağlanıyorsa yine sınırsız döngü meydana gelir. İkinci bahsedilen durum genellikle programcının hatasından kaynaklanır, ilk durum ise zaman zaman sonsuz döngüyü kullanmamız gerektiği için yapılır. Bu duruma aşağıda, break ve continue ifadelerini anlatacağımız konu başlığında değineceğiz.

Do While Döngüsü

do while döngüsünün çalışma mantığı while döngüsüyle aynıdır. do while döngüsünde farklı olarak koşul döngünün sonunda bulunur. while döngüsünde koşul doğru ise komutlar işlerken; do while döngüsünde koşul doğru olmasa bile ilk önce döngü içindeki kod bloku çalışır, ardından koşula bakılır ve koşul sağlandığı sürece bu işlem devam eder. do while döngüsünün genel kullanımları aşağıdaki gibidir:

Tek Satırlı Kullanım:

do
  komut;
while (koşul);

Çok Satırlı Kullanım:

do{
  komut1;
  komut2;
  komut3;
  ...
} while(koşul);

Şimdi 2 tane örnek ile duruma biraz daha açıklık getirelim:

Örnek 1: İlk örneğimizde 3 > 5 gibi doğru olmayan bir önerme(koşul) kullanarak döngünün çalışıp çalışmayacağına bakalım.

#include "stdafx.h"
#include <iostream>

using namespace std;

int main()
{
  do {
    cout << "Herkese Merhaba!" << endl;
  } while (3 > 5);

  system("pause");
  return 0;
}

Gördüğünüz gibi 3 > 5 gibi doğru olmayan bir önerme yazmamıza rağmen döngü içerisindeki kod bloku 1 kere de olsa çalıştı.

Not: Üstteki örnekte döngü bloku içerisine tek satır kod yazmama rağmen { } blok parantezlerini kullandım. Sizin de bu şekilde kullanmanızı tavsiye ederim, çünkü; bu şekilde kodun anlaşılabilirliği artar ve hata yapmamız zorlaşır.

Örnek 2: Şimdiki örneğimiz de ise değişken kullanarak normal tekrar eden bir do while döngüsü yapalım.

#include "stdafx.h"
#include <iostream>

using namespace std;

int main()
{
  int i = 0;

  do {
    cout << "Sayinin degeri: " << i << endl;
    i++;
  } while (i != 0 && i < 10); //i değişkeni sıfırdan farklı ve i < 10 olduğu sürece tekrar et.

  system("pause");
  return 0;
}

Üstteki örnekteki döngüye verdiğimiz i != 0 **&&** i < 10 koşulu ile i değişkeninin sıfırdan farklı VE 10’dan küçük olması durumunda çalışmasını söyledik. Ancak dikkat ederseniz i değişkeni başlangıçta sıfır değerine sahip ve bu da koşulun yerine getirilmemesi demek oluyor. Ancak döngü koşul sağlanmasa dahi 1 kez çalışacağı için koşula bağlı kalmadı ve döngünün içerisindeki kodu çalıştırdı. Döngünün içerisinde kod i değişkeninin değerini arttırınca koşul sağlanmış oldu ve döngü çalışmaya devam etti ve i değeri 10’dan küçük olduğu sürece işlem böyle sürdü. En sonunda i‘nin değeri 10 olunca koşul yerine getirilmemiş oldu ve döngü tekrar etmedi.

For Döngüsü

fordöngüsünün kullanımı aşağıdaki gibidir:

for( değer ataması; Koşul; Arttırma; )
{
komut1;
komut2;
...
}

Değer ataması kısmında döngü içerisinde ve döngü koşulunu belirlerken kullanılacak değişken belirlenir. Koşul kısmı ise diğer döngülerde olduğu gibi mantıksal operatörler ile koşul belirlenir. Arttırma kısmında ise tanımlanan değişkenin arttırma (veya azaltma) işlemi uygulanır. Özetle for döngüsünün akışı:

  1. for döngüsü ilk çalıştığında değer ataması kısmında belirlenen kod çalışır ve değişkenin ilk değeri belirlenmiş olur.
  2. Koşul kontrol edilir ve koşul sağlanıyorsa for döngüsünün bloku içindeki kodlar çalışır, sağlanmıyorsa döngü kırılır.
  3. Arttırma kısmındaki kod ile tanımlanmış değişkenin değeri belirlenen şekilde değiştirilir.
  4. 2 numaralı maddedeki işlem yapılarak döngü devam eder.

Şimdi for döngüsü kullanarak ekrana 1’den 10’a kadar olan sayıları yazdıralım:

#include "stdafx.h"
#include <iostream>

using namespace std;

int main()
{
  for (int i = 1; i <= 10; i++)
  {
    cout << i << endl;
  }

  system("pause");
  return 0;
}

Üstteki kodun çıktısı aşağıdaki şekildeki gibidir:

Örnekte for döngüsü içerisinde i isminde ilk değeri 1 olan değişken tanımladık. Koşulu da i değişkenin 10’dan küçük eşit olduğu sürece devam etmesini sağlayan i <= 10mantıksal ifadesini girdik. Arttırma kısmına ise ++ operatörünü kullanrak i değişkeninin değerini 1 arttırdık. Bu döngüyü kullanarak farklı türde örnekler yapabilirsiniz. Peki for döngüsüne sadece koşul girersek yani değişken tanımlama(değer atama) ve arttırma işlemini yapmazsak ne olur? for döngüsü while döngüsü olur :) Aşağıda basit bir örnek ile bu konuya değindikten sonra for döngüsü konusunu da bitireceğiz.

#include "stdafx.h"
#include <iostream>

using namespace std;

int main()
{
  int i = 1;

  for ( ; i <= 10; )
  {
    cout << i << endl;
	i++;
  }

  system("pause");
  return 0;
}

Üstteki kodu incelediğinizde while döngüsü başlığındaki örnekteki gibi bir işlem yapıldığını fark edeceksiniz. Değişken tanımlama döngü dışında normal bir değişken tanımlaması gibi yapılmış. Arttırma işlemi ise döngü içerisinde yapılmış.

Kodun çıktısı ise yine üstteki örnekteki ile aynı:

Tabi böyle bir kullanımın hiçbir anlamı yoktur. Bunu kullanmak yerine while döngüsü kullanabiliriz. Amacım sadece for döngüsünün kullanımına dikkat çekmekti. Ayrıca ikinci kısmı yani koşul kısmı boş olan for döngüsü de kurabilirsiniz. Koşul kısmı boş olan bir for döngüsü sonsuz döngü oluşturacaktır.

Break ve Continue İfadeleri

break ve continueifadeleri döngüyi kırmak(bitirmek) ve döngünün sonraki adımına atlamak için kullanılırlar. Bazı durumlarda döngünün bazı adımlarını atlamak isterken bazı durumlarda da döngüyü bitirmek isteyebiliriz. İşte bu tür durumlarda yardımımıza break ve continue ifadeleri koşuyor. İlk örneğimizde 3 sayısı hariç 1’den 10’a kadar olan tüm sayıları yazdıralım:

#include "stdafx.h"
#include <iostream>

using namespace std;

int main()
{
  for (int i = 1; i <= 10; i++)
  {
    if (i == 3)
      continue; //Tek satır olduğu için blok parantezi kullanmadım.

    cout << i << endl;
  }

  system("pause");
  return 0;
}

Kodun çıktısı:

Gördüğünüz gibi 3 sayısı hariç 1’den 10’a kadar olan tam sayıları yazdırdık. if yapısını kullanarak i değişkenin değeri 3’e eşit olduğu durumda continue ifadesi ile sonraki kodları işlemeden döngünün bir sonraki adımına geçtik ve böylece 3 sayısı ekrana yazdırılmadı. Şimdi ise break ifadesi için bir örnek yapalım: Bu örneğimizde kullanıcının girdiği sayıların ortalamasını veren uygulama yapacağız. Kullanıcı istediği kadar sayı girebilmesi için sonsuz bir döngü kuracağız ve sonsuz döngüyü kullanıcının isteği doğrultusunda bitireceğiz. Örneğimizde while döngüsü ile sonsuz bir döngü yaratalım ve bu döngüden çıkmak için kullanıcıdan -1(eksi bir) sayısının girilmesini bekleyelim. Kullanıcı -1‘den farklı bir sayı girdiği sürece bu sayıları toplayalım ve döngünün sonunda bu girilen sayıların ortalamasını ekrana yazdıralım:

#include "stdafx.h"
#include <iostream>

using namespace std;

int main()
{
  int donguSayisi = 0; //Ortalamayı hesaplamak için kaç tane sayı girildiğini tutan değişken.
  float girilenSayilarinToplami = 0; //Kullanıcıdan alınan sayıların toplamını tutan değişken.
  float girilenSayi = 0; //Kullanıcıdan okunan sayıyı geçici olarak tutan değişken.

  cout << "Sayilari girip enter tusuna basiniz, sonucu almak icin -1 giriniz." << endl;

  while (true)
  {
    cout << "Sayi giriniz:";
    cin >> girilenSayi; //Kullanıcıdan sayıyı okuyoruz.

    if (girilenSayi == -1)  //Kullanıcı -1 girerse döngüyü bitiriyoruz.
    {
      break; //Döngüyü bitiren ifade
    }

    girilenSayilarinToplami += girilenSayi; //Girilen sayıyı, girilen sayıların toplamını tutan değişkene ekliyoruz.

    donguSayisi++; //Döngü sayısını 1 arttırıyoruz.
  }

  cout << "Girilen sayilarin toplami: " << girilenSayilarinToplami << endl;
  cout << "Toplam girilen sayi: " << donguSayisi << endl;
  cout << "Sayilarin Ortalamasi: " << girilenSayilarinToplami / donguSayisi << endl;

  system("pause");
  return 0;
}

Gerekli açıklamaları yorum satırı olarak kodların yanına yazdım. Özetleyecek olursak, kullanıcının -1 yazana kadar girmiş olduğu sayıların ortalamasını alıp ekrana yazdırdık. Kodun çıktısı ise aşağıdaki gibidir:

break ve continue ifadelerinin basitçe örnek üzerinde kullandık. Bu ifadeler döngülerin olmazsa olmazlarındandır. Sizler de bu ifadeleri kullanarak çeşitli örnekler yapabilir ve bu ifadelerin kullanımını kavrayabilirsiniz.

← Önceki Blog Sonraki Blog →