while Döngüsü

Programlama gerçekten
de tekrarlamadan ibarettir. Bizler nadiren sadece bir kez çalışan
programlar yazarız. Yazdığımız çoğu program bir kez çalışır ve her
çalışmasında hemen hemen aynı şeyi tekrarlar. Ancak her çalışmada
doğru sonucu oluşturacak kadar ufak farklar vardır. Sıklıkla, bir
programın içinde bile tekrarlamalar bulunur. Tabi yine ufak
farklarla. Bu da bizim bu makalede inceleyeceğimiz konu. C# dili
özellik olarak tekrarlama durumlarını icra eder. Biz bu tekrarlama
durumlarına Döngü deriz.

Yeni kiraladığımız bir
evin kirasının 1000 YTL olduğunu varsayalım. Ve her yıl kirayı %5
arttıracağımızı düşünelim. Önümüzdeki 10 yıl içinde vereceğimiz
kira miktarının ne olacağını hesaplayan bir program yazalım.

using System;

class KiraHesabi
{
static void Main()
{
decimal Kira = 1000, ArtisMiktari = 5.0m;
Console.WriteLine("2006 yılındaki kira={0} YTL", Kira);
Console.WriteLine("2007 yılındaki kira={0} YTL", Kira *= (1 + ArtisMiktari / 100));
Console.WriteLine("2008 yılındaki kira={0} YTL", Kira *= (1 + ArtisMiktari / 100));
Console.WriteLine("2009 yılındaki kira={0} YTL", Kira *= (1 + ArtisMiktari / 100));
Console.WriteLine("2010 yılındaki kira={0} YTL", Kira *= (1 + ArtisMiktari / 100));
Console.WriteLine("2011 yılındaki kira={0} YTL", Kira *= (1 + ArtisMiktari / 100));
Console.WriteLine("2012 yılındaki kira={0} YTL", Kira *= (1 + ArtisMiktari / 100));
Console.WriteLine("2013 yılındaki kira={0} YTL", Kira *= (1 + ArtisMiktari / 100));
Console.WriteLine("2014 yılındaki kira={0} YTL", Kira *= (1 + ArtisMiktari / 100));
Console.WriteLine("2015 yılındaki kira={0} YTL", Kira *= (1 + ArtisMiktari / 100));
Console.WriteLine("2016 yılındaki kira={0} YTL", Kira *= (1 + ArtisMiktari / 100));
}

}

Kopyalama ve yapıştırma
mükemmel değil mi? Rakamların alt alta gelmesi için matematik
hesabını WriteLine cümlesinin içinde
yaptık. Her ifade Kira değişkeninin değerini arttırıyor. 2005 yılı
için ifadeyi yazdıktan sonra bu ifadeyi kopyaladım ve 9 kere
yapıştırdım ve yılların yazıldığı rakamları değiştirdim. Sonucu
aşağıdaki gibi elde ettik.

decimal
değişken kullandığımızdan dolayı oluşan fazla haneleri saymasak
iyi çalışmış gibi görünüyor. Fakat eminim ki bu programda güzel
bir şeylerin eksik olduğuna benle aynı fikirdesiniz. Sadece birkaç
yıl için pek fazla kötü görünmüyor. Fakat daha fazla yıl için bir
hesaplama yapacak olsak işler kötüye giderdi. Birbirinin aynı
koddan sayfalar dolusu istemezsiniz. Ya bu kodları yazdıktan sonra
küçük bir yanlışlığa rastlarsanız ne olacak?

Zorlama ile bazı
problemler çözmek işe yarayabilir, genellikle döngü kullanmaktan
daha kolaydır. C# ‘ta en basit döngü while
ifadesidir. else kısmı olmayan
bir if ifadesine çok benziyor. while
anahtar kelimesini bir parantezler içerisindeki bir
boolean ifade takip eder. Bir çift küme parantezi bir
veya birden fazla döngü kodunu takip eder.

while (boolean ifade)
{
// döngünün içindeki diğer ifadeler
}

