Bölüm 7: Döngüler - Kapsamlı Çalışma Materyali

📚 Kaynak Bilgisi

Bu çalışma materyali, bir dersin sesli transkripti ve kopyalanmış metin kaynaklarından derlenmiştir. İçerik, C++ programlama dilindeki döngü yapılarını detaylı bir şekilde ele almaktadır.

---

💡 Giriş: Döngülerin Programlamadaki Rolü

Döngüler, programlamanın temel mantıksal yapılarından biridir ve bilgisayarların belirli görevleri yinelemeli (tekrar tekrar) gerçekleştirmesini sağlar. Bu yineleme işlemi, programcının başlangıçta belirttiği adım sayısı kadar veya belirli bir koşul gerçekleşene kadar devam edebilir. Döngüler, programlamada zaman ve maliyetin düşürülmesi açısından oldukça etkilidir. Bu bölümde, C++ programlama dilinde kullanılan başlıca döngü yapıları olan for, while, do-while döngüleri ve iç içe döngüler detaylı bir şekilde incelenecektir.

✅ Anahtar Kavramlar ve Öğrenme Hedefleri

📚 Anahtar Kavramlar

• while döngüsü
• for döngüsü
• do-while döngüsü
• İç içe döngüler
• break komutu
• continue komutu
• Sonsuz döngü

🎯 Öğrenme Hedefleri

Bu bölümü tamamladıktan sonra öğrenci:

• Döngülerin temel kavramlarını ve programlamadaki önemini bilir.
• while, for ve do-while döngülerinin sözdizimlerini ve akış diyagramlarını anlar.
• Her bir döngü türünün ne zaman ve hangi durumlarda kullanılacağını ayırt edebilir.
• break ve continue komutlarının döngü kontrolündeki rollerini kavrar.
• İç içe döngü yapılarını oluşturabilir ve kullanabilir.
• Verilen problemlere uygun döngü yapılarını seçerek çözüm üretebilir.

---

1️⃣ Döngü Türleri

C++ programlama dilinde dört temel döngü yapısı bulunmaktadır:

1. while Döngüsü
2. do-while Döngüsü
3. for Döngüsü
4. İç İçe Döngüler (Nested Loops)

Döngüler aynı zamanda sabit döngüler (yineleme sayısı önceden bilinen, örn: for) ve koşullu döngüler (bir koşul doğru olduğu sürece çalışan, örn: while, do-while) olarak sınıflandırılabilir.

1.1. While Döngüsü

📚 Tanım: Koşullu döngüler sınıfında yer alan while döngüsü, belirli bir koşul doğru olduğu sürece çalışmaya devam eder. Döngünün başlatılması ve sürdürülmesi tamamen bu koşulun doğruluğuna bağlıdır. Koşul sağlanmadığında döngü başlatılmaz veya çalışma esnasında koşul bozulursa döngü sona erer.

📝 Sözdizimi (Syntax):

while (koşul) {
    // işlem(ler)
}

📊 Akış Diyagramı:

Başla
  |
  V
Koşul (Doğru mu?)
  | Evet (1)
  V
İşlem(ler)
  |
  V
Koşul (Doğru mu?) <-- Tekrar buraya döner
  | Hayır (0)
  V
Bitir

Akış diyagramında 1 (true) ve 0 (false) mantıksal ifadeleri temsil eder. Koşul doğru olduğu sürece işlemler yapılır, yanlış olduğunda döngüden çıkılır.

Örnek 7.1: Ekrana 5 defa "Ankara Üniversitesi" yazdıran program

#include <iostream>
using namespace std;

int main() {
    int a = 0; // Sayaç değişkeni
    while (a < 5) { // a, 5'ten küçük olduğu sürece döngü devam eder
        cout << "Ankara Universitesi\n";
        a = a + 1; // Sayaç her adımda artırılır
    }
    return 0;
}

✅ Açıklama: a değişkeni 0'dan başlar. Her döngüde "Ankara Üniversitesi" yazılır ve a bir artırılır. a 5 olduğunda koşul (a < 5) yanlış olur ve döngü sona erer. Sayaç artırılmazsa program sonsuz döngüye girer.

