Sitede Ara
Site Üyelik
Kullanıcı Adınız :
Şifreniz :
Site Anket
Yeni web sitemizi nasıl buldunuz ?
Çok güzel
Güzel
İdare Eder
Kötü
C Ders Notları
C Programlama ders notu ve Dev c++ programı
02 Mart 2010 Salı 02:13 tarihinde eklendi. Toplam 50328 defa okundu.
C ders notunu indirip içindeki örnekleri iyice inceleyiniz. Ve size Verdiğim Dev C++ programını bilgisayarınıza kurunuz. Aklınıza takılan yeri burdan yada direkt okula getirip sorabilirsiniz.
Şimdiden Başarılar Dilerim....

C ders Notu İçin TIKLAYINIZ

Dev C programını indirmek için tıklayınız.
Arkadaşlar normalde programı kurarken dil seçenekleri var ordan türkçe yi seçersiniz.
Eğer ki ingilizce kurduysanız onun içinde;
PROGRAMI AÇ!
TOOLS > Environment Options > lnterface>Language SEÇENEĞİ VAR TÜRKÇE YAP."

KOLAY GELSİN!

Dev c kullanımı için tıklayınız.


1. Programlamaya Giriş 

1.1. Bilgisayar Nedir? 
1.2. Bilgisayar Yazılımı 
1.3. Programlama Dilleri 
1.4. Yazılım Geliştirme 

1.4.1.  Problemin Anlaşılması ve Çözümlenmesi 
1.4.2.  Tasarım 
1.4.3.  Kodlama 
1.4.4.  Sınama ve Kanıtlama (Testing and Verifying) 
1.5. Basit bir problem
1.6. C Programlarının Hazırlanması

1. Programlamaya Giriş 

Amaç :
  1. Bilgisayar ve bilgisayar yazılımlarının tanımlanması
  2. Programlama dilleri ve program geliştirme tekniklerinin tanıtılması
  3. Temel problem çözme tekniklerinden olan  olan yukarıdan aşağı tasarım (top-down design) tekniğinin tanıtılması ve bu teknikle algoritmaların yazılması.
  4. Kullanacağımız C derleyici  ortamında, C pogramlarının nasıl hazırlanacağının gösterilmesi.

1.1. Bilgisayar Nedir? 

Bilgisayar, mantıksal ve aritmetiksel işlemleri çok hızlı biçimde  yapan bir araçtır. Günümüzün bilgisayarları, saniyede milyonlarca aritmetiksel işlemi  yapabilecek kapasitededir. 

İlk üretilen bilgisayarlar, oldukça büyük ve yavaştı. Ama gün geçtikçe küçüldüler ve güçleri de hızla arttı. Örneğin, yirmi-otuz yıl önceki ancak bir odaya sığabilecek bir bilgisayarın yaptığı işlerden çok daha fazlasını, bugünkü kişisel bilgisayarlar, daha hızlı bir şekilde yapabilmektedir. Bu yüzden, bilgisayarlar günümüzde çok değişik alanlarda ve ortamlarda kullanılmaktadır. Hemen hemen her evde ve işyerinde artık bir bilgisayar görmek olasıdır. 

Bir bilgisayar sisteminin fiziksel yapısını oluşturan, klavye, ekran, işlemci, disk, bellek gibi parçaların hepsi birden bilgisayar donanımı olarak adlandırılmaktadır. Bilgisayarın çalışmasını denetleyen birer komutlar kümesi olan programlar da bilgisayar yazılımı olarak adlandırılır. Bir bilgisayar sisteminin, bu iki parçaya da ihtiyacı vardır. Her biri, diğeri olmadan hiçbir işe yaramaz. Günümüzde, donanım fiyatları hızla düşmekte, ama yazılım maliyetleri tam tersine artmaktadır. Bu dersteki amacımız bilgisayar yazılımı geliştirmek olduğundan, biz yalnızca  bilgisayar yazılımı ile ilgileneceğiz. 

1.2. Bilgisayar Yazılımı 

Bilgisayar yazılımı (program), bilgisayara bir işi yaptırmak için verdiğimiz komutlar kümesidir. Yazılımları genel olarak iki kategoride sınıflandırabiliriz : 
İşletim sistemleri : 
Kullanıcı ile bilgisayar arasındaki iletişimi sağlayan programlardır. Bilgisayar sisteminin bütün hareketlerini denetler ve sistemdeki  MİB ve ana bellek gibi kaynakların yönetimi ile ilgilenirler. Örneğin, sizin kullandığınız Windows’95 ya da Windows NT birer işletim sistemidir. Diğer bazı işletim sistemleri şunlardır : UNIX, DOS, Solaris, MacOS. 
Uygulama Programları : 
İşletim sistemi dışında kalan diğer programlara verilen genel bir addır. Örneğin, MSWord, havayolları rezervasyon sistemi, bilgisayar oyunları, programlama dillerinin derleyicileri, bizim yazacağımız C programları birer uygulama programıdır. 

1.3. Programlama Dilleri 

Bir problemi çözmek için gerekli olan komutlar çok değişik programlama dilleri kullanılarak yazılabilir. Bazı programlama dillerinde yazılan programlar, doğrudan bilgisayarın merkezi işlem birimi (MİB) tarafından anlaşılabilir. Diğer bazı dillerde yazılan programlar ise o dilin derleyicisi tarafından merkezi işlem biriminin anlayacağı dile çevrilir. 

Programlama dillerini üç genel kategoriye ayırabiliriz : 

  • Makina dilleri 
  • Assembly dilleri 
  • Yüksek seviyeli programlama dilleri (high-level languages) 
Makina dili : 
Her bilgisayar MİB’inin anlayacağı kendi makina dili vardır. Örneğin, Pentium işlemcinin makina dili, Sparc işlemciden farklıdır. Makina dilindeki bir komut, bit (0 ya da 1) gruplarından oluşur. Örneğin, makina dilinin bir komutu iki değerin toplanması ya da bir değerin ana belleğin bir bölgesinde saklanması gibi basit işlemleri içerir. İnsanların makina dilinde program yazması hemen hemen olanaksızdır. Örneğin, bir makina dilinde iki sayının toplanması, 

01000110011101000111101010000010010101101000010

biçiminde ifade edilebilir. 

Assembly dili : 
Bir assembly dili, makina dilindeki komutları İngilizce benzeri bir dille ifade eder. Genelde assembly dilindeki her komut makina dilindeki bir komuta denk düşer. Assembly dilindeki bir program assembler diye bilinen bir yazılım tarafından makina diline çevrilir. Assembly dilinde program yazmak da makina dilinde olduğu gibi zor ve zaman alıcıdır. Assembly dilinde iki sayının toplanması, 
LOAD A 
ADD B 
STORE C 
biçiminde ifade edilir. 
Yüksek Seviyeli Programlama Dilleri ( YSPD ) :
Makina dilinde çok sayıda komutla yapılabilecek bir iş, yüksek seviyeli programlama dilinin bir komutu ile yapılabilir. Bu yüksek seviyeli diller, İngilizce ya da Türkçe gibi doğal bir dil değil, kendi yapısı ve dilbilgisi kuralları olan, insanlar için anlaşılması kolay olan dillerdir. Bu derste öğreneceğimiz C, bir yüksek seviyeli programlama dilidir. 
Yüksek seviyeli programlama dilinde yazılan bir program, derleyici (compiler) dediğimiz yazılımlar tarafından, makina dilindeki denk bir programa dönüştürülür. Bilgisayar tarafından çalıştırılacak olan program, makina dilindeki programdır. Her programlama dili için ayrı bir derleyici vardır. C'de yazacağınız programlar C derleyicisi ile makina diline çevirilecek ve bu makina dilindeki program çalıştırılacaktır.
C gibi diğer bazı yüksek seviyeli programlama dilleri arasında Pascal, Fortran, Basic, Java, C++, Cobol, Lisp ve Prolog sayılabilir. Bu dillerin birkaçında, iki sayının toplanması şöyle ifade edilir: 
C:=A+B;    (Pascal) 
C=A+B;     (C ve Java) 
C=A+B      (Fortran) 
Bazen yüksek seviyeli programlama dilinde yazılmış bir program, makina diline çevrilmek yerine başka bir ara dile çevrilebilir. Bu ara dildeki komutlar, hiçbir makinaya bağımlı değildir. Bu ara dildeki  programlar, o dilin yorumlayıcısı (interpreter) olarak bilinen yazılımlar tarafından çalıştırılır. Bunun amacı, ara dildeki programların değişik bilgisayarlarda hiçbir değişikliğe uğramadan kullanılabilmesidir.  Örneğin Java derleyicisi Java programlarını böyle ara bir dile çevirir ve bu dildeki programlar bir Java yorumlayıcısı tarafından çalıştırılır.

1.4. Yazılım Geliştirme 

Bir program, bir problemi çözmek için yazılan komutlar kümesidir. Bu komutlar, İngilizce ya da Türkçe gibi dillerde değil, bilgisayar sisteminin anlayacağı bir dildedir. Bu derste, biz, komutlarımızı C dilini kullanarak yazacağız. 

Bir program yazmadan önce, ilk yapacağımız iş, o problemi nasıl çözeceğimize karar vermek ve çözümün adımlarını belirlemek olmalıdır. Bu işte bize yardımcı olabilecek çeşitli problem çözme teknikleri vardır. Bu tekniklerden yararlandığımızda, yarattığımız çözümü bir programa dönüştürmek kolay olacaktır. En temel problem çözme tekniği, yukarıdan-aşağı tasarım yöntemidir. Bu yöntemde ilk verilen problem, küçük alt problemlere bölünür. Bu alt problemler, gerekirse, daha küçük (basit) alt problemlere bölünürler.  En sonunda elde edilen alt problemler, ayrı ayrı çözülürler ve bu çözümler ana problemin çözümünü elde etmek için birleştirilirler. Bu yöntem, algoritma yazımından söz ederken örneklerle açıklanacaktır. 

Bir problemi çözmek için yazacağımız programı oluştururken, genelde,  aşağıdaki yazılım geliştirme aşamalarından geçmek zorundayız: 

1.4.1. Problemin Anlaşılması ve Çözümlenmesi :
İlk yapacağımız iş, problemin tam olarak ne olduğunu anlamaktır. Bu nedenle, problemin çözümünden neler beklediğimizi ve yaratacağımız çözümün girdi ve çıktılarının neler olacağını kesin olarak belirlemeliyiz. 
1.4.2. Tasarım :
Tasarım aşaması programı oluşturmadaki en önemli adımlardan biridir ve çok kolay değildir. Tasarım için ne kadar çok vakit harcarsak, programı yazma ve çalıştırma aşamalarında o kadar az sorun yaşarız ve programı o kadar çabuk çalıştırırız.  Bu aşamada, problemi çözmek için kullanılacak çözüm adımlarını iyice düşünmemiz ve bu çözüm adımlarını gösteren bir liste yapmamız gerekir. Bir problemin çözüm adımlarını gösteren bu listeye algoritma denir. Böyle bir liste tasarlamak için geliştirilmiş pek çok yöntem vardır. Bunlardan biri de yukarıdan-aşağı tasarım tekniğidir. Bu teknikle önce problemin ana adımları çıkarılır; daha sonra, her adım için, gerekiyorsa, daha detaylı biz çözüm tasarlanır. Böylece verilen büyük problem daha küçük ve çözümü daha kolay küçük problemlere bölünmüş olur. Bu çözümlerin ardarda sıralanmasıyla problem için bir algoritma geliştirmiş oluruz. 

Oluşturulan algoritma pseudocode denilen, Türkçe ve İngilizce gibi doğal ama sınırlı  yapısı olan bir dilde yazılabilir. Bir programlama diline çevirmeden önce, bu algoritmanın doğru bir çözüm olduğu kanısında olmalıyız. Bu aşamayı atlayarak doğrudan programlamaya geçmek, büyük programlar yazarken işimizi çok zorlaştıracaktır. 

1.4.3.  Kodlama : 
Bu aşamada, kağıt üzerinde geliştirdiğimiz algoritmayı bir programlama diline çeviririz ve programı bilgisayara gireriz. Biz C dilini bu aşamada kullanacağız. Bu yüzden, C programlama dilinin yapısını bilmemiz gerekecektir. Algoritmamızın her adımı, ona karşılık gelen C program parçasına çevrilecektir. Oluşturulan program büyük ihtimalle ilk denemede çalışmayacak, çeşitli hatalar verecektir. Kodlama aşamasında bu hataları bulmak ve düzeltmek gerekir.
1.4.4. Sınama ve Kanıtlama (Testing and Verifying) : 
Geliştirdiğimiz programın doğruluğunu sınayarak istediğimiz gibi çalışıp çalışmadığını görmek zorundayız. Bu amaçla, program üzerinde çeşitli testler yaparak, programın o testlere nasıl karşılık verdiğine bakarız. Bunu sağlamak için program değişik girdilerle çalıştırılır ve ürettiği sonuçlara bakılır. Sonuçlar beklendiği gibiyse, programın doğru çalıştığı kanıtlanmış olur; değilse doğru çalışmayan parçaları bularak düzeltmemiz gerekir. Bu bazen tasarımda düzeltmeler yapmayı bile gerektirebilir.

1.5. Basit bir problem 

Basit bir problemle program tasarlama işlemini anlatmaya çalışalım. Bir grup öğrenciye anket yapacağımızı ve onlara ülkenin kuzeyinden mi, güneyinden mi, doğusundan mı yoksa batısından mı geldiklerini soracağımızı varsayalım. Anketin sonuçlarına göre her yönden gelen öğrencilerin sayılarını ayrı ayrı bulalım. 

Problemin Anlaşılması ve Çözümlenmesi:

Kuzey, güney, doğu, batı olmak üzere dört yön var. Her yön için ayrı sayaç tutarsak, her öğrencinin cevabına göre doğru sayacın değerini bir arttırırız. Öğrenciler bitince bu dört sayacın değerini bastırırız.
Girdiler: öğrencilerin cevapları
Çıktılar: 4 tane sayılan değer
Tasarım:
Bu problemi yukarıdan-aşağı tasarım yöntemini kullanarak çözeceğiz. Çözüm adımlarını bir algoritma gibi göstereceğiz. İlk önce problemimizi aşağıdaki üç ana adıma ayıralım. 

1. Anket için hazırlık yap.
2. Anketi başlat: Öğrencileri sıraya diz ve nereden geldiklerini tek tek sor.
3. Sonuçları bastır.

Bu üç adımı biraz daha ayrıntılı vermemiz gerekir.  Bunu da aşağıdaki şekilde yapabiliriz.

1. Anket için hazırlık yap.

1.1. Bir kağıda dört kutu çiz ve bunları K, G, D, ve B olarak adlandır.
1.2. Her kutunun içine ilk değer olarak sıfır yaz.
2. Anketi başlat.
2.1. Öğrencilere sıraya girmelerini söyle. 
2.2. Sırada öğrenci olduğu sürece aşağıdaki işlemleri yap.
2.2.1. Sıradaki öğrenciye nereden geldiğini sor.
2.2.2. Doğru kutudaki değere bir ekle.
3. Her kutunun içindeki değeri bastır.