while
ile if arasındaki farklar şunlardır:

if
cümlesinde eğerboolean ifade doğru (true)
ise küme parantezleri arasındaki ifadeleri sadece bir kez
çalıştırır. while ise boolean
ifadesi doğru olduğu müddetçe küme parantezleri arasındaki
ifadeleri çalıştırmaya devam eder. Çalışma boolean
ifade yanlış (false) olana kadara devam
eder.

Değeri 55 olan bir i
değişkeni olduğunu varsayalım. Şimdi bir if
cümlesi yazalım

if ( i < 100 )
{
Console.WriteLine ( i ) ;
}

Sonuç 55 olarak ekrana
yazılacaktır.

Aynı ifadeyi
while için yazalım.

while ( i < 100 ) 
{
Console.WriteLine( i ) ; 
}

Bu sefer sonuç
aşağıdaki gibi olacaktır:

55

55

55

55

...

Sonsuz döngü
olarak bilinen bu döngü devamlı çalışmaya devam edecektir. Fakat
genellikle program bitmeden bu sonsuz döngüleri bitirmek
isteyeceksin. Program sonsuz döngüye girdiğinde konsol penceresini
kapatarak veya "Ctrl +C" tuşlarını kullanarak döngüyü
durdurabilirsin. Tabiî ki kesinlikle sonsuz döngü içeren
uygulamalar var, fakat çoğu durumda küme parantezinin içindeki
kodlar boolean ifadenin içindeki değişkeni
değiştirirler.

Şimdi 100’e kadar sayan
bir program yazalım.

using System;

class CountUntill100 // 100'e kadar say 
{
static void Main()
{
int i = 0;
while (i < 100)
{
Console.WriteLine(i);
i++;
}
Console.WriteLine("i'nin son değeri:{0}", i);
}

}

i’nin
değeri 100’den küçük olduğundan, işletimin devamında
while ifadesine gelindiğinde işletim while
ifadesinin küme parantezlerini işleterek ilerleyecek. Küme
parantezlerinin içindeki ifade i’nin değerinin
yazacak ve değişkeni arttıracak. Ve işletim boolean
ifadeye geri dönecek. i hala 100’dem küçük mü?
Eğer öyleyse küme parantezinin içindeki ifade tekrar işletilecek.
Bu işlemlerin her bir ilerlemesine iteraston (yineleme) adı
verilir. Programın çıktısı aşağıdaki gibidir.

99 gösterildikten sonra
i’nin değeri 100 e arttırılır. Programın devamı
boolean ifadeye döner. i’nin
değeri 100’den küçük mü? Hayır. Programın işletimi
while ifadesinden sonraki program kodu ile devam
eder. Şimdi i değişkenin değeri 100’e eşit oldu.
En son olarak program "i'nin son değeri 100" yazar.

i’nin
değeri 100’e ulaştığında ( veya 100 değerinin üzerine ulaştığında
) küme parantezleri içerisindeki ifadeler işletilmeyecek.

Aşağıda bu programda
kullandığımız while döngüsünün başka bir
varyasyonu gösterilmektedir.

while ( i < 100 )
{
i++;
Console.WriteLine(i);
}

i’nin
değeri Console.WriteLine çağrısından önce
arttırıldığı için bu döngü 1 den 100 e kadar olan sayıları
gösterir. Döngü i değeri 100’e ulaştığında hemen
durmaz. WriteLine çağrısından sonra
işletim döngünün başına döner ve bundan sonra boolean
ifade tekrar kontrol edilir.

Not: Küme parantezleri
arasında sadece 1 ifade varsa küme parantezlerini kullanmanıza
gerek yoktur.

Şimdi i
değişkenin değerini Console.WriteLine çağrısının
içinde arttırarak küme parantezlerini kullanma derdinden de
kurtulalım.

while ( i < 100 )
Console.WriteLine(i++);