Örnek 7.2: 1'den 10'a kadar sayıları yan yana yazdıran program

#include <iostream>
using namespace std;

int main() {
    int i = 1;
    while (i <= 10) {
        cout << i << ", ";
        i = i + 1;
    }
    return 0;
}

1.1.1. break Komutu

📚 Tanım: break komutu, döngü koşulu bozulmadan istenilen bir sonuca ulaşıldığında döngüyü sonlandırmak için kullanılır. Program break komutu ile karşılaştığında, döngü o noktada sona erer ve kontrol döngüden sonraki ilk ifadeye geçer. Bu komut while, do-while, for ve iç içe döngülerde kullanılabilir.

Örnek 7.3: Negatif sayı girilene kadar karekök hesaplayan program

#include <iostream>
#include <cmath> // sqrt fonksiyonu için
using namespace std;

int main() {
    double sayi, sonuc;
    while (true) { // Sonsuz döngü
        cout << "Karekökü hesaplanacak sayıyı giriniz (Negatif sayı çıkış yapar): ";
        cin >> sayi;
        if (sayi < 0) { // Negatif sayı girilirse
            break; // Döngüyü sonlandır
        }
        sonuc = sqrt(sayi);
        cout << sayi << " sayısının karekökü: " << sonuc << endl;
    }
    cout << "Negatif bir sayı girildiği için döngü sonlandırılmıştır!" << endl;
    return 0;
}

✅ Açıklama: while(true) ile sonsuz bir döngü oluşturulur. Kullanıcı negatif bir sayı girdiğinde if (sayi < 0) koşulu sağlanır ve break komutu döngüyü anında sonlandırır.

1.1.2. continue Komutu

📚 Tanım: continue komutu, döngü yinelemesi (iteration) esnasında programın bu komuttan sonra gelen ifadeleri değerlendirmemesini ve döngünün bir sonraki yineleme adımı ile yeniden başlatılmasını sağlar. Bu komut da while, do-while, for ve iç içe döngü yapılarında kullanılabilir.

Örnek 7.4: Geçersiz not girişlerini atlayarak öğrenci ortalaması hesaplayan program

#include <iostream>
using namespace std;

int main() {
    int vize, final;
    double ortalama;
    char cikis;

    while (true) {
        cout << "Öğrencinin Vize Notunu Giriniz (0-100): ";
        cin >> vize;
        if (vize > 100 || vize < 0) { // Geçersiz not kontrolü
            cout << "Geçerli Bir Değer Giriniz (0-100 arası)!" << endl;
            continue; // Bu iterasyonu atla, bir sonraki iterasyona geç
        }

        cout << "Öğrencinin Final Notunu Giriniz (0-100): ";
        cin >> final;
        if (final > 100 || final < 0) { // Geçersiz not kontrolü
            cout << "Geçerli Bir Değer Giriniz (0-100 arası)!" << endl;
            continue; // Bu iterasyonu atla, bir sonraki iterasyona geç
        }

        ortalama = vize * 0.3 + final * 0.8; // Vize %30, Final %80
        cout << "Öğrencinin Ortalaması: " << ortalama << endl;

        cout << "Programdan Çıkış İçin 'C', Devam İçin 'D' Giriniz: ";
        cin >> cikis;
        if (cikis == 'C' || cikis == 'c') { // Çıkış kontrolü (büyük/küçük harf duyarlılığına dikkat)
            break;
        }
    }
    cout << "Program kullanıcının isteği ile sonlandırılmıştır!" << endl;
    return 0;
}

⚠️ Önemli Not: C++ büyük-küçük harf duyarlı (Case Sensitive) bir programlama dilidir. Bu örnekte çıkış için hem 'C' hem de 'c' kontrol edilmiştir.

1.2. Do-While Döngüsü

