Koşula bağlı çalışma
C’de, bazı durumlarda belirli işlem satırlarının istenen koşullar sağlandığında çalışması gerekebilir. Bu koşulları devreye sokmaya yarayan program yapılarına Program Kontrol Terimleri adı verilir.
Belirlediğimiz koşullar sağlandığında çalışmasını istediğimiz işlem satır veya satırlarını programlarımıza ekleyebiliriz. Tanımlanan koşul sağlandığında, koşula bağlı olarak tanımlanan işlem satır veya satırları devreye girecek aksi takdirde, bu satırları işlem yapmadan atlayacaktır. Tanımlanan koşul sağlanmadığında, söz konusu işlem satır veya satırları programda hiç yer almamış gibi işlem görür. Koşula bağlı olarak devreye giren işlem satırları programlarımızda çok büyük kolaylık ve esneklik sağlayacaktır.
If yapısı
Koşula bağlı işlem satırı veya satırları çalıştırma olanağı sağlayan deyimlerden bir tanesi ve belki de en sık kullanılanı if deyimidir. Bir if deyiminin genel yapısı aşağıda gösterilmektedir:
1
2
3
4
5
6
7
8
9
10
11
if (ifade) işlem-satırı;
if (ifade) {
işlem-satırı;
.
.
.
işlem-satırı;
}
Bir if yapısı tek bir işlem satırı veya birden fazla işlem satırı içerebilir.
Eğer if yapısında, if deyiminden sonra yer alan parantezler içindeki ifade doğru sonuç verirse (ifade sonucu 0’dan farklı ise), if kalıbı içinde yer alan işlem satır veya satırları çalışır. Eğer ifade yanlış bir sonuç verirse (ifade sonucu 0’a eşit ise), if kalıbı içinde yer alan yer alan işlem satırı veya satırları devre dışı kalır. Yani, program o işlem satırları hiç yazılmamış gibi bir sonraki işlem satırından çalışmaya devam eder.
Daha açık ifade etmek gerekirse, biz if satırını kullanarak programa şu talimatı vermiş oluyoruz:
if yapısına geldiğinde, eğer parantez içinde yer alan koşul doğru sonuç verirse, if kalıbı içindeki işlem satırlarının gereğini yap, aksi takdirde bir sonraki işlem satırına geç!
Şimdi, if satırında parantezler içinde yer alan ifadenin neler yaptığını inceleyelim. Genel olarak, bu ifade ilişkisel bir işlemci kullanarak iki değeri karşılaştırır, bir değerin diğeri ile olan ilişkisini kontrol eder.
Koşul bölümünü oluşturan ifade iki değeri karşılaştıran tek bir ilişkisel işlem veya birden fazla ilişkişel işlemi birleştiren mantıksal işlemlerden oluşur.
Yukarıda bahsettiklerimizi bir örnek üzerinde incelemeye çalışalım:
Örnek
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#include <stdio.h>
int main(void)
{
int id = 21;
if (id == 21) printf("id değişken değeri 21 sayısına eşittir!");
id = 35;
if (id == 21) printf("\nid değişken değeri 21 sayısına eşittir!");
return 0;
}
Yukarıdaki programı derleyip çalıştırdığımızda, aşağıdaki ifadeleri ekrana yazar:
1
2
3
id değişken değeri 21 sayısına eşittir!
Program, id değişkenine 21 değerini atar. Sonra if satırında id değişken değeri ile 21 sayısını == ilişkisel işlemcisini kullanarak karşılaştırır. id değişken değeri 21 sayısına eşit olduğu için ifade doğru sonuç olarak verdiğinden, aynı satırdaki printf() fonksiyonu karakter dizisini ekrana yazar. id değişkenine 35 değerini atar. İkinci if yaısında bu kez ifade yanlış sonuç verdiğinden, printf() fonksiyonu devreye girmez.
Şimdi, öğrendiklerimizi örneklerle pekiştirmeye çalışalım:
Örnek
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#include <stdio.h>
int main(void)
{
int id = 21;
if ((id>0) && (id<100)) {
printf("id değişken değeri pozitif bir sayıdır!\n");
printf("id değişken değeri 0-100 arasında bir sayıdır!");
}
return 0;
}
Yukarıdaki programı derleyip çalıştırdığımızda, aşağıdaki ifadeleri ekrana yazar:
1
2
3
4
id değişken değeri pozitif bir sayıdır!
id değişken değeri 0-100 arasında bir sayıdır!
Yukarıdaki örnekte, program id değişkenine 21 değerini atar. Sonra if satırında id değişken değerini kullanarak yaptığı 2 farklı karşılaştırma sonucu da doğru sonuç verdiğinden, kod bloğu içindeki işlem satırlarının gereğini yaparak karakter dizilerini ekrana yazar.
Örnek
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#include <stdio.h>
int main(void)
{
int id;
printf("Bir int değer giriniz: ");
scanf("%d", &id);
if (id == 21) printf("Girdiğiniz sayı 21'dir!");
if (id < 21) printf("Girdiğiniz sayı 21'den küçüktür!");
if (id > 21) printf("Girdiğiniz sayı 21'den büyüktür!");
return 0;
}
Program, klavyeden bir int değer girmenizi ister. Girdiğiniz değeri id değişkenine atar. İlk if satırında id değişken değeri ile 21 sayısını == ilişkisel işlemcisini kullanarak karşılaştırır. Eğer id değişken değeri 21 sayısına eşit ise, ifade doğru olan 1 değerini sonuç olarak vereceğinden, aynı satırdaki printf() fonksiyonu karakter dizisini ekrana yazar. Değişken değeri 21 sayısından farklı ise bir sonraki satıra geçer. Sonra, ikinci if satırında id değişken değeri ile 21 sayısını < ilişkisel işlemcisini kullanarak karşılaştırır. Eğer id değişken değeri 21 sayısından küçük ise, ifade doğru olan 1 değerini sonuç olarak vereceğinden, aynı satırdaki printf() fonksiyonu karakter dizisini ekrana yazar. Eğer id değişken değeri 21 sayısından büyük veya eşitse bu satırda hiç bir işlem yapmadan bir sonraki satıra geçer. Üçüncü if satırında ise, id değişken değeri ile 21 sayısını > ilişkisel işlemcisini kullanarak karşılaştırır. Eğer id değişkeni 21 sayısından büyük ise, ifade doğru olan 1 değerini sonuç olarak verdiğinden, aynı satırdaki printf() fonksiyonu karakter dizisini ekrana yazar. Eğer id değişken değeri 21 sayısından küçük veya eşit ise bu satırda hiç bir işlem yapmaz ve program sona erer. Sonuç olarak, eğer girdiğiniz sayı 21 sayısına eşit ilk if satırı, 21 sayısından küçük ise ikinci if satırı ve 21 sayısından büyük ise üçüncü if satırı program tarafından dikkate alınır.
Örnek
1
2
3
4
5
6
7
8
9
10
11
12
13
14
#include <stdio.h>
int main(void)
{
int id;
printf("4 * 7 = ? işleminin sonucunu giriniz: ");
scanf("%d", &id);
if (id == 28) printf("Cevabınız doğrudur!");
if (id != 28) printf("Cevabınız yanlıştır!");
return 0;
}
Program, 4 ile 7 sayılarının çarpım sonucunun girilmesini ister. Cevabı id değişkenine atadıktan sonra, değişken değerini ilk if satırında == ilişkisel işlemcisini kullanarak, doğru cevap olan 28 sayısı ile karşılaştırır. Eğer değişken değeri 28 sayısına eşit ise aşağıdaki cümleyi ekrana yazar:
1
2
3
Cevabınız doğrudur!
Aksi takdirde, bir sonraki satıra geçer. Bu satırda değişken değerini != ilişkisel işlemcisini kullanarak yine doğru cevap olan 28 sayısı ile karşılaştırır. Eğer değişken değeri 28 sayısından farklı ise aşağıdaki cümleyi ekrana yazar, aksi takdirde hiç bir işlem yapmadan sona erer.
1
2
3
Cevabınız yanlıştır!
Örnek
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#include <stdio.h>
int main(void)
{
char cd;
printf("Bir harf giriniz: ");
scanf("%c", &cd);
if (cd >= 'a' && cd <= 'z')
printf("Girdiğiniz harf küçük bir harftir!");
if (cd >= 'A' && cd <= 'Z')
printf("Girdiğiniz harf büyük bir harftir!");
return 0;
}
Program, bir harf girilmesini ister. Girilen harf küçük ise ilk if satırındaki, büyük ise ikinci if satırındaki karakter dizisini ekrana yazar. Program if satırında yer alan ifadelerde hem ilişkisel hem de mantıksal işlemcileri birlikte kullanmaktadır.
Örnek
1
2
3
4
5
6
7
8
9
10
11
12
13
#include <stdio.h>
int main(void)
{
int id;
id = 256;
if (id % 16 == 0) printf("256 sayısı 16 sayısına tam olarak bölünebilir!");
if (id % 16 != 0) printf("126 sayısı 16 sayısına tam olarak bölünmez!");
return 0;
}
Yukarıdaki programı derleyip çalıştırdığımızda, aşağıdaki ifadeleri ekrana yazar:
1
2
3
256 sayısı 16 sayısına tam olarak bölünebilir!
Program, 256 sayısını id değişkenine atar. % işlemcisini kullanarak, değişken değeri 16 sayısına bölündükten sonra, kalan değer 0 ise, girilen sayının 16 sayısına tam olarak bölünebileceğini, 0’dan farklı ise 16 sayısına tam olarak bölünemeyeceğini değerlendirir. 256 sayısı 16 sayısına tam olarak bölündüğünden ilk satırdaki karakter dizisini ekrana yazar.
C’de, if koşul ifadesi içinde daha kısa ifadeler kullanabiliriz. Programlarımızda, koşul ifadeleri içinde aşağıdakine benzer tanımlamalar yapabiliriz:
1
2
3
4
int id;
if(id) printf("id değişkeni 0'dan farklıdır!"); // if(id!=0)
if(!id) printf("id değişkeni 0'a eşittir!"); // if(id==0)
İlk satırda gördüğümüz if(id) ifadesi if(id!=0) ifadesi ile tamamen aynı işlemi gerçekleştirir. Yani id değişken değeri 0’dan farklı ise işlem satırının gereği program tarafından yerine getirilecek demektir. İkinci satırda yer alan if(!id) ifadesi ise if(id==0) ifadesi ile tamamen aynı işlemi gerçekleştirir. Yani id değişken değeri 0’a eşit ise işlem satırının gereği program tarafından yerine getirilecek demektir.
Şimdi, bu özelliği bir örnek üzerinde incelemeye çalışalım:
Örnek
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#include <stdio.h>
int main(void)
{
int id1, id2;
id1 = 21;
id2 = 0;
if (id1!=0) printf("id1 değişken değeri 0'dan farklıdır!\n");
if (id2==0) printf("id2 değişken değeri 0'a eşittir!\n\n");
if (id1) printf("id1 değişken değeri 0'dan farklıdır!\n");
if (!id2) printf("id2 değişken değeri 0'a eşittir!");
return 0;
}
Yukarıdaki programı derleyip çalıştırdığımızda, aşağıdaki ifadeleri ekrana yazar:
1
2
3
4
5
6
7
id1 değişken değeri 0'dan farklıdır!
id2 değişken değeri 0'a eşittir!
id1 değişken değeri 0'dan farklıdır!
id2 değişken değeri 0'a eşittir!
Program, tanımladığı id1 ve id2 adlı int değişkenlerine sırasıyla 21 ve 0 sayılarını atar. İlk if işlem satırında parantez içinde yer alan id1 değişken değeri olan 21 0’dan farklı olduğundan satırda yer alan karakter dizisini ekrana yazar. İkinci if satırında id2 değişkeni 0 değerini taşıdığından, satırda yer alan karakter dizisini ekrana yazar. Üçüncü if işlem satırında parantez içinde yer alan id1 değişken değeri olan 21 0’dan farklı olduğundan satırda yer alan karakter dizisini ekrana yazar. Dördüncü if satırında id2 değişkeni 0 değerini taşıdığından, 0 değerinin değili 1 olduğundan, satırda yer alan karakter dizisini ekrana yazar.
Else yapısı
Şimdi, if deyiminin else deyimi ile birlikte kullanılmasını incelemeye çalışalım. else deyimi tek başına değil sadece if deyimi ile birlikte ve if deyiminin peşinden kullanılabilir. if ve else işlem satırlarının program içindeki genel yapısı aşağıdaki gösterilmektedir:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
if (ifade) işlem-satırı;
else işlem-satırı;
if (ifade) {
işlem-satırı;
.
.
.
işlem-satırı;
}
else {
işlem-satırı;
.
.
.
işlem-satırı;
}
if else yapılarında if ve else deyimlerine ait işlem satır sayısı en az bir olmak üzere daha fazla sayıda da olabilir.
Eğer if koşulunda yer alan ifadenin sonucu doğru ise, program if satırındaki işlem satır veya satırlarının gereğini yerine getirir, else satır veya satırlarına hiçbir işlem yapmaz. Eğer if satırında yer alan ifade sonucu yanlış ise, program if yapısındaki işlem satırını veya satırlarını dikkate almaz, else satırındaki işlem satır veya satırlarının gereğini yerine getirir. Program if ve else işlem satır veya satırlarında sadece birisine işle yapmak zorundadır.
Sadece if satırlarından oluşan bir programda bütün if satırları da işlem görebilir, hiçbir if satırı da görmeyebilir. Elde edilecek sonuç tamamen if satırlarından tanımlanan ifadelerin doğruluğuna bağlıdır ve birbirinden bağımsızdır. if ve else gruplarından oluşan işlem satırlarında ise if ya da else işlem satırlarından birisi mutlaka çalışacaktır. Çünkü biri diğerinin alternatifidir ve birbirine bağlıdır. Program if satırının ifadesinin sonucunun doğru olduğunu belirleyip ilgili işlem satırını çalıştırdığında, artık else ile ilgili işlem satırına işlem yapma şansı yoktur.
Şimdi vereceğimiz örneklerle öğrendiklerimizi incelemeye çalışalım:
Örnek
1
2
3
4
5
6
7
8
9
10
11
12
13
14
#include <stdio.h>
int main(void)
{
int id1, id2;
id1 = 21;
id2 = 35;
if (id1==id2) printf("id1 ve id2 değişken değerleri birbirine eşittir!");
else printf("id1 ve id2 değişken değerleri birbirine eşit değildir!");
return 0;
}
Yukarıdaki programı derleyip çalıştırdığımızda, aşağıdaki ifadeleri ekrana yazar:
1
2
3
id1 ve id2 değişken değerleri birbirine eşit değildir!
Program, önce oluşturduğu id1 ve id2 adlı değişkenlere sıra ile 21 ve 35 değerlerini atar. if satırında, parantez içindeki ifade de yer alan == işlemcisi ile iki değişken değerinin eşit olup olmadığını kontrol eder. İki değişken değeri birbirine eşit olmadığından if satırında herhangi bir işlem yapmadan doğrudan else satırına geçer ve yukarıdaki karakter dizisini ekrana yazar.
if else kalıplarında, else işlem satırında yer alan bir ifadeye bağlı bir değerlendirme yapılmaz. Sadece if satırında yapılan değerlendirmeden olumsuz sonuç alındığında else satırındaki işlemler devreye girer.
Örnek
1
2
3
4
5
6
7
8
9
10
11
12
13
14
#include <stdio.h>
int main(void)
{
int id;
printf("8 * 9 = ? işleminin sonucunu giriniz: ");
scanf("%d", &id);
if (id == 72) printf("Cevabınız doğrudur!");
else printf("Cevabınız yanlıştır!");
return 0;
}
Program, 8 ile 9 sayısının çarpım sonucunu vermenizi ister. Verdiğiniz cevabı id değişkenine atayarak, değişken değerini if satırında doğru cevap olan 72 sayısı ile karşılaştırır. Eğer değişken değeri 72 sayısına eşit ise aşağıdaki cümleyi ekrana yazar:
1
2
3
Cevabınız doğrudur!
Aksi takdirde, else satırına geçer ve aşağıdaki cümleyi ekrana yazar:
1
2
3
Cevabınız yanlıştır!
Kod blokları
Şimdi, if ve else yapılarında iki veya daha fazla işlem satırını birleştirerek kullanmaya çalışacağız. Ancak, öncelikle kod bloğu kavramını ele alalım.
C’de, iki veya daha fazla işlem satırını birleştirerek belirli bir koşula veya döngüye bağlı olarak çalıştırabiliriz.
Birden fazla işlem satırının bir araya getirilerek kullanılmasına Kod Bloğu adı verilir.
Kod bloğu { ve } işaretleri arasında yer alır. Kod bloğunun genel yapısı aşağıda gösterilmektedir:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
if (ifade) {
işlem satırı;
.
.
.
işlem satırı;
}
else {
işlem satırı;
.
.
.
işlem satırı;
}
if satırındaki ifade doğru sonuç verdiği zaman, program if deyiminin hemen peşinden gelen { } işaretleri arasında yer alan işlem satırlarından oluşan kod bloğunun gereğini yerine getirir. Eğer ifade yanlış sonuç verirse, program bu kez else deyiminin hemen peşinde yer alan { } işaretleri arasındaki işlem satırlarından oluşan kod bloğunun gereğini yerine getirir. Daha açık bir şekilde ifade etmek gerekirse, if ve else deyimleri tek bir işlem satırının çalışmasını sağlayabilecekleri gibi aynı anda birden fazla işlem satırının da çalışmasını sağlayabilirler.
Bir if veya else satırında koşul sağlandığında, koşula bağlı olarak devreye giren kod bloğu içinde yer alan işlem satırları sıra ile çalıştırılır. C’de, if ve else deyimlerinden sonra yer alan tek bir işlem satırı ya da kod bloğu kendisi ile bağlantılı olan diğer if ya da else satırında işlem satırı ya da kod bloğu kullanılması konusunda belirleyici değildir. Farklı bir ifade ile, if veya else yapısında bir kod bloğu kullanmamız, if veya else yapısına bağlı olan else veya if yapısında da kod bloğu kullanmamızı gerektirmez.
Şimdi öğrendiklerimizi örnekler üzerinde incelemeye çalışalım:
Örnek
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#include <stdio.h>
int main(void)
{
int id;
printf("Bir int değer giriniz: ");
scanf("%d", &id);
if(id%2) {
printf("Girdiğiniz sayı tek bir sayıdır: %d\n", id);
printf("Sayının 3 katı: %d", 3 * id);
}
else {
printf("Girdiğiniz sayı çift bir sayıdır: %d\n", id);
printf("Sayının 2 katı: %d", 2 * id);
}
return 0;
}
Yukarıdaki örnekte, program size int bir değer girmenizi ister. Girdiğiniz değeri id değişkenine atar. if satırında id değişken değerinin tek sayı olup olmadığını kontrol eder. Tek bir sayı ise if koşuluna bağlı olarak tanımlanmış kod bloğu içindeki karakter dizisini ve değişken değerinin 3 katını hesaplayarak ekrana yazar. Sayı çift ise else satırına bağlı olarak tanımlanmış kod bloğu içindeki karakter dizisini ve değişken değerinin 2 katını hesaplayarak ekrana yazar.
Örnek
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#include <stdio.h>
int main(void)
{
int id1, id2;
printf("Bir int değer giriniz: ");
scanf("%d", &id1);
printf("Bir int değer giriniz: ");
scanf("%d", &id2);
if((id1+id2)>100) {
printf("Girdiğiniz sayıların toplamı 100'den büyüktür!\n");
printf("Girdiğiniz sayıların toplamı: %d", id1+id2);
}
else printf("Girdiğiniz sayıların toplamı 100'den küçüktür!");
return 0;
}
Yukarıdaki örnekte, program iki adet int değer girmenizi ister. Girdiğiniz değerleri sıra ile id1 ve id2 adlı değişkenlere atar. if satırında değişken değerlerinin toplamının 100 sayısından büyük olup olmadığını kontrol eder. Eğer büyük ise, if satırı ifadesi doğru sonuç vereceğinden, ilgili kod bloğunda yer alan karakter dizisini ve girdiğiniz sayıların toplamını ekrana yazar. Aksi takdirde, else satırında yer alan karakter dizisini ekrana yazar. Bu örnekte, if yapısı için kod bloğu, else yapısı için ise tek bir işlem satırı tanımlanmıştır.
Örnek
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#include <stdio.h>
int main(void)
{
int id;
printf("Bir int değer giriniz: ");
scanf("%d", &id);
if (id % 5 == 0 && id <= 300) {
printf("Girdiğiniz sayı 300'den küçük veya eşittir ve\n");
printf("5 sayısına kalansız olarak bölünür!");
}
else {
printf("Girdiğiniz sayı 300'den büyüktür veya\n");
printf("5 sayısına bölümünde kalanı vardır!");
}
return 0;
}
Program, bir int değer girilmesini ister. Girilen int değeri if satırında 2 ayrı ilişkisel işlemci ile işleme sokar, işlem sonuçlarını && mantıksal işlemcisi ile birleştirir. Eğer, if satırındaki ifade doğru sonuç verirse, girilen sayı 300 sayısından küçük veya eşitse ve 5 sayısına tam olarak bölünürse, if satırındaki işlem satırında yer alan karakter dizilerini ekrana yazar. Aksi takdirde, else deyimi kod bloğunda yer alan karakter dizilerini ekrana yazar.
İç içe if ve else yapıları
C’de, bir if veya else deyimine bağlı olarak çalıştırılan işlem satırında yeni bir if deyimi yer alabilir. Yine bir if veya else deyimine bağlı olarak çalıştırılan kod bloğu içinde yer alan işlem satırlarından birisinde yeni bir if deyimi yer alabilir. Başka bir ifade ile, bir if deyimi başka bir if veya else deyiminin içinde kullanılabilir. İçte kalan if deyimi dıştaki if deyimine ait ifadenin doğru olması halinde programın çalıştırdığı tek bir satır olabileceği gibi, dıştaki if deyimine ait bir kod bloğunun işlem satırlarından biri de olabilir.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
if(ifade)
if(ifade) işlem-satırı;
if(ifade) {
if(ifade) {
işlem-satırı;
işlem-satırı;
}
}
if(ifade) {
işlem-satırı;
if(ifade) işlem-satırı;
işlem-satırı;
}
if (ifade) {
işlem satırı;
if (ifade) {
işlem-satırı;
if(ifade) işlem-satırı;
else işlem-satırı;
işlem-satırı;
}
else {
işlem-satırı;
if(ifade) işlem-satırı;
else işlem-satırı;
işlem-satırı;
}
}
else {
işlem-satırı;
if(ifade) işlem-satırı;
else işlem-satırı;
}
Yukarıda farklı şekilde tanımlanmış iç içe if else kalıpları bulunmaktadır. Bu şekilde tanımlanmış kodlarda, herhangi bir if ya da else işlem satırı ya da kod bloğunda yer alan if deyimlerine bağlı işlemlerin devreye girebilmesi için, kendisinden üstte yer alan tüm if ya da else koşulları ile kendi koşulunun doğru sonuç vermesi gerekir.
Şimdi örneklerle konuyu detaylı olarak incelemeye çalışalım:
Örnek
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#include <stdio.h>
int main(void)
{
int id;
id = 42;
if (id<100)
if (id%2==0)
printf("id değişken değeri 100'den küçük çift bir sayıdır!");
return 0;
}
Yukarıdaki programı derleyip çalıştırdığımızda, aşağıdaki ifadeleri ekrana yazar:
1
2
3
id değişken değeri 100'den küçük çift bir sayıdır!
Program, id değişkenine 42 sayısını atar. İç içe yer alan her iki if satırında yer alan ifade doğru sonuç verdiğinden printf() fonksiyonu karakter dizisini ekrana yazar.
Örnek
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#include <stdio.h>
int main(void)
{
int id;
printf("Bir int değer giriniz: ");
scanf("%d", &id);
if (id<100) {
printf("id değişken değeri 100'den küçük bir sayıdır!\n");
if (id%2==0) printf("id değişken değeri çift bir sayıdır!\n");
printf("id değişken değerinin iki katı: %d", 2*id);
}
else printf("id değişken değeri 100'den büyük bir sayıdır!");
return 0;
}
Program, klavyeden bir int değer girmenizi ister. Girdiğiniz değer 100’den küçük ise (30 sayısını girerseniz), aşağıdaki satırları ekrana yazar:
1
2
3
4
5
id değişken değeri 100'den küçük bir sayıdır!
id değişken değeri çift bir sayıdır!
id değişken değerinin iki katı : 60
Bu durumda, if kod bloğunun her iki printf() fonksiyonunda yer alan karakter dizileri ile kod bloğu içindeki if satırında tanımlanan printf() fonksiyonu karakter dizisini ekrana yazar. Eğer girdiğiniz değer 100’den büyük ise aşağıdaki satırı ekrana yazar:
1
2
3
id değişken değeri 100'den büyük bir sayıdır!
Yukarıdaki satırlar bir if deyimine ait ifadenin doğru sonuç vermesi halinde program tarafından çalıştırılacak bir kod bloğunun içinde yer alan bir if deyimini göstermektedir. Yukarıdaki kod bloğu içinde yer alan ilk ve üçüncü sıradaki işlem satırları dıştaki if deyiminin doğru sonuç vermesi durumunda çalışmaktadır. İçteki if deyimine bağlı işlem satırı ise ancak içteki if deyimine ait ifade doğru sonuç verdiğinde devreye girmektedir.
İç içe if deyimlerinin kullanıldığı programlarda, bazı else işlem satırlarının hangi if satırlarına bağlı olarak çalıştığını belirlemek sorun yaratmaktadır. Bir else satırı daima aynı blokta yer aldığı en yakın if satırı ile ilgilidir. Programları yazarken bu konuda bir hataya düşmemek için yazım kurallarını uygularken birbiri ile ilgili deyimleri aynı sütun hizasında tanımlamak dikkate değer şekilde bu tip sorunların giderilmesine katkı sağlamaktadır.
Örnek
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
#include <stdio.h>
int main(void)
{
int id;
printf("Bir int değer giriniz: ");
scanf("%d", &id);
if(id > 100) { // 1
printf("Girilen sayı 100'den büyüktür!\n"); // 2
if(id % 2 == 0) { // 3
printf("Girilen sayı çift bir sayıdır!\n"); // 4
if (id<=150) printf("Girilen sayı 100-150 arasındadır!"); // 5
else printf("Girilen sayı 150'den büyüktür!"); // 6
}
else printf("Girilen sayı tek bir sayıdır!"); // 7
}
else { // 8
if(id == 100) printf("Girilen sayı 100'dür!"); // 9
else printf("Girilen sayı 100'den küçüktür!"); // 10
}
return 0;
}
Yukarıdaki programı derleyip çalıştırdığımızda, eğer 264 değerini girersek, aşağıdaki ifadeleri ekrana yazar:
1
2
3
4
5
Girilen sayı 100'den büyüktür!
Girilen sayı çift bir sayıdır!
Girilen sayı 150'den büyüktür!
Program, int bir değer girmenizi ister. Girilen değeri id değişkenine atar.
1 sayısı ile gösterilen işlem satırındaki if koşulunda, id değişken değeri 100’den büyük ise, ilk if yapısı içine girer ve 2 sayısı ile gösterilen işlem satırında ilk karakter dizisini ekrana yazar. 3 sayısı ile gösterilen işlem satırında, id değişken değeri çift bir sayı ise, ikinci if yapısına girer ve 4 sayısı ile gösterilen işlem satırındaki karakter dizisini ekrana yazar. 5 sayısı ile gösterilen işlem satırındaki if koşulunda, id değişken değeri 150 sayısından küçük veya eşit ise aynı işlem satırındaki karakter dizisini aksi takdirde 6 sayısı ile gösterilen else işlem satırındaki karakter dizisini ekrana yazar. id değişken değeri 100’den büyük tek bir sayı ise, 7 sayısı ile gösterilen else işlem satırındaki karakter dizisini ekrana yazar.
Eğer id değişken değeri 100’den küçük veya eşit ise, 8 sayısı ile gösterilen else kod bloğuna giriş yapar. id değişken değeri 100 sayısına eşit ise, 9 sayısı ile gösterilen if işlem satırındaki karakter dizisini aksi takdirde, 10 sayısı ile gösterilen else işlem satırındaki karakter dizisini ekrana yazar.
Programda birbiri ile ilgili if ve else deyimleri aynı sütun hizasında tanımlandığından programın okunurluğu daha kolaydır.
if - else if kalıbı
Şimdiye kadar incelediğimiz örnek programlarda if ve else deyimlerini kullanarak iki seçenekli bir sistem oluşturduk. if deyimine ait ifade doğru bir sonuç verirse if deyimi ile bağlantılı tek bir işlem satırı veya bir kod bloğu, aksi takdirde else deyimi ile bağlantılı tek bir işlem satırı veya bir kod bloğu program tarafından çalıştırılmakta idi. İkiden fazla seçeneğe sahip bir sistem oluşturmak için seçenek sayısı kadar if deyimi kullanıyorduk. Şimdi, ikiden fazla seçeneğe sahip bir sistem oluşturmak için if-else-if kalıbının kullanılmasını birlikte inceleyelim. if-else-if kalıbı için kullanılan genel yapı aşağıda gösterilmektedir:
1
2
3
4
5
6
7
8
if(ifade) işlem-satırı
else if(ifade) işlem-satırı
else if(ifade) işlem-satırı
.
.
.
else if(ifade) işlem-satırı
else işlem-satırı
Yukarıda gösterilen işlem satırlarının herhangi birinin yerine kod bloğu da kullanılabilir.
if-else-if kalıbında, bir if satırı, istediğiniz sayıda else if satırı ve isteğe bağlı olarak tanımlanan tek bir bir else satırı bulunur. Yani, else satırının tanımlanması şart değildir.
Program, en başta yer alan if satırı ile if-else-if kalıbını değerlendirmeye başlar. İlk doğru ifadenin bulunduğu if veya else if satırı ile karşılaştığında ilgili işlem satırını çalıştırır. Kalıbın geri kalan tüm satırlarını değerlendirmeye almadan geçer. Eğer if ve else if satırlarında yer alan ifadelerden hiç biri doğru bir sonuç vermezse, else satırında yer alan işlem satırını çalıştırır. else satırı da mevcut değilse, program if-else-if kalıbının hiç bir satırını çalıştırmadan, program if-else if kalıbından hemen sonra gelen işlem satırından itibaren çalışmasına devam eder. if-else-if kalıbında sadece tek bir satır işlem görür.
Bir if-else-if kalıbında else satırı tanımlanmaz ve kalıp içindeki if ve else if satırlardan herhangi birindeki koşul sağlanmazsa, kalıp içindeki hiçbir işlem satırı devreye girmez. else satırı tanımlanırsa, kalıp içindeki if ve else if satırlardan herhangi birindeki koşul sağlanmasa bile, else satırna bağlı işlem satırları mutlaka devreye girer.
if-else-if kalıbının aynı sayıda if satırı ile sağlanan seçenek sistemine göre bir avantajı vardır. if satırları ile sağlanan seçenek sisteminde program doğru sonuç veren bir ifadenin bulunduğu bir if satırını çalıştırdıktan sonra, diğer if satırlarını da değerlendirmek zorundadır. if-else-if kalıbında ise program doğru sonuç veren bir ifadenin bulunduğu bir if veya else if satırını çalıştırdıktan sonra if-else-if kalıbının geriye kalan satırlarını değerlendirmek zorunda değildir.
Şimdi, örneklerle öğrendiklerimizi data detaylı olarak incelemeye çalışalım:
Örnek
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#include <stdio.h>
int main(void)
{
int id;
printf("Bir int değer giriniz: ");
scanf("%d", &id);
if(id < 100) printf("Girdiğiniz sayı 100'den küçüktür!");
else if(id < 200) printf("Girdiğiniz sayı 200'den küçüktür!");
else if(id < 300) printf("Girdiğiniz sayı 300'den küçüktür!");
else if(id < 400) printf("Girdiğiniz sayı 400'den küçüktür!");
else printf("Girdiğiniz sayı 400'den büyük veya eşittir!");
return 0;
}
Yukarıdaki örnekte, program bir int değer girmenizi ister. Girdiğiniz int değer için 5 seçenekli bir if-else-if kalıbı kullanır. Eğer girdiğiniz sayı 100’den küçük ise sadece if satırında yer alan karakter dizisini ekrana yazar. else if satırlarındaki ifadeler doğru sonuç vereceği halde onları hiç değerlendirmeye almadığından, else if satırlarında yer alan karakter dizilerini ekrana yazmaz. Eğer girdiğiniz sayı 200’den küçük ise sadece ilk else if satırında yer alan karakter dizisini, 300’den küçük ise sadece ikinci else if satırında yer alan karakter dizisini, 400’den küçük ise son else if satırında yer alan karakter dizisini ekrana yazar. Eğer if ve else if satırlarındaki ifadelerden hiçbiri doğru sonuç vermezse else satırında yer alan karakter dizisini ekrana yazar. Başka bir deyişle, bir if-else-if kalıbındaki bütün satırlarda yer alan ifadeler doğru sonuç verse bile, program sadece doğru ifade sağlayan ilk satırı çalıştırır.
Örnek
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
#include <stdio.h>
int main(void)
{
int id1, id2;
printf("Bir int değer giriniz: ");
scanf("%d", &id1);
id2 = 0;
if(id2++ && (id1 < 100)) printf("Girdiğiniz sayı 100'den küçüktür!"); // 1
else if(id2++ && (id1 < 200)) printf("Girdiğiniz sayı 200'den küçüktür!"); // 2
else if(id2++ && (id1 < 300)) printf("Girdiğiniz sayı 300'den küçüktür!"); // 3
else if(id2++ && (id1 < 400)) printf("Girdiğiniz sayı 400'den küçüktür!"); // 4
else { // 5
printf("Girdiğiniz sayı 400'den büyük veya eşittir!");
id2++;
}
printf("\nif-else-if kalıbında yapılan değerlendirme sayısı: %d", id2);
return 0;
}
Yukarıdaki örneğin bir önceki örnekten tek farkı if-else-if kalıbının her satırına eklenmiş olan id2++ ifadesidir. Kalıbın işlem gören her satırında program bu değişken değerini artırır. Burada amaç, bir satır doğru olarak sonuç verdiğinde geri kalan satırlara herhangi bir işlem yapılmadığının gösterilmesidir. Sonuçta, kalıp içinde işlem gören satır sayısı ekrana yazılır. Girdiğiniz sayının değeri id2 değişken değerini değiştirir. Eğer 200 ile 300 arasında bir sayı girerseniz program aşağıdaki satırları ekrana yazar:
1
2
3
4
Girdiğiniz sayı 300'den küçüktür!
if-else-if kalıbında yapılan değerlendirme sayısı: 3
Program, bu durumda if-else-if kalıbı içinde sadece 1, 2 ve 3 sayısı ile gösterilen işlem satırlarını değerlendirmektedir. 3 sayısı ile gösterilen işlem satırındaki koşul doğru sonuç verdiğinden, bu işlem satırndaki karakter dizisini ekrana yazar. 4 ve 5 sayısı ile gösterilen işlem satırlarına hiçbir işlem yapmaz.
Şimdi, yukarıdaki örnekte if-else-if kalıbı ile sağlanan seçenek sisteminin yerine if satırlarından oluşan bir seçenek sistemi kullanalım:
Örnek
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#include <stdio.h>
int main(void)
{
int id;
printf("Bir int değer giriniz: ");
scanf("%d", &id);
if(id < 100) printf("Girdiğiniz sayı 100'den küçüktür!\n");
if(id < 200) printf("Girdiğiniz sayı 200'den küçüktür!\n");
if(id < 300) printf("Girdiğiniz sayı 300'den küçüktür!\n");
if(id < 400) printf("Girdiğiniz sayı 400'den küçüktür!\n");
if(id >= 400) printf("Girdiğiniz sayı 400'den büyük veya eşittir!");
return 0;
}
Yukarıdaki örnekte, program if satırlarından oluşan bir seçenek sistemi oluşturduğu için eğer 100’den küçük bir sayı girerseniz ilk dört if satırındaki ifadeler doğru sonuç vereceğinden, program ilk 4 if satırında yer alan karakter dizilerinin hepsini ekrana yazar. Yani, program her if satırını ayrı ayrı değerlendireceğinden doğru sonuç veren ifadelerin yer aldığı bütün satırlardaki karakter dizilerini ekrana yazar.
if ve if-else kalıplarında olduğu gibi if-else-if kalıplarında da işlem satırları yerine kalıbın istediğimiz satırlarında kod bloğu kullanabiliriz. Şimdi, bu konuyu bir örnek üzerinde incelemeye çalışalım:
Örnek
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
#include <stdio.h>
int main(void)
{
int id;
printf("Bir int değer giriniz: ");
scanf("%d", &id);
if(id<100) {
printf("Girdiğiniz sayı 100'den küçüktür: %d\n", id);
printf("Girdiğiniz sayının 5 katı: %d\n", 5*id);
}
else if(id<200) {
printf("Girdiğiniz sayı 100-200 arasındadır: %d\n", id);
printf("Girdiğiniz sayının 4 katı: %d\n", 4*id);
}
else if(id<300) {
printf("Girdiğiniz sayı 200-300 arasındadır: %d\n", id);
printf("Girdiğiniz sayının 3 katı: %d\n", 3*id);
}
else if(id<400) {
printf("Girdiğiniz sayı 300-400 arasındadır: %d\n", id);
printf("Girdiğiniz sayının 2 katı: %d\n", 3*id);
}
else printf("Girdiğiniz sayı 400'den büyük veya eşittir: %d", id);
return 0;
}
Program int bir değer girmenizi ister. Girilen değeri id değişkenine atar. Bir if-else-if kalıbı içinde, id değişken değerinin sıra ile 100, 200, 300 ve 400 sayılarından küçük olup olmadığını kontrol eder. if-else-if kalıbı içinde doğru koşulu sağlayan işlem satırına bağlı kod bloğunu devreye sokar ve ilgili karakter dizilerini ekrana yazar.
? işlemcisi ile koşula bağlı programlama
C dilinde kullanılan işlemcilerden biri de, if yapısı yerine kullanılabilen ? işlemcisidir. ? işlemcisinin genel yapısı aşağıda gösterildiği şekildedir:
koşul ? ifade1 : ifade2;
? işlemcisi en az 3 değer gerektirir. ? işaretinden önce bir koşul, ? işaretinden sonra ise arasında : işareti bulunan iki ifade yer almalıdır. Koşul sonucunda elde edilen değer 1 (doğru) veya 0 (yanlış) olmalıdır. İfade bir sabit, değişken veya sabit ve değerlerin karışımından oluşan bir değerdir.
if else yapısında, if ve else satırlarının birbirinin alternatifi olduğundan, biri çalıştığında diğerinin devre dışı kaldığından bahsetmiştik. Yukarıdaki yapıyı if else yapısı ile tanımlayabiliriz. Aşağıda, ? işlemcisi ve if yapısı ile yapılan tanımlamalar aynı işlemi gerçekleştirir.
1
2
3
4
if (koşul) ifade1;
else ifade2;
koşul ? ifade1 : ifade2;
Bir örnek ile konuyu incelemeye çalışalım:
Örnek
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
#include <stdio.h>
int main(void)
{
int id1, id2, id3, id4;
id1 = 73;
id2 = 16;
// ? işlemcisi ile koşula bağlı değerlendirme
id3 = (id1 > id2) ? id1-id2 : id1+id2; // 1
// if else kalıbı ile koşula bağlı değerlendirme
if (id1 > id2) id4 = id1-id2; // 2
else id4 = id1+id2; // 3
printf("id3 değişken değeri: %d\n", id3);
printf("id4 değişken değeri: %d", id4);
return 0;
}
Yukarıdaki programı derleyip çalıştırdığımızda, aşağıdaki ifadeleri ekrana yazar:
1
2
3
4
id3 değişken değeri: 57
id4 değişken değeri: 57
Program, id1 ve id2 adlı int değişkenlerine atadığı değerleri, önce ? işlemcisi sonra if else kalıbı ile koşula bağlı değerlendirme yapar. 1 sayısı ile gösterilen işlem satırında, id1 değişken değeri id2 değişken değerinden büyük olduğundan ve koşul doğru sonuç verdiğinden, ? ifadesinden hemen sonra yer alan id1-id2 ifadesi gerçekleşir. Böylece, 57 değerini id3 değişkenine atar. Aynı değerlendirmeyi if else kalıbı ile yapar ve 57 değerini id4 değişkenine atar. id3 ve id4 değişken değerlerini ekrana yazar.
? işlemcisini sadece bir değişkene değer atama amaçlı olarak değil aynı zamanda farklı fonksiyon çağrıları için de kullanabiliriz. Bu özelliği bir örnek üzerinde incelemeye çalışalım:
Örnek
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
#include <stdio.h>
void fonk1(int id1, int id2);
void fonk2(int id1, int id2);
int main(void)
{
int id1, id2;
printf("Bir int değer giriniz: ");
scanf("%d", &id1);
printf("Bir int değer daha giriniz: ");
scanf("%d", &id2);
(id1 > id2) ? fonk1(id1, id2) : fonk2(id1, id2);
return 0;
}
void fonk1(int id1, int id2)
{
printf("Değişken değerlerinin farkı: %d", id1-id2);
}
void fonk2(int id1, int id2)
{
printf("Değişken değerlerinin toplamı: %d", id1+id2);
}
Program, iki adet int değer girmenizi ister. Bu değerleri id1 ve id2 değişkenlerine atar. ? İşlemcisinin kullanıldığı işlem satırında, id1 değişken değeri id2 değişken değerinden büyük ise fonk1() fonksiyonunu çağırarak iki değişken değerinin farkını, aksi takdirde fonk2() fonksiyonunu çağırarak iki değişken değerinin toplamını ekrana yazar. Burada, fonk1() ve fonk2() içinde tanımlanan id1 ve id2 değişkenlerinin lokal değişenler olduğuna, iki fonksiyon içinde tanımlanmış değişkenlerle int main(void) fonksiyonu içindeki tanımlanmış değişkenlerin birbirinden tamamen farklı olduğuna dikkat ediniz.