YILDIZ TEKNİK ÜNİVERSİTESİ
BİLGİSAYAR ve ÖĞRETİM TEKNOLOJİLERİ EĞİTİMİ BÖLÜMÜ
DERS: PROGRAMLAMA DİLLERİ – 1DERSİ VEREN: Öğr. Gör. Filiz Eyüboğlu SINIF: 2
DÖNEM: 1
TÜM DERS NOTLARI: www.bto.yildiz.edu.tr, ders notları linkinde. Bu notlar aşağıdaki 1.no.lu kaynaktan yararlanılarak hazırlanmıştır.
DİĞER KAYNAKLAR:
1. Deitel & Deitel. (2000). C++ How To Program. Third Edition. New Jersey: Prentice Hall 2. http://www.bups.bilkent.edu.tr/ibcomp/cpp/cpp.html
KONU 1: BİLGİSAYARLAR ve C++ İLE PROGRAMLAMAYA GİRİŞ HEDEFLER:
1- Programlama dillerinin evrimi bakımından dil sınıflarını öğrenme 2- Tipik bir C++ program geliştirme ortamını anlama
3- C++ ile basit programlar yazabilme 4- Basit G/Ç cümleleri yazabilme 5- Temel veri türlerini tanıma
6- Aritmetik operatörleri kullanabilme
7- Aritmetik operatörlerin önceliklerini anlama 8- Basit karar verme cümleleri yazabilme İÇERİK:
Giriş:
Bilgisayar nedir?
İşletim sistemlerinin evrimi
Kişisel, Dağıtık ve İstemci/Sunucu Ortamlar
Dil çeşitleri: Makine dili, “assembly” dili ve yüksek seviyeli diller C ve C++’nın tarihçesi
Yapısal programlama
Nesne teknolojisi: Yazılımda yeni eğilim C++ programı yürütmenin aşamaları C++ ile programlamaya giriş
Basit bir program: bir satır yazma
Diğer bir basit program: 2 tamsayının toplanması Bellek kavramları
Aritmetik
Karar verme: Eşitlik operatörleri ve ilişkisel operatörler
GİRİŞ
BİLGİSAYAR NEDİR?: Bilgisayar, insanın yapabileceğinden milyonlarca hatta milyarlarca kat hızlı hesaplama yapan ve/ya mantıksal kararlar verilebilen bir alettir. Süper bilgisayarlar saniyede yüz milyarlarca toplama yapabilirler ki bu bir insanın basit bir hesap makinesiyle onlarca yılda yapabileceği işlem miktarıdır.
Bilgisayarlar, bilgisayar programı denen komut setlerinin kontrolu altında verileri işlerler.
Bilgisayarda çalışan bilgisayar programlarına yazılım denir. Bunları geliştiren, yazan kişilere de bilgisayar programcısı denir.
Bilgisayar 6 mantıksal bölümden oluşur:
1- Giriş birimi 2- Çıkış birimi 3- Bellek
4- Aritmetik mantık birimi Merkezi işlem birimi 5- Kontrol birimi
6- İkincil bellek
İŞLETİM SİSTEMLERİNİN EVRİMİ
İlk bilgisayarlar bir anda bir iş yapabiliyorlardı. Delikli kartlarla yazılan programlar, kart okuyucudan bilgisayara okutularak sırayla (bir anda bir iş) çalıştırıldı. Bir anda bir işin çalıştığı bu ortamda bilgisayarın tüm kaynakları verimli biçimde kullanılmamış olmaktadır.
MİB çalışırken giriş ve çıkış birimleri boş beklemektedir. Daha verimli kaynak kullanımı için giderek “çoklu programlama” ya izin veren işletim sistemleri geliştirilmiştir. Bu ortamlarda bir anda birden fazla iş çalışır, ancak hala kullanıcılar programlarını kartlara delerek bilgisayara girmektedir.
1960’larda “timesharing” işletim sistemleri geliştirilmiştir. Timesharing bir ortamda kullanıcılar bilgisayara, terminaller (bir ekran ve klavye) aracılığıyla erişirler. Böylelikle onlarca hatta yüzlerce kişi aynı anda tek bir bilgisayara erişebilmekte ve kullanmaktadır.
KİŞİSEL, DAĞITIK ve İSTEMCİ/SUNUCU İŞLEM
1977’de Apple şirketi kişisel bilgisayarları popülerleştirdi. İlk başta hobisel bir yaklaşım olan kişisel bilgisayar kullanımı 1981’de IBM’in Personal Computer’ı tanıtmasıyla sadece evlerde değil iş yaşamında da çok yoğun biçimde kullanılmaya başladı.
Fakat bu bilgisayarlar tek başına birimlerdi. Bilgisayardaki veriyi paylaşabilmek için başka bir bilgisayara taşınabilir disklerle taşımak gerekiyordu. Tek başına, bağımsız üniteler halinde bulunan bilgisayarların LAN veya büyük ağlar aracılığıyla birbirine bağlanmasıyla dağıtık işlem (“distributed processing”) başladı. Bugün artık büyük miktarlarda veri, bilgisayar ağlarında yer alan File Server denen ve ortak kullanılacak program ve verileri saklayan bilgisayarlar aracılığıyla istemci bilgisayarlar tarafından kullanılabilmektedir (istemci/sunucu ortam).
C ve C++ günümüzde, bu ortamları (bilgisayar ağları, dağıtık istemci/sunucu ortamlar, bunları destekleyen işletim sistemleri) yazmakta yaygın olarak kullanılan dillerdir.
PROGRAMLAMA DİLLERİ
Programlamanın evrimi bakımında 4 sınıftan bahsedebiliriz:
1- Makine dilleri (1.kuşak): sayılardan oluşan, sadece belirli bir makinenin anlayacağı , hata yapmaya çok açık diller
2- Assembly dilleri (2.kuşak): İngilizce benzeri komutlardan oluşan diller. Assembly dili ile yazılmış bir program, bir çevirici (translator) ile makine diline çevrilerek çalıştırılır.
Oldukça anlaşılabilir gözükmesine karşın çok basit bir iş için bile çok sayıda komut yazmak gerekmektedir.
3- Yüksek seviyeli diller (3.kuşak) - “procedural” diller. “NASIL” yapılacağını ayrıntılı olarak bildirdiğimiz diller. İngilizceye benzer, aritmetik işlemlerde kullandığımız işaretleri kullanır, daha hızlı ve kolay program yazılır. C ve C++ bu gruptadır. Çok sayıda dil geliştirilmiştir. Yaygın kabul görenler:
Fortran IBM 1954 Mühendislik uygulamalarında hala yaygın olarak kullanılır.
Cobol 1959 Günümüz ticari uygulamalarının yarısı Cobol ile yazılmıştır.
Pascal Niklaus Wirth 1971 Akademik kullanım için
4- Çok yüksek seviyeli diller (4.kuşak): “NE” yapılacağını söyledğimiz diller: LISP, SNOBOL, FORTH, SQL...
C ve C++’nin TARİHÇESİ BCPL 1967 Martin Richards
B 1970 Ken Thompson Bell Laboratuarları C 1972 Dennis Ritchie Bell “
UNIX işletim sisteminin yazılmasında kullanıldı. Makineden bağımsız bir dil.
C++ 1980 Bjarne Stroustrup AT&T
1983 – 1989 ANSI C’nin standart tanımını yaptı, 1990’da yayımlandı: ANSI/ISO 9899:1990 C++, C’ye birtakım ek özellikler ile nesne-yönelimli programlama (“object-oriented programming”) yetenekleri getirmiştir. Nesneler tekrar tekrar kullanılabilir yazılım bileşenleridir; yazılım geliştirmede büyük kolaylık (verimlilik) sağlarlar.
Diğer nesne-yönelimli diller:
Smalltalk Xerox’s Palo Alto Araştırma Merkezi
Java Sun Microsystems-James Goslin 995 (1993 WWW popülerliği)
C++ STANDART KİTAPLIK
C++ programları sınıflar (“classes”) ve fonksiyonlardan (“functions”) oluşur. Bunlar program parçalarıdır. Bunların bir kısmını programcı yazar, bir kısmı da standart kitaplıkta hazır bulunur.
YAPISAL PROGRAMLAMA
1960’lara kadar programlama çok karmaşık, zor, maliyetli...
1960’larda yapısal programlama ortaya çıkmaya başladı. Yapısal programlama, daha açık, net, anlaşılabilir, okuması, izlemesi, sınaması kolay programlar yazmak için bir yaklaşımdır.
3 temel yapı kullanılır: sıra, tekrar yapısı ve karar verme yapısı. Goto kullanılmaz ya da mümkün olduğunca az kullanılır. Buna uygun ilk dillerden biri (ve en popüleri diyebiliriz) Pascal (Niklaus Wirth,1971). Akademik ortamlarda yapısal programlamayı öğretmek için geliştirildi. Pek çok okulda yaygın olarak kullanıldı. Ancak, ticari uygulamalarda ve her türlü iş ortamına uygun uygulamalarda gereksinilen pek çok olanağı içermemesi, üniversite dışında yaygın kabul görmemesine neden olmuştur.
Ada – 1970’ler – 1980’lerin başı - US Dept. Of Defense ANAHTAR YAZILIM TRENDİ: NESNE TEKNOLOJİSİ
Yazılım teknolojisindeki gelişme ve ilerlemeler; yapısal programlama, yapısal tasarım, yapısal analiz ile başladı. Ancak nesne yönelimli analiz, tasarım ve programlama ile daha çok gelişme elde edildi. Nesne yönelimli ile çevremizdeki tüm nesneleri (araba, öğrenci, ders, insan, uçak, sınıf vb) modelleriz. Modellediğimiz bu yazılım parçalarını tekrar tekrar kullanabildiğimiz gibi, bu tarz yazılan yazılımlar, daha iyi organize ve anlaşılır oldukları için bakımları da çok kolay olmakta ve programcıya zaman ve maliyetten büyük tasarruf sağlamaktadır (Yazılım maliyetinin %80’i programlamanın başında ve yazımındaki emeğe değil sonradan yapılan sürekli bakıma aittir).
C++, nesne yönelimli bir dil olarak anılmasına karşın hibrid bir dildir. Yani hem yapısal hem de nesne yönelimli program yazmayı mümkün kılar
Classes and Data Abstraction konusuna kadar C++ ile “procedural” programlama kavramlarını göreceğiz: kontrol yapıları, fonksiyonlar, veri türleri, giriş/çıkış, diziler, pointer ve stringler. Bu bölümlerde C++’ın C kısmı, C++ procedural enhancements to C kapsanacaktır.
C++ PROGRAMI YÜRÜTME AŞAMALARI
Unix ortamında bir C++ programının yürütülmesi için 6 aşamadan geçilir:
1- Edit : kaynak programın bir editör program ile yazılması. Uzantısı .cpp, .cxx veya .c 2- Ön işleme (“preprocess”): derleme öncesi bazı işlemler
3- Derleme: derlemenin çıktısı: amaç program
4- Link: programımızda kullanacağımızı belirttiğimiz standart kitaplık veya özel kitaplıklarda bulunan fonksiyonların amaç programla bir araya getirilmesi (link edilmesi) 5- Yükleme (“load”) – programın ve varsa gerekli bazı modüllerin (paylaşılan kitaplıklardan)
diskten alınıp belleğe yüklenmesi 6- Yürütme
Şema: s. 15 (Deitel)
TAŞINABİLİRLİK (“portability”)
Taşınabilir programlar yazmak mümkünse de değişik sistemler ve değişik derleyiciler arasında birtakım problemler çıkmaktadır. Taşınabilirlikle ilgili konular ANSI C Standart dokümanında yer almaktadır: www.ansi.org Doküman adı: Information Technology – Programming languages – C++. Doküman numarası: ISO/IEC 14882-1998.
Daha eski taslak versiyonu (ücretsiz): www.cygnus.com/misc/wp/
İYİ PROGRAM YAZMA TAVSİYELERİ:
C++ programlarınızı basit ve straightforward biçimde yazın: KIS (“Keep It Simple”).
Kullandığınız C++ sürümünün kılavuzu elinizin altında olmalı.
En iyi öğretici bilgisayarınızdır. Kitaplarda veya derslerde işlenen konuları, verilen örnekleri, bilgisayarda çalıştırarak, çıkan hata mesajlarını okuyup, tekrar deneyerek öğrenebilir ve tecrübe kazanabilirsiniz.
C++ İLE PROGRAMLAMAYA GİRİŞ
BASİT BİR PROGRAM: BİR SATIR METNİN YAZDIRILMASI
// C++ ile ilk programım
#include <iostream>
int main()
{ std::cout << “Herkese Merhaba!\n”;
return 0; // program sonu }
Herkese Merhaba!
// C++’de açıklama satırının başına konur. Bu satırlar için derleyici bir iş yapmaz; bu satırlar program dökümünde aynen yer alan; programın okunabilirliği, anlaşılabilirliği için gerekli açıklama satırlarıdır. İyi bir programcı gerekli yerlere gerekli açıklamaları koyar.
C dilinde ise açıklama /* */ arasına konur.
# ile başlayan satırlar ön derleyici (“preprocessor”) içindir. Örnek programımızda # ile başlayan satır ön derleyiciye giriş/çıkış ile ilgili iostream başlık dosyasını (“header file”) programa dahil etmesini söyler.
int main () her C++ programında olması gerekir.
Her C++ programı bir veya birkaç fonksiyondan oluşur. ()’ler main’in bir fonksiyon olduğunu; “main” sözcüğü de bunun ana fonksiyon olduğunu belirtmektedir.
int integer (tamsayı) anlamında.
int main ()’in anlamı: bu ana fonksiyonun çalıştıktan sonra verdiği değer, bir tamsayıdır.
(return 0 ile dönen sıfır )
Bir fonksiyonun gövdesi (“body”) köşeli sol parantez ile { başlar, köşeli sağ parantez ile } biter.
std::cout ekrana çıkış almak için. İlerki bölümlerde daha ayrıntılı göreceğiz.
std::cin klavyeden girileni okumak için
<< “stream insertion operator”
\n karakterlerinin çıktıda yer almadığına dikkat edin!
\ “escape” karakteri
n imlecin alt satıra konumlanmasını söyler.
\n yeni satır
\t bir “tab” ileri gitmek için
\r imleç yeni yazılan sol başına konumlanır (“carriage return”)
\a uyarı sesi
Herkese Merhaba! cümlesini başka nasıl yazdırabilirdik?
std::cout << “Herkese “;
std::cout << “Merhaba!\n”;
ŞÖYLE YAZARSAM ÇIKTI NASIL OLUR???
std::cout <<”Herkes\ne\nMerhaba!\n”;
Herkes e
Merhaba!
BAŞKA BİR BASİT PROGRAM: iki tamsayının toplanması // İKİ TAMSAYIYI TOPLAYAN PROGRAM
#include <iostream>
int main() {
int tamsayi1, tamsayi2, toplam; //tanımlamalar std::cout << “Birinci tamsayıyı giriniz\n”;
std::cin >> tamsayi1; //klavyeden girilen sayıyı oku
std::cout << “İkinci tamsayıyı giriniz\n”;
std::cin >> tamsayi2; // klavyeden girilen sayıyı oku toplam = tamsayi1 + tamsayi2;
std::cout << “Toplam = “ << toplam << std::endl;
return 0; // programın başarıyla bittiğini gösterir }
std::endl =Î endl “end line” yani satır sonu demektir. Yaptığı iş, yeni satırı yazdıktan (ekrana yolladıktan sonra) çıkış buffer’larını temizlemektir. Bilindiği gibi, çıkışa gönderilecek veriler, gönderilmeden önce çıkış buffer’larında biriktirilir. Çıkış işleminden sonra buffer’ların boşaltılması/temizlenmesi için endl kullanırız.
ÖNEMLİ NOTLAR:
C++, büyük ve küçük harfe duyarlı bir dildir.
Cümleler ; (noktalı virgül) ile biter.
İYİ PROGRAM YAZMA TAVSİYELERİ:
1- Bir fonksiyonun gövdesinin içine yazılan satırlar 3 boşluk içerden yazılır (“indentation”)
2- Tanımlamalar ile yürütülebilir cümleler arasında bir satır boşluk bırakınız.
3- Anlamlı değişken isimleri kullanınız.
4- İkili (“binary”) operatörlerin sağ ve solunda birer boşluk bırakınız.
ARİTMETİK OPERATÖRLER
C++ işlemi Aritmetik operatör Cebirsel ifade C++ ifadesi
Toplama + f+7 f + 7
Çıkarma - p-c p – c
Çarpma * bm b * m
Bölme / x/y x / y
Modulus % r mod s r % s
C++’da aritmetik işlemlerde operatörlerin öncelik sırası kuralları:
1- Parantez içleri en önce hesaplanır.
2- Daha sonra, çarpma, bölme, modulus işlemleri yapılır. Bir aritmetik ifadede birden fazla çarpma, bölme, modulus işlemi varsa, bu işlemlerdeki operatörler SOLDAN SAĞA doğru uygulanır. Çarpma, bölme, mod operatörlerinin önceliği aynıdır.
3- En son toplam ve çıkarma işlemleri yapılır. Bir ifade, birden fazla toplama ve çıkarma işlemi içeriyorsa, bunlara ait operatörler SOLDAN SAĞA uygulanır.
ÖRNEKLER: ss. 31 – 33 (Deitel)
İYİ PROGRAM YAZMA TAVSİYELERİ:
Cebirde olduğu gibi, gereksiz parantezler konmayabilir. Ancak, özellikle uzun ifadelerde alt ifadeleri parantez içlerin alarak anlaşılabilirliği artırmak iyidir.
İLİŞKİSEL OPERATÖRLER ve EŞİTLİK OPERATÖRLERİ
İlişkisel operatörler C++ karşılığı C++ örneği Anlamı
> > x > y x, y’den büyüktür
< < x < y x, y’den küçüktür
>= x >= y x, y’den büyüktür veya y’ye eşittir
<= x <= y x, y’den küçüktür veya y’ye eşittir.
Eşitlik operatörleri
= == x ==y x, y’ye eşittir
!= x != y x, y’ye eşit değildir
SIK YAPILAN HATALAR:
==, >=, <=, != operatörlerini yazarken iki karakter arasında boşluk bırakılmamalıdır veya iki karakterin yeri değiştirilmemelidir.
Eşitlik operatörü ==’ yi, atama için kullanılan = ile karıştırmayınız.
EŞİTLİK VE BAĞINTI OPERATÖRLERİNİ KULLANAN BİR PROGRAM ÖRNEĞİ
// if cümlesi ile eşitlik ve ilişki/bağıntı operatörlerini kullanan bir program
#include <iostream>
using std::cout; // program cout kullanır using std::cin; // program cin kullanır using std::endl; // program endl kullanır.
int main () {
int sayi1, sayi2;
cout << “İki tamsayi giriniz.\n”
<< “Ben aralarındaki ilişkiyi söyleyeceğim: “;
cin >> sayi1 >> sayi2;
if (sayi1 == sayi2)
cout << sayi1 << sayi2 << “’ye eşittir.” << endl;
if (sayi1 != sayi2)
cout << sayi1 << sayi2 << “’ye eşit değildir.” << endl;
if (sayi1 < sayi2)
cout << sayi1 << “, “ << sayi2 << “’den küçüktür.” << endl;
if (sayi1 > sayi2)
cout << sayi1 << “, “ << sayi2 << “’den büyüktür.” << endl;
if (sayi1 <= sayi2)
cout << sayi1 << “, “ << sayi2 << “’den küçük veya eşittir.” <<
endl;
if (sayi1 >= sayi2)
cout << sayi1 << “, “ << sayi2 << “’den büyük veya eşittir.” <<
endl;
return 0;
}
İki tamsayı giriniz.
Ben size aralarındaki ilişkiyi söyleyeceğim: 3 7 3, 7’ye eşit değildir.
3, 7’den küçüktür.
3, 7’den küçük veya eşittir.
İki tamsayı giriniz.
Ben size aralarındaki ilişkiyi söyleyeceğim: 22 12 22, 12’ye eşit değildir.
22, 12’den büyüktür.
22, 12’den büyük veya eşittir.
İki tamsayı giriniz.
Ben size aralarındaki ilişkiyi söyleyeceğim: 7 7 7, 7’ye eşittir.
7, 7’den küçük veya eşittir.
7, 7’den büyük veya eşittir.
using cümleleri: cout ve cin’den önce std:: kullanımını ortadan kaldırır. Hatırlanacağı gibi ilk basit örneğimizde std::cout kullanmıştık. Çok sayıda giriş / çıkış yapılacağı zaman her cout ve cin’den önce std:: kullanmak çok pratik olmayacaktır. Bu nedenle using kullanmakta fayda vardır.
İYİ PROGRAM YAZMA TAVSİYELERİ:
1- Programın okunabilirliğini artırmak için if yapısının içinde yer alan cümleleri 3 boşluk içerden yazınız.
2- Bir satırda birden fazla cümle yer almamalı.
3- Bir cümle bir satıra sığmayıp alt satırdan devam edecekse, cümleyi anlamlı bir yerinden bölmeye özen gösteriniz.
*** Konu 1’in sonu ***
YILDIZ TEKNİK ÜNİVERSİTESİ
BİLGİSAYAR ve ÖĞRETİM TEKNOLOJİLERİ EĞİTİMİ BÖLÜMÜ
DERS: PROGRAMLAMA DİLLERİ – 1
DERSİ VEREN: Öğr. Gör. Filiz Eyüboğlu SINIF: 2
DÖNEM: 2002-2003 güz dönemi
TÜM DERS NOTLARI: www.bto.yildiz.edu.tr, ders notları linkinde. Bu notlar aşağıdaki 1.no.lu kaynaktan yararlanılarak hazırlanmıştır.
DİĞER KAYNAKLAR:
3. Deitel & Deitel. (2000). C++ How To Program. Third Edition. New Jersey: Prentice Hall 4. http://www.bups.bilkent.edu.tr/ibcomp/cpp/cpp.html
KONU 2: KONTROL YAPILARI HEDEFLER:
9- Yukarıdan aşağı (“top-down”) algoritma geliştirebilme 10- Yapısal programlamayı anlama
11- Seçim yapma yapılarını (if, if/else, switch) kullanabilme 12- Tekrar etme yapılarını (while, do/while, for) kullanabilme 13- Sayaç kontrollu tekrarı anlama
14- Mantıksal işlem, atama operatörleri, artırma ve eksiltmeyi kullanabilme 15- Program kontrol cümlelerini (break, continue) kullanabilme
İÇERİK:
Algoritmalar
“Pseudocode”
Kontrol yapıları: if, if/else, while
“Yukarıdan-aşağı” yaklaşımla algoritma tasarlama Atama operatörleri
Tekrar için sayaç-kontrollu yapı: for Çoklu-seçme yapısı: multiple
Tekrar yapısı: do/while Break ve continue cümleleri Mantıksal operatörler
GİRİŞ
Bir problemi çözecek programı yazmaya başlamadan önce, problemi tam olarak anlamak ve çözüm için dikkatlice planlama yapmak gerekir. Daha sonra program yazamaya başlanabilir.
Programı yazarken de – planlama kadar önemli bir konu - dilin sunduğu yapı bloklarını ve program yapılandırma ilkelerini çok iyi bilmektir. Bu konumuzda, yapısal programlama yaklaşımını, C++’nin bu konuda sağladığı yapıları kullanarak öğreneceğiz.
ALGORİTMA
Algoritma, bir problemi çözmek için - yürütülecek eylemlerin, ve - bu eylemlerin sırasını belirten bir talimattır, prosedürdür .
Bir bilgisayar programında yürütülecek cümlelerin sırasını belirlemeye program denetimi (“program kontrol”) denir. Bu derste, C++’ın program denetimiyle ilgili yeteneklerini göreceğiz.
PSEUDOCODE
Pseudocode, algoritma geliştirmede programcılara yardımcı olan dildir; günlük konuşma dilimizde kullandığımız sözcüklerden oluşur. Bu dille yazılan program bilgisayarda yürütülemez; ancak programcıya geliştirmeye çalıştığı algoritma üzerinde düşünmesini, onu şekillendirmesini, oluşturmasına yarar. İyi yazılmış bir pseudocode’u gerçek bir programlama diline çevirmek kolay olur.
Pseudcode ile sadece yürütülecek cümleleri yazarız. int x gibi tanımlamaları yazmayız.
Tanımlamalar (“declarations”) yürütülebilir cümleler değildir. int x dediğimiz zaman bilgisayar x için bir yer ayırır.
Bazı programcılar, pseudocode’un baş kısmında, kullanacakları değişkenlerin ad ve amaçlarını listelemeyi tercih ederler.
KONTROL YAPILARI
Normalde, bir programdaki cümleler yazıldıkları sırayla, biri diğerinin ardından yürütülürler.
Buna sıralı yürütme (“sequential execution”) denir.
Sıralı yürütmeye basit bir örnek ver, akış şeması ile. s.62
Yürütmek istediğimiz cümle, sıradaki cümle değil de, programın daha ilerisinde veya baş tarafında olabilir. Yürütmenin bir sonraki cümleye değil de programın başka bir yerindeki cümleye yönlendirilmesine kontrolun transferi denir. 1960’larda kontrolun transferi için çokça kullanılan goto cümlesi yazılım geliştirenlerin işini zorlaştırmıştır. Goto’nun fazlaca kullanıldığı bir programı yazmak, takip etmek, anlamak zordur. Yapısal programlama dediğimiz kavramla goto’lar mümkün olduğunca ya da tümden yok edilirler. Bohm ve Jacopini bir programın goto’suz, üç tür yapı - sıralı, seçme, tekrar yapıları – kullanılarak yazılabileceğini göstermiştir. 1970’lerde yapısal programlamadan çok ciddi biçimde söz edilmeye ve kullanılmaya başlanmıştır. Bu yaklaşım yazılım geliştirme zamanını azaltmıştır.
Bildiğiniz gibi, akış şeması bir algoritmanın ya da algoritma parçasının görsel ifadesidir.
Pseudocode gibi akış şeması da algoritma geliştirmede kullanışlıdır.
Akış şeması sembolleri geçen dönem EBT2’de öğrenildi.
if SEÇME YAPISI ( “if selection structure”)
Seçme yapısı, çeşitli eylem seçeneklerinden birini seçmek için kullanılır. Örneğin,
“öğrencinin notu 60’dan fazla ise, ‘geçti’ yaz “ demek istiyorsak...Bunu ifade edebilmek için, öğrenci notunun 60’dan büyük eşit olup olmadığını sınamamız gerekir. Sınama yaptığımızda
koşul doğru ise “geç” yazdırırız, koşul yanlış ise hiçbir şey yaptırmadan sıradaki cümle ile yürütme devam eder. Bunu C++ ile şöyle ifade ederiz:
if (not >= 60)
cout << “geçti”;
((((( BU İFADEYİ AKIŞ ŞEMASI İLE GÖSTER ))))) s.64 şekil. 2.3 SIK YAPILAN HATALAR:
C++ anahtar kelimelerini değişken veya fonksiyon adı olarak kullanmak. Anahtar sözcükler aşağıda verilmiştir.
C ve C++’da ortak olan anahtar kelimeler: s.63
auto break case char const continue default do double
else enum extern float for goto if int
long register return
Short signed sizeof static struct switch typedef union unsigned void volatile while
Sadece C++’da geçerli olan anahtar sözcükler:
asm bool catch class const_cast delete
dynamic_cast explicit false friend inline mutable namespace
new operator private
protected pubic reinterpret_cast static_cast template this
throw true try typeid typename using
virtual wchar_t
İYİ PROGRAM YAZMA TAVSİYELERİ:
if cümlesinde koşulun doğruluğuna göre yapılacak eylemi (if’in gövdesine yazılacak cümleleri) bir sonraki satırdan ¼ inç veya 3 boşluk içeriden yazınız.
if/else SEÇME YAPISI ( “if/else selection structures”)
if/else yapısı, koşulun doğruluğuna veya yanlışlığına göre değişik işlemler yaptırmak için kullanılır.
if (not >= 60)
cout << “geçti”;
else
cout << “kaldı”;
((((( BU İFADEYİ AKIŞ ŞEMASI İLE GÖSTER )))))
Yukarıdaki if/else örneğini C++’da, ?: koşul operatörü kullanarak şöyle de yazabiliriz.
cout << (not >= 60 ? “geçti” : “kaldı” );
Birden fazla durumu sınamak için içiçe if/else cümleleri kullanılır.
if (grade >= 90) cout <<”A”;
else
if (grade >= 80)
cout << “B”;
else
if (grade >= 70)
cout << “C”;
else
if (grade >= 60)
cout << “D”;
else
cout << “F”;
Aynı kod şöyle de yazılabilir (çok fazla sağa doğru uzamayı engellemek için):
if (grade >= 90) cout << “A”;
else if (grade >= 80) cout << “B”;
else if (grade >= 70) cout << “C”;
else if (grade >= 60) cout << “D”;
else
cout << “F”;
PERFORMANS İLE İLGİLİ İPUCU:
İçiçe if/else yapısı, bir seri tek seçim yapan if cümlelerinden daha hızlı çalışır.
if yapısında gövdeye tek bir cümle koymayı gördük. Birden fazla sayıda cümle koyacaksak bunlar { } parantezlerinin arasına alınır ve bu tarz parentezler arasında bulunan cümleler topluluğuna Bileşik Cümle (“compound statement”) denir.
Örnek:
if (not >= 60)
cout << “geçti.\n”;
else {
cout << “kaldı.\n;
cout << “Bu dersi tekrar almak zorundasınız.\n;
}
SIK YAPILAN HATALAR
- if cümlesinde, koşuldan sonra ; (noktalı virgül) koymak
- if, if/else gövdesinde parantezi kapamayı unutmak, veya yanlış yerde kapatmak while
TEKRAR YAPISI (while repetition structure)
Tekrar yapısı, programcının bir eylemi belirli bir koşul doğru olduğu müddetçe tekrar etmesini sağlar.
Alış veriş listesinde daha mal olduğu müddetçe
Bir sonraki malı al, sonra üzerini çiz gibi.
Örnek bir program: 2’nin 1000’den büyük yapan ilk üssünü bulunuz.
carpim isimli degişkene 2 sayısını atamış olalım.
int carpim = 2;
Aşağıdaki w h i l e yapısı bittiğinde, carpim degiskeni istenen cevabı içerecektir.
while (carpim <= 1000) carpim = 2 * carpim;
Carpim, ilk giriste 2, daha sonra 4,8,16,32,64,128, 256, 512, 1024 değerlerini alır.
1024 > 1000 oldugunda while’ın yürütülmesi durur.
ALGORİTMA GELİŞTİRME
ÇALIŞMA-1: (sayaç kontrollu tekrar kullanarak)
On öğrencilik bir sınıf sınava girdi. Aldıkları notlar size verildi. Sınıfın ortalamasını bulacak algoritmayı geliştirip, daha sonra C++ ile yazınız.
Ortalama ne demek? 10 notu toplayıp, 10’a böleceğiz.
10 not okumamız gerektiği için s a y a ç kullanarak okuma işlemini tekrar etmemiz gerekir.
Sayaç, 10’u geçtiği anda tekrar işlemi bitmeli.
Okuduğumuz notları üstüste toplayacağımız bir değişkenimiz olmalı. Buna t o p l a m diyelim.
toplam = 0 sayac = 1
while s a y a c ondan küçük eşit olduğu müddetçe
bir sonraki notu oku bu notu t o p l a m‘ a ekle s a y a c’ ı bir artır
t o p l a m’ ı ona bölerek o r t a l a m a’yı hesapla o r t a l a m a ‘yı yazdır.
// sayac kontrollu tekrar ile sınıf ortalamasını bulan program
#include <iostream>
using std::cout using std::cin;
using std::endl;
int main() {
int toplam, // notların toplamı
sayac, // girilen notların sayısı
not // bir not
ortalama; // notların ortalaması
// ilk değerlerin atanması toplam = 0;
sayac = 1;
while (sayaca <= 10) {
cout << “notu giriniz: “;// bir notun girilmesini iste
cin >> not; // girilen değeri not değişkenine al
toplam = toplam + not; // notu toplama ekle sayac = sayac + 1; // sayacı artır }
ortalama = toplam / 10;
cout << “Sınıf ortalaması = “ << ortalama << endl;
return 0;
}
SIK YAPILAN HATALAR
- Toplam, sayac gibi değişkenlere ilk değer atamalarını unutmayınız. Unutursanız değişkenin içinde hangi sayı olduğunu bilemezsiniz ve program beklenenden farklı değerler üretir.
İlk değer atamalarını unutmak, yazım (“syntax”) hatası vermez, ancak programınız istenen sonucu vermediği için mantık hatası oluşmuş olur.
- Sayaç kontrollu döngüde, döngüden çıkıldığında (while’dan çıkıldığında) sayacın değeri saydığımızdan / istediğimizden 1 fazla olacaktır (örneğimizde döngüden çıkıldığında sayac 11’dir. Öğrenci sayısı ondur). Dolayısıyla hesaplamalarda s a y a c değişkenini kullanırsak hesap hatası oluşur.
İYİ PROGRAM YAZMA TAVSİYESİ
Her bir değişkeni ayrı bir satırda tanımlayınız.
ÇALIŞMA-2 Yukarıdan aşağı yaklaşımla (“top-down”) algoritma geliştirme (işaret kontrollu tekrar ile - “flag controlled repetition”)
Sınıf ortalaması problemini genelleştirelim.: herhangi bir sayıda notu okuyup ortalama alacak bir algoritma geliştiriniz.
Herhangi bir sayıda giriş yapılacağına göre girişlerin bittiğini nasıl anlayacağız? Bunun bir yolu, “sentinel” veya “flag” veya “dummy” değer denen özel bir değer ile girişlerin sonunu belirtmektir. Bu değer, giriş verileri ile karışmayacak bir değer olmalıdır. Giriş verileri arasında yer alan bir flag değeri seçmek mantık hatasıdır. Sorumuzda, öğrenci notları girileceğinden ve notlar negatif olmayacağından, negatif bir sayıyı örneğin -1’i kullanabiliriz. Buna göre, girilen sayılar 75, 82, 67, 30, 25, -1 şeklinde olacaktır. –1 giriş sonunu belirtir ve hesaplamalara karışmaması gerekir.
Sınıf ortalaması problemini yukarıdan-aşağı yaklaşımla ele alacak olursak:
Yapacağımız işte temel aşamalar nelerdir?
1- İlk değer atamalarını yap 2- Oku; topla, sayacı artır 3- Ortalamayı al, yazdır.
1. aşamayı ele alıp detaylandıracak olursak:
toplam’a sıfır ata sayac’a bir ata
2. aşama bir tekrar yapısı / döngü gerektirir. Kaç not okuyacağımızı bilmediğimiz için flag kontrollu bir yapı kurmamız gerekir. Notu okuyup, okur okumaz bu özel değeri içerip içermediğini test etmeliyiz. Buna göre 2.aşama şöyle detaylandırılır:
ilk değeri oku
okunan değer f l a g değerinden farklı olduğu müddetçe notu toplama ekle
sayacı bir artır bir sonraki notu oku
3. aşama için de şunları yazabiliriz:
sayac sıfır değilse
toplamı sayaca bölerek ortalamayı hesapla ortalamayı yazdır
değilse (else)
“herhangi bir not girilmedi” yazdır.
ÖNEMLİ NOT: Bölme işlemlerine dikat!!! “Divide by zero is a fatal logic error”.
// Örnek: Deitel s. 77’de, fig.2.9
// flag kontrollu olarak yazılmış sınıf ortalaması programı
#include <iostream>
using std::cout;
using std::cin;
using std::endl;
using std::ios;
#include <iomanip> // setprecision kullanmak için bu olmalı using std::setprecision;
using std::setiosflags;
int main()
{ int toplam, sayac, not;
double ortalama;
toplam = 0;
sayac = 0;
cout << “Notu giriniz: (bitirmek için –1 giriniz) “;
cin >> grade;
while (not != -1) {
toplam = toplam + not;
sayac = sayac + 1;
cout << “Notu giriniz: (bitirmek için –1 giriniz) “;
cin >> grade;
}
if (sayac != 0 ) {
ortalama = static_cast<double>(toplam) / sayac;
cout << “Sınıf ortalaması: “ << setprecision (2) << setiosflags( ios::fixed | ios::showpoint) << ortalama << endl;
} else
cout << “hiç not girimedi” << endl;
Ondalık virgülden Ondalık virgülden sonra sıfırlar varsa onları Bilimsel
gösterim
return 0;
}
d o u b l e & float reel sayı; ondalık virgülü olan sayılar
i n t tamsayı
double, float’tan daha büyük sayıları veya daha fazla duyarlılıkla saklar.
Ortalamayı hesaplarken, toplam ve sayac değişkenlerimiz int türünde olduğu için bunların bölümünden elde edilecek sayı int olacak ve ondalık virgülden sonraki kısmı olmayacaktı.
Oysa bir ortalama alırken virgülden sonraki kısma da ihtiyacımız vardır. Bunun için cast operatörü kullandık (lab’daki bilgisayarlarda yüklü Turbo C/C++ V3’de bu geçerli olmayabilir).
The cast operator static_cast<double>() creates a temporary floating-pint copy of its operand in parentheses – toplam. Using a cast operator in this manner is called explicit conversion. The value stored in t o p l a m is still an integer. The calculation now consists of a floating-point value (temporary double version of total) divided by the integer sayac.
Implicit Conversion (Programcı açıkça belirtmediği halde yapılan dönüştürme): Bir aritmetik ifadede hem int hem de double operand’lar varsa, derleyici int operand’ları double’a dönüştürür.
ÇALIŞMA 3 – Yukarıdan aşağı algoritma geliştirme (içiçe kontrol yapıları kullanarak) Bir derste birinci konu sonunda yapılan sınavın sonuçlarını değerlendirmek üzere bir algoritma geliştireceksiniz (Bu değerlendirmeye göre bir sonraki konuya geçilip geçilmeyeceğine karar verilecek)
Size 10 öğrencinin notlarını içeren bir liste verilecek. Listede, her ismin yanında öğrenci sınavı geçtiyse 1, kaldıysa 2 yazıyor olacak.
Programınız sınavın sonuçlarını şu şekilde analiz etmeli:
1. Her bir sonucu (1 veya 2) oku. Program her seferinde başka bir sonuç okumak istediğinde ekranda “sonucu girin: “ mesajı görüntülenmeli.
2. Her sonuç türünün kaç tane olduğunu say.
3. Geçen ve kalan öğrencilerin sayılarını görüntüle.
4. Eğer sekizden fazla öğrenci sınavı geçtiyse “Bir sonraki konuya geçilebilir” mesajını görüntüle.
Bunları dikkatlice okuduktan sonra şu kararlara varabiliriz:
1- program 10 sonuç işleyecek. Bunun için sayac-kontrollu döngü kullanılmalı.
2- her bir sonuç okuduktan sonra bunun 1 mi 2 mi olduğunu program kontrol etmeli.
Programımızda 1 için kontrol edip, 1 değilse 2 olduğunu varsayabiliriz.
3- Hem geçenlerin hem de kalanların sayısı istendiğine göre 2 sayac kullanmak gerekir.
4- Tüm sonuçlar işlendikten sonra geçenlerin sayının 8’den fazla olup olmadığına karar vermeliyiz.
Pseudocode ile yazmaya başlayalım.
Değişkenlere ilk değerlerini ata
On sınav notunun girişini yap; kalan ve geçenleri say
Sonuçları yazdır ve bir sonraki konuya geçilip geçilmeyeceğine karar ver
Değişkenlere ilk değerlerini ata kısmını açalım:
Gecenler’e sıfır ata Kalanlar’a sıfır ata OgrenciSayaci’na bir ata
On sınav notunun girişini yap; kalan ve geçenleri say’ı açalım:
While OgrenciSayaci ondan küçük veya eşit olduğu müddetçe Bir sonraki sonucu oku
Ogrenci geçtiyse
Gecenler’i bir artır degilse
Kalanlar’ı bir artır
OgrenciSayaci’ni bir artır
Sonuçları yazdır ve bir sonraki konuya geçilip geçilmeyeceğine karar ver kısmını açalım:
Gecenlerin sayısını yazdır Kalanların sayısını yazdır Gecenler 8’den fazla ise
“Bir Sonraki Konuya Geç” yaz
Bu pseudocode, C++’a geçmeyi sağlayacak kadar rafine edilmiş durumda.
// Şekil. 2.11 s.84
// Sınav sonuçlarının analizi
#include <iostream>
using std::cout;
using std::cin;
using std::endl;
int main() {
int gecenler = 0, kalanlar = 0, ogrencisayaci = 1,
Değişkenleri tanımladığımız anda bu şekilde ilk değer atamalarını da yapabiliriz. Bu yaklaşım, bazı değişkenlere ilk değer atamalarını
unutmamızı engeller.
sonuc;
while (ogrencisayaci <= 10) {
cout << “Sonuç gir (geçti için 1, kaldı için 2): “;
cin >> sonuc;
if ( sonuc == 1)
gecenler = gecenler + 1;
else
kalanlar = kalanlar + 1;
ogrencisayacı = ogrencisayaci + 1;
}
cout << “Geçenlerin sayısı: “ << gecenler << endl;
cout << “Kalanların sayısı: “ << kalanlar << endl;
if (gecenler > 8 )
cout << “BİR SONRAKİ KONUYA GEÇİLEBİLİR” << endl;
return 0;
}
Sonuç gir ( geçti için 1, kaldı için 2): 1 Sonuç gir ( geçti için 1, kaldı için 2): 1 Sonuç gir ( geçti için 1, kaldı için 2): 1 Sonuç gir ( geçti için 1, kaldı için 2): 1 Sonuç gir ( geçti için 1, kaldı için 2): 1 Sonuç gir ( geçti için 1, kaldı için 2): 1 Sonuç gir ( geçti için 1, kaldı için 2): 2 Sonuç gir ( geçti için 1, kaldı için 2): 1 Sonuç gir ( geçti için 1, kaldı için 2): 1 Sonuç gir ( geçti için 1, kaldı için 2): 1 Geçenlerin sayısı: 9
Kalanların sayısı: 1
BİR SONRAKİ KONUYA GEÇİLEBİLİR
TAVSİYE:
Bazı programcılar pseudocode ile algoritma geliştirmeyi zaman kaybı olarak görerek doğrudan dil ile kodlamaya geçseler de bu yaklaşım basit ve bilinen problemler için uygundur; karmaşık ve büyük projelerde çok ciddi hatalara yol açabilir.
ATAMA OPERATÖRLERİ
c = c + 3; şeklindeki bir atama cümlesi c += 3 şeklinde yazılabilir.
Bu ifadedeki += (toplama atama operatörü), sağ taraftaki değeri, sol taraftaki değere ekler ve sonuc sol taraftaki değişkenin içine konur.
Diğer aritmetik atama operatörleri:
-= c -= 7; c = c – 7;
*= b *= 5; b = b * 5;
/= a /= 2; a = a / 2;
%= d %= 4; d = d % 4;
ARTIRMA ve AZALTMA OPERATÖRLERİ
Birli (“unary”) operatörler - yani tek bir operandı olan.
++a ön artırma operatörü a’yı 1 artır, sonra, a’nın bulunduğu ifadede bu yeni değeri kullan.
a++ sonra artırma operatörü a’nın bulunduğu ifadede a’nın mevcut değerini kullan; sonra a’yı 1 artır.
--b ön eksiltme operatörü b’yi 1 azalt; b’nin bulunduğu ifadede bu yeni değeri kullan.
b-- sonra eksiltme operatörü b’nın bulunduğu ifadede b’nın mevcut değerini kullan; sonra b’yı 1 azalt.
DİKKAT: Bu operatörleri yazarken operand ile arasında boşluk bırakılmamalıdır.
Aşağıdaki 3 atama cümlesi gecenler = gecenler + 1;
kalanlar = kalanlar + 1;
Atama operatörleri kullanılarak şöyle yazılır:
gecenler += 1;
kalanlar += 1;
Ön artırma operatörleri ile ++gecenler;
++kalanlar; şeklinde yazılır.
ŞU ANA KADAR GÖRDÜĞÜMÜZ OPERATÖRLERİN ÖNCELİK SIRASI
( ) soldan sağa parentez
++ -- static cast<türü> () soldan sağa unary (postfix)
++ -- + - sağdan sola unary (prefix)
* / % soldan sağa
multiplicative
+ - soldan sağa additive
<< >> soldan sağa
insertion/extraction
< <= > >= soldan sağa relational
== != soldan sağa equality
?: sağdan sola conditional
= += -= *= /= %= sağdan sola assignment
, soldan sağa comma
Aşağıdaki program parçasını inceleyelim:
// sayaç-kontrollu tekrar
#include <iostream>
using std::cout;
using std::endl;
int main() {
int sayac = 1;
while (sayac <= 10) {
cout << sayac << endl;
++sayac;
}
return 0;
}
Şekil: 2.16
Şekil 2.16’daki programda, s a y a c’a 1 atanarak başlanmış ve w h i l e cümlesine koşul olarak ( s a y a c <= 10 ) konmuştur. Buna göre sayac = 11 olduğunda döngü biter.
Döngüden çıkışta sayac’ın değeri 11’dir.
s a y a c = 0 ile başlatılıp döngü şu şekilde yapılabilir:
while ( ++sayac <= 10)
cout << sayac << endl;
Bu tür kullanımda, sayac, while’daki koşul test edilmeden önce artırılır. Daha az satır kodlama bakımından tercih edenler olabilir. Ancak bu yazış, deneyim gerektirdiği gibi programı izleme, anlama, bakımı zorlaştırmaktadır. .
İYİ PROGRAMLAMA TAVSiYELERİ:
Her kontrol yapısından önce ve sonra okunabilirliği/anlaşılabilirliği sağlamak için birer boş satır bırakınız.
for TEKRAR YAPISI
Şekil 2.16’daki programı for kullanarak yazalım.
// for yapısı kullanarak sayaç-kontrollu tekrar
#include <iostream>
using std::cout;
using std::endl;
int main() {
// ilk değer atama, tekrar koşulu, artırma...herşey f o r // yapısının başlığında
for (int sayac = 1; sayac <= 10; sayac++) cout << sayac << endl;
return 0;
}
Şekil. 2.17 s.91
SIK YAPILAN HATALAR:
While ve for cümlelerinin koşulllarında yanlış bağıntısal operatörler ve/veya yanlış son değerler kullanmak.
Örneğin, birden ona kadar sayılar yazdırılacaksa, sayac = 1 ile başlayıp, (sayac <= 10) koşulu sınanmalıdır. Ancak çoğu kişi sayac = 0 ile başlayıp koşulu (sayac < 10) şeklinde yazmayı tercih eder. İkide doğru. ANCAK İKİSİNİ BİRBİRİNE KARIŞTIRMAYIN!
for yapısının genel formatı:
for ( ilk değer atama; döngü devam koşulu; artırma ) cümle
İlk değer atama kısımında döngü kontrol değişkenine ilk değer ataması yapılır.
Dööngünün devam testi kısmında, döngünün devam koşulu sınanır.
Artırma kısmında da döngü kontrol değişkeni artırılır.
Daha anlaşılır olması bakımından pek çok durumda f o r yerine ona denk şu w h i l e yapısı kullanılır.
ilk değer atama;
while ( döngü devam koşulu ) {
cümle
artırma }
SIK YAPILAN HATALAR: s.93
for yapısının başlık kısmı içinde tanımlanıp değer atanan bir değişkeni, for’un gövdesi dışında kullanmak. ANCAK bu kural özellikle eski C++ derleyicilerinde farklılıklar gösterebilir. Bu bakımdan, taşınabilirlik için,
1- her for yapısında farklı bir kontrol değişkeni kullanın ya da
2- aynı değişkeni kullanmak birden fazla for yapısında kullanmak istiyorsanız, bu değişkeni ilk for yapısının dışında ve yapıdan önce tanımlayınız.
for yapısının başlık bölümünde yer alan ilk değer atama ve artırma kısımlarında birden fazla ifade yer alabilir, bu durumda bunlar virgül ile ayrılırlar. Yani ilk değer atama kısmında birden fazla değişkeni tanımlayıp değer atayacaksanız bunlar virgülle ayrılırlar. Döngünün devam koşuluna geçmek için noktalı virgül kullanılmalıdır. Devam koşulunun sınanmasından sonra, artırma kısmına geçerken de arada noktalı virgül olmalıdır. Noktalı virgül yerine virgül koymak yazım (syntax) hatasına yol açar.
İlk değer atamalarda sadece for için gerekli değişkenleri tanımlayınız. for dışında kullanılacak değişkenleri for yapısının dışında tanımlayınız.
for yapısının başlık bölümünde yer alan 3 ifade seçimliktir; yani hepsinin konması gerekmez.
Örneğin döngü devam koşulu kaldırılırsa sonsuz döngü meydana gelir.
Artırma kısmı kaldırılıp, aşağıdaki ifadelerden biri kullanılarak for’un gövde kısmına konabilir. Bu ifadeler birbirine denktir.
sayac = sayac + 1 sayac +- 1
++sayac ---Æ sayac’ı bir artırıp gövdeyi çalıştırır.
sayac++ ---Æ gövdeyi çalıştırdıktan sonra sayac bir artırılır. Bu nedenle bu daha doğal bir kullanımdır.
Önce veya sonra artırmadaki farklılık böyle bir kullanımda sorun yaratmaz çünkü s a y a c değişkeni bir aritmetik ifadede yer almamaktadır.
for yapısının başlık bölümündeki 3 ifade (ilk değer atama; döngü devam koşulu; artırma) aritmetik ifadeler içerebilir.
Örnek olarak, x=2 ve y=10 kabul edelim. Eğer x ve y döngünün gövdesinde değiştirilmiyorsa şu iki cümle birbirine denktir:
for ( int j = x; j <= 4 * x + y; j += y / x) for ( int j = 2; j <= 80; j += 5)
NOT: - artırma kısmı negatif olabilir. Bu durumda kontrol değişkeninin değeri eksiltilerek aşağı doğru sayma yapılmış olur.
- for’a ilk başlayışta döngü devam koşulu yanlış ise, for’un gövdesi yürütülmez, kontrol, for yapısından sonraki ilk cümleye geçer.
F o r yapısının akış şeması, w h i l e’ın akış şemasına benzer.
Örnek olarak:
f o r ( int j = 1; j <= 10; j++) cout << j << endl;
Şekil. 2.19 s. 95 Tipik bir for tekrara yapısının akış şeması
for yapısı kullanan örnekler
a) kontrol değişkenini 1’den 100’e kadar 1 artırın.
for ( int i = 1; i <= 100; i++ )
b) kontrol değişkenini 100’den 1’e kadar –1 azaltın.
for ( int i = 100; i >= 1; i-- )
kontrol değişkeninin azaltma veya artma durumuna göre doğru bağıntısal operatörü kullanmaya dikkat ediniz.
c) kontrol değişkenini 7’den 77’ye kadar 7’şer artırın.
for ( int i = 7; i <= 77; i += 7 )
d) kontrol değişkenini 20’den 2’ye –2’şer azaltın.
for (int i = 20; i >= 2; i-=2)
e) kontrol değişkenini 2,5,8,11,14,17,20 değerlerini alacak şekilde ayarlayın.
for (int j = 1; j <= 20; j += 3) j = 1
j <= 10 doğru Cout << j << endl; j++
yanlış
f) kontrol değişkenini 99,88,77,66,55,44,33,22,11,0 değerleini alacak şekilde ayarlayın.
for ( int j = 99; j >= 0; j-=11 )
BASİT BİR PROGRAM
// 2’den 100’e kadar çift sayıların toplamı bulan program
#include <iostream>
using std::cout;
using std:: endl;
int main() {
int toplam = 0;
for (int sayi = 2; say,i <= 100; sayi +=2 )
toplam += sayi;
cout << “Toplam = “ << toplam << endl;
return 0;
}
Toplam = 2550 Şekil. 2.20 s.96
for’un gövde kısmı, başlık kısmının içine alınarak şöyle de yazılabilirdi:
for (int sayi = 2; // ilk değer ata sayi <= 100; // devam koşulu
toplam += sayi; // toplamı oluştur
sayi += 2) // kontrol değişkenini artır
ANCAK BU ŞEKİLDE – gövdeyi başlığın içine alarak - KODLAMAK PROGRAMIN OKUNABİLİRLİĞİNİ AZALTMAKTADIR.
BAŞKA BİR for ÖRNEĞİ:
1000 lirasını %5’den yıllık faize yatıran bir kişinin, faiz ve anaparadan hiç çekmediğini düşünürsek 10 sene sonra kaç lirası birikmiş olur.
a = p (1 + r)ⁿ
p: ilk yatırılan anaparanın miktarı r: yıllık faiz oranı
n: yıl sayısı
a: n sene sonunda oluşan toplam para
• for döngüsü 10 kez dönmeli
• kontrol değişkeni birer birer artacak
• C++, üs alma operatörü içermediğinden pow standart kitaplık fonksiyonu kullanacağız.
pow (x,y) x’in y’ninci üssünü alır. x ve y double tanımlanmalıdır.
• Bu programımızın çalışması için <cmath> dahil edilmelidir.
• pow’un argümanı oalacak sene değişkeni tamsayıdır (int). Pow çalışırken int’i double’a çevirerek geçici bir yere koyar.
Yukardaki formüle göre programda
Belirli bir senenin sonunda oluşan para = anapara * pow (1.0 + oran, sene) şeklinde hesaplanacatır.
DİKKAT:
Bilgisayarda 14.234 ve 18.673 olarak saklı olan iki para değeri, print işlemi esnasında setprecision(2) belirtilmişse 14.23 ve 18.67 olarak yazılırlar. Bu değerler toplandığında siz sonucu 32.90 beklerken, virgülden sonraki ve printte görmediğimiz 3.basamaktaki değerler nedeniyle toplam 32.91 olacaktır.
Bunun farkında olun. Para hesaplarına dikkat!
Faiz probleminin C++ ile kodlanması
// Bileşik faiz hesabı yapan program
#include <iostream>
using std::cout;
using std::endl;
using std::ios;
#include <iomanip>
using std::setw;
using std::setiosflags;
using std::setprecision;
#include <cmath>
int main() {
double miktar,
anapara = 1000.0,
oran = .05;
// Çıktının başlığını yazdır
cout ( “SENE “ << setw (21) << HESAPTAKİ MİKTAR” << endl;
// set the floating-point number format
cout << setiosflags( iosfixed | ios::showpoint ) << setprecision (2);
for (int sene =1; sene <= 10; sene++) {
miktar = anapara * pow (1.0 + oran, sene);
cout << setw (4) << sene << setw(21) << miktar << endl;
} return 0;
}
SENE HESAPTAKİ MİKTAR
1 1050.00
2 1102.50
3 1157.62
4 1215.51
5 1276.28
6 1340.10
7 1407.10
8 1477.46
9 1551.33
10 1628.89
Şekil. 2.21 s. 98
switch YAPISI: ÇOKTAN SEÇME İÇİN (“multiple-selection”)
Anımsanacağı gibi if cümlesi tek bir koşulun doğru olma durumuna göre bir seçeneğin (single-selection) yürütülmesini; if / else koşulun doğru veya yanlışlığına göre iki değişik seçenekten (double selection) birinin yürütülmesini sağlıyordu. Zaman zaman algoritmamız ikiden fazla seçeneğin sınanıp her bir seçenek için değişik işlerin yapılmasını gerektirebilir.
C++’da bu iş için switch yapısı kullanılır.
Örnek Program: Harf notlarının sayılması
// Harf notlarını sayan program
#include <iostream>
using std::cout;
using std::cin;
using std::endl;
int main() {
int not,
sayacA = 0, // A’ların sayısı sayacB = 0, // B’lerin sayısı sayacC = 0, // C’lerin sayısı sayacD = 0, // D’lerin sayısı sayacF = 0; // F’lerin sayısı cout << “Harf notlarını giriniz. “ << endl
<< Girdi sonunu belirtmek için EOF karakterini giriniz. “ <<
endl;
while ( ( not = cin.get () ) != EOF ) cin.get() klavyeden girilen bir karakteri okur ve not değişkenine koyar. Bu komutun detayı konu 6’da...Not, integer bir değişken.
Aslında okunan karakterin, karakter bir değişkene konması gerekirdi, ancak C++’in çok önmeli bir özelliği karakterlerin
int değişkenlere atanmasına izin vermesidir.
{
switch (not)
EOF, IBM PC uyumlu makinelerde ctrl Z
{
case ‘A’:
case ‘a’:
++sayacA;
break;
switch’den çıkmak için break gerekli case ‘B’:
case ‘b’:
++sayacB;
break;
... hepsini yazmadım ...
case ‘F’:
case ‘f’:
++sayacF;
break;
case ‘\n’: // ignore new lines,
case ‘\t’: // tabs,
case ‘ ‘: // spaces in input break;
default: // catch all other characters
cout << “Yanlış bir harf girdiniz. ”
<< “Yeni bir harf giriniz.” << endl;
} }
cout << “\n\nHER BİR HARF NOTUNDAN KAÇ TANE OLDUĞU: “ << “\nA: “ << sayacA
<< “\nB: “ << sayacB << “\nC: “ << sayacC << “\nD: “ << sayacD
<< “\nF: “ << sayacF << endl;
return 0;
}
Harf notlarını giriniz.
Girdi sonunu belirtmek için EOF karakterini giriniz.
A B C
C A
D F C E
Yanlış harf girdiniz. Yani bir harf giriniz.
D A B
HER BİR HARF NOTUNDAN KAÇ TANE OLDUĞU:
A: 3 B: 2 C: 3 D: 2 F: 1
Şekil. 2.22 s. 101 switch örneği
Yukarıda, karakterlerin tamsayı değişkenlere atanabildiğini gördük, çünkü her bir karakter 1 bayt yer tutar. Dolayısıyla, kullanım alanına göre, bir karaktere, bir tamsayı ya da bir karakter muamelesi yapabiliriz. Örneğin,
cout << “ ‘a’ karakterin değeri: “ << static_cast< int > (‘a’) << endl;
cümlesinin yazdığı satır aşağıdaki gibidir:
a karakterinin değeri: 97
--- DENEMEDİM...AMA static-cast’ı denediğim başka bir programda ÇALIŞMADI.
Static-cast’ın Turbo C++ version 3’deki karşılığını bulmak gerek.---
do / while TEKRAR YAPISI
do/while yapısı while yapısına benzemekle beraber fark şudur: while yapısında, döngü devam koşulu döngünün başında sınanır. do/while yapısında ise, döngü devam koşulu döngü yürütüldükten sonra sınanır. Buna göre döngü gövdesi içinde yer alan ifadeler en az bir kere yürütülmüş olur. do/while bittiğinde, while’dan sonraki cümle yürütülür.
do/while yapısının gövdesi içinde tek bir cümle varsa gövdeyi paranteze almak gerekmez (while ve for’daki gibi) , birden fazla cümle varsa parantez içine alınmalıdır (yoksa mantık hatası oluşur). Ancak tek bir cümle bile olsa, do/while yapısında parantez kullanmak iyidir;
karışıklığı önlemek için. Yani do
do Cümle
{
while (koşul); yerine cümle
}
while (koşul);
SIK YAPILAN HATALAR
while, do/while ve for yapılarında döngü devam koşulunda sınanan kontrol değişkeninin değeri , başlık veya gövde bölümlerinden birinde mutlaka değiştiriliyor olmalıdır. Kontrol değişkenini değiştirmemek sonsuz döngüye neden olur.
// fig. 2.24 do/while yapısı
#include <iostream.h>
int main() Do/while’ın akış
şeması
{ int sayac = 1;
do {
cout << sayac << “ “ ; } while (++sayac <= 10);
cout << endl;
return 0;
}1 2 3 4 5 6 7 8 9 10
break ve continue CÜMLELERİ
break ve continue cümleleri kontrolun akışını (“flow of control”) değiştirirler. break cümlesi; while, for, do/while, switch yapılarında kullanıldığında, yapıdan anında çıkmayı sağlar; bu durumda kontrol, yapıdan sonraki ilk cümleye geçer (programın yürütülmesi bu cümleyle devam eder).
Şekil. 2.26 f o r yapısı içinde b r e a k ‘in kullanımını göstermektedir.
// f o r içinde b r e a k kullanan program
#include <iostream.h>
int main() {
int x;
for ( x = 1; x <= 10; x++ ) {
if (x==5)
break; // break loop only if x is 5 cout << x << “ “;
}
cout << “\nBroke out of loop at x of “ << x << endl;
return;
}
1 2 3 4
Broke out of loop at x of 5 Şekil. 2.26 s. 108 Deitel
continue
cümlesi, while, for, do/while yapıları içinde kullanıldığında, gövdenin içinde continue’dan sonra gelen cümleleri atlayarak, döngüye devam eder: kullanılmakta olan yapı while veya do /while ise döngü devam koşulu sınanır, for ise, kontrol değişkeninin artırım işlemi yapılır, sonra devam koşulu sınanır.for ve continue kullanımına başka bir örnek:
// şekil.2.27 f o r ve c o n t i n u e kullanımına örnek
#include <iostream.h>
int main() {
for ( x = 1; x <= 10; x++ ) {
if (x==5)
continue; // skip the remaining code in loop only if x is 5 cout << x << “ “;
}
cout << “\n5’i yazmamak için c o n t i n u e kullanıldı. “ << endl;
return;}
1 2 3 4 6 7 8 9 10
şekil.2.27 5’i yazdırmamak için c o n t i n u e kullanıldı.
ÖNEMLİ NOT: Bazı programcılar break ve continue kullanımının yapısal programlamayı ihlal ettiğini düşünürler. Esasen bu cümlelerin işlevleri, ilerde görceğimiz yapısal programlama teknikleriyle sağlanabilir. Bu durumda, break ve continue kullanmaya gerek kalmaz.
MANTIKSAL OPERATÖRLER
Şimdiye kadar basit koşulların nasıl ifade edildiğini (tek bir koşul) gördük: sayac <= 10 , toplam > 1000 , flag != 0 gibi. Birden fazla koşulu sınamak içinse içiçe if’ler veya if/else yapıları kullanabileceğimizi gördük.
Daha karmaşık koşulların ifadesi için veya basit koşulların biraraya getirilmesi için C++, mantıksal operatörler sağlar: && (mantıksal AND) ve || (mantıksal OR) ve
! (mantıksal NOT).
İki koşulun aynı anda doğru olması durumunda belirli bir işlem yapmak istiyorsak bu koşulları mantıksal VE ile bağlayarak ifade etmeliyiz:
Örneğin:
if (cinsiyet == 1 && yas >= 65) ++grup1;
if’in başlığındaki koşul, ancak, && ile bağlanmış her iki koşul da doğruysa doğrudur.
((((( logical AND, OR, NOT biliniyor mu???? ))))) Mantıksal AND:
ifade1 ifade2 ifade1 && ifade2 yanlış yanlış yanlış
yanlış doğru yanlış doğru yanlış yanlış
doğru doğru doğru
SIK YAPILAN HATALAR:
3 < x < 7 şeklinde bir ifade, her ne kadar matematiksel olarak doğruysa da bunu C++’da (3<x && x<7) şeklinde yazmak gerekir.
Mantıksal OR:
ifade1 ifade2 ifade1 || ifade2 yanlış yanlış yanlış
yanlış doğru doğru doğru yanlış doğru doğru doğru doğru
if (donem_ortalamasi <= 90 || final_notu >= 90 ) cout << “Ogrencinin notu: A “ << endl;
&& operatörünün, ||’ye göre önceliği vardır.
Soldan sağa işlem yapılır.
&& ve || içeren bir ifadenin doğruluğu ya da yanlışlığı kesin olarak belli olduğu anda daha sağdaki ifadelerin değerlendirilmesinde gerek kalmaz. Örneğin,
if (cinsiyet == 1 && yas >= 65 ) ifadesinde cinsiyet bire eşit değilse yani birinci ifade yanlış ise, yaş koşulunu sınamaya gerek yoktur çünkü && ile bağlı iki ifadeden biri yanlış ise tüm ifadenin sonucu yanlış olacaktır.
Mantıksal NOT (“logical negation”)
ifade !ifade
doğru yanlış yanlış doğru
EŞİTLİK (==) ve ATAMA (=) OPERATÖRLERİNİN KARIŞMASI
Ne kadar deneyimli olursa olsun C++ programcıları zaman zaman atama operatörü = ile eşitlik koşulu sınamasa kullanılan ==’ i birbirinin yerine kullanabilmektedirler. Böyle bir hata durumunda program doğru olarak derlenmekte ancak yürütüldüğü zaman ya yanlış sonuçlar veya mantık hatası vermektedir. Örneğin
if ( odeme_kodu == 4)