Bu örnekte görüldüğü gibi problemin çözümü için bazı adımların birkaç kez yinelenmesi gerekebilir. (2.2.1. ve 2.2.2. adımları sırada öğrenci olduğu sürece tekrar tekrar yapılmalıdır. 3. adıma ancak sırada başka öğrenci kalmamışsa geçilebilir. Bunun ve diğer işlemlerin C'da nasıl yapılacağını ilerideki derslerimizde göreceğiz)
Kodlama ve Sınama ve kanıtlama:
Bu son iki aşamayı C'yi öğrendikten sonra siz yapabilirsiniz.


      Açıkladığımız yazılım geliştirme aşamalarının ilk iki adımı birkaç örnekle daha incelemek isterseniz örnekler'i tıklayınız. 

1.6. C Programlarının Hazırlanması

Algoritmayı tasarladıktan sonra onu bir programlama dili kullanarak bir program haline getirmek (kodlamak) gerekir. Biz bu amaçla C öğreneceğiz. C programı yazabilmek için önce onun 'gramer'ini öğrenmek gerekir. Bir programlama dilinin gramerine sözdizim (syntax) denir. Bunu ileriki derslerimizde detaylı olarak göreceğiz. Şimdi burada  bir C programını yazarken ve çalıştırırken  neler yapmamız gerektiğini  özetleyeceğiz.

Herhangi bir  C programını hazırlamak ve çalıştırmak için aşağıdaki aşamalardan geçmemiz gerekecektir: 

  • Kurgulama (Editing) 
  • Derleme (Compiling) 
  • Çalıştırma (Executing) 
Bu aşamaları bir işletim sistemi ortamında (DOS ya da UNIX gibi) ya da kullandığımız dilin sağladığı tümleşik geliştirme ortamında (integrated development environment-IDE) yapabiliriz. Biz bu derste Borland Turbo C++ tümleşik geliştirme ortamını kullanacağız. Bu ortamı sitemizden burayı tıklayarak download edebilirsiniz. Bilgisayarınızda başka C derleyicisi olsa bile dersimizi takip ederken bu derleme ortamını kullanmanızı tavsiye ediyoruz. Çünkü ders notlarındaki programlar yalnızca bu ortamda test edilmiştir. Farklı ortamlarda çalışmayabilirler.

Şimdi bu program hazırlama aşamalarını kısaca açıklayalım.

1.6.1. Kurgulama: 

Yazacağımız C programını bir editör yardımı ile bir kütüğün içine koymalıyız. Kullanacağımız editör vi, emacs, MS editör ya da notepad  gibi bir kütüğü ASCII text olarak yaratabilecek olan bir editör olabilir (MS-Word, WordPerfect gibi yazılımlar kullanılmamalıdır). Ya da editörü ile beraber gelen bir paket derleyici ortamında yaratılabilir. Borland Turbo C++ ortamındaki editör yardımıyla yaratılan kütüğün adı .cpp eki ile biter (bu isimlendirme sisteme bağlıdır; bazı sistemler .c eki koyabilir). Bu ek o kütüğün bir C programı sakladığını gösterir. Örneğin, Test1.cpp ve Test2.cpp birer C programı saklayan kütüklerin adları olabilir. 

1.6.2. Derleme:

Bir editör yardımı ile bir C programını saklayan Test1.cpp kütüğünü yaratmış olduğumuzu varsayalım. İkinci adım, bu kütüğü C derleyicisiyle derlemektir. Bir başka deyişle, yüksek seviyeli dille yazılan programımızı, makina diline çevirmemiz gerekmektedir. Eğer yazdığımız programda hiçbir yazım hatası yoksa, C derleyicisi makina dilinde bir program üretecektir. Bu programı saklayan kütüğün adı Test1.obj olabilir (bu isimlendirme de sisteme bağlı). Bu kütüğün içindekileri ekranda göremez, bastıramaz ve bir editörde değiştiremezsiniz. Çünkü bu kütüğün formatı farklıdır. Eğer programımızda yazım ya da gramer hataları varsa, Test1.obj kütüğü üretilmeyecek ve  C derleyicisi programımızdaki hataları, hata mesajları ile bize bildirecektir. Bu durumda programımızdaki hataları bulup hataya neden olan yerleri yine editör yardımıyla düzeltmeliyiz. Düzeltmeleri yaptıktan sonra, programımızı yeniden derlemeliyiz. Bu işe programımızdaki bütün yazım hataları temizlenene kadar devam etmeliyiz. Hatasız programlar için yaratılan Test1.obj kütüğü yazdığımız C programının makina dili türünden gösterimidir. Bu dilin komutları makinaya bağlıdır ve yalnızca çalıştığınızın aynısı olan ortamlarda ve makinalarda çalıştırılabilir.

C ve benzeri yüksek seviyeli programlama dilleri programcıların işine yarayacak birçok hazır program parçacıkları sunarlar. Bunlar program yazarken bazı işlemleri yapmada büyük kolaylık sağlarlar. Bağlayıcı (linker) dediğimiz bir program derleyicinin yarattığı makina dilindeki programı  bu hazır program parçacıklarından gerekli olanları ile birleştirir ve çalıştırılmaya hazır bir bütün program oluşturur. 

1.6.3. Çalıştırma:

Çalıştıracağımız program, yaratılan Test1.obj kütüğündeki program olacaktır. Bunu çalıştımak için  yükleyici (loader) dediğimiz yazılım programı belleğe yükler ve MİB'den programı başlatmasını ister.  Bazı sistemler bu işlemin işletim sistemi ortamında bir komutla yapılmasına izin verirler. Tümleşik geliştirme ortamında ise editör, derleyici, bağlayıcı ve yükleyici hep birlikte bir paket olarak sunulur. Bu tip ortamlarda programcı programını editörde yazdıktan sonra menüler yardımı ile derleyip çalıştırabilir.

Biz bu derste kullanacağımız Borland Turbo C++ tümleşik geliştirme ortamınında da kurgulama, derleme ve çalıştırma aşamalarını menüler yardımıyla yapacağız. Gelecek haftadan itibaren  C programlarının yapısını incelemeye ve basit programlar yazmaya başlayacağız. Ders notlarını anlamanız için bu hafta bu yazılımı  mutlaka bilgisayarınıza yüklemiş  ve sitede verilen örnek programları çalıştırmış olmanız gerekiyor. Borland Turbo C++'yi yüklemek ve kullanmak için yapmanız gerekenleri burayı tıklayarak öğrenebilirsiniz.


2. C Programlama Diline Giriş
2.1. C Programlarının Yapısı
2.1.1. Önişlemci bildirimleri
2.1.2. main işlevi
2.1.3. Özel sözcükler
2.1.4. Tanımlayıcılar
 2.2. Veri Türleri 
2.2.1. İkilik Düzendeki (Binary) Sayılar
2.2.2. Standart Veri Türleri 
2.2.3. Değişkenlerin Tanımlanması 
 2.3. Atama ifadesi 
2.3.1. İşleçlerin Öncelikleri (Operator Precedence)
2.3.2. Atama İfadesinde Türlerin Uyuşması
 2.4.  Basit Girdi/Çıktı 
2.4.1. Basit Çıktı
2.4.2. Basit Girdi
2.4.3. Çıktıların Biçimlendirilmesi
2.4.4. Örnek program
2.5. Hata Mesajları
2.5.1. Derleme hataları
2.5.2. Çalıştırma hataları
2.5.3. Mantık hataları

2. C Programlama Diline Giriş

Amaç :

     
  • Basit C program örnekleri ile C programlarının yapısını  tanıtmak.
  • Veri türlerini tanıtmak ve değişkenlerin bellekte nasıl gösterildiği anlatmak. 
  • Atama ifadesinin kullanımını göstermek.
  • C programlarında nasıl basit girdi/çıktı yapılacağını öğretmek.   
  • Derleme hataları, çalışma hataları ve mantık hatalarının nedenlerini anlatmak.
Bu haftaki dersimize başlamadan önce C derleyicisini kendi bilgisayarınıza yüklemiş, ve sitede verdiğimiz örnek programları çalıştırmış olmanız gerekiyor. Hatırlayacağınız gibi, bir C programını çalıştırmak için onu önce derlemek gerekiyor. C programlarının hazırlanması ile ilgili notları tekrar gözden geçirmek isterseniz burayı tıklayınız.

Bu derste C programlarının genel yapısını, temel yapı taşlarını ve bazı çalıştırılabilir ifadelerini örneklerle inceleyeceğiz.

2.1. C Programlarının Yapısı

Bu bölümde bir C programının yapısını inceleyeceğiz. Şekil 2.1'de verilen  C programı derleyicinin editöründe yazılıp, ornek.cpp   kütüğünün içinde saklandıktan sonra, menüden Compile seçilerek derlenir ve bu derleme sonucunda ornek.obj kütüğü yaratılır. Bu kütükte saklanan makina dilindeki program, menüden Run seçilerek  çalıştırılır. 


 
 
Satır 1-7, 17,21.Açıklama satırları /* ile */ arasında kalan satirlardir.Sadece kodun daha anlaşılabilir olması için bize bir sey ifade ederler.Bilgisayar bunları göz önüne almaz.   1 /* Yazar: Nihan Kesim Cicekli
    2 * Tarih: Temmuz 2000
    3 *
    4 * Basit bir C programi
    5 *
    6 * Bu program adinizi okur ve adinizi Merhaba kelimesi ile birlikte basar.
    7 */
    8
Satır 9-10. Önişlemci bildirimleri  9 #include
   10 #define UZUNLUK 10
   11
Satır 12-25.main fonsiyonunun tanımı 12 int
   13 main(void)
   14 {
Satır 15.Değişken tanımlanması 15  char yourName[UZUNLUK];
   16
   17  /* Adi oku */
   18  printf("Adinizi girin ve enter tusuna basin> ");
   19  scanf("%s", yourName);
   20  /* Mesaji yaz */
   21  printf("Merhaba %s! n", yourName);
   22
   23  return(0);
   24 }
Şekil 2.1: Basit Bir C Programı

Satır numaraları açıklama yapmak için kullanılmıştır.
Bu programı kendi bilgisyarınıza yüklemek için buraya tıklayınız.

Şekil 2.1'deki programda ' /* '  ile başlayıp  ' */ ' biten kısımlardaki herşey açıklamalardır. Programlama açısından hiçbir önemi olmayan bu satırlar yalnızca programı açıklamak için kullandığımız bilgileri kapsar. C derleyicisi bu bölümleri açıklama olarak görür ve dikkate almaz.

Programımızın içinde, kodun okunmasını kolaylaştırmak için, istediğimiz kadar boş satır kullanabiliriz. C derleyicisi bu boş satırları gözönüne almaz. 

Şimdi bu örnek programı kullanarak C programlarının genel yapısını inceleyelim. Bu C programı iki kısımdan oluşur: Önişlemci bildirimleri ve main işlevi.

2.1.1. Önişlemci bildirimleri

Önişlemci bildirimleri # ile başlayan komutlardır. Bunlar C'nin önişlemcisi tarafından kullanılır. C'nin önişlemcisi program derlenmeden önce programın metininde  bu komutları kullanarak  bazı değişiklikler yapar ve program ondan sonra derlenir. #include ve #define C'de en çok kullanılan önşlemci bildirimleridir. 

C dili program yazmada yararlı olabilecek birçok hazır işlevi programcının kullanımına sunar. Bu hazır işlevler C'nin değişik kütüphanelerinde saklanır. Her kütüphanede adı .h uzantısıyla biten bir üstbilgi kütüğü vardır.  #include bildirimi programın C'nin kütüphanelerinden birine erişimini sağlar. Bu bildirim ile C önişlemcisi bir kütüphanenin üstbilgi kütüğündeki bazı tanımları programa aktarır ve program bu değişikliklerden sonra derlenir. Örneğin şekildeki programda kullanılan 

#include
önişlemciye bu programda kullanılan bazı işlev isimlerinin ( printf ve scanf gibi) stdio.h adlı üstbilgi kütüğünde olduğunu bildirir. 

Diğer önişlemci bildirimi 

#define UZUNLUK 10
C önişlemcisinin, program içinde UZUNLUK sözcüğünün geçtiği her yerde bu sözcüğü 10 rakamı ile değiştirmesini sağlar. Örnek programımızda UZUNLUK yalnızca 
char yourName[UZUNLUK];
satırında kullanılmış. Bu durumda C önişlemcisi bu satırı 
char yourName[10]
olarak değiştirecektir. #define bildiriminde programımızda kullanacağımız, değeri program çalıştığı sürece değişmeyecek olan sabit değerleri tanımlayabiliriz. Bu programda UZUNLUK 10 olarak belirtildiği için programımız sadece 10 harfe kadar olan isimleri okuyabilir. 
 

2.1.2. main işlevi

Her C programının bir main işlevi içermesi gerekir. Bu işlevin başlangıcı

int main(void)
ya da
int main()
sözcükleriyle belirtilir ve { ile } arasında kalan kısım işlevin gövdesidir. Bu programı çalıştırdığımızda ilk olarak bu main işlevine girilecek ve programın komutları o noktadan itibaren sırayla çalışmaya başlayacaktır.

C'de her işlevin gövdesi iki kısımdan oluşur: tanımlamalar kısmı ve çalıştırılabilir ifadeler. Tanımlamalar kısmında  işlevin  bellekte kullanacağı alanların isimleri tanımlanır ( yourName gibi) ve bu bilgiler derleyici tarafından kullanılır. Çalıştırılabilir ifadeler algoritma basamaklarının C'deki yazılımlarıdır ve  makina koduna bunlar çevirilip çalıştırılırlar.

main işlevi noktalama işaretleri ve bazı özel semboller ( *,= gibi) içerir. Örneğin noktalı virgül ( ; ) işareti her çalıştırılabilir ifadenin sonunu gösterir.  { ve } işaretleri işlevin başlangıç ve bitiş yerlerini belirtir. Genelde her işlevde bir return ifadesi olmak zorundadır. 


 

2.1.3. Özel sözcükler

Programımızda açıklamaların dışındaki satırlarda görülen bütün sözcükler ya özel sözcüklerdir ya da tanımlayıcılardır. Özel sözcüklerin hepsi küçük harflerle yazılırlar ve C'de hepsinin bir anlamı vardır. Bu sözcükler bilinen anlamlarından farklı bir amaçla kullanılamazlar. Programda geçen özel sözcükler ve anlamları aşağıdaki tabloda özetlenmiştir. C'deki özel sözcüklerin tamamını kitabımızın Appendix E kısmında ya da burada bulabilirsiniz.


 
 
Özel Sözcük  Programdaki Anlamı
int integer(tam sayı)
void main işlevi işletim sisteminden hiç veri almıyor
char karakter veri türü
return kontrol işlevden işletim sistemine geçiyor

2.1.4. Tanımlayıcılar

İşlev isimleri, bellek bölgelerinin isimleri (değişken ya da sabit isimleri) tanımlayıcılar olarak adlandırılır. İki türlü tanımlayıcı vardır: standart tanımlayıcılar ve kullanıcının tanımladığı tanımlayıcılar. Standart tanımlayıcıların da özel sözcükler gibi özel anlamları vardır. Örneğin programda printf ve scanf C'nin stdio (standard input/output) kütüphanesinde tanımlanmış iki işlevin  ismileridir. Bunların özel sözcüklerden farkı anlamlarının  programcı tarafından değiştirilebilir olmasıdır. 

Programlarımızda kullandığımız ya da hesapladığımız verileri tutan bellek bölgelerine kendimiz isimler veririz. Bunlara kullanıcının tanımladığı tanımlayıcılar denir. Örnek programda yourName ve UZUNLUK bu tip tanımlayıcılardır. Tanımlayıcılara istediğimiz isimleri verebiliriz. Yalnız şu kurallara dikkat etmemiz gerekir: 

  • Tanımlayıcı isimleri sadece harfler, rakamlar ve _ işaretini içerebilir.
  • Tanımlayıcı ismi rakamla başlayamaz.
  • Özel sözcükler tanımlayıcı ismi olarak kullanılamaz.
Örnek bazı tanımlayıcılar:   x,  y,  number1,  number2,  p5, newValue,   birKelime 

Bazı geçersiz tanımlayıcılar:   1a  (rakamla başlıyor),  b+1   ('+' karakteri tanımlayıcıda kullanılamaz)

C büyük harf küçük harf ayrımına duyarlı olduğundan, aynı harfin büyük harfi küçük harfinden farklıdır. Bu nedenle örneğin test1 , Test1 ve TEST1 üç farklı tanımlayıcı olarak algılanır.

2.2. Veri Türleri 

Tanımlayacağımız her değişken bellekte bir bölgeye denk gelecektir. Bir değişkenin türü o değişkene denk düşen bellek bölgesinin büyüklüğünü ve o bölgenin içindeki bilginin nasıl yorumlanacağını gösterir. Bir değişkene yeni bir değer verdiğimizde, verdiğimiz bu değer o değişkene denk düşen bellek bölgesine eski değeri yok ederek saklanır. 

Örneğin, 

int x;
tanımlaması, x değişkeni için 32 bitlik bir bellek bölgesinin kullanılacağını ve bu bölgenin içindeki bitlerin bir tamsayı (integer) olarak yorumlanacağını gösterir. 

Aşağıdaki atama ifadesi ile x değişkenine 10 değerini verebiliriz: 

x = 10;
Bu atama ifadesinden sonra, x değişkenine denk gelen bellek bölgesi 10 sayısını 32 bit’lik bölgeyi kullanarak bir tamsayı olarak tutacaktır. Bu bellek bölgesi sonradan yeni bir atama ifadesi ile değiştirilebilir. Örneğin, 

   x = 20;

atama ifadesi x değişkenin içine 20 sayısını koyacaktır ve eski değer olan 10 buradan silinecektir. 

2.2.1 . İkilik Düzendeki (Binary) Sayılar:

Bilgisayardaki her değer, ikilik düzendeki sayılar ile gösterilir. İkilik düzendeki tek bir rakam (0 ya da 1) bir bit olarak adlandırılır. Her bir bit iki değişik durumu gösterir. Bit dizgileri daha büyük sayıları göstermekte kullanılır. Her bit dizgisinin  kaç değişik değeri gösterebileceği o dizgideki bit sayısına bağlıdır. Eğer bir bit dizgisinde N bit varsa, o dizgi 2N değişik değeri gösterebilir. Örneğin bit sayısına göre kaç değişik değer gösterilebileceği aşağıdaki tabloda verilmiştir: 

1 bit 21=2 değişik değer : 0 1 
2 bit 22=4 değişik değer : 00 01 10 11 
3 bit 23=8 değişik değer : 000 001 010 011 100 101 110 111 
:
32 bit 232=4,294,967,296 değişik değer 
64 bit 264=18,446,744,073,709,551,616 değişik değer

Gördüğünüz gibi dizgiye her bit eklediğimizde, o dizginin gösterebileceği değişik değerin sayısı iki katına çıkar. Tanımlayacağımız her değişken bellekte bir bit dizgisi olarak tutulacaktır ve bu bit dizgisinin nasıl yorumlanacağı ise o değişkenin türüne bağlı olacaktır. Örneğin veri türü int olan bir değişken 32 bitlik bir bit dizgisi olarak tutulacaktır ve bu bit dizgisi artı ya da eksi bir tamsayı olarak yorumlanacaktır. 

C'deki her veri türü bir değerler kümesinden ve onların üzerinde yapılabilecek işlemlerden oluşur. Her veri türünün int , double , char   gibi bir adı olacaktır. Bellekte tutulan her değer belirli bir veri türü kullanılarak yorumlanacaktır. C’deki her değişkenin bir türü olacaktır ve bir değişkenin türünün ne olacağını tanımlama (declaration) ifadesi ile belirtiriz. Örneğin, 

int x, y;
int z;
double d;
tanımlama ifadeleri x, y, z değişkenlerinin türlerinin tamsayıların gösteriminde kullanılan bir veri türü olan int olacağını ve d değişkeninin türünün ise reel sayıların gösteriminde kullanılan bir veri türü olan double olacağını belirtir. C'de kullanılan her literalin (sabit sayı) de bir veri türü vardır. Örneğin, 5 bir tamsayıyı (yani int ) ve 5.0 bir reel sayıyı (yani double ) gösteren birer literaldir. Bellekte 5 ve 5.0 gösteren bit dizgileri tamamen farklı iki dizgi olacaklardır. 

C'de standart  veri türleri char,double,int gibi önceden tanımlanmış veri türleridir.  double ve int   reel ve tamsayıları programlarımızda göstermek için kullanılır. char ise her türlü karakter bilgisini saklamak için kullanılan bir veri türüdür.  Standart veri türleri ile tanımlanan değişkenler için gerekli bellek, tanımlama (declaration) sırasında otomatik olarak ayrılır. C 'de standart veri türleri dışında programcı kendisi değişik veri türleri de tanımlayabilir (enumerated types). Ayrıca dinamik veri türleri de vardır (pointers). Dinamik veri türü olarak tanımlanan bir değişken için gerekli bellek bölgesi tanımlama anında değil de programın çalışma zamanında ayırılır. 

Biz bu derste sadece standart veri türlerini anlatacağız. Önce sayısal veri türlerini, daha sonra da karakter veri türünü tanıtacağız.

2.2.2. Standart Veri Türleri:

C programlama dilinde aşağıdaki anahtar sözcüklerle ifade edilen 10 standart veri türü vardır: 

 short, unsigned short, int, unsigned, long, unsigned long, float, double, long double, char 

Tamsayılar için standart veri türleri:

Tamsayıların gösteriminde altı değişik veri türü kullanabiliriz. Bu veri türleri şunlardır: 

  • short 
  • unsigned short 
  • int 
  • unsigned 
  • long
  • unsigned long
Bu altı veri türünden üçü(unsigned long, unsigned, unsigned short) sadece pozitif sayıların gösteriminde, diğer üçü (short, int, long) ise hem pozitif hem de negatif sayıların gösteriminde kullanılabilir.Bu veri türlerinde farklı olan diğer bir nokta da değişik miktarda bellek kullanmalarıdır. Bu durumda gösterebilecekleri tamsayıların büyüklükleri de farklı olacaktır. Bu veri türlerinden biri ile tanımlanan değişkene denk düşen bellekteki bit dizgisi bir tamsayı (artı ya da eksi) olarak yorumlanacaktır. Her bir veri türü, yalnızca  biri eksi (en küçük değer) diğeri artı (en büyük değer) olan belirli iki tam sayı arasındaki değerleri gösterebilir. Aşağıdaki tablo her veri türünün kaç bitlik bellek bölgesi kullandığını ve bu veri türü ile gösterilebilen en küçük ve en büyük tamsayıları gösterir. 
 
Veri Türü  Bellek Kapasitesi En Küçük Değer  En Büyük Değer
short 16 bit -215 = -32,768 215-1 = 32,767
unsigned short 16 bit 0 216 - 1 = 65,535
int 16 bit -215 = -32,768 215-1 = 32,767
long 32 bit -231 = -2,147,483,648  231-1 = 2,147,483,647 
unsigned long 32 bit 0 232 - 1 = 4,294,967,295
 
C programlama dilinde tamsayıları aşağıdakiler gibi yazabiliriz: 
5, 3344, -89
C'de  int veri türü değerleri aynı zamanda  mantıksal değerler olan doğru ve yanlışı ifade etmek için de kullanılır. Bir int   değer pozitif ise doğru; sıfır  ya da negatif ise yanlış olan bir durumu gösterebilir. Örneğin, int bir değer bir lambanın açık ya da kapalı olması gibi iki değişik değeri olan durumları göstermekte kullanılabilir. Pozıtif ise lamba açık; değilse kapalı olarak kabul edilebilir. int değerlerinin bu tip kullanımını daha sonraki derslerimizde detaylı olarak inceleyeceğiz.

Reel sayılar için standart veri türleri:

Reel sayılar için kullanılan üç standart veri türü vardır: 

  • float 
  • double
  • long double 
Bu üç veri türü de reel sayıların gösteriminde kullanılır. Bir reel sayı, bilimsel notasyonda mantissa * 2power formülüyle gösterilebilir; böylece bir reel sayıyı bilgisayarda göstermek için kullanılan bit dizgisinin bir bölümü sayının rakamlarını gösteren mantissa için ayrılmış ve diğer bir bölümü de üs ( power ) göstermek için ayrılmıştır. float, double ve long double veri türlerinin kullandıkları bellek büyüklüğü ve mantissa ve power için ayırdıkları bit miktarı farklıdır. Aşağıdaki tablo bu veri türlerinin kaç bitlik bir alan kullandıklarını ve yaklaşık olarak gösterebilecekleri en küçük ve en büyük sayıları gösterir. 
 
 
  Veri Türü  Bellek Kapasitesi   En Küçük Değer    En Büyük Değer 
float 32 bit -3.4x10-37 3.4x1038
double  64 bit -1.7x10308 1.7x10308
long double 80 bit -3.4x104932 1.1x104932
 
float veri türü sayının 6 rakamını, double veri türü 15 rakamını, long double veri türü ise 19 rakamını saklayabilir. 

Reel sayıları yazmak için noktalı notasyonu ya da bilimsel notasyon olarak bilinen e-notasyonunu kullanabiliriz. Bazı reel sayıları aşağıdaki gibi yazabiliriz: 

5.0 7.34 0.5e+12 -15.35e-15
e-notasyonunda yazılan 0.5e+12 sayısı 0.5x1012 sayısına, -15.35e-15 sayısı -15.35x10 -15 sayısına eşittir.

char standart veri türü:

char veri türü, harf, rakam ya da noktalama işareti gibi herhangi bir karakter değeri temsil eder.  Her karakter sabiti iki tırnak işareti ( '' )   arasına yazılır. Örneğin, bazı karakter sabitleri aşağıdaki gibi yazılabilir: 

'A'   'B'   'a'   'b'   '0'   '1'   '*'    ':'   '"'    ' '
Sondan ikinci karakter çift tırnak işaretini.("), sonuncu ise boşluk karakterini göstermek için kullanılır (iki tırnak içine bir boşluk yazılır). Karakter değerleri char  veri türü ile tanımlanmış bir değişkenin içinde saklanır. C değişik karakter değerlerinin karşılaştırılması ya da üzerlerinde aritmetik işlem yapılması gibi işlemler yapmaya izin verir.

2.2.3. Değişkenlerin Tanımlanması 

Bir değişken belirli bir veri türünü tutan bir bellek bölgesini gösteren bir tanımlayıcıdır. Bütün değişkenler kullanılmadan önce tanımlanmalıdır. Bir tanımlama ifadesi aynı veri türüne sahip olacak bir ya da daha fazla değişkenin tanımlanmasında kullanılır. Bir tanımlama ifadesinin yapısı aşağıdakiler gibi olmalıdır: 

veri-türü değişken-adı;
veri-türü değişken-adı1,değişken-adı2, ... ,değişken-adın ;
Örneğin, 
int sum;
int x,y;
double z;
Birinci tanımlama ifadesi sum değişkeninin türünün int olacağını, ikinci tanımlama ifadesi x ve y değişkenlerinin türünün int olacağını ve üçüncü ifade de z değişkeninin türünün double olacağını gösterir. Bir tanımlama ifadesinde birden fazla değişken tanımlanacaksa, bu değişkenler virgüllerle ayrılır. 

Değişkenlere ilk değerleri istenirse tanımlanma anında verilebilir. Örneğin, 

int sum = 0;
int x=0, y=10;
tanımlama ifadeleri aynı zamanda sum , x ve y değişkenlerine ilk değerlerini verirler. 

Sayfa Başına

2.3. Atama ifadesi 

Atama ifadesi, bir değişkene yeni bir değer vermek için kullanılır. Genelde aritmetik hesapların yapılmasında kullanılır. Bir atama ifadesinin yapısı aşağıdaki gibidir: 

değişken = deyim;
C'de = işareti atama işlecidir. Sağdaki deyimin (expression) değeri bulunur ve bulunan değer soldaki değişkenin içine konur. 

Deyim sadece bir değişken ya da sabit de olabilir. Örneğin, 

int x, y;
x = 5;
y = x;
x = 6;
komutları ilk önce x değişkenin içine 5 değerini koyar; daha sonra x değişkenin içindeki değeri y değişkenin içine kopyalar ve en son olarak da x değişkenin içine 6 değerini, içindeki eski değeri silerek koyar. 

Genel olarak bir deyim, işleçler (operators) ve işlenenlerden (operands) oluşan bir dizgidir. C'deki bazı aritmetik işleçler şunlardır: 

  • + toplama    
  • - çıkartma    
  • * çarpma    
  • / bölme    
  • % kalan (mod operator)   
İşlenen (operand) ise bir değişken, bir sabit ya da diğer tek bir değeri gösteren yapılar olabilir. Örneğin, 
x = y + 1;
y = x * z;
atama ifadelerinde, önce y+1 deyimini hesaplamak için y ’nin içindeki değer 1 ile toplanır ve sonuç x değişkeni içinde saklanır; sonra x*z deyimini hesaplamak için de x ’in içindeki değer z ’nin içindeki değer ile çarpılır ve sonuç y değişkeninin içinde saklanır. 

2.3.1 . İşleçlerin Öncelikleri (Operator Precedence)

Eğer bir deyimde birden fazla işleç varsa bu işleçleri hangi sırada yapacağımız işleçlerin önceliğine göre belirlenir. Örneğin, 

x = y + z * 5;
ifadesinde ilk önce çarpma işlemini mi, yoksa toplama işlemini mi yapacağız? 

Bu iki değişik sıra deyim sonucunun tümüyle iki farklı değerde olması demektir. C programlama dilinde çarpma işlecinin önceliği toplama işlecininkinden daha yüksek olduğu için  ilk önce çarpma işlemi yapılacaktır. Yani ilk önce z ve 5 çarpılacak ve elde edilen sonuç ile y toplanacaktır. 

Bazen bir deyimde ardarda gelen iki işlecin önceliği aynı olabilir. Bu durumda, işleçlerin hangi sırada yapılacağını gösteren birleşme (associativity) kuralına bakılarak işlem sırası belirlenir. Örneğin C'de  toplama ve çıkartma aynı önceliğe sahiptir. Aşağıdaki ifadede toplama işlemleri soldan sağa doğru yapılacaktır: 

x = y + z + 5;
Yani ilk önce x ve y toplanacak ve o toplamın sonucu 5 ile toplanacaktır. Bu örnekte toplamaların hangi sırada yapılacağı sonucu etkilemeyebilir; ama aşağıdaki örnekte etkileyecektir: 
x = y - z + 5;
Yukarıdaki örnekte - ve + işleçleri aynı önceliğe sahip olduklarından, bu işlemleri soldan sağa doğru yaparız (ilk önce işlemi, sonra + işlemi). 

İşleç öncelikleri parantezler kullanılarak değiştirilebilir. Örneğin, 

x = (y+z) * 5;
komutunda parantezleri kullanarak + işleci, * işlecinden daha önce yapılmaya zorlanmıştır. 

Ders kitabımızın 2.5. kısmında  C'deki  işleçlerin öncelik sırası anlatılmıştır. 

Örnekler:


 
Deyim                                              Deyimin Değeri 

2.3.2. Atama İfadesinde Türlerin Uyuşması

Normal olarak bir atama ifadesinin solundaki değişkenin türü ile sağındaki deyimin türü aynı olmak zorundadır. Eğer sol taraftaki değişken türü int ise, sağ taraftaki deyimin türü de int olmak zorundadır. Örneğin, 

int x;
double y;
x = y;
atama ifadesiyle  bir double değeri, bir int değişkeni içine saklanmak istendiğinden, C derleyicisi bu atama ifadesine hata mesajı verecektir. Bunun nedeni herhangi bir double değeri, bir bilgi kaybı olmadan bir int değeri olarak saklanamaz. 

Ancak bazı durumlarda C derleyicisi, değişkenin türü ile deyim türünün aynı olmasında ısrar etmez. Örneğin, 

int x;
double y;
y = x;
komutuna C derleyicisi hata vermez. x değişkenin içindeki int değeri otomatik olarak bir double değere çevrilir ve bu double değer, y değişkenin içinde saklanır. Bu, otomatik tür değiştirme (automatic type casting) olarak bilinir. Örneğin, bütün tamsayı veri türlerindeki değerler otomatik olarak double değerine dönüştürülebilir. Bir tamsayı veri türündeki değer, o veri türünden daha fazla bellek kullanan tamsayı veri türüne otomatik olarak dönüştürülebilir. Örneğin, bir short değeri otomatik olarak int ya da long değerine dönüştürülebilir. 

Deyimlerin hesaplanması anında da otomatik tür değiştirme meydana gelebilir. Örneğin, 

5 + 3.2
deyiminin değeri hesaplanırken, 5 ilk önce double bir değere dönüştürülür ve bu double değerle 3.2 double değeri toplanır. Diğer bir deyişle, bu deyimdeki toplama işlemi, double değerlerin toplama işlemidir. Bu deyimin sonucunun  türü de double olacaktır. 

Sayfa Başına

2.4. Basit Girdi/Çıktı 

Hemen hemen bütün programlar dışarıdan girdi aygıtları vasıtasıyla veri alırlar ve hesapladıkları verileri kullanıcıya ekran, yazıcı gibi çıktı aygıtları vasıtasıyla sunarlar. Programın dış dünyadan veri almasına girdi işlemi; hesapladığı sonuçları sunmasına da çıktı işlemi denir. 

C'de bütün girdi ve çıktı işlemleri girdi/çıktı işlevleri dediğimiz özel programlar tarafından yapılır.  En çok kullanılan girdi/çıktı işlevleri C'nin standart girdi/çıktı kütüphanesinin bir parçası olarak sunulmuştur. Bu programlara 

#include
önişlemci yönlendirmesiyle erişebiliriz. Bu derste en temel girdi ve çıktı işlevleri olan scanf ve printf 'in nasıl kullanıldıklarını göstereceğiz.

2.4.1. Basit Çıktı 

Bir programın sonuçlarını görebilmek için,  sonuçları tutan değişkenlerin değerlerini ya da mesajları bir çıktı aygıtında gösterebilmek gerekir. Bu amaçla printf işlevini kullanırız. Örneğin, 

printf( " bir dizgi.n " );
işlev çağırma komutu, bilgisayarın ekranına çift tırnak (") sembolleri arasında kalan kısmı  yazar ve imleç bir sonraki satıra geçer. Yani, ekranda, 
bir dizgi.
yazısını görürüz. Burada kullanılan n satır değiştirme damgasıdır (newline escape sequence). Bu karakter dizisi o andaki çıktı satırını sonlandırır ve imleci yeni satıra geçirir. Bir sonraki printf işlevini çağırma komutu verileri yeni satıra yazar. Eğer çıktımızı ekrana yazdırırken bir sonraki çıktı için alt satıra gitmek istemezsek, n  kullanmamalıyız. Örneğin, 
printf( " bir dizgi. " );
işlev çağırma komutu, ekrana bir dizgi yazdıktan sonra, imleç bir alt satıra gitmeyecek o yazıdan hemen sonraki noktada bulunacaktır. Örneğin, 
printf( " bir dizgi. " );
printf( " diger dizgi " );
işlev çağırma komutları ekrana 
bir dizgi.diger dizgi
yazısını yazacaktır. Ama, 
printf( " bir dizgi.n " );
printf( " diger dizgi " );
komutları ekrana 
bir dizgi.
diger dizgi
yazılarını yazacaktır. 

printf   işlevini çağırma ifadesinin  genel yapısı aşağıdaki gibidir:

printf( biçimleme dizgisi, çıktı_listesi)
Biçimleme dizgisi çift tırnak içinde yazılır, çıktı listesinde de değişkenler virgüllerle ayrılarak sıralanır. Örneğin
printf("Toplam uzunluk %f kilometredir. n",kms);
ifadesi çalıştığında, eğer kms değişkeninin değeri 10.0 ise, ekranda
Toplam uzunluk 10.0 kilometredir.
yazısı görülecektir. Burada %f damgası double veri türünde bir değişken değeri için yer tutma görevini yapar. printf biçimleme dizgisini ekrana yazarken %f yerine çıktı listesindeki double değişkenin değerini yazar.

printf işlevi değişkenlerin değerlerini yer tutucu damgalar vasıtasıyla yazar. Bütün yer tutucular % işareti ile başlar. Her veri türü için ayrı bir yer tutucu damga vardır. Aşağdaki tablo char , int ve double veri türleri için kullanılan yer tutucu damgaları göstermektedir. Diğer yer tutucu damgaları ve değiştirme damgalarını kitabımızın 598-599. sayfalarında bulabilirsiniz.


 
 
Yer tutucu Veri türü Kullanıldığı işlev
%c char printf/scanf
%d int printf/scanf
%f double printf
%lf double scanf

Biçimleme dizgisi birden fazla yer tutucu damga içerebilir. Eğer çıktı listesinde birden fazla değişken ya da sabit varsa biçimleme dizgisi aynı sayıda yer tutucu damga içermelidir. C bunlarla değişkenleri soldan sağa olmak üzere sırasıyla eşleştirir. Örneğin, i ve j'nin int veri türünde değişkenler olduklarını ve değerlerinin sırasıyla 5 ve 9 olduğunu varsayarsak,

printf("%d %c %d esittir %d", i, '+', j, i+j);
ifadesi,
5 + 9 eşittir 14
yazacaktır.Bu ifadedeki biçimleme dizgisi ekrana yazılırken ilk %d i 'nin değeri ile, %c '+' ile, ikinci %d j'nin değeri ve üçüncü %d i+j değeri ile yer değiştirmiştir.

2.4.2. Basit Girdi 

Örnek programımızda gördüğünüz 

scanf("%s", yourName);
ifadesi scanf işlevini standart girdi aygıtından yourName değişkenine veri kopyalamak için çağırır. Standart girdi aygıtı çoğu kez klavyedir. Dolayısıyla bilgisayar kullanıcı klavyeden ne veri girerse onu yourName değişkeninin içinde saklamaya çalışacaktır.

scanf işlevini çağırma ifadesinin genel yapısı  printf   işlevini çağırma ifadesininkine benzer:

scanf( biçimleme dizgisi, girdi _listesi)
Biçimleme dizgisi scanf 'e ne tür bir veri girileceğini söyler. Örnekte görülen " %s " yer tutucu damgası yourName değişkeni için bir karakter dizisi beklendiğini belirtir. Tamsayı okuyacak olsaydık biçimleme dizgisine " %d ", reel sayı için " %lf ", karakter veri için ise " %c " yazacaktık.  Örneğin,
scanf("%c%c", &harf1, &harf2);
ifadesi veri türü char olduğunu varsaydığınız harf1 ve harf2 değişkenlerine klavyeden girilen iki karakter değerini kopyalayacaktır. 
scanf("%d%lf", &age, &average);
ifadesi ise int veri türündeki age değişkeni ile double veri türündeki average değişkenine değerlerini klavyeden okur.

Bu örneklerde programdaki ifadeden farklı olarak  değişkenlerin başına & işareti koyduk. & işareti önüne koyulduğu değişkenin bellekteki adresini döndüren bir işlemcidir. Bu işareti char , int ve double veri türündeki değişkenleri okurken koymamız gerekir. Ancak örnek programımızdaki tanımlama kısmında yaptığımız gibi bir dizi(array) tanımlamışsak veya bir değişkeni tanımlarken * kullanıldıysa bu işarete gerek yoktur. Bunun neden böyle olduğunu daha sonraki derslerimizde açıklayacağız!

Klavyeden kaç tane veri alınacağı  biçimleme dizgisindeki yer tutucu damgaların sayısıyla belirtilir. Verileri okuma işleminde verilerin türleri çok önemlidir. C int ya da reel sayıları okurken sayıların başındaki boşlukları atlar ve sayının bir parçası olamayacak ilk karaktere kadar (boşluk ya da  baska herhangi bir karakter) olan karakterleri sayı olarak okur. char veri türü okunurken ise her boşluk ayrı bir karakter olarak görülür. char veri türü okurken de boşlukları atlamak istersek, kaç boşluk atlamak gerekiyorsa o kadar boşluk karakterinin biçimleme dizgisine yazmamız gerekir. 

Bir programa klavyeden veri girerken biçimleme dizgisinde belirtilenden daha fazla veri girersek fazladan girilen veriler bellekte saklanır ve programda (varsa) bir sonraki scanf ifadesi tarafından okunur. Daha az veri girersek, program biz gerekli veri bilgisini  tamamlayana kadar bekler.


 

2.4.3. Çıktıların biçimlendirilmesi

Bu bölümde programımızın çıktılarının ekrandaki görüntülerini nasıl kontrol edeceğimizi göstereceğiz.
int veri türündeki değerlerin görünüşünü düzenlemek için, değeri yazmak için kaç kolonluk yer ayırmak gerektiğini "%d" damgasına ekleriz. Örneğin

printf("   Sonuc = %3d kilo %4d gramdır.n", k, g);
ifadesi, eğer k değişkeninin değeri 21, g değişkeninin değeri 50 ise
   Sonuc =  21 kilo   50 gramdır.
çıktısını verecektir. Burada 21 değeri 3 karakterlik bir alana, 50 değeri de 4 karakterlik bir alana yazılmıştır. 

Reel sayıların görünüşünü ayarlamak için hem kaplayacağı toplam kolon sayısını hem de noktadan sonra kaç basamak basılacağı bilgisini vermek gerekir. Toplam alanı belirtirken noktanın kaplayacağı bir kolonu da saymak gerekir.  Örneğin 3.14159 değerini taşıyan pi değişkenini 

printf(" PI =  %5.2f n", pi);
ifadesiyle yazmak istersek, ekranda
  PI =   3.14
görülecektir. " %5.2f " damgasıyla pi değişkenini toplam 5 kolonluk alana noktadan sonra 2 basamak bırakarak yazmak istediğimizi söylüyoruz. Çıktıda = işaretinden sonra 2 boşluk vardır. Biri biçimleme dizgisinde yazdığımız boşluktur, diğeri ise pi 'yi yazmak için kullandığımız toplam 5 kolonluk alandan kalan boşluktur.

2.4.4. Örnek Program 

Aşağıdaki  program girdi/çıktı işlemlerini örneklemek amacıyla verilmiştir.




 /* Yazar : Nihan Kesim Cicekli
 * Tarih : Temmuz 2000
 *
 * Bu program, iki tamsayiyi klavyeden okur ve
 * bu iki sayinin toplamini ve birinci ile ikinci sayi arasindaki
 * farki bularak ekrana bastirir.
 */

#include

int
main (void) {
   int i,j; /* okunan iki sayi */
   int toplam, fark; /* bulunacak toplam ve fark */

   /* Tamsayilari bildirim basarak oku*/
   printf("Birinci sayiyi girin:");
   scanf("%d", &i);

   printf("Ikinci sayiyi girin:");
   scanf("%d", &j);

   /* Toplami bul */
   toplam = i+j;

   /* Farki bul */
   fark = i-j;

   /*Toplami ve farki ekrana yazdir */
   printf("Toplam = %3dn", toplam);
   printf("Fark   = %3dn", fark);

   return(0);
}
 

Bu programı kendi bilgisyarınıza yüklemek için buraya tıklayınız.


Bu program, her sayıyı okumadan önce, ekrana, printf işlevi ile kullanıcıya ne yapacağını söyleyen bildirimi bastırır ve kullanıcının yazdığı sayı okunarak değişkenin içinde saklanır. 

Sayılar okunup değişkenler içinde saklandıktan sonra, toplamları ve farkları atama ifadeleri ile bulunur. Bulunan sonuçlar, printf işleviyle ekrana gönderilir. 

Bu örnek programı kendi bilgisayarınızda çalıştırın. Daha sonra biçimleme dizgisini değiştirerek sonuçların ekranda nasıl gösterildiğini inceleyin.

Sayfa Başına

2.5. Hata Mesajları

Bu haftadan itibaren kendi programlarımızı yazmaya başlayacağız. İdeal bir durumda, yazdığımız program bilgisayarda ilk denememizde hiç hata vermeden tam istediğimiz gibi çalışabilir. Ama bu büyük ihtimalle hiç olmayacağı için karşılaşacağımız hata çeşitlerini bilmemizde yarar vardır. Üç hata çeşidi ile karşılaşabiliriz: Derleme sırasındaki hatalar, çalıştırma sırasındaki hatalar ve mantık (ya da tasarım) hataları.

2.5.1. Derleme hataları

Derleme hataları program derlenirken ortaya çıkan hatalardır. Bunlar aynı zamanda syntax hataları olarak da bilinir. Programınızı yazarken yazım hataları yaparsanız (imla hatası gibi), C'nin kurallarına uymazsanız (örneğin ; ya da { ve } gibi işaretleri yanlış yerlerde kullanmak gibi) derleme hataları alırsınız. Bunlar bulması ve düzeltmesi en kolay hatalardır. C'de en sık yapılan yazım hatalarından birkaçını sıralayalım.

C'de komut içeren her ifade ';' işareti ile bitirilmelidir. Bu C'nin ifadeleri birbirinden ayırabilmesi için gereklidir. Eğer ';' unutulursa C derleyicisi hata mesajı verecektir.

Açıklamalar  mutlaka ' /* ' ile başlamalı ve ' */ ' ile bitmelidir. 

Programların bölümlerinin başlangıç ve sonlarını belirleyen '{' ve '}' işaretlerini unutmak ya da yanlış kullanmak da en yaygın hatalardır.

Programda kullanılan bir değişkenin tanımlanması unutulursa bu da bir derleme hatasına sebep olur.

2.5.2. Çalıştırma hataları

Çalıştırma hataları program derlendikten sonra çalıştırılırken alınan hatalardır. Programınızı syntax hatalarından temizledikten sonra çalıştırdığınızda programın çıktısı yerine hata mesajı alırsanız ya da programınız hiç sonuç vermeden ekran kilitlenmiş gibi boş kalırsa çalıştırmada bir hata var demektir. Bu tip hataların nedeni daha zor bulunur, çünkü nedenler programın içeriğine göre çok çeşitlidir. Örneğin programınızda bir bölme işlemi vardır ve programın çalışma sırasında bölen değer sıfır oluyordur. İşte bu durumda sıfıra bölme işlemi çalıştırma hatası verecektir. Bu tip hataları programlama yeteneğiniz arttıkça bulmanız ve düzeltmeniz kolaylaşacaktır.

2.5.3. Mantık hataları

Mantık hataları da algoritma  tasarımı sırasında ya da algoritmayı programa kodlarken yapılan  bir hatadan kaynaklanır. Mantık hataları genelde derleme ve çalıştırma hatalarından kurtulduktan sonra ortaya çıkar. Bu aşamada programınız çalışır ve bir çıktı verir. Ancak çıktıyı incelediğinizde bunun sizin istediğiniz çıktı olmadığını görürsünüz. Örneğin  çıktılar düzgün bir sırada alt alta çıkmamıştır, ya da rakamlar hatalı hesaplanmıştır ya da program eksik çıktı vermiştir.  Bu tip hataları düzeltmek için programın bazı kısımlarını yeniden yazmak hatta bazen algoritmayı değiştirmek gerekebilir.


3. Karar Verme Yapıları 
3.1. Koşullar
3.2. IF ifadesi 
3.2.1. Bir seçenekli if ifadesi 
3.2.2. İki seçenekli if ifadesi 
Örnekler 
3.3. Öbek İfade (Compound Statement) 
Örnekler 
3.4. İç-İçe IF İfadeleri (Nested IF Statements) 
Eşleşmemiş Else Problemi (Dangling Else Problem)
3.5. IF-ifadeleri ile Bir C Programı 
3.6. switch ifadesi 
 

3. Karar Verme Yapıları

Amaç:

Bu hafta seçeneğe dayalı işlemlerin nasıl yapılacağı gösterilecek. 

  1. Bu amaçla C'de bulunan karar verme yapılarından if ifadesinin seçeneğe dayalı işlemlerde nasıl kullanılacağını göreceğiz. Bu ifadenin değişik yapılarını ve nasıl çalıştığını inceleyeceğiz.  
  2. Karar verme bir mantıksal deyim (logical expression) sonucuna bağlı olacağından, mantıksal deyim yapıları da ayrıntılı olarak sunulacaktır.  
  3. Çoktan seçmeli işlemlerde kullanacağımız diğer bir karar verme yapısı olan switch ifadesi de tanıtılacaktır.   

3.1. Koşullar

Koşullar sonucu 1 (doğru) ya da 0 (yanlış) olan mantıksal deyimlerdir. Basit bir mantıksal deyim karşılaştırma (relational) işleçleri kullanılarak yaratılabilir. Örneğin,
    x < y
mantıksal deyimi, x ve y değişkenlerinin < karşılaştırma işleci kullanılarak birleştirilmesiyle yaratılmıştır. Eğer x değişkenin değeri, y değişkenin değerinden daha küçükse, bu mantıksal deyimin sonucu 1 (doğru) olacaktır; aksi halde bu deyimin sonucu 0 (yanlış) olacaktır. 

Genelde bir mantıksal deyim  bir karşılaştırma işleciyle yaratıldığında aşağıdaki yapıda olur: 
         deyim1  karşılaştırma-işleci  deyim2 

Genelde buradaki deyim1 ve deyim2 birer aritmetik deyim olabilir ve onların sonuçları karşılaştırma-işleci kullanılarak karşılaştırılabilir. C'de kullanılan karşılaştırma işleçleri şunlardır: 
 

< küçük  eğer sol taraftaki değer sağ taraftaki değerden küçükse, 
sonuç 1, aksi halde 0
<=  küçük ya da eşit  eğer sol taraftaki değer sağ taraftaki değerden küçük 
ya da eşitse, sonuç 1, aksi halde 0
> büyük eğer sol taraftaki değer sağ taraftaki değerden büyükse, 
sonuç 1, aksi halde 0
>= büyük ya da eşit  eğer sol taraftaki değer sağ taraftaki değerden büyük 
ya da eşitse, sonuç 1, aksi halde 0
==  eşit  eğer sol taraftaki değer sağ taraftaki değere eşitse, 
sonuç 1, aksi halde 0
!= eşit değil  eğer sol taraftaki değer sağ taraftaki değere eşit değilse, 
sonuç 1, aksi halde 0
 
Örneğin, x değişkeni 10 değerini ve y değişkeni 5 değerini tutuyor olsun. Bu durumda aşağıdaki mantıksal deyimlerin değerleri şöyle olacaktır: 
 
Mantıksal Deyim 
Sonuç
x >1 1 (doğru)
x <10 0 (yanlış)
x >= 10 1 (doğru)
x >y 1 (doğru)
x ==y 0 (yanlış)
x !=y 1 (doğru)
(y+6) >x 1 (doğru)
(y-x) >=(x*y) 0 (yanlış)

Daha karmaşık mantıksal deyimler, mantıksal  işleçler (logical operators) kullanılarak yaratılabilir. Bu mantıksal işleçlerden çoğu iki mantıksal deyimden yeni bir mantıksal deyim yaratırlar; bir tanesi ise tek mantıksal deyimden yeni bir mantıksal deyim yaratır. C programlama dilindeki mantıksal işleçlerden bazıları şunlardır: 
 

 mantıksal-deyim1 && mantıksal-deyim2   ve (and)
 mantıksal-deyim1 || mantıksal-deyim2    veya (or) 
  ! mantıksal-deyim    değil (not) 

Bu mantıksal işleçlerin sonucu bu işleçlerin doğruluk tablolarına (truth tables) göre bulunur. Bu işleçlerin doğruluk tabloları aşağıdaki gibidir: 
 

Deyim E1 E2 Sonuç
E1 && E2 sıfır değil (doğru) sıfır değil (doğru) 1 (doğru)
  sıfır değil (doğru) 0 (yanlış) 0 (yanlış)
  0 (yanlış) sıfır değil (doğru) 0 (yanlış)
  0 (yanlış) 0 (yanlış) 0 (yanlış)
E1 || E2 sıfır değil (doğru) sıfır değil (doğru) 1 (doğru)
  sıfır değil (doğru) 0 (yanlış) 1 (doğru)
  0 (yanlış) sıfır değil (doğru) 1 (doğru)
  0 (yanlış) 0 (yanlış) 0 (yanlış)
! E1 sıfır değil (doğru)   0 (yanlış)
  0 (yanlış)   1 (doğru)
 
Bu tabloda da görüldüğü gibi C mantıksal bir deyimin sonucunu  daima 0 ya da 1 olarak hesaplar. Ancak C sıfır olmayan herhangi bir değeri de 'doğru' olarak görür. Şimdilik biz doğru değeri hep 1 tamsayısı ile göstereceğiz. Örneğin, x değişkeni 10 değerini ve y değişkeni 5 değerini tutuyor olsun. Bu durumda aşağıdaki mantıksal deyimlerin değerleri şöyle  olacaktır: 
 
 
  Mantıksal Deyim   Sonuç
(x>1) && (y<5)  0 (yanlış) 
(x>1) || (y<5)  1 (doğru) 
(x>1) ^ (y<5)  1 (doğru) 
 !(x>1)  0 (yanlış) 

Mantıksal işleçlerin de aritmetik işleçler gibi bir öncelik sırası vardır. Şimdiye kadar gördüğümüz işleçler öncelik sırasına göre şöyle sıralanır: 

1. !  -  (unary minus) 
2. *  /  % 
3. + - 
4. < > <=  >= 
5. ==  != 
6. ^
7. && 
8. ||
1 numaradaki işleçler önceliği en yüksek işleçler, 8 numaradaki işleç önceliği en düşük işleçdir. Örneğin, 
x>1 || y>2 && z>3
mantıksal deyiminde &&   işlemi || işleminden önce yapılacaktır. Çünkü onun önceliği daha yüksektir. Bütün işleçlerin öncelik sırası kitabımızın Appendix C bölümünde bulunabilir. Bu öncelik sırasını açık hale getirmek ya da değiştirmek istersek parantezler kullanabiliriz. Örneğin  yukarıdaki ifadeyi
(x>1 || y>2) && z>3
şeklinde yazarsak, || işlemi && işleminden önce yapılacaktır.

Programlarımızda birşeyin doğru ya da yanlış olduğunu  int veri türündeki bir değişken kullanarak gösterebiliriz. Atama ifadesiyle bu değişkene 0 değeri verirsek yanlış, sıfır olmayan bir değer verirsek doğru olarak kabul ederiz. Örneğin, flag int veri türünde bir değişken olsun ve bu değişkenle x değikeninin 10'dan büyük olup olmama durumunu belirtmek isteyelim. Bu durumu aşağıdaki atama ifadesiyle belirtebiliriz.

 flag = (x>1); 
Bu atama ifadesi eğer x 'in değeri 10'dan büyükse flag 'a 1 (doğru), değilse flag'a 0 (yanlış) değerini koyacaktır.
cift = (n % 2 == 0);
ifadesi ise eğer n bir cift sayıysa cift 'e 1 değerini verecektir. 

Özetleyecek olursak C'de koşul şunlardan biridir: 
 

  • bir int değer ya da bir int değişken 
  • yalnızca karşılaştırma işleçleri kullanılarak yaratılan basit bir mantıksal deyim 
  • diğer mantıksal deyimlerden mantıksal işleçler kullanılarak yaratılan bir mantıksal deyim 

Kısa devre değerlendirme (Short-circuit Evaluation)

İf ifadesine geçmeden önce C'nin koşulların sonucunu hesaplama  şeklini anlatmak gerekir. C mantıksal deyimlerin sadece bir bölümünün değerini hesaplar. Bütün deyim ancak gerektiği durumlarda hesaplanır. Örneğin a || b deyimi a doğruysa do ğru olacaktır. Bu yüzden C bu tip bir ifadeyi çalıştırırken eğer ilk değer sıfır değilse ikinci değeri hiç hesaplamaz. Benzer şekilde a && b deyimi  a yanlış ise yanlış olacaktır. Bu tip koşullarda da C ilk değer sıfırsa ikinci değere hiç bakmadan sonucu sıfır olarak bulur. Bu değerlendirme metoduna kısa devre değerlendirme diyoruz.
 

3.2. IF ifadesi 

Programlarımızda bir komutlar kümesinden koşullara bağlı olarak yalnızca birini çalıştırmak isteyebiliriz. Diğer bir deyişle bazı durumlarda, komutlardan yalnızca birini çalıştırır diğerlerini çalıştırmayabiliriz. C programlama dilinde koşula bağlı çalıştırma işlemini genellikle if ifadesini kullanarak yaparız. C'de if ifadesinin iki değişik yapısı vardır. 

    3.2.1. Bir seçenekli if ifadesi   

Bu yapıyla bir komutlar dizisini koşula bağlı olarak ya çalıştırırız yada çalıştırmayız.Bir seçenekli if ifadesinin yapısı şöyledir: 
    if ( koşul )
        doğru-ifade; 
Bu if ifadesinde ilk önce bir mantıksal deyim olan koşul 'un değeri bulunur. Eğer koşulun değeri sıfır değilse (yani doğruysa) doğru -ifade çalıştırılır. Aksi halde doğru -ifade hiç çalıştırılmadan bir sonraki ifadeye geçilir. Buradaki koşul herhangi bir mantıksal deyim olabilir ve doğru-ifade C' deki herhangi başka bir ifade  olabilir. Şimdiye kadar gördüğümüz ifade yapıları şunlardır: atama ifadesi, işlev çağırma ifadesi ve if ifadesi. Tabii burada kullanılacak ifadeler bunlarla sınırlı değildir; daha sonra göreceğimiz gruplama (block), while , for gibi diğer ifadeler de olabilir. 

    3.2.2. İki seçenekli  if ifadesi 

Bu ifadeyle koşula bağlı olarak iki C ifadesinden birini çalıştırabiliriz. İki seçenekli if ifadesinin yapısı aşağıdaki gibidir: 
    if ( koşul ) 
         doğru-ifade ; 
    else
         yanlış-ifade ; 
Eğer koşul değeri sıfır değilse doğru-ifade çalıştırılır, aksi halde (yani değeri sıfırsa)  yanlış-ifade çalıştırılır. Bu yapıda da doğru-ifade ve yanlış-ifade C 'deki herhangi bir ifade olabilir.

NOT: Daha önce algoritmalarımızda kullandığımız eğer-değilse türü karar verme işlemlerini C'de if ifadeleriyle yapabiliriz.

    Örnekler:
1. 
    if (y != 0) 
         x = x / y; 
    else 
         printf("y is zero n"); 
Bu örnekte y' nin değeri sıfırdan farklı ise, x' in içindeki değer y' nin içindeki değer ile bölünür ve sonuç x' in içinde saklanır. Aksi halde y' nin sıfır olduğunu gösteren mesaj ekrana  yazılır. 
2. 
    if (x >= 0) 
         printf("x is positive n"); 
    else 
         printf("x is negative n"); 
Eğer x' in değeri 0'a eşit ya da büyük ise, ekrana onun pozitif olduğu, aksi halde onun negatif olduğu  yazılır. 
3. 
    if (x < 0) 
         sign = -1; 
    else 
         sign = 1; 
    absulatex = sign * x; 
Eğer x' in değeri 0'dan küçük ise, sign değişkenin içine –1 değeri, aksi halde 1 değeri konur. Bu sign değişkeni içindeki değer, x değişkenin pozitif ya da negatif olduğunu gösterir. if ifadesinden sonraki atama ifadesi de x değerini sign değeri ile çarparak x' in mutlak değerini bulur. 
4. 
    if ((x>1) && (x<10)) 
         x = x + 1; 
Bu ifadedeki atama ifadesi yalnızca x değeri 1'den büyük ve 10'dan küçük olduğu zamanlarda çalıştırılacaktır. Aksi halde bu if ifadesi hiçbir şey çalıştırmadan bir sonraki ifadeye geçilecektir. 

3.3. Öbek İfade (Compound Statement) 

'{' ve '}' sembolleri arasında kalan komutlar kümesi öbek ifade olarak adlandırılır. Öbek ifade de C programlama dilindeki ifadelerden biridir. Diğer ifadelerin kullanıldığı her yerde bir öbek ifade de kullanılabilir. Diğer ifadelerden sonra her zaman ' ; ' işareti koyarız, ama öbek ifadesini kapatan '}' den sonra ' ; ' işareti koymamıza gerek yoktur. Daha önce öbek ifadesiyle karşılaşmıştık. Örneğin bir işlevin gövdesi bir öbek ifadedir. If ifadesi içinde öbek ifadesini doğru -ifade veya yanlış -ifade yerine kullanabiliriz. If ifadesinin koşulu doğru olduğunda (ya da else kısmında) eğer birden fazla işlem yapmamız gerekiyorsa, bu işlemleri yapan bütün C ifadelerini bir öbek ifadesi biraraya toplarız. 
    Örnekler:
1. 
    if (indirimOrani != 0) { 
         indirim = fiyat * indirimOrani; 
         fiyat = fiyat - indirim; 
Bu örnekte iki atama ifadesi bir öbek ifade içinde toplanmıştır. Eğer  if ifadesinin koşulu 1 ise bu öbek ifadedeki bütün ifadeler çalıştırılacaktır. 
2. 
     if (x>y) { 
         temp = x; 
         x = y; 
         y = temp; 
Bu  örnekte, eğer x 'in değeri y 'nin değerinden büyük ise, üç atama ifadesini kapsayan öbek ifade çalıştırılır.  Bu öbek ifadedeki atama ifadeleri x ve y değişkenlerinin içindeki değerlerin yerlerini temp değişkenini kullanarak değiştirir. Eğer x' in değeri y' den büyük değilse bu öbek ifades hiç çalıtırılmaz. 
3. 
    if (x != y) { 
        printf("x ve y farkli degerlere sahipler. n"); 
        printf("x: %d  y: %d n", x, y); 

    else { 
        printf("x ve y ayni degerlere sahipler. n"); 
        printf("x ve y: %d n", x); 
Bu örnekteki if i fadesi eğer x 'in değeri y 'nin değerinden farklı ise bunu gösteren mesajı bir satıra yazar ve sonra x ve y 'nin değerlerini bir sonraki satıra ayrı ayrı yazar. Aksi halde, eşit oldukları mesajını yazar ve sadece x değerini yazar. Görüldüğü gibi bu örnekteki if ifadesinin hem doğru - ifadesi , hem de yanlış-ifadesi birer öbek ifadedir. 

3.4. İç-İçe IF İfadeleri (Nested IF Statements) 

İkiden fazla koşulu  içeren karar verme yapılarında da if-ifadelerini  kullanabiliriz.  Eğer bir if - ifadesinin doğru-ifadesi ve/veya yanlış-ifadesi de başka bir if -ifadesi ise, böyle if -ifadelerini iç-içe if -ifadeleri olarak adlandırırız. 

Örneğin, 

if (x<10) 
    printf("x bir rakamdan olusur"); 
else
  if (x<100) 
      printf("x iki rakamdan olusur"); 
  else
      printf("x ikiden fazla rakamdan olusur");

ifadesi bir iç-içe if -ifadesidir. Dışarıdaki if -ifadesinin (kırmızı renkle gösterilen) yanlış-ifadesi (else kısmı) başka bir if -ifadesidir (yeşille gösterilen). İlk önce x 'in 10'dan küçük olup olmadığı sınanacaktır. Eğer küçükse, x 'in tek rakamdan oluştuğunu yazacak olan printf   işlevi  çalışacaktır.  Değilse,  dışardaki  (kırmızı) if -ifadesinin else -bölümündeki if ifadesi çalışacaktır.  Bu durumda (yani x 10'dan küçük değilken), x 'in 100'den küçük olup olmadığı kontrol edilecektir. Eğer küçükse, ikinci if ifadesinin (yeşil olan) doğru bölümünü oluşturan ve x 'in iki rakamdan oluştuğunu  yazan  printf   işlevi  çalışacaktır.  Aksi  halde (yani x 100'den küçük değilse)  ikinci  if -ifadesinin else -bölümünü oluşturan ve x 'in ikiden fazla rakamdan oluştuğunu yazacak olan printf işlevi çalışacaktır. 

Aşağıdaki örnekte bir iç-içe if ifadesi görülmektedir. Bu yapı her if -ifadesinin (sonuncu if -ifadesi hariç) else -bölümünde yine bir if -ifadesi yazarak ortaya çıkmıştır. Birbiriyle eşleşen if ve else 'ler aynı renkte gösterilmiştir. 
 

  if (grade>=90) 
     printf("A"); 
  else if (grade>=80) 
     printf("B"); 
  else if (grade>=70) 
     printf("C"); 
  else if (grade>=60) 
     printf("D"); 
  else
     printf("F"); 

Bu if ifadesi, eğer grade 90'dan büyük ya da eşitse A yazar. Değilse, grade' in 80'den büyük ya da eşit olup olmadığını kontol eder ve eğer öyleyse B yazar. Değilse ve grade' in değeri 70'ten büyük ya da eşit ise C yazar. Aksi halde, grade' in değerini tekrar 60 ile karşılaştırır ve bu karşılaştırmanın sonucuna göre D ya da F yazar. 
 

    Eşleşmemiş Else Problemi (Dangling Else Problem) 
C programlama dili, her zaman bir else -ifadesini bir önceki if -ifadesinin parçası olarak görür.  Bu yüzden iç-içe if -ifadelerini kullanırken, eğer bazı if -ifadelerin else -bölümleri yoksa dikkatli olmalıyız. Örneğin, 
    if (x>5)  YANLIŞ
      if (y>5) 
             printf("x ve y 5 den buyuk"); 
    else
         printf("x 5 den kucuk ya da esit"); 
Bu  iç-içe if -ifadesi beklediğimiz davranışı  göstermeyecektir.  Buradaki  else bölümü ,  dışardaki  if -ifadesi ile değil de içerideki if -ifadesiyle eşleşecektir (yeşil renkle gösterilmiştir).  Bu yüzden x 'in 5'ten küçük ya da eşit olduğunu yazan printf komutu, x 'in 5'ten büyük ve y 'nin 5'ten küçük ya da eşit olduğu durumlarda çalıştırılacaktır. Eğer else bölümünü dışardaki if -ifadesi (kırmızı olan) ile eşleştirmek istiyorsak, yukarıdaki örneği aşağıdaki gibi değiştirmeliyiz: 
    if (x>5) { DOĞRU 
      if (y>5) 
            printf("x ve y 5 den buyuk"); 
    }
    else
        printf("x 5 den kucuk ya da esit"); 
Böylece x , 5'ten büyük değilse, else kısmı çalıştırılacaktır. Bu yazımda dışarıdaki (kırmızı) if -ifadesinin doğru bölümü  bir öbek ifadedir ve bu öbek ifade  bir seçenekli if ifadesini kapsamaktadır. Gördüğünüz gibi burada tek bir ifadeyi öbek ifadenin içine koyduk. Bunu if ve else'leri doğru eşleştirmek için yaptık. 
 

3.5. IF-ifadeleri ile Bir C Programı 

MinValue.cpp

/*
 * Bu program uc tamsayiyi klavyeden okur ve 
 * bu uc sayinin en kucugunu bularak ekrana bastirir. 
 */ 
#include

int main () { 

   int num1,num2,num3; /* okunan tamsayilar */
   int minValue;     /* bulunacak olan en kucuk deger */ 

   /* Ilk tamsayiyi oku */
   printf("Birinci tamsayiyi girin : "); 
   scanf("%d", &num1);

   /* Ikinci tamsayiyi oku */
   printf("Ikinci tamsayiyi girin : "); 
   scanf("%d", &num2);

   /* Ucuncu tamsayiyi oku */
   printf("Ucuncu tamsayiyi girin : "); 
   scanf("%d", &num3);

   /* En kucuk degeri bul: 
       1. ve 2. sayilarin en kucugunu bul ve minVal da sakla 
       3. sayidaki ve minValue'daki degerin en kucugunu bul, 
       minValue'daki deger, 3 sayinin en kucugu olacaktir.*/

   if (num1
      minValue = num1; 
   else 
      minValue = num2; 

   if (num3
      minValue = num3; 

   /* En kucuk degeri ekrana yazdir */ 
   printf("En kucuk deger: %d n", minValue); 
   return(0);


Bu program üç tamsayıyı ayrı ayrı okur ve okuduğu bu sayıları num1 , num2 ve num3 değişkenleri içinde saklar. Sayılar okunduktan  sonra  bu  üç  sayının  en  küçüğü,  iki  if -ifadesi kullanılarak bulunur. İlk if -ifadesi iki seçenekli bir if ifadesidir ve ilk iki sayının en küçüğünü minValue değişkenin içinde saklar. İkinci if -ifadesi bir seçenekli if ifadesidir ve eğer num3 değişkeninin içindeki değer, minValue değişkeninin içindeki değerden küçükse, num3' teki değer minValue 'ya aktarılır. Böylece minValue girilen üç sayının en küçüğünü tutacaktır. Daha sonra bu en küçük değer ekrana yazdırılır. 
 
 

3.6. switch ifadesi 

Çok sayıdaki seçenekler arasından bir seçim yapmak isteniyorsa, diğer bir karar verme yapısı olan switch -ifadesi de kullanılabilir. Seçenekler arasındaki seçim tek bir değişkenin  ya da basit bir deyimin değerine dayalı olarak yapılıyorsa switch -ifadesi çok yararlı olabilir. Seçimin dayalı olduğu bu deyimin veri türü ya int ya da char olmalıdır. double veri türü olamaz. switch ifadesinin genel  yapısı şöyledir: 
    switch ( kontrol-deyimi ) {
        değer-kümesi-1
         ifade(ler)
                    break ;
        değer-kümesi-2
         ifade(ler)
                    break ;
        ... 
        ... 
        değer-kümesi-n
         ifade(ler)
                    break ;
        default
         ifade(ler)
    }
Burada kontrol-deyimi veri türü int ya da char olan bir deyimdir; değer-kümeleri kontrol-deyiminin alabileceği değerlerin listesidir ve ifade(ler) de C'deki herhangi bir veya daha fazla ifade olabilir. Değer kümeleri bir ya da daha fazla 
case sabit :
şeklindeki etiketlerden oluşur. break ve default: kısımları switch ifadesinde bulunmak  zorunda değildir (optional).

Bir switch -ifadesinde ilk önce kontrol-deyiminin değeri hesaplanır. Bu değer her değer-kümesindeki etiketlerin sabitleri ile tek tek karşılaştırılır. İçindeki sabit, kontrol deyiminin değerine eşit olan ilk değer-kümesi bulunana kadar bu karşılaştırmaya devam edilir. Eşitlik bulununca o case etiketini takip eden ifade(ler)  ilk break ifadesine gelininceye kadar çalıştırılırlar. Bulunan ilk break ifadesinden sonra switch ifadesinin geri kalan kısmı çalıştırılmadan atlanır. Hiç break ifadesi yoksa çalıştırma işlemi  switch -ifadesinin sonuna erişene kadar devam eder. 

Eğer değer kümelerindeki bütün etiket sabitleri kontrol deyiminin değerinden farklıysa,  default kısmı seçilir ve bu kısımdaki  ifadeler çalıştırılır. default kısmı yoksa bütün switch ifadesinin gövdesi hiç çalıştırılmadan atlanır.

Örnek: 


switch (x) { 
    case 1: printf("x in degeri 1 n"); 
            break; 
    case 2: printf("x in degeri 2 n") 
    case 3: 
    case 4: printf("x in degeri 3 ya da 4 n") 
            break; 
    default: printf("x in degeri 1,2,3,4 degil n"); 
}

Eğer x 'in değeri 1 ise, ilk case etiketindeki ifade ler çalıştırılır. İlk  printf işlevi çağırılır ve sonra  break ifadesi çalıştırıldığında switch -ifadesinin çalışması bitmiş demektir. Böylece switch -ifadesinden sonraki ifadeye geçilir. Ekranda şunları görürüz: 

    x in degeri 1 
Eğer x 'in değeri 2 ise, ikinci case etiketindeki ifadelere gidilir. İlk önce x 'in değerinin 2 olduğunu yazan olan printf işlevi çalışır. Bu etiketin altında   hiç bir break -ifadesi olmadığı için  üçüncü değer-kümesindeki ifadeler de çalıştırılmaya başlanır. Böylece ekrana x 'in değerinin 3 ya da 4 olduğunu yazacak printf işlevi çalıştırılır. Daha sonra break -ifadesi çalıştırıldığında switch -ifadesinden çıkılır. Ekranda şunları görürüz: 
    x in degeri 2 
    x in degeri 3 ya da 4 
Eğer x 'in değeri 3 ise, üçüncü değer kümesine gidilir. Bu kümede iki case etiketi vardır. Buradaki ifadeler çalıştığında İlk önce x 'in değerinin 3 ya da 4 olduğunu yazacak olan printf komutu çalışır. Daha sonra break -ifadesi çalıştırıldığında switch -ifadesinden çıkılır. Ekranda şunları görürüz: 
    x in degeri 3 ya da 4
Eğer x 'in değeri 1,2,3 ya da 4 değilse, default kısmına gidilir ve oradaki ifade çalıştırılır. switch -ifadesinin sonuna eriştiğimizden switch -ifadesinden çıkarız. Ekranda şunları görürüz: 
    x in degeri 1,2,3,4 degil
4. Döngü Yapıları
4.1. while İfadesi
4.1.1. Kontrol Değerli Döngüler (Sentinel Controlled Loops) 
4.1.2. Sayaç Kontrollü Döngüler (Counter-Controlled Loops ) 
4.1.3. Örnek Programlar
4.2. for ifadesi
4.2.1. Arttırma ve azaltma işleçleri
4.3. do-while ifadesi
4.4. İç-içe döngüler
4.5. Örnek Programlar 

4. Döngü Yapıları

Amaç:
Bu hafta döngü yapıları tartışılacaktır. Döngü yapılarını kullanarak bir ifade kümesi birden fazla kere tekrar ettirilebilir. 

  1. İlk olarak temel bir döngü yapısı olan while ifadesi incelenecektir. 
  2. Değişik döngü türlerinin while ifadesi ile nasıl gösterileceği incelenecektir.
  3. Diğer döngü yapıları olan for ve do-while ifadeleri tanıtılacaktır.
  4. İç-içe döngülerin nasıl kurulduğu anlatılacaktır.
4.1. while İfadesi

Bir ifade kümesinin tekrarlanması işlemi döngü (loop) olarak bilinir. Döngüler C dilinde birkaç değişik ifade ile yaratılabilir. Bunlardan en temeli while -ifadesidir. Diğer ifadelerle yaratılabilen bir döngü, while -ifadesi kullanılarak da yaratılabilir.

while ifadesinin yapısı şöyledir:

  while ( koşul )
        ifade

Burada koşul  bir mantıksal deyimdir ve döngünün gövdesini oluşturan ifade C dilindeki herhangi bir ifade olabilir. Koşulun değeri sıfır olmadığı sürece (yani koşul doğru olduğu sürece) döngünün gövdesi tekrarlanır ve koşulun değeri 0 (yani yanlış) olduğunda tekrarlama işlemi sona erecektir. Eğer while -ifadesine başlamadan önce koşulun değeri 0 ise, döngünün gövdesini oluşturan ifade hiç çalıştırılmayacaktır. Eğer koşulun değeri sıfırdan farklı  ise ifade bir kere çalıştırıldıktan sonra,  while 'ın başına geri dönülür ve koşulun değeri tekrar hesaplanır. Döngünün tekrar çalıştırılıp çalıştırılmayacağı yine koşulun değerine bağlı olacaktır. Normal olarak döngü gövdesinde yaptığımız işlemlerin sonucuna göre, döngü gövdesi belirli bir miktarda tekrar edildikten sonra koşulun değeri 0 olur ve döngüden çıkılır. Eğer koşulun değeri hiç bir zaman 0 olmazsa, döngü sonsuz kere tekrar edilecektir ve bu olay sonsuz döngü (infinite loop) olarak bilinir. Döngünün gövdesi herhangi bir C ifadesi olabilir, ama genelde  döngülerin gövdesi bir öbek ifade olacaktır. 

while ifadesinin çalışma mantığı aşağıdaki grafiksel akış şemasından da anlaşılabilir.
 


 

Şimdi while ifadesinin kullanışını basit örnek program parçaları ile anlatacağız.
 

Örnek 1.

 
x = 1;
while (x < 10) {
   printf("%d n",x); 
   x = x + 1;
}
Bu örnek, bir atama ifadesi ve bir while -ifadesinden oluşur. while -ifadesinin koşulu mantıksal deyim  x<10 ve gövdesi iki ifadeyi kapsayan bir öbek ifadedir. İlk atama ifadesiyle x değişkenine 1 değeri konduktan sonra, while -ifadesi şöyle çalışacaktır:
 
  • 1 değeri, 10'dan küçük olduğu için, koşulun değeri 1 olacaktır. Böylece while -ifadesinin gövdesini oluşturan öbek ifade çalıştırılır. Bunun sonucu olarak x değişkenin değeri ekrana yazılır ve x değişkenin değeri bir artırılır ( yani değeri 2 olacaktır). 
  • Bundan sonra yine while -ifadesinin başına gidilir ve koşulun değeri yeniden hesaplanır. Burada da, 2 değeri 10'dan küçük olduğu için koşulun değeri yine 1 olacaktır. Bu yüzden gövde yeniden çalıştırılacaktır. 
  • Bu while -ifadesi 9 kere x 'in 1'den 9'a kadar olan değerleri için tekrar edilir. Böylece ekranda, 1'den 9'a kadar değerleri görürüz. x 'in değeri 10 olduğunda, koşulun değeri 0 olacağı için, while ifadesinin gövdesi bir daha çalıştırılmaz ve kontrol while -ifadesinden sonraki ifadeye geçer. 

 

Örnek 2.

 
x = 1;
while (x != 10) {
   printf("%d n",x); 
   x = x + 2;
}
Bu örnekteki while ifadesi sonsuz döngüye bir örnektir. Burada amacımız 10 dan küçük tek sayıları yazdırmaktı, ama koşulumuzu yanlış seçtiğimizden dolayı sonsuz bir döngüye neden oluyoruz. Bu  while ifadesinin koşulu mantıksal deyim  x != 10 (x 10 dan farklı ise) ve gövdesi iki ifadeyi kapsayan bir öbek ifadedir. İlk atama ifadesiyle x değişkenine 1 değeri konduktan sonra, while -ifadesi şöyle çalışacaktır:
 
  • 1 değeri, 10'dan farklı olduğu için, koşulun değeri 1 olacaktır. Böylece while -ifadesinin gövdesini oluşturan öbek ifade çalıştırılır. Bunun sonucu olarak x değişkenin değeri ekrana yazılır ve x değişkenin değeri 2 artırılır ( yani değeri 3 olacaktır). 
  • Bundan sonra yeniden while -ifadesinin başına gidilir ve koşulun değeri  hesaplanır. Burada da, 3 değeri 10'a eşit olmadığı için koşulun değeri yine 1 olacaktır. Bu yüzden gövde yeniden çalıştırılacaktır. 
  • Bu while -ifadesinde x 'in değeri hiç bir zaman 10 olmayacağından, x 'in alacağı bütün değerler için bu döngü tekrarlanacaktır. Sonuç olarak çıktı olarak ekranda  1 3  5 7 9 11 13 15 ...... olarak bütün tek sayılar basılacak, bu döngü sonsuza kadar tekrar edecektir. Yani while ifadesinden sonraki ifadeye hiç geçilemeyecektir. 

Burada sonsuz döngüden kurtulmak için şartı  x<10 olarak değiştirmek yeterli olacaktır.
 
 

Örnek 3.

 
/* x ve y değişkenleri 0 dan büyük iki pozitif tamsayı 
   tutuyor olsunlar */

while ((x > 0) && (y > 0)) {
   printf("%d n",x * y); 
   x = x - 2;
   y = y - 3;
}

Bu örnekteki while ifadesin koşulu karmaşık bir mantıksal deyimdir. Bu döngü x ve y nin değeri 0 dan büyük olduğu sürece tekrarlanacaktır. Herhangi birinin (veya ikisinin de)  değeri 0 dan büyük olmadığı bir anda tekrarlama işlemi duracaktır. Bu while -ifadesinden önce x 'in değerinin 7 ve y nin değerinin 5 olduğunu varsayalım. Bu durumda while -ifadesi şöyle çalışacaktır:
 
  • 7 ve 5 değerleri 0 dan büyük olduğundan, koşulun değeri 1 olacaktır. Böylece while -ifadesinin gövdesini oluşturan öbek ifade çalıştırılır. Bunun sonucu olarak  7 ile 5 çarpımı olan 35 değeri ekrana yazılır, ve x'in değeri 2 azaltılarak 5 ve y'nin değeri 3 azaltılarak 2 olur.
  • Bundan sonra yeniden while -ifadesinin başına gidilir ve koşulun değeri tekrar hesaplanır. Burada da, 5 ve 2 değerleri 0 dan büyük olduğu için koşulun değeri yine 1 olacaktır. Bu yüzden gövde tekrar çalıştırılacaktır. Böylece 5 ile 2 nin çarpımı olan 10 değeri ekrana yazılır, ve x'in değeri 2 azaltılarak 3 ve y'nin değeri 3 azaltılarak -1 olur. 
  • Bundan sonra yeniden while -ifadesinin başına gidilir ve koşulun değeri tekrar hesaplanır. Burada 3 değeri 0 dan büyük ama -1 değeri 0 dan büyük değildir. Böylece koşulun değeri 0 olur ve program döngüden çıkar, ve  while -ifadesinden sonraki ifade çalışmaya başlar. 

 

4.1.1. Kontrol Değerli Döngüler (Sentinel Controlled Loops)

Bazı durumlarda döngünün kaç kere çalışması gerektiğini bilebiliriz. Ama bazen de  döngünün kaç kere çalışacağını, o döngüyü yazarken bilemeyebiliriz. Örneğin bir sınavın sonuçlarını klavyeden okuyup  bu sonuçların ortalamasını bulmak isteyelim. Sınavda kaç kişi olduğunu bilmediğimiz durumda döngümüzü nasıl kurmalıyız ? Döngümüzü nasıl durdurabiliriz ?

Bu amaçla bir kontrol değeri (sentinel value) kullanırız. Bir sınav notu olamayacak bir değeri (örneğin –1), kontrol değeri olarak seçeriz. Klavyeden normal olarak sınav notlarını girerken, en son değer olarak bu kontrol değerini gireriz. Bu kontrol değeri girildikten sonra, döngümüzün çalışmasını durdururuz. Bu işi yapacak  C programının parçası aşağıdaki gibi olacaktır:



 
toplam = 0;    /* notlarin toplami */
ogrenciSayisi = 0;  /* ogrenci sayisi */

/* ilk notu oku */
printf("bir not giriniz (durdurmak icin –1): ");
scanf("%d",¬);
 

/* not –1'den farkli oldugu surece okumaya devam et */
while (not != -1) {
    toplam = toplam + not;    /* notu toplama ekle */
    ogrenciSayisi = ogrenciSayisi + 1;   /* Öğrenci Sayısını bir artır */ 
    /* diger notu oku */
    printf("bir not giriniz (durdurmak icin –1): ");
    scanf("%d",¬);
}
printf(" nnOrtalama: %f5.2 n",(toplam/ogrenciSayisi));


Bu örnek program parçasında, ilk önce notların toplamını tutacak olan toplam değişkenin içine 0 değeri konur ve ilk not klavyeden okunarak not değişkenin içine saklanır. Bundan sonraki ifademiz while -ifadesidir. Bu while -ifadesi not değişkeninin içindeki değer –1 değerinden farklı olduğu sürece tekrarlanacaktır. Böylece not değişkeninin değeri –1'den farklı olduğunda while -ifadesinin gövdesini oluşturan öbek ifade çalıştırılır. Bu öbek ifadede, ilk önce not değişkeni toplam değişkenine eklenerek sonuç yine toplam değişkeni içinde saklanır. Bundan sonra klavyeden yeni bir not değeri okunarak not değişkeninin içinde saklanır ve tekrar while -ifadesinin başına dönülür. Bu işlem klavyeden –1 değeri girilene kadar tekrar edilecektir ve –1 değeri girildiğinde tekrarlama işlemi durdurularak while -ifadesinden sonraki ifadeye geçilecektir. Bu durumda toplam değişkenin içinde –1 değeri hariç ondan önce okunan bütün değerlerin toplamı olacaktır. Bu toplam değer öğrenci sayısına bölünerek sınavın ortalaması while -ifadesinden sonraki printf komutuyla ekrana yazdırılır.
 
 

4.1.2. Sayaç Kontrollü Döngüler  (Counter-Controlled Loops)

Bazı durumlarda bir döngüyü bir sayaç kullanarak tasarlayabiliriz. Böyle sayaç kontrollü bir döngüdeki temel öğeler şunlardır:
 

1. Bu tür döngünün bir sayacı olur ve bu sayaç bir değişken ile ifade edilir.  Bu değişken döngü sayacı (loop counter) olarak bilinir.
2. Döngü sayacına bir atama ifadesiyle ilk değer verilir.
3. Döngü sayacının değeri, bir mantıksal deyim ile kontrol edilir.
4. Döngünün gövdesinin her çalışmasından sonra, döngü sayacının değeri bir artırma (ya da eksiltme) işlemi ile değiştirilir.

Örneğin aşağıdaki while -ifadeli program parçası sayaç kontrollü bir döngüdür.

Bu sayaç kontrollü döngü, sayac değişkeninin 1'den 10'a  kadar olan değerleri için 10 kere tekrar edilecektir. Burada sayac değişkenine ilk değer bir atama ifadesiyle verilmiştir. Döngünün her tekrarında sayac değişkeni bir artırılacaktır. Bu sayac değişkenin değeri 10'u geçtiğinde tekrarlama bitecektir. Bu döngüye ilk girildiğinde sayac değişkeninin değeri 1 olacaktır ve döngü gövdesinin en sonundaki atama ifadesiyle bu değer bir arttırılacaktır. Böylece ikinci defa girildiğinde sayac değişkenin değeri iki olacaktır. Bu döngü 1'den 10'a kadar olan sayıların toplamını bulmak için kullanılabilir. Bu döngüden çıkıldığında toplam değişkeni, 1'den 10'a kadar olan sayıların toplamını tutacaktır.

Bir önceki bölümde eğer öğrenci sayısını bilirsek, o program parçasını sayaç kontrollü bir döngü kullanarak tekrar yazabiliriz. Bu durumda klavyeden sınav notlarını girmeye başlamadan önce, ilk olarak oğrenci sayısını gireriz. Bu işi yapacak bir C programının parçası aşağıdaki gibi olacaktır:



 
toplam = 0; /* notlarin toplami */

/* öğrenci sayısını oku */
printf("Ogrenci Sayisi: ");
scanf("%d ",&ogrenciSayisi);

/* Öğrenci sayısı kadar notu klavyeden oku */
sayac = 1;
while (sayac <= ogrenciSayisi) {
    /* notu oku */
    printf("bir not giriniz: ");
    scanf("%d ",¬); 
    toplam = toplam + not; /* notu toplama ekle */
    sayac = sayac + 1;   /* sayacı bir artır */
}
printf("Ortalama: %f5.2 n", (toplam/ogrenciSayisi));


Bu örnek program parçasında, ilk önce notların toplamını tutacak olan toplam değişkenin içine 0 değeri konur ve öğrenci sayısı klavyeden okunarak ogrenciSayisi değişkeni içine saklanır. sayac değişkeni  ilk öğrenciyi belirtmek amacıyla 1'e eşitlenir. Bundan sonraki ifademiz while -ifadesidir. Bu while -ifadesi sayac<=ogrenciSayisi koşulu doğru olduğu sürece tekrarlanacaktır. Döngünün gövdesinde okunan not toplam değere eklendikten sonra, sayac değişkeni 1 artırılarak döngü başına gidilir. Öğrenci sayısı kadar not okunduktan sonra sayac değişkenin değeri ogrenciSayisi değişkeni içindeki değerden bir fazla olacaktır. Bu da sayac<=ogrenciSayisi koşulunu yanlış yapacak ve döngüden çıkmamıza neden olacaktır. Son olarak da toplam değer öğrenci sayısına bölünerek sınavın ortalaması  while -ifadesinden sonraki printf komutuyla ekrana yazdırılır.
 

4.1.3. Örnek  Programlar
 

Program 1:

Bu program verilen artı bir tamsayının faktöryel değerini hesaplar ve sonucu ekrana yazdırır. Bu örnekte döngümüzün kaç kere dönmesi gerektiği girilen tamsayıya bağlı olduğu için sayaç kontrollü bir döngü kullanmak uygun olmuştur.

Faktoryel.cpp


  /*
   * Bu program klavyeden girilen bir arti tamsayinin faktoryel 
   * degerini hesaplar, ve sonucu ekrana yazar.
   */ 

   #include
   int main(){
      int num,       /* okunan tamsayi */
          factVal,       /* sayinin faktoryel degeri */
          sayac;         /* sayac degiskeni */
 

      /* tamsayiyi oku */
      printf("Bir arti tamsayi girin: "); 
      scanf("%d",&num); 
      while (num <= 0) { 
          printf("Bir arti tamsayi girin: "); 
          scanf("%d",&num); 
      }  

      /* sayinin faktoryel degerini bul */
      sayac = 2; 
      factVal = 1;
      while (sayac <= num) {
          factVal = factVal * sayac;
          sayac = sayac + 1; 
      } 

      /* sonucu yaz */ 
      printf("Girilen tamsayi: %d n",num); 
      printf("Sayinin faktoryel degeri: %d",factVal); 
      return(0); 

  } 


Program 2:

Bu program ise biraz daha karmaşık bir program. Bu örnekte bir dizi tamsayı klavyeden okunur ve okunan sayılar üzerinde belirli işlemler yapılır. Burada kaç tane sayı girileceği belli olmadığından girilecek son sayı 0 seçilerek dizinin sonu belirlenir. Kontrol değerli bir döngü yapısı bu örnek için uygun olduğu için o tür bir döngü yapısı kullanılmıştır.

Bu örnekte göreceğiniz gibi döngü gövdesi oldukça çok ifadeyi kapsayan bir öbek ifade olabilir. Bu öbek ifadenin içinde diğer ifadelere ek olarak  iç-içe bir if ifadesi de kullanılmıştır.

PosNegCount.cpp


/*
 * Bu program klavyeden girilen tamsayilar arasında arti ve 
 * eksi olanların sayisini bulur. Her tamsayi ayri bir satirdan girilir 
 * ve  en sondaki sayi arti veya eksi sayi olarak 
 * gormedigimiz 0'dir.
 *
 * Bu program ayni zamanda, girilen sayilar arasındaki ilk arti sayinin ilk
 * girildigi sirayi ve ikinci girildigi sirayi bulur.
 *
 * Bu program girilen arti ve eksi sayilarin toplam sayisini da
 * bastirir.
 * Girilen arti sayilardan ilkinin degerini, ilk ve ikinci girildigi siralari (eger
 * ikinci defa girilmediyse ikinci pozisyon icin 0) basar.
 */

#include
#define sentinel  0    /* Dizideki son sayi */

int
main(){
   int anInt, /* okunan tamsayi */
   numOfPos,  /* pozitif sayilarin sayisi */
   numOfNeg,  /* negatif sayilarin sayisi */
   locOfFirstPos, /* ilk pozitif sayinin pozisyonu */
   secLocOfFirstPos, /* ilk pozitif sayinin ikinci pozisyonu */
   firstPos, /* ilk pozitif sayinin degeri */
   loc; /* okunan sayinin pozisyonu */

   /* degiskenlerin ilk degerlerini ver  */
   loc = 0; numOfPos = 0; numOfNeg = 0;
   firstPos = 0; locOfFirstPos = 0; secLocOfFirstPos = 0;

   /* Ilk tamsayiyi oku */
   printf("Tamsayi girin (bitirmek icin 0): ");
   scanf("%d",&anInt);

   /* negatif ve pozitif sayilarin sayisini bul.
      ayni zamanda ilk pozitif sayinin ilk ve ikinci pozisyonunu bul. */
   while (anInt != sentinel) {
      loc = loc + 1;
      if (anInt<0)   /* negatif sayi */
         numOfNeg = numOfNeg + 1; 
      else {        /* pozitif sayi */
         numOfPos = numOfPos + 1;
         if (locOfFirstPos==0) {    /* ilk pozitif sayi */
            firstPos = anInt;
            locOfFirstPos = loc;
         }
         else if((secLocOfFirstPos==0) && (firstPos==anInt))
                  /* ilk pozitif sayinin ikinci gorulusu */
                  secLocOfFirstPos = loc;
      }
      /* tamsayiyi oku */
      printf("Tamsayi girin (bitirmek icin 0): ");
      scanf("%d",&anInt);
   }
   /* sonuclari yaz */
   printf("Negatif sayilarin sayisi: %d n", numOfNeg);
   printf("Pozitif sayilarin sayisi: %d n", numOfPos);
   if (locOfFirstPos!=0) {
      printf("Ilk pozitif sayinin degeri: %d n", firstPos); 
      printf("Ilk pozitif sayinin pozisyonu: %d n ", locOfFirstPos);
      printf("Ilk pozitif sayinin ikinci pozisyonu: %d n", secLocOfFirstPos);
   }
   return(0);
}



4.2. for ifadesi

for ifadesi döngülerin kurulmasında kullanılan başka bir yapıdır.  Bu döngü yapısı özellikle sayaç kontrollü döngülerin yazılımında while -ifadesinden daha uygundur.  for -ifadesinin yapısı şöyledir:

    for ( ilklendirme ; döngü koşulu ; güncelleme )
      ifade
Burada,
 
  • ilklendirme bu sayaç kontrollü döngününün döngü sayacına  ilk değerini verir. Bu ifade sadece bir kere döngüye girmeden önce çalıştırılır.
  • döngü koşulu  değeri her seferinde döngüye girmeden önce bulunur ve bu değer 1 (doğru)  ise döngüye girilir ve ifade çalıştırılır; aksi halde döngüden çıkılır. Bu mantıksal deyimin değeri genelde sayaç değişkenin değerine bağlı olacaktır. 
  • güncelleme döngünün gövdesini oluşturan ifade ifadesinin çalıştırılmasından sonra çalıştırılacaktır. Görevi sayaç değişkenin değerini güncellemektir. 
  • ifade döngünün gövdesini oluşturan ifadedir. Herhangi bir C ifadesi olabilir

Bir for -ifadesi, her zaman bir while -ifadesi olarak aşağıdaki gibi yeniden yazılabilir:

ilklendirme ;
while ( döngü koşulu ) {
      ifade ;
      güncelleme ;
}
Daha önce  verdiğimiz aşağıdaki while -ifadeli sayaç kontrollü döngü

   toplam = 0;
   sayac = 1;
   while (sayac <= 10) {
      toplam = toplam + sayac;
      sayac = sayac + 1;
   }

for -ifadesi kullanılarak şöyle yazılabilir:

toplam = 0;
for (sayac = 1; sayac <= 10; sayac = sayac + 1)
   toplam = toplam + sayac;
Bu for -ifadesinde, ilk önce,
sayac = 1
ifadesiyle sayac değişkenine ilk değer verilir. Bu ifade sadece bir kere çalıştırılacaktır. Bundan sonra döngü gövdesi çalıştırılmadan önce, sayac değişkeninin  değeri
sayac <= 10
koşulu ile kontrol edilecektir. Bu koşulun değeri eğer 1 ise döngü gövdesini oluşturan
toplam = toplam + sayac
ifadesi çalıştırılacaktır. Gövdenin çalıştırılmasından sonra, sayac değişkeninin değerini değiştirmek için
sayac = sayac + 1
ifadesi çalıştırılacaktır. Bu işlemden sonra sayaç değerinin son değere gelip gelmediği tekrar kontrol edilir ve bu kontrolün sonucuna göre döngü tekrar edilir ya da döngüden çıkılır.

for ifadesinin çalışma mantığı aşağıdaki grafiksel akış şemasından da anlaşılabilir.


 

Şimdi for ifadesinin kullanılışını basit örnek program parçaları ile anlatalım.
 

Örnekler:
 
 

1.
for (i=1; i<=100; i=i+1)
ifade
Burada döngünün gövdesi olan ifade, i değişkeninin 1'den 100'e kadar olan değerleri için 100 kere tekrar edilir. Gövdeye ilk girildiğinde i değişkenin değeri 1, ikinci girildiğinde 2, ... ve en son girildiğinde ise 100 olacaktır.
2.
for (i=100; i>=1; i=i-1)
ifade
Burada döngünün gövdesi olan ifade, i değişkeninin 100'den 1'e kadar olan değerleri için 100 kere tekrar edilir. Gövdeye ilk girildiğinde i değişkenin değeri 100, ikinci girildiğinde 99, ... ve en son girildiğinde ise 1 olacaktır.
3.
for (i=2; i<=20; i=i+2)
ifade
Burada döngünün gövdesi olan ifade, i değişkeninin 2 ve 20 arasındaki alacağı çift sayı değerleri için 10 kere tekrar edilir. Gövdeye ilk girildiğinde i değişkenin değeri 2, ikinci girildiğinde 4, ... ve en son girildiğinde ise 20 olacaktır.
4.
for (i=100; i>=10; i=i-10)
ifade
Burada döngünün gövdesi olan ifade, i değişkeninin 100 ve 10 arasındaki 10'nun katları olarak alacağı değerler için 10 kere tekrar edilir. Gövdeye ilk girildiğinde i değişkenin değeri 100, ikinci girildiğinde 90, ... ve en son girildiğinde ise 10 olacaktır.

4.2.1  Arttırma ve Azaltma İşleçleri

Örneklerde de gördüğünüz gibi for ifadesiyde olsun, while ifadesiyle olsun sayaç kontrollu döngülerde sayaç değişkeninin değerini hep

sayac = sayac + 1;
ya da 
sayac = sayac - 1;
gibi atama ifadeleri ile güncellememiz gerekiyor.  Eğer sayacın değeri sadece 1 arttırılıyor ya da 1 azaltılıyorsa bu tip değiştirmeleri yapmak için  C'deki arttırma ( ++ ) ve azaltma ( -- ) işleçlerini kullanabiliriz.  Her iki işleç de tek işlenenle çalışır. Yukarıdaki ilk atama ifadesini arttırma işleci ile 
sayac ++;       ( ya da      ++sayac; )
şeklinde yazabiliriz. Bu ifade sayac ın değerini bir arttırır. İkinci atama ifadesini ise
sayac --;       ( ya da     --sayac;)
şeklinde yazabiliriz. Bu ifade de sayac ın değerini bir azaltır.  Buna göre yukarıda verdiğimiz ilk örnekteki for ifadesi de
for (i=1; i<=100; ++i)
şeklinde yazılabilir. 

Arttırma ve azaltma işleçlerini kullanırken dikkat etmemiz gereken bir nokta vardır. Bu işleçlerin değişkenin önüne ya da arkasına yazılması bazı durumlarda farklı sonuçlar doğurabilir. Azaltma işlecinin kullanıldığı aşağıdaki iki ifadeyi inceleyelim:


 
printf("%3d %3d n", --n, n);  printf("%3d %3d n", n--,n); 
Eğer n değişleninin değeri 5 ise ilk printf ifadesi ekrana 
  4   4
değerlerini; ikinci printf ifadesi ise ekrana
  5   4
değerlerini yazacaktır. Eğer -- işleci değişkenin önüne yazılırsa ilk önce değişkenin değeri bir azaltılır sonra bulunan değer kullanılır. Eğer -- işleci değişkenin arkasına yazılırsa önce değişkenin değeri kullanılır sonra değeri bir azaltılır. Aynı durum ++ işleci için de sözkonusudur. Aşağıdaki iki atama  ifadesini inceleyelim:
 
 
   j = ++i;     j = i++;

Bu atama ifadelerinden önce i 'nin değerinin 2 olduğunu varsayalım. Bu durumda ilk atama ifadesi önce i 'yi bir arttırır, sonra değerini j 'de saklar. Sonuç olarak i 'nin değeri 3, j' ninki de 3 olur.
İkinci atama ifadesi ise önce j 'ye i' nin değerini verir, sonra i' nin değerini bir arttırır. Sonuçta i 3, j 2 değerlerini saklarlar.

Eğer bir değişkenin değeri birden fazla arttırılacak ya da azaltılacaksa C'deki atama ifadelerini aşağıdaki gibi daha kısa bir şekilde yazabiliriz:

sayac += 10;            /* sayac = sayac + 10; */
ya da 
sayac -= 5;            /* sayac = sayac - 5;  */
 
4.3. do-while ifadesi

do-while döngü yapısı while -ifadesine benzer. while -ifadesinde döngünün devam edip etmeyeceğini konrol eden mantıksal deyimin değeri döngü gövdesine girmeden kontrol edilir. Eğer değer hemen 0 (yanlış) olur ise, while -ifadesinin gövdesi hiç çalıştırılmadan döngüden hemen çıkılabilir. do-while ifadelerinde ise döngü koşulu döngü gövdesi çalıştırıldıktan sonra yapılır. Bu da, do-while ifadesinin gövdesinin en az bir kere çalıştırılacak olması demektir. Bu yüzden, do-while ifadesi gövdesi en azından bir kere çalıştırılması gereken döngü yapılarının tasarımında kullanılabilir.

do-while ifadesinin genel yapısı şöyledir:

do
   ifade
while ( koşul ) ;
Bu yapıda gövdeyi oluşturan ifade çalıştırıldıktan sonra, bir mantıksal deyim olan koşulun değeri bulunur. Eğer değeri sıfırdan farklı (doğru) ise döngü yeniden çalıştırılır. Burada ifade herhangi bir C ifadesi olabilir, ama genelde bir öbek ifade olacaktır. Buradaki do-while ifadesinin sonundaki while anahtar sözcüğü, bu ifadenin sonunu belirtir. Programlarımızda bunu, while -ifadesinin başlangıcını gösteren while anahtar sözcüğüyle karıştırmamak gerekir.

Yukarıdaki gibi bir do-while ifadesi aşağıdaki gibi bir while -ifadesine eşit olacaktır:.

ifade
while ( koşul )
     ifade ;
Daha önceki örneğimiz, do-while ifadesi kullanılarak şöyle yazılabilir:
toplam = 0;
sayac = 1;
do {
   toplam = toplam + sayac;
   sayac = sayac + 1;
} while (sayac <= 10);
Çoğu durumda bir döngü tasarlanırken, üç döngü ifadesinden biri kullanılabilir. Diğer bir deyişle aynı işi üç değişik şekilde yapabiliriz. Ama her durum için, bu üç ifadeden birini kullanmak daha uygun olacaktır. Uygun ifadeyi kullanmak, programımızın daha kısa ve daha anlaşılır olmasını sağlayacaktır. Örneğin sayaç kontrollü döngüler için for -ifadesini kullanmak daha uygundur. Tabii bu demek değildir ki aynı işi while -ifadesiyle yapamayız. Önemli olan her durum için en uygun ifadeyi seçmektir. Yukardaki örnek Program 2'deki kontrol değerli döngüde, hem döngünün içinde hem de döngünün dışında klavyeden okuma yapmak zorunda kaldık. Bu nedenle kodumuz biraz uzun olmuştu. O örnek için do-while yapısı kullanmak daha uygun olabilir. Bu durumda kodumuz aşağıdaki gibi olacaktır:
 
 

toplam = 0; /* notlarin toplami */
ogrenciSayisi = 0;  /* Öğrenci Sayısı */

/* not –1 den farkli oldugu surece okumaya devam et */
do {
    /* notu oku */
    printf("bir not giriniz (durdurmak icin –1) ");
    scanf("%d",¬);
    /* notu toplama ekle */
    if (not != -1) {
       toplam = toplam + not;
       ogrenciSayisi = ogrenciSayisi + 1;
    }
} while (not != -1);
printf("Ortalama: %f5.2 n ", (toplam/ogrenciSayisi));
 

Bu durumda notların okunmasını sadece bir noktadan (döngünün içinden) yaparız.

d o-while ifadesinin çalışma mantığı aşağıdaki grafiksel akış şemasından da anlaşılabilir.
 


 
 

 

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

Eğer bir döngünün gövdesinde diğer bir döngü bulunuyorsa, bu tür döngüler iç-içe döngüler olarak bilinir. Bu durumda içteki döngü dıştaki döngünün her adımında yeniden çalıştırılacaktır. Örneğin,

deger = 0;
for (i=1; i<=10; i=i+1)
   for (j=1; j<=5; j=j+1)
      deger = deger + 1;
program parçasında iç-içe döngüler kullandık. Dıştaki döngü (kırmızı olan) bir for -ifadesi ve bu döngünün gövdesi diğer bir for -ifadesidir (yeşil olan). Dıştaki döngü 10 kere tekrarlanacaktır. İçteki döngü de, dıştaki döngünün her tekrar edilişinde 5 kere tekrar edilecektir. Böylece içteki döngünün gövdesini oluşturan atama ifadesi 50 kere tekrar edilmiş olacaktır. Bu yüzden bu for -ifadesinden  çıktığımızda, deger değişkeni 50 değerini tutacaktır.

Aşağıdaki örnek, yukarıdaki örneğe benzemektedir, ama içteki döngünün tekrar ediliş sayısı her defasında farklı olacaktır:

deger = 0;
for (i=1; i<=10; i=i+1)
   for (j=1; j<=i ; j=j+1)
      deger = deger + 1;
Burada dıştaki döngü 10 kere tekrarlanacaktır. İçteki döngü ise her seferinde j 'nin 1'den i 'nin o andaki değerine kadar olan değerleri için tekrar edilecektir. Bu durumda dıştaki döngünün ilk dönüşünde i 'nin değeri 1 olacağından, içteki döngü sadece 1 kere tekrar edilecektir. Dıştaki döngünün ikinci tekrarında i 'nin değeri 2 olacaktır ve içteki döngü 2 kere tekrar edilecektir. Bu demektir ki içteki döngü dıştaki döngünün her seferinde i kere tekrar edilecektir. i 'nin değeri 1'den 10'a kadar değişeceğinden, içteki döngünün gövdesini oluşturan atama ifadesi 1+2+3+...+10=55 kere tekrar edilecektir.

Şimdi iç-içe döngü yapılarına örnek olarak, basit bir program parçası vereceğiz.
 

Örnek.

Aşağıdaki gibi bir dik üçgeni ekrana yazdırmak istiyoruz.

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

Bunun için for-ifadeli aşağıdaki gibi bir iç-içe döngü kullanabiliriz.

  for (i=1; i<=5; ++i) {
     for (j=1; j<=i; ++j)
         printf("*");
      printf("n");
  }

İstenen şekilde 5 satır yıldız vardır. İlk satırda bir  yıldız, sonraki her satırda bir önceki satırdan bir fazla yıldız vardır. Dışardaki döngü 5 kere dönecektir, ve her dönüşte üçgenin bir satırı yazılacaktır. Birinci dönüşte tek yıldızlı birinci satır, ikinci dönüşte iki yıldızlı ikinci satır olmak üzere satırlar basılır. Döngünün içinde i değişkeninin değeri satır numarasını gösterecektir. Dış döngünün gövdesi diğer döngüyü ve printf işlevini çağıran  ifadeyi içeren bir öbek ifadedir (başlangıç ve bitişi kırmızı renkle gösterilmiştir). İç döngü ise 1 den i değerine kadar gövdesini tekrarlar. Bu yüzden iç döngünün gövdesi ilk satırda bir kere, ikinci satırda iki kere tekrarlanarak çalışacaktır. İç döngünün gövdesinde çağırdığımız printf işlevi  bir * karakteri yazar. Dış döngünün gövdesinde çağırdığımız printf işlevi bir sonraki satıra geçmemizi sağlar.

 

4.5.  Örnek Programlar
 

Örnek 1.

İlk örnek program ekranda bir merdiven çizer. Bu işlemi yaparken, for ifadesi kullanarak yaratılmış sayaç kontrollü iç-içe döngüler kullanır.

Merdiven.cpp


/*  
 * Bu program asagi dogru bir merdiven cizer.
 * Basamak sayisi programin girdisi olarak okunur.
 */

#include

#define MAXBASAMAK 7    /* en fazla basamak miktari */

int
main()
{
   int  basamak_sayisi = 0;     /* basamak sayisi */
   int i,j,k,x,y;

   /* basamak sayisini oku */
   do {
      printf("Basamak sayisini girin > ");
      scanf("%d", &basamak_sayisi);
      if (basamak_sayisi > MAXBASAMAK) {
        printf("En fazla %d basamak cizilebilir n", MAXBASAMAK);
        basamak_sayisi = MAXBASAMAK;}
      else if (basamak_sayisi <= 0)
        printf("Sifirdan buyuk bir sayi girmeniz gerekiyordu. n");
   } while (basamak_sayisi <= 0);

   x=0;
   y=5;

   /* basmak sayisi kadar basamaklari ciz */
   for (i=1; i <= basamak_sayisi; ++i) {
      for (k=1; k<=x; ++k)
        printf(" ");
      x += 5;
      printf("******n");
      for (j=1; j<=2; ++j){
         for (k=1; k<=y; ++k)
            printf(" ");
         printf("* n");
      }
      y += 5;
   }
   return (0);
}
 



Örnek 2.

İkinci örnek program ekranda çarpım tablosunu yazar. Bu işlemi yaparken iç-içe döngüler kullanır.

CarpimTablosu.cpp


/*
 * Carpim tablosunu bastir
 */
#include

#define MAXROW  15     /* maximum sira */
#define MAXCOL  10     /* maximum kolon */
#define CIZGI_UZUNLUGU MAXCOL*5+5

int
main()
{
   int row,col;  /* sira ve kolon sayaci */

   /* Basligi yazdir */
   printf("nnn%35sn", "CARPIM TABLOSU");

   /* Kolon basliklarini yazdir */
   printf("     ");
   for (col=1; col <= MAXCOL; ++col)
      printf("%5d", col);
   printf("n");

   /* Kolon basliklarinin altina cizgi cek */
   for (col=1; col <= CIZGI_UZUNLUGU; ++col)
      printf("-");
   printf("n");

   /* Carpim tablosundaki degerleri satir basliklariyla beraber yazdir */
   for (row=1; row<=MAXROW; ++row) {
      printf("%2d | ", row);
      for (col=1; col<=MAXCOL; ++col)
         printf("%5d", row*col);
      printf("n");
   }
   return(0);
}


 






ibrahim sarıkaya
Yorum c++
hocam bizim okuldaki c++ türkçe neden c++ 'ın ingilizcesini gönderdiniz
07 Mart 2010 Pazar 12:01
Hüseyin Burak GELGÖR
Yorum Tesekkürler
çok sagolun hocam elinize saglık
02 Mart 2010 Salı 04:12
Yazılım & Tasarım : Mahmut ÖZDEMİR | Destek : Gökhan DOKUYUCU
Copyright © 2009 - Gökhan Dokuyucu. Sitemizdeki resim ve yazıların her hakkı saklıdır