📚 Tanım: do-while döngüsü, while döngüsüne oldukça benzer ancak döngü denetimi döngü sonunda gerçekleştirilir. Bu özelliği sayesinde döngü içerisindeki ifadeler en az bir kez çalıştırılır.

📝 Sözdizimi (Syntax):

do {
    // işlem(ler)
} while (koşul);

📊 Akış Diyagramı:

Başla
  |
  V
İşlem(ler)
  |
  V
Koşul (Doğru mu?)
  | Evet (1)
  V
İşlem(ler) <-- Tekrar buraya döner
  | Hayır (0)
  V
Bitir

Akış diyagramından da rahatlıkla görülebileceği üzere döngü içerisindeki işlem(ler) en az bir kez çalıştırılır ve döngü denetimi bu işlem sonrasında gerçekleştirilir.

Örnek 7.5: Kullanıcı isteğine göre sayı kontrolü yapan program

#include <iostream>
using namespace std;

int main() {
    int sayi;
    char devam;
    do {
        cout << "Bir Sayı Giriniz: ";
        cin >> sayi;
        if (sayi == 0) {
            cout << "Girilen Sayı 0'a eşittir.\n";
        } else if (sayi < 0) {
            cout << "Girilen Sayı 0'dan küçüktür.\n";
        } else { // sayi > 0
            cout << "Girilen Sayı 0'dan büyüktür.\n";
        }
        cout << "Yeni Bir Sayı Girmek İstiyor musunuz? (Evet için E, Hayır için H'ye basınız): ";
        cin >> devam;
    } while (devam == 'E' || devam == 'e'); // Kullanıcı 'E' veya 'e' girene kadar devam et
    return 0;
}

✅ Açıklama: Program, kullanıcıdan bir sayı alıp kontrol eder ve sonucu yazdırır. Ardından kullanıcıya devam edip etmek istemediğini sorar. Koşul (devam == 'E' || devam == 'e') doğru olduğu sürece döngü devam eder. İlk başta koşul kontrol edilmediği için işlemler en az bir kez yapılır.

1.3. For Döngüsü

📚 Tanım: for döngüsü, yineleme sayısının önceden belirlendiği durumlarda kullanılan sabit bir döngü türüdür. Döngünün başlangıç değeri, son değeri ve artış miktarı tanımlamaları ile döngünün kaç defa tekrar edeceği döngü başında belirtilir.

📝 Sözdizimi (Syntax):

for (Başlangıç Değeri; Koşul; Artış Miktarı) {
    // işlem(ler)
}

Döngünün başlangıç değeri, koşul ve artış miktarı arasında noktalı virgül (;) karakteri kullanılır. Bu döngü yapısında döngü değişkeni ve değişken türü döngü başlangıç kısmında tanımlanabilir.

📊 Akış Diyagramı:

Başla
  |
  V
Başlangıç Değeri
  |
  V
Koşul (Doğru mu?)
  | Evet (1)
  V
İşlem(ler)
  |
  V
Artış Miktarı
  |
  V
Koşul (Doğru mu?) <-- Tekrar buraya döner
  | Hayır (0)
  V
Bitir

Örnek 7.6: Kullanıcının girdiği sayıya kadar olan sayıları toplayan program

#include <iostream>
using namespace std;

int main() {
    int sayi, toplam = 0;
    cout << "1'den büyük bir sayı giriniz: ";
    cin >> sayi;

    for (int i = 1; i <= sayi; i++) { // i=1'den başlayıp sayi'ya kadar birer birer artır
        toplam += i; // toplam = toplam + i;
    }
    cout << "1 ile " << sayi << " arasındaki sayıların toplamı: " << toplam << endl;
    return 0;
}

✅ Açıklama: Döngü değişkeni i for döngüsü içinde tanımlanmıştır (int i = 1). Bu durumda i değişkeninin etki alanı sadece for döngüsü ile sınırlıdır.

Örnek 7.7: Girilen sayının asal olup olmadığını bulan program

#include <iostream>
using namespace std;