Sonek arttırma
operatörü değişkenin değerini ekranda gösterildikten sonra
arttırır. Bu örnekte program 0’dan 99’a kadar sayıları ekranda
gösterir. Eğer önek arttırma operatörünü kullanırsak;

while ( i < 100 )
Console.WriteLine(++i);

değişken ekranda
gösterilmeden önce arttırılacak ve program ekranda 1’den 100’e
kadar olan sayıları gösterecek.

Aynı zamanda i
değişkenini boolean ifadenin içinde de
arttırabiliriz. Örneğin;

while ( i++ < 100 )
Console.WtiteLine(i);

Sonek artırım operatörü
i değişkenin değerini boolean
ifadede kullanıldıktan sonra, Console.WriteLine
çağrısından önce artırıyor. Program ekranda 1’den 100’e kadar
sayıları gösteriyor. Aynı ifadenin önekli versiyonu;

while ( ++i < 100 )
Console.WriteLine(i);

Şimdi ise program
ekranda 1’den 99’a kadar sayıları görüntülüyor. i
değişkenin değeri 100’e artırıldığında boolean
ifaden yanlış döner ve programın işletimi while
döngüsünden bir sonraki ifadeden devam eder.

while
döngü gövdesindeki bu farkları özellikle vurguluyorum. Problem
genellikle while döngüsünün başlangıç ve bitiş
sınırlarının yönetiminde ortaya çıkar. boolean
ifadedeki değişkeni nerede ve nasıl değiştireceğini dikkatlice
belirlemen gerekiyor. Boolean ifadede kullanılan < yerine <= ve >
yerine >= ifadelerini de kullanarak döngünün sonunda ek bir döngü
sağlayabilirsin.

Şimdi kira hesabı yapan
programımızı tekrar yazalım.

using System;

class KiraHesabi
{
static void Main()
{
int BaslangicYili = 2006;
int BitisYili = 2016;
decimal Kira = 1000;
decimal ArtisMiktari = 5.0m;

while (BaslangicYili <= BitisYili)
{
Console.WriteLine("{0} {1}", BaslangicYili, Kira);
Kira *= (1 + ArtisMiktari / 100);
Kira = Decimal.Round(Kira, 2);
BaslangicYili++;
}
}
}

Bu hesaplama biraz
değişik. Kirayı ve yılı ekrana yazdıktan sonra program gelecek
yılın kirasını hesaplıyor ve decimal olarak
tanımlanmış kira değerinin virgülden sonraki kısmını 2 basamak
kalana kadar yuvarlıyor. Programın çıktısı aşağıdaki gibi olur.

Program 2016 yılındaki
son kirası hesapladıktan sonra, Kira ve BaslangicYili değerlerini
arttırarak bir sonraki döngüye hazırlıyor. Kirayı hiçbir zaman
kullanmayacak olmamıza rağmen hesaplıyor. Bu örnekte çok fazla bir
yük oluşturmuyor ama daha büyük programlarda problem olabilir.

Programın çıktısına
baktığımızda programın 2006 dan 2011 e kadar olanları kiraları
hesaplamak için 11 tane WriteLine çağrısı
yaptığını fark ederiz. Fakat program bu yıllar arasındaki kiraları
hesaplamak için 10 kez hesap yapmaya ihtiyaç duyar. Bunun için
while döngüsünün dışında fazladan bir
WriteLine çağrısı yaparak bir çözüm
oluşturabiliriz.

using System;

class KiraHesabi
{
static void Main()
{
int BaslangicYili = 2006;
int BitisYili = 2016;
decimal Kira = 1000;
decimal ArtisMiktari = 5.0m;

while (BaslangicYili < BitisYili)
{
Console.WriteLine("{0} {1}", BaslangicYili, Kira);
Kira *= (1 + ArtisMiktari / 100);
Kira = Decimal.Round(Kira, 2);
BaslangicYili++;
}
Console.WriteLine("{0} {1}", BaslangicYili, Kira);

}
}

Yeni program çıktısı
aşağıda.