int main() {
    int sayi;
    int sayac = 0; // Bölen sayısını tutar

    cout << "Bir Sayı Giriniz: ";
    cin >> sayi;

    for (int i = 1; i <= sayi; i++) {
        if (sayi % i == 0) { // sayi, i'ye tam bölünüyorsa
            sayac++; // Bölen sayısını artır
        }
    }

    if (sayac == 2) { // Sadece 1'e ve kendisine bölünüyorsa (2 bölen)
        cout << "Girilen Sayı Asaldır" << endl;
    } else {
        cout << "Girilen Sayı Asal Değildir" << endl;
    }
    return 0;
}

✅ Açıklama: Asal sayı tanımından yola çıkılır: Sadece 1'e ve kendisine tam bölünebilen sayılar asal sayılardır (yani 2 adet tam böleni vardır). % (modulo) operatörü, bir sayının diğer sayıya bölümünden kalanı verir.

1.3.1. Sonsuz For Döngüsü

for döngüsü, başlangıç değeri, koşul ve artış miktarı belirtilmeden de kullanılabilir.

for (;;) {
    cout << "Ankara Universitesi\n";
}

Bu örnekte, döngü başlangıç değeri, son değer ve artış miktarı belirtilmemiştir. Döngü bu haliyle sonsuz bir döngü formuna dönüşmüştür. Başlangıçta program döngü içerisine girer ve manuel olarak sonlandırılmadığı sürece (örneğin Ctrl+C ile) sürekli çalışır.

1.4. İç İçe Döngüler (Nested Loops)

📚 Tanım: Karar ifadelerinde (if) olduğu gibi, döngü yapılarının da iç içe oluşturulması mümkündür. Bir döngü içerisinde başka döngü yapıları tanımlanabilir. Bu yapıya iç içe döngüler denir. İç içe döngüler, genellikle matrisler, tablolar veya desenler oluşturmak gibi çok boyutlu yinelemeli işlemlerde kullanılır.

Örnek 7.9: 3x3 yıldız (*) deseni oluşturan program (İç içe for)

#include <iostream>
using namespace std;

int main() {
    for (int i = 1; i <= 3; i++) { // Dış döngü: Satırları kontrol eder
        for (int j = 1; j <= 3; j++) { // İç döngü: Sütunları kontrol eder
            cout << "* "; // Yıldız ve boşluk yazdır
        }
        cout << "\n"; // Her satır bitiminde alt satıra geç
    }
    return 0;
}

✅ Açıklama: Program ilk çalıştırıldığında önce dıştaki döngü (i) ve hemen ardından içteki döngü (j) başlatılır. i değişkeni 1 değerine sahipken, j değişkeni 1'den 3'e kadar değerler alır. j değişkeninin her bir değerinde ekrana bir adet * karakteri basılır. İçteki döngü bittiğinde (j 3 olduğunda), dıştaki döngünün etki alanındaki cout << "\n"; ifadesi çalıştırılır ve ekranda bir alt satıra geçilir. Bu işlem, i değişkeninin ikinci değeri (2) için döngü yeniden başlatılarak devam eder.

Örnek 7.10: Farklı döngü türlerinin iç içe kullanımı (for ve while)

#include <iostream>
using namespace std;

int main() {
    for (int i = 1; i <= 5; i++) { // Dış döngü (for): Satırları kontrol eder (1'den 5'e kadar)
        int sayi = 1; // Her dış döngü iterasyonunda sayi'yı sıfırla
        while (sayi <= i) { // İç döngü (while): Sütunları kontrol eder (i'ye kadar)
            cout << sayi << " ";
            sayi++;
        }
        cout << "\n"; // Her satır bitiminde alt satıra geç
    }
    return 0;
}

Ekran Çıktısı:

1
1 2
1 2 3
1 2 3 4
1 2 3 4 5

✅ Açıklama: Bu örnekte bir for döngüsü içerisinde bir while döngüsü kullanılmıştır. Dıştaki for döngüsü satır sayısını (i) kontrol ederken, içteki while döngüsü her satırdaki sayıların miktarını ve değerini (sayi <= i) belirler. sayi değişkeni her dış döngü iterasyonunda 1'e sıfırlandığı için her satır 1'den başlar.

---

🎯 Özel Odak Alanı: Detaylı Açıklama ve Sorular

💡 Döngü Seçimi İçin İpuçları

Hangi döngüyü kullanacağınız, çözmeye çalıştığınız probleme bağlıdır:

• for döngüsü: ✅ Eğer bir işlemi belirli sayıda tekrar etmeniz gerekiyorsa veya bir aralıkta (başlangıç ve bitiş değeri belli) işlem yapacaksanız for döngüsü en uygunudur. Sayaç değişkeninin başlangıcı, bitişi ve artış miktarı tek bir satırda tanımlanır, bu da kodu daha düzenli yapar.
• while döngüsü: ✅ Eğer bir koşul doğru olduğu sürece bir işlemi tekrar etmeniz gerekiyorsa ve tekrar sayısı önceden belli değilse while döngüsü tercih edilir. Örneğin, kullanıcıdan geçerli bir giriş alana kadar tekrar sormak gibi durumlarda idealdir.
• do-while döngüsü: ✅ Eğer döngü içerisindeki işlemlerin en az bir kez çalıştırılması garanti edilmeli ve koşul daha sonra kontrol edilmeli ise do-while döngüsü kullanılır. Örneğin, bir menü gösterip kullanıcıdan seçim alırken, menünün en az bir kez gösterilmesi gerektiği durumlarda faydalıdır.

⚠️ Sonsuz Döngüler ve Kaçınma Yolları

📚 Tanım: Sonsuz döngü, döngü koşulunun asla yanlış (false) olmaması ve bu nedenle döngünün sürekli çalışmaya devam etmesidir. Bu durum genellikle programın kilitlenmesine veya beklenmedik davranışlara yol açar.

Nedenleri:

• Sayaç değişkeninin güncellenmemesi (örn: a++ unutulması).
• Döngü koşulunun her zaman doğru olacak şekilde yanlış yazılması (örn: while (1) veya while (true) kullanıp break ile çıkış yapılmaması).

Nasıl Önlenir:

• Döngü değişkenlerinin her iterasyonda doğru şekilde güncellendiğinden emin olun.
• Koşullu döngülerde, döngüyü sonlandıracak bir durumun veya koşulun varlığını kontrol edin.
• while(true) gibi sonsuz döngüler kullanıyorsanız, döngüden çıkışı sağlayacak bir break komutunun uygun bir koşul altında tetiklendiğinden emin olun.

💡 Döngü Kontrol Komutlarının Detaylı Kullanımı (break ve continue)

• break:

  • İşlevi: Döngüyü tamamen sonlandırır ve kontrolü döngüden sonraki ilk ifadeye taşır.
  • Kullanım Alanı: Belirli bir koşul sağlandığında döngünün geri kalanını çalıştırmadan çıkmak istediğinizde. Örneğin, bir arama işleminde aranan eleman bulunduğunda döngüyü sonlandırmak.
  • Örnek: Kullanıcıdan pozitif sayı alana kadar tekrar sormak ve pozitif sayı girildiğinde döngüden çıkmak.

  int sayi;
  while (true) {
      cout << "Pozitif bir sayı giriniz: ";
      cin >> sayi;
      if (sayi > 0) {
          break; // Pozitif sayı girildi, döngüden çık
      }
      cout << "Hatalı giriş! Lütfen pozitif bir sayı girin.\n";
  }
  cout << "Girilen pozitif sayı: " << sayi << endl;
  