Dikkat ederseniz
boolean ifadede ki içindeki <=
karşılaştırmasını < olarak değistirdim.
Böylelikle döngünün içinde en son olarak 2015 yılı için hesap
yapılacak. Döngünün altındaki WriteLine çağrısı
döngünün içinde önceden hesaplanan 2016 yılının kirasını ekrana
yazdırıyor.

Bir diğer varyasyon ise
Console.WriteLine ile döngüden önce ilk yılı ve
kirasını ekrana yazdırıp daha sonra bu değerleri döngünün içinde
arttırarak yazma işlemi yapmak. Yani hesaplama döngünün başında
yapılıyor ve WriteLine çağrısı döngünün en
altında yapılıyor.

using System;

class KiraHesabi
{
static void Main()
{
int BaslangicYili = 2006;
int BitisYili = 2016;
decimal Kira = 1000;
decimal ArtisMiktari = 5.0m;

Console.WriteLine("{0} {1}", BaslangicYili, Kira);
while (BaslangicYili < BitisYili)
{
BaslangicYili++;
Kira *= (1 + ArtisMiktari / 100);
Kira = Decimal.Round(Kira, 2);
Console.WriteLine("{0} {1}", BaslangicYili, Kira);

}

}
}

Yine çıktısı aşağıda
görülüyor.

Bu iki çözüm de ideal
değil çünkü ikisi de birbiri ile aynı WriteLine
çağrısı içermektedir. Birini değiştirdiğinde diğerini de
değiştirmek zorundasın.

Biz bu örnekte olduğu
gibi döngünün içinde 11 WriteLine çağrısı ve 10
kez de hesap yapmak istiyorsak döngünün ortalarında bir yerde
döngüden çıkmamız gerekiyor. break
olarak adlandırılan ifade ile döngünün ortasında döngüden
çıkabilirsin. Bu ifade her zaman aşağıdaki şekilde kullanılır.

break;

break
ifadesini noktalı virgül takip eder. Bu ifade kullanıldığında
döngüden çıkmaya ve programın döngüden bir sonraki ifadeden devam
etmesine neden olur. Genellikle break
ifadesi bir if bloğu ile kullanılır.

if ( BaslangicYili == BitisYili )
break;

Kira hesabının bir
diğer versiyonu aşağıdaki gibi yazıldığında gereksiz bir
hesaplamadan bizi kurtarır.

using System;

class KiraHesabi
{
static void Main()
{
int BaslangicYili = 2006;
int BitisYili = 2016;
decimal Kira = 1000;
decimal ArtisMiktari = 5.0m;

while (BaslangicYili <= BitisYili)
{
Console.WriteLine("{0} {1}", BaslangicYili, Kira);
if (BaslangicYili == BitisYili)
break;

Kira *= (1 + ArtisMiktari / 100);
Kira = Decimal.Round(Kira, 2);
BaslangicYili++;
}
}
}

Şimdi while
döngüsündeki boolean ifadeyi true
kullanarak programın başka bir versiyonunu yazalım. Unutmayın ki
break olmadan bu bir sonsuz döngü olacaktır.

using System;

class KiraHesabi
{
static void Main()
{
int BaslangicYili = 2006;
int BitisYili = 2016;
decimal Kira = 1000;
decimal ArtisMiktari = 5.0m;

while (true)
{
Console.WriteLine("{0} {1}", BaslangicYili, Kira);
if (BaslangicYili == BitisYili)
break;

Kira *= (1 + ArtisMiktari / 100);
Kira = Decimal.Round(Kira, 2);
BaslangicYili++;
}
}
}

break
gibi while döngüsü içinde kullanılan bir
diğer atlama komutu da continue’dur. Genellikle
if karar yapısı ile tetiklenir. Bu ifade döngü
içindeki arta kalan ifadenin atlanmasını sağlar. Ve program bir
sonraki iterasyondan devam eder.

Örneğin, kira hesabı
programımızda sonu 0 ile biten yıllarda kiranın artmamasını yani
bir önceki yıl ile aynı kalmasını istediğimizi farz edelim. Yani
2010 yılında ki kiranın 2009’daki kira ile aynı kalmasını
istediğimizi düşünelim.

Şimdi bir önceki
yazdığımız orijinal koda bir bakalım.

while ( BaslangicYili<=BitisYili )
{
Console.WriteLine("{0} {1}", BaslangicYili,Kira);

if ( BaslangicYili == BitisYili )
break;

Kira *= ( 1 + ArtisMiktari/100);
Kira = Decimal.Round(Kira,2);
BaslangicYili++;
}

Bu kodu sihirli 2010
yılı için if ifadesi ile yazmanın bir yolu
aşağıdaki gibi olabilir.

while ( BaslangicYili<=BitisYili )
{
Console.WriteLine("{0} {1}", BaslangicYili,Kira);

if ( BaslangicYili != BitisYili )
{ 
Kira *= ( 1 + ArtisMiktari/100);
Kira = Decimal.Round(Kira,2);
}
BaslangicYili++;
}

if
ifadesi 2009 yılının kirası gösterildikten sonraki artışları
engeller. Bu nedenle de 2009 ile 2010 yılları arasıdan kira artışı
meydana gelmez. Bu işlemi aynı zamandan if ile
birlikte continue

while ( BaslangicYili<=BitisYili )
{
Console.WriteLine("{0} {1}", BaslangicYili,Kira);
BaslangicYili++;


if ( BaslangicYili ==2010 )
continue;

Kira *= ( 1 + ArtisMiktari/100);
Kira = Decimal.Round(Kira,2);
}

BaslangicYili
değişkenin artırılmasını döngünün başına aldım ve if
ifadesini bunun devamına yazdım. Eğer BaslangicYili değişkeni
2010’a ulaşırsa continue ifadesi döngünün bir
sonraki iterasyondan devam etmesini sağlayacak. Döngünün için deki
son iki ifade bu şekilde atlanmış oluyor.

while
döngüsünün bir diğer çeşidi de do döngüsü. while
döngüsünün genel ifadesini bir kez daha hatırlayalım.

while ( boolean ifade )
{
// while döngüsünün gövdesi
}

Şimdide do
döngüsünün genel ifadesini tanıyalım. do
döngüsü aynı zamanda while komutunu da
içeriyor.