• continue:

  • İşlevi: Mevcut iterasyonu atlar ve döngünün bir sonraki iterasyonuna geçer. continue komutundan sonra gelen kodlar o iterasyonda çalıştırılmaz.
  • Kullanım Alanı: Belirli bir koşul sağlandığında mevcut iterasyonda bazı işlemleri atlamak ve döngünün bir sonraki adımına geçmek istediğinizde. Örneğin, bir listedeki çift sayıları atlayıp sadece tek sayılar üzerinde işlem yapmak.
  • Örnek: 1'den 10'a kadar olan sayılardan sadece tek olanları ekrana yazdırmak.

  for (int i = 1; i <= 10; i++) {
      if (i % 2 == 0) { // Eğer sayı çift ise
          continue; // Bu iterasyonu atla, bir sonraki sayıya geç
      }
      cout << i << " "; // Sadece tek sayılar yazdırılır
  }
  // Çıktı: 1 3 5 7 9
  

📝 Pratik Uygulama Soruları

1. Soru 1: Faktöriyel Hesaplama Kullanıcıdan bir tam sayı alan ve bu sayının faktöriyelini (n!) hesaplayan bir C++ programını for döngüsü kullanarak yazınız. (Örn: 5! = 5 * 4 * 3 * 2 * 1 = 120)

   // Çözüm İpucu: Faktöriyel 1'den başlar ve girilen sayıya kadar çarpılır.
   // int faktoriyel = 1;
   // for (int i = 1; i <= sayi; i++) { faktoriyel *= i; }
   

2. Soru 2: Şifre Doğrulama Kullanıcıdan "admin" şifresini girmesini isteyen bir program yazınız. Şifre doğru girilene kadar kullanıcıdan tekrar şifre isteyiniz. Bu işlemi do-while döngüsü kullanarak gerçekleştiriniz.

   // Çözüm İpucu: Şifre değişkeni tanımlayın. do bloğunda şifre isteyin, while koşulunda şifrenin doğruluğunu kontrol edin.
   // string sifre;
   // do { cin >> sifre; } while (sifre != "admin");
   

3. Soru 3: Belirli Aralıktaki Sayıların Toplamı (Atlama ile) 1'den 20'ye kadar olan sayılardan, 5'e tam bölünebilenleri atlayarak diğer sayıların toplamını bulan bir C++ programını while döngüsü ve continue komutu kullanarak yazınız.

   // Çözüm İpucu: Bir sayaç ve toplam değişkeni kullanın. Eğer sayı 5'e bölünüyorsa continue ile atlayın.
   // int i = 1, toplam = 0;
   // while (i <= 20) { if (i % 5 == 0) { i++; continue; } toplam += i; i++; }
   

4. Soru 4: Ters Üçgen Deseni Aşağıdaki ekran görüntüsünü verecek olan C++ programını iç içe for döngüsü kullanarak yazınız.

   *****
   ****
   ***
   **
   *
   

   // Çözüm İpucu: Dış döngü satırları (5'ten 1'e), iç döngü sütunları (dış döngü değişkenine bağlı olarak) kontrol etmeli.
   // for (int i = 5; i >= 1; i--) { for (int j = 1; j <= i; j++) { cout << "*"; } cout << "\n"; }
   

---

📝 Bölüm Özeti

Döngüler, programlama dillerinde yinelemeli işlemlerin gerçekleştirilmesinde temel bir role sahiptir. Programlarda tekrar eden işlemlerin etkin bir şekilde uygulanması gerektiğinde döngü yapıları kullanılmaktadır. Döngüler, programcılara daha esnek ve dinamik bir kod geliştirme imkânı sunarak, karmaşık algoritmaların daha sade bir biçimde ifade edilmesine olanak tanır.

Programlama süreçlerinde döngüler, sabit (for) veya koşullu (while, do-while) yapılar şeklinde tercih edilebilir. Koşullu döngüler, belirli bir koşul sağlandığı sürece çalışmaya devam ederken, sabit döngülerde yineleme sayısı önceden tanımlanır. break ve continue gibi kontrol komutları, döngülerin akışını daha esnek bir şekilde yönetmeye olanak tanır. İç içe döngüler ise çok boyutlu veya karmaşık desen oluşturma gibi durumlarda güçlü bir araçtır.

Döngü yapıları, algoritmaların verimli bir şekilde uygulanması ve programların performansının artırılması açısından programlama dillerinin vazgeçilmez bir bileşenidir.