do
{
// do döngüsünün gövdesi
{
while ( boolean ifade );

do
döngüsün en sonunda noktalı virgül olduğuna dikkat edin.
while döngüsünde olduğu gibi do döngüsünde de
break ve continue ifadelerini
kullanabilirsin.

do
döngüsünün yapısı boolean ifadeyi döngünün
başında değil de sonunda değerlendirir. do
döngüsünde gövde boolean ifadeyi dikkate
alınmadan en az kez çalışır.

do
döngüsü kullanıcıdan giriş alan programlarda
kullanışlıdır. Şimdi toplama yapan basit bir program yazalım.

using System;

class TopamaProgrami
{
static void Main()
{
string Cevap;

do
{
Console.Write("Birinci sayıyı gir: ");
double d1 = Double.Parse(Console.ReadLine());

Console.Write("ikinci sayıyı gir: ");
double d2 = Double.Parse(Console.ReadLine());

Console.WriteLine("Toplam : {0}", d1 + d2);

Console.WriteLine("Başka bir toplama yapmak ister misin?(e/h)");
Cevap = Console.ReadLine().Trim();

} while (Cevap.Length > 0 && Cevap.ToLower()[0] == 'e');
}
}

Buradaki string
tipindeki Cevap değişkeni neden while
bloğu içinde tanımlanmadı diye düşünebilirsiniz. Bunun nedeni;
değişkenin bloğun altındaki while
ifadesinin içindeki boolean ifadenin
içinde kullanılmasıdır.

Bu programın anahtar
kısmı do döngüsünün altına yakın yerde
ortaya çıkar. Buradaki bir komut kullanıcıya bir tane daha
hesaplama yapıp yapmayacağını sorar ve string
tipindeki Cevap değişkeni bu cevabı saklar. while
ifadesinin içindeki boolean ifade ilk önce Cevap
değişkenin uzunluğunun 0’dan büyük olup olmadığını kontrol eder.
Eğer öyleyse Cevap değişkenin büyük harflerle yazılmış olmasına
karşın değişken küçük harflere çevriliyor ve ilk harfinin ‘e’ olup
olmadığına bakıyor. Eğer ilk karakter ‘e’ ise programın işletimi
döngünün en başına dönecek ve oradan devam edecek.

boolean
ifadenin içindeki Cevap.Length ifadesi kullanıcın
sorulan soruya karşılık olarak basitçe enter
tuşuna basıp basmadığını kontrol etmek için kullanılıyor. Eğer
kullanıcı cevap için sadece enter’e basmış ise
Console.ReadLine boş bir string
döndürecektir ve bu string’in ilk karakterine
ulamaya çalışmak kural dışı bir durum oluşturacaktır. Kullanıcı
‘Y’ veya ‘y’ ile başlayan bir şeyler yazdığında ki yazdıklarında
boşluk bıraksa bile program devam edecek. Kullanıcıdan cevabını
istediğimizde kullandığımız Trim() fonksiyonu
boşluklardan kurtulmamızı sağlıyor.

Tabiî ki program eğer kullanıcı bizim sorduğumuz iki komuta doğru
yanıtları vermez ise yani sayıları istediğimiz ve cevabı
istediğimiz komutlara diğer tipler değişkenler yazarsa program
hata verecektir. Bu hataları nasıl halledeceğimizi başka bir
makalede anlatacağız.

Bazen aşağıdaki gibi
hatalar yapabiliriz.

while ( i < 100 )
{
// diğer ifadeler
}
while ( i < 101 )

Bu örnekte ilk önce bir
while ifadesi yazıyoruz. Daha sonra
do döngüsü oluşturduğumuzu düşünüp
döngünün sonuna bir while daha
yazıyoruz.

while ( i < 100 )
{
// diğer ifadeler
}

Yukarıdaki kısımda
i değişkeni döngü bittiğinde muhtemelen 100
değerini alacak olduğundan ikinci kısımdaki

while ( i < 101 )

ifadesi sonsuz bir
döngü olacak. Bu program asılı kalacakmış gibi görünüyor. Ve
muhtemelen bir çıktı da görüntülenemeyecek.

Ne zaman bir konsol
programı asılı kalırsa ctrl+c tuşlarını
kullanarak programı durdurabilirsin. Bundan sonra kaynak kodunu
tekrar incelemeli ve sonsuz döngü nerede oluşuyor bulmaya
çalışmalısın. Eğer kodunda bununla ilgili bir kanıt bulamıyorsan
while döngüsünün başına ve sonuna birkaç tane
“Burası döngünün girişi”, “Döngü bitiyor” gibi ifadeler içeren
WriteLine çağrısı koyabilirsin. Böylelikle
programı çalışırken inceleyebilirsin. Bu şekilde fazladan
ihtimalleri sınırlamış olursun.

Döngülerin bir diğer
yaygın kullanım alanı da dizilerle birlikte kullanımıdır. Şimdi
önceden girilen bir sayı dizisinin sayılarının karelerini ve
küplerini bula bir programı while
döngüsü ile yapalım.

using System;
class KareKub
{
static void Main()
{
int[] SayiDizisi = {10,11,12,13,14,15};

int i = 0 ;

while ( i < SayiDizisi.Length )
{
Console.WriteLine("{0} {1,6} {2,6} " ,SayiDizisi[i], Math.Pow(SayiDizisi[i],3), Math.Pow(SayiDizisi[i],3));
i++;
}
}
}

Burada girilen sayı
dizisin içindeki sayıları karelerini ve küplerini alan bir
programı yazdık. Dizinin eleman sayısı kadar dönen bir döngü
oluşturduk. Programın çıktısı da aşağıdaki gibi oluşuyor