webmaster
 
Konu Kilitli
15-07-2009 13:06:45
 

PASCAL Programının Yapısı, KOMUTLARI

PASCAL Programının yapısı, ÖRNEKLER


Pascal Programının Yapısı

Program Program_Adı;
Tanımlamalar
Procedure ve Function'lar
Ana program
şeklinde kısaca tanımlamabilir. Ancak bu yapıyı biraz açarsak genel olarak bir pascal programı şu şekildedir:
Program Program_Adı;
Uses
Kullanılacak Unit'ler
Type
Özel veri tipleri
Const
Sabit değerler
Var
Değişken tanımlamaları
Label
Etiketler
Procedure ve Function'lar
Begin
Ana program
End.
Yukardaki yapıda kalın olan yazılar Pascal'ın kendi deyimleri, diğer yazılar ise bunların altına nelerin geleceğidir. Anlayacağınız Pascal'da bir program "Program" deyimiyle başlar ve bunun hemen yanına programın ismini yazarsınız. Ve yine gördüğünüz gibi bir her program "End." ile biter.

Uses: Bu deyim ile programımızın kullanacağı unit'lerin isimlerini programa anlatırız. Unitlerin ne olduğunu daha sonra göreceğiz ama genelde bir pascal programının basşında "Uses Crt;" şeklinde bir kod bulunur. Burada Crt isimli Pascal'ın hazır unit'lerinden birisini kullanacağımızı belirtiriz.
Type: Pascalda kendi değişken tiplerimizi oluşturabiliriz. Bu işlemi bu etiketin hemen altında yazdığımıza komutlarla yaparız.
Const: Programımızda kullanacağımız sabit verileri burdan girebiliriz.
Var: Kullanacağımız değişkenleri burada tanımlarız.
Label: Programlarımıza etiket kullanmak istersek buraya etiket isimlerini yazabiliriz.
Procedure Function'lar: Kendi yapacağımız komutlar olan procedure ve functionları buraya yazarız.
Begin: Her programın başında Begin kullanılır. Programımızın başladığını belirtir. Bu ifadeden sonra programımızı yazarız.
End: Programı bitirdiğimiz anlamındadır. Bunun altına yazılacak satırlar bir işe yaramaz, yani çalışmazlar.


Buradaki birçok şeyi daha bilmiyorsunuz ama zaten buraya da öğrenmek için geldiniz. Merak etmeyin, hepsini tek tek anlatacağım. Zaten her programda da bunların hepsini kullanmayacağız. Mesela şu da bir programdır ve ekrana "Merhaba" yazar:
begin
write('Merhaba');
end.
Gördüğünüz gibi ne prosedür, ne label ne var, ne de program adı var ama programımız aslanlar gibi çalışır. Bu programı Pascal'da yazıp çalıştırırsanız ekrana Merhaba yazar. Ama hemen program ekranına döndüğü için bunu göremezseniz Alt+F5'e basın bakabilirsiniz.
Pascal'da program yapısını da kısaca gözden geçirdik. Artık biraz daha TP'a (Turbo Pascal) ısınmış olduk. Sonraki derste de birkaç yazım kuralına değindikten sonra program yapmaya başlayacağız. Gerçi eğer yukardaki örneği yaptıysanız ilk programımızı yapmış olduk.
Pascal'ın Genel Yazım Kuralları
TP'ın da her programlama dilinde olduğu gibi yazım kuralları vardır. Bunları Türkçe'deki imla kurallarına benzetebilirsiniz. Ancak Türkçe'de bir ayırma ekini ( ' ) ya da noktalı virgülü ( yazmazsanız karşıdaki insan cümleyi anlar fakat Pascal'da ya da başka bir programlama dilinde bir noktalı virgül ya da nokta yüzüden 100'lerce sayfalık programınız ya hiç çalışmayabilir ya da yanlış çalışabilir. Ama bunu söyledim diye korkmayın. Zaten Pascal sizi uyarır ve oraya ne koymanız gerektiğini söyler. Fakat zaten siz iyi bir programcı olduktan sonra bu hataları yapmayacaksınız.
  • <LI class=MsoNormal>İlk olarak pascalda bütün komutlar noktalı virgül ( ile biter. Dikkat edin komutlar diyorum, satır değil. Bir satırda 3 komut varsa 3 noktalı virgül olmalı. Type, Var Const gibi ifadeler komut değildir ama bunlardan bazılarına noktalı virgül koysanız da bir zararı olmaz. Yanlış biryere noktalı virgül koyarsanız zaten Pascal bunu size söyler. Hatta noktalı virgül koymayı unutursanız da size söyler. <LI class=MsoNormal>Pascal'da aynı satırda en fazla 126 karakter uzunluğunda yazı yazabilirsiniz. Daha uzun olursa yine TP sizi uyarır. <LI class=MsoNormal>Pascal'da bir satırda birden çok komut kullanabilirsiniz. Her komutun sonuna koyduğumuz noktalı virgül sayesinde pascal bu komutları birbirinden ayırabilir. <LI class=MsoNormal>Pascal'da program, değişken, sabit, label... isimleri tanımlarken harf, rakan ve alt çizgi ( _ ) dışında başka bir karekter (>,+,/,{,*,-,û©,",=,',],%,$,@... gibi) ve boşluk kullanamazsınız. Ayrıca yine Türkçe'ye özel karakterleri (İ,ı,û,ğ,ü,Ü,ç,Ç,Ö,ö,ş,Ş) bu tip isimlerde kullanamazsınız. Ama ekrana yazı yazdırırken her türlü karakteri kullanabilirsiniz. Ayrıca pascalda ayrılmış (reserved) denilen kelimeleri de değişken, label, sabit... isimleri olarak kullanamazsınız. Bunları kullanırsanız pascal sizi uyarır. Bu ayrılmış kelimler "begin, end, var, not, and, or, for, label, do, if, else..." gibi kelimelerdir. Bu kelimelerin tam listesini en son olarak vereceğim. <LI class=MsoNormal>Pascal'da Begin ile başlayan ve end; ile biten ve arasında sınırsız sayıda komut bulunabilen kısımlara blok denir ve bu bloklar tek bir komut yapa paket gibi kullanılabilir. Buna daha sonra yeri gelince değineceğiz.
  • İyi bir Programcı yazdığı programların bazı yerlerine orada ne yaptığına ilişkin birtakım notlar yazar. Bu yazılar programa dahil değildir ve istenilen herşey yazılabilir. Böyle bir yazı yazacaksanız { ile } arasına veya (* ile *) arasına yazmak zorundasınız. Buna ilerde örnekler vereceğiz.
Aynı satıra birçok komut yazılabileceği gibi bir komut alt alta birden çok satıra bölünerek de yazılabilir. Tabii kelimeler bölünemez. Mesela
if a>b then write('A daha büyük') else write('B daha büyük'); komutu ile
if a>b then
write('A daha büyük')
else
write('B daha büyük'); ifadesi aynı işi yapar ve pascal hiçbir hata vermez.
  • <LI class=MsoNormal>Pascalda bir değişkene değer atarken := iki ifadeyi karşılaştırırken ise sadece = kullanılır. Bunları değişkenler konusunda ele alacağız.
  • Pascal'da kullanılan her değişken önceden tanımlanmalıdır. Aksi takdirde tanınmayacak ve hata verilecektir. Ayrıca sabitlere değer ataması yapılamaz.
Şimdilik birkaç kural yazdım ama aklıma geldikçe ilave ederim. Ayrıca bazı kurallar konu aralarında belirtilecek.
Pascal'da Değişken, Sabit, Tip ve Labeller
Her programlama dilinde değişkenler vardır. Değişkenler programlamada hayati önem taşır. Değişkeni program içinde bir değeri ya da bilgiyi tutan bir birim olarak ifade edebiliriz. Bu bölümde değişkenleri tüm tipleriyle çok ayrıntılı ve bol örnekli anlatacağım. Ayrıca sabitler, tipler ve labelleri de öğreneceğiz. Adından da anlaşılabileceği gibi değişkenlerin değeri program içinde istenildiği kadar değiştirilebilir. Bir değişkenin bir adı, tipi ve değeri vardır. Değişken adı olarak istediğiniz ismi verebilirsiniz. Değişkenin tipini ise programınızın başında var deyimi ile tanımlamak zorundasınız.
Var Deyimi:
Programda kullanacağımız bütün değişkenleri programın başında tanımlamak ve cinsini (sayı mı, yazı mı.. gibi) belirtmek zorundayız. Her programlama dilinde buna gerek olmayabilir ama Pascal'da bu iş mecburidir. Değişkenlerimizi Var deyiminde sonra tanımlamamız gerekir. Var deyimi bir komut olmadığından sonuna noktalı virgül konulmaz. Genel kullanım şekli:

Var
değişken: değişken_tipi;

şeklindedir ve Pascal'da program yapısı dersinde gördüğümüz yerde kullanılır. Değişken tiplerini görürken bu deyimin kullanılışını göreceğiz. Merak edenler için söyleyim: Var kelimesi İngilizce Variable kelimesinin kısaltılmışıdır ve değişken ya da kısaltma anlamındadır.
Değişken Tipleri
Pascal'da her değişkenin bir tipi olmak zorundadır. Bir değişken programın başında hangi tipte tanımlandıysa programın sonuna kadar o tipte bilgi saklayabilir ve o değişkene o tipten başka bir tipte veri atanamaz, eklenemez. Yani mesela sayı tipinde bir değişkene "kalkan" değeri atanamaz. Bu durumda program hiç çalışmaz ve Pascal editörü hata verip o yanlışlığın yapıldığı değişkene imleci getirip hata uyarısı yapar.



Sayısal Değişkenler:
Adından da anlaşılacağı gibi değeri bir sayı olabilen değişkenlerdir. Bu değişkenler bir sayıyı tutarlar. Ayrıca matematiksel işlemlerde de kullanılabilirler. Birkaç çeşidi vardır. Öncelikle sayısa değişkenleri ikiye ayırmak gerekir. Birncisi tasayılar ve ikincisi gerçek (ondalıklı) sayılar. Tam sayıların ve ve gerçek sayıların da kendi aralarında sınıfları vardır. İlk önce tamsayı tiplerinden başlayalım. Tamsayı tiplerini hemen bir tabloda verelim:
Tip adı
Sınırları
Kapladığı alan
Shortint
-128..127
1 byte
Byte
0..255
1 byte
Integer
-32768..32767
2 byte
Word
0..65535
2 byte
Longint
-2147483648..2147483647
4 byte
Tabloda tip adı dediğimiz şey var deyimiyle kullanacağımız ad, sınırları o sayısal değikenin alabileceği değerlerin sınırıdır. Yani byte tipinde bir değişkenin değeri 256 olamaz. Buna göre bizim işimize hangisi yarıyorsa onu kullanabiliriz. Kapladığı alan ise bu değişken için hafızada kullanılan alanın byte cinsinden değeridir. Programlarımızın hafızada (hard-disk'te değil) az yer kaplaması daha iyidir. Bunun için gereksiz yere longint değişkenini kullanmamamız iyi olur. Çünkü pascalda en fazla 64 kilobyte'lık (yaklaşık 64000 byte) değişken kullanabiliriz. Hemen bunlarla ilgili birkaç örnek program yapalım.
Örnek 1: Bu program 2 sayıyı toplar ve sonucu ekrana yazar. Şimdilik ekrana nasıl yazdığımızın üzerinde durmayalım ama zaten sizin de anlayacağınızı düşünüyorum.
Program Toplama_Denemesi;
Uses Crt;
Var
sayi1,sayi2: integer;
toplam: integer;
Begin clrscr;
sayi1:=19;
sayi2:=81;
toplam:=sayi1+sayi2;
write('Bu sayıların toplamı=',toplam);
readln;
end.
Bu program ekrana 100 yazar. Çünkü toplam isimli değişkenimizin son değeri 100'dür. Burada readln komutu enter'a basılmasını bekler. Bunu daha sonra göreceğiz. Write ise ekrana birşeyler yazar. Bunu da ayrıntılı olarak inceleyeceğiz. Clrscr ise ekranı temizler. Şimdilik görmemiz gereken atama işlemleri, yani bir değişkenin değerini değiştirme ve değişkenleri tanımlama. Gördüğünüz gibi 3 tane değişkenimiz var ve bunları iki satırda tanımlıyoruz. Hepsinin tipi de aynı olduğu için üç değişkenimizi birden



Var
sayi1, sayi2, toplam: integer;
şeklinde topluca ya da üçünü de ayrı ayrı tanımlayabiliriz. Bu sizin keyfinize kalmış.
Örnek 2: Bu program da kullanıcıdan (yani sizden) aldığı iki sayıyı çarpıp ekrana yazar:
Program Carpma_Denemesi;
Uses Crt;
Var
a, b, c: integer;
Begin clrscr;
write('Birinci sayıyı giriniz:');
readln(a);
write('İkinci sayıyı giriniz:');readln(b);
c:=a*b;
writeln('Sonuç=',c);
readln;
End.
Gördüğünüz gibi ilk önce a ve b değişkenlerinin değeri kullanıcıdan alınıyor, sonra c değişkeninin değeri a ile b'nin çarpımı olacak şekilde hesaplanıp ekrana yazdırılıyor. Burada readln(değişken_adı); komutunu daha sonra anlatacağız. Şimdilik kullanıcıdan bir bilgi almak amacıyla kullanıldığını bilseniz yeter. Pascal'da aynı satıra birden çok komut yazılabileceğini ve büyük-küçük harf ayrımı olmadığını tekrar hatırlatıyım.
Örnek 3: Son olarak sizin kaç yaşında olduğunuzu bulan basit bir program yapalım:
Program Yas_Bul;
Uses Crt;
Var
simdiki_yil, dogum_yili: integer;
yas: byte;
Begin clrscr;
write('Kaç yılında doğdunuz: ');readln(dogum_yili);
write('Şimdi hangi yıldayız: ');readln(simdiki_yil);
yas := simdiki_yil - dogum_yili;
writeln('Siz şu anda ',yas,' yaşındasınız!');
Readln;
End.
Gördüğünüz gibi simdiki_yil ve dogum_yili değişkenlerini integer yaparken yas değişkenini byte yaptık. Çünkü 255 yaşından daha büyük insan olamaz. Bu durumda boşyere onu da integer yapıp hafızada yer işgal etmeyelim. İyi bir programcı olmak için bunlara dikkat etmeliyiz. Yine iyi bir programcı olarak değiken isimlerimizi anlamlı ve mümkün olduğunca kısa ve o değişkenin içeriği ile alakalı yapalım. Program içinde hata yapmamak için bunlar gerekli. Çünkü değişkenlerimize d1, d2, d3, d4... gibi isimler verirsek sonra hangisinin içeriği ne onu karıştırabiliriz. Değişken isimlerinin uzunluğu yanılmıyorsam 50 karekter kadar olabilir ve boşluk içeremez, sayı ile başlayamaz. Bu arada crt uniti ise clrscr komutunu kullanmak için gereklidir ve Pascal'ın hazır unit'lerindendir (Unit'in ne olduğunu şimdilik boşverin!).
Tamsayı değişkenlerin ne olduğunu artık az-çok anladık. Siz de üzerinde denemeler yaparak daha iyi öğrenebilirsiniz. Zaten her programımızda kullanacağız. Tamsayı değişkenlere ondalıklı bir sayı veremeyiz. Yani a bir tamsayı ise a:=2.9 dersek program çalışmaz. Bu tür ondalıklı (gerçek, gerçek ya da real) sayıları kullanmak için gerçel değişkenler kullanmalıyız.
Gerçek Sayı Tipleri:
Tabii bunlara gerçek diyorsak diğerleri sahte değil. Gerçekten kastımız virgüllü ya da ondalıklı ya da kesirli demektir. Bu tip sayıların da tıpkı tamsayılarda olduğu gibi çeşitleri var. Bu çeşitliliğin temel sebebi gereksiz hafıza kullanmaya engel olmaktır. Gerçek sayı tipleri şunlardır:
Tip adı
Sınırları
Kapladığı alan
Real
2.9 x 10^-39..1.7 x 10^38
6 byte
Single
1.5 x 10^-45..3.4 x 10^38
4 byte
Double
5.0 x 10^-324..1.7 x 10^308
8 byte
Extended
3.4 x 10^-4932..1.1 x 10^4932
10 byte
Comp
-2^63+1..2^63-1
8 byte
Burada Real'den başka tiplerin de olduğunu bilmeniz için hepsini gösterdim ama gerçekte sadece Real tipini kullanmanız yeterlidir. Html'de bir sayının üstünü göstermek olmadığından tablo biraz kötü gözüktü. Ben birisini yazı ile yazarsam siz diğerlerini anlarsınız. Real'in sınırları "2.9 çarpı 10 üzeri -39'dan 1.7 çarpı 10 üzeri 38'e kadardır". Real tipinin dışındaki tipleri kullanabilmeniz için prograınızın en başına {$N+} yazmanız gerekebilir. Bunu bilmeniz gerekmiyor, real size yeter. Şimdi biraz da bu tip gerçek değişkenlerle örnek yapalım.
Örnek 1: Bu program girilen sayının karekökünü bulur. sqrt(); komutunu sonra anlatırız. Şimdilik bu komutun bir sayının karekökünü bulmaya yaradığını bilmeniz yeter.
Program Karekok;
Uses Crt;
Var
sayi:integer;
karekoku:real;
Begin clrscr;
write('Bir tamsayı giriniz: ');readln(sayi);
karekoku:=sqrt(sayi);
write('Bu sayının karekökü: ',karekoku:16:5);
readln;
end.
Burda kullanılan write komutunun özel bir şekli. Sayıyı düzgün yazdırmayı sağlıyor. Daha sonra ayrıntılı göreceğiz. Bunları kaldırıp direk olarak
write('bu sayının karekökü:',karekoku);
şeklinde yazıp deneyin. Sayıyı bilimsel olarak sonuna E falan koyarak yazar.


Örnek 2: Bu program kullanıcıdan 3 dersinin notunu ister ve ortalamasını bulup ekrana yazar.
Program ortalama_bul;
Uses crt;
Var
not1, not2, not3: integer;
ort: real;
Begin Clrscr;
Write('Matematik Notunuz (0..100 arası): ');readln(not1);
Write('Fizik Notunuz (0..100 arası): ');readln(not2);
Write('Kimya Notunuz (0..100 arası): ');readln(not3);
ort:=(not1 + not2 + not3)/3;
write('Ortalamanız: ',ort:5:2);
Readln;
End.
Burada dikkat etmeniz gereken birşey daha var. ortalamayı hesaplarken yaptığımız işleme dikkat edin. Tıpkı matematik dersinde gördüğümüz gibi parantezlerin işlem önceliği var. Sayılarla yapabileceğiniz aritmetik işlemleri ilerde göreceğiz.
Buraya kadar yapılan ve bundan sonra yapılacak bütün örnekleri kendi elinizle Pascal editöründe yazmanızı tavsiye ederim. Yoksa öğrenemezsiniz. Ama eğer kodları direk olarak Pascal editörüne aktarmak istiyorsanız kodu işaretleyip sağ tıklayın ve kopyala yapın. Daha sonra Not defterini (notepad) açıp oraya yapıştırın kodları ve kaydedin. ama kaydederken dosya isminin sonuna .pas yazın. Mesela deneme.pas gibi. Kaydettikten sonra daha önce anlattığımız şekilde üstüne çift tıklayarak açabilirsiniz. Sonra istediğiniz gibi düzeltebilir veya çalıştırabilirsiniz.

Bir önceki yazı Pascal Programlama Diline Giriş hakkında bilgi vermektedir.

15-07-2009 13:07:32
 
String Değişken tip:
Programcı diliyle bu tip değişkenler alfasayısal değerler alabilir. Halk dilinde ise bunlara yazı ya da sayısal olmayan veri diyebiliriz. Yani sizin yaşınız sayısal bir değer ise isminiz alfasayısal bir değerdir. Alfasayısal ifadeler iki tırnak içerisinde gösterilir. Yani isminizi 'Halil İbrahim Kalkan' şeklinde gösterirsiniz. Ancak sayı değil dekik diye içerisinde sayı geçmeyecek diye birşey yoktur. Yeni 'Beim yaşım 17.' cümlesi ve '392' sayısı da tırnak içerisinde yazıldığından string tiplerdir ve matematiksel işlemlerde kullanılamazlar. Ya da mesela telefon numaranız bir sayı olduğu halde bunu tutmak için sayısal değişken kullanılmaz, onun yerine string değişken kullanılır. Çünkü telefon numaranızın üstünde çıkartma, kök alma gibi matematiksel işlem yapmayacaksınız. Ama tabii ki bu size kalmış. İsterseniz telefon numarası için longint değişken tanımlayabilirsiniz.
String değişkenlerin içerisinde maksimum 255 karekterlik bilgi bulunabilir. Bu karekter her türlü harf, sayı, işaret, boşluk... olabilir. Mesela 'a=2x5+3/62' diye bir string ifade yazılabilir. Anlayacağınız tırnak içerisinde ne varsa sabittir.





Örnek bir program yazalım:
Program String_tip_ornegi;
Uses crt;
Var
isim: string;
yas: byte;
begin clrscr;
write('Adınızı yazınız: ');readln(isim);
write('Yaşınızı yazınız: ');readln(yas);
clrscr;
writeln('Merhaba ',isim);
writeln('Sizin yaşınız ',yas);
readln;
end.
Bu programı pascal'da yazıp çalıştırırsanız sizin isminizi ve yaşınızı alıp ekrana geri yazar. Şimdi dikkat ettiyseniz 'Adınızı yazınız: ' ifadesi de aslında string ifadedir. Bu ifade değişken değil, sabit olduğundan iki apostrof işareti arasına yazılır. Peki bu ifadeleri de bir değişkenin değeri yapalım ve öyle yazdıralım:
Program String_tip_ornegi;
Uses crt;
Var
isim, ad_iste, yas_iste, yas_yaz, ad_yaz: string;
yas: byte;
begin clrscr;
ad_iste:='Adınızı yazınız: ';
yas_iste:='Yaşşınızı yazınız: ';
write(ad_iste);readln(isim);
write(yas_iste);readln(yas);
clrscr;
yas_yaz:='Sizin yaşınız ';
ad_yaz:='Merhaba ';
writeln(ad_yaz,isim);
writeln(yas_yaz,yas);
readln;
end.
Bu programı yazıp çalıştırınca bir önceki program ile tamamen aynı işi yaptığını göreceksiniz. Ama burada gereksiz yere fazla değiken kullanıp fazla işlem yaptık. Ama amacımız öğrenmek. Gördüğünüz gibi string tipdeki bir değişkene veri aktarımı sayısal tipli bir değişkene veri aktarımı ile aynı ama burada verileri iki apostrof işareti arasına yazıyoruz ( '.....' gibi ). Bu arada eğer programları kopyala/yapıştır yolu ile pascal'a aktarıyorsanız (ki bunu yapmasanız daha iyi öğrenirsiniz) Türkçe karakterlerde sorunlar vuku bulmuş olabilir(!). Bu windows ile ms-dos'un ascii karakterlerinin farklı olmasından kaynaklanıyor ve telafisi zor. En iyisi elle yazmak. Bu arada ilerde ascii'nin de ne olduğuna değineceğimiz için "bu ascii de ne demek" diye düşünmenize gerek yok.
Bir string ifade aksi belirtilmedikçe maksimum 255 karakter uzunluğunda olur ve hafızada 256 byte alan işgal eder. Aksi belirtilmedikçe diyince hemen aksini belirtip daha uzun olabileceğiniz sanmayın. Tersine daha az olabilir. Peki nasıl aksini belirteceğiz.


Var
isim: string[40];
şeklinde. Artık isim adlı string değişkenimiz en fazla 40 karakter uzunluğunda olabilir ve 41 byte yer kaplar (Neden mi 41 byte? Unutmazsak sonra anlatırız onu da!). Bir insanın ismi de 40 harften fazla olamayacağından (ya da olsa bile kısa yazsın sayın kullanıcılarımız!) gereksiz yere 256 bytelık yer işgal etmeyip 215 byte kar edelim. Artık bu değşkene 40 harften daha uzun bilgi girilmek istenirse sadece ilk 40 karakterini alır ve gerisini yok sayar.
String tipin çok özelliği var. Bunları ilerdeki konularda göreceğiz. Ancak şimdi String tiplerde çok işinize yarayacak (ilk etapta gereksiz gözükebilir ama döngüleri ve karar deyimlerini gördükten sonra daha iyi anlayacaksınız) bir özelliğe gözatalım. Bir string değişkenin x. karakterini elde etmek için string_ifade[x] şeklinde kullanılır. Yani isim adlı bir string değişkenimizi isim='www.kalkan.cjb.net' olarak tanımlayııp sonra da write(isim[5]); komutunu verirsek ekrana sadece k harfi yazılır. Bununla ilgili çok örnek yapacağımızdan şimdilik üzerinde durmayalım ve örnek yapma işini size bırakalım.
Sayısal ve string değişkenlerden sonra programcılığın vazgeçilmez değişkeni olan Char tipini anlatalım. Şimdilik fazla işinize yaramayacak (çünkü daha kontrol ve karar verme'yi görmedik) ama ilerde programlarınızda ilk tanımlayacağınız değişken olacağından emin olabilirsiniz.
Char Değişken Tipi:
String değişkenler 255 karakterlik veri alabiliyordu. Char ise tahmin edeceğiniz gibi daha fazla karakter almıyor! Char tipinde bir değişken yanlızca bir adet karakter alabilir ve bir byte yer kaplar hafızada. Yine string tipindeki gibi değer atamasında iki apostrof işareti arasına en fazla 1 karakter olabilecek şekilde yazılır. Örnek bir program yapalım daha iyi anlarız.
Program Char_Tipinde_alistirma;
Uses crt;
var
c: char;
isim: string;
a: byte;
begin
clrscr;
write('Yine adınızı girin bakalım....: ');readln(isim);
write('Şimdi en fazla ',length(isim),' olacak şekilde sıfından büyük bir sayı giriniz: '); readln(a);
c:=isim[a];
writeln('Sizin isminizin ',a,'. harfi "',c,'"');readln;
end.

Bu örnek şimdiye kadar yaptıklarımızın en karışığı gibi gözükebilir ama biraz dikkat ederseniz anlayacağınız kesin. clrscr; komutuna kadar olan yeri biliyorsunuz. Ondan sonra isim adlı değişkene ekrandan (daha sonra ayrıntılı olarak anlatacağımız şekilde) bilgi girilmesi isteniyor. Ondan sonra yazılan write ifadesinde bilmediğimiz birşey var. Length fonksyonu bir string tipli ifadenin kaç karakter uzunluğunda olduğunu verir. Bunu da daha sonra anlatacağız. Ondan sonra c:=isim[a]; ifadesinde c adlı char değişkene isim değikeninin a. karakterini atıyoruz. Mesela isminiz "Osman" ise ve a değerine de 3 girdiyseniz c:= ifadesinin karşısındaki değer 'm' olur. Yani c değişkeninin değerine 'm' harfini (karakterini) atamış oluruz. Programı birkaç defa çalıştırarak daha iyi anlayabilirsiniz.
Tabii bu şekilde bizim pek işimize yaramayabilir ama özellikle bir char tipindeki değişkeni readkey komutuyla kullanılarak faydalanabiliriz. Bunlara ilerde değineceğiz.
Bunların dışında şu anda hemen kullanamayacak olsak da diğer tiplere de kısaca değinelim.
Boolean Tipli değişkenler:
Değeri ya TRUE (doğru) ya da FALSE (yanlış) olabilen değişkenlerdir. Mantıksal karşılaştırmalarda kullanılabilir. Hafızada 1 byte alan kaplar.
Bundan sonraki tipdeki olan dizi ve record tipleri için sonraki derslerde özel bir bölüm açıp anlatacağı çünkü kullanım alanları çok geniş.
Dizi (Array) tipli değişkenler:
Dizi değişken genelde benzer bilgileri bulunduran değişkenlerdir. Örnek verirsek daha iyi anlaşılır. Önceki programlarımızın birisinde hatırlarsanız bir öğrencinin üç notunun ortalamasını bulmuştuk. Peki 1 değil de 100 öğrenci varsa ne olacak. Her birisi için üç not ve bir ortalama olmak üzere 4 değişken tanımlarsak toplam 400 değişken tanımlamamız lazım. Bu hem çok uzun zaman alır, hem de değişken isimlerini birbirine karıştırmamız olasıdır. Bunun yerine 100 öğrencinin 3'er notunu ve ortalamasını sadece 2 değişken kullanarak kolayca tutabiliriz. Bunun için değişken tanımlarımız
Var
notlar: Array[1..100,1..3] of byte;
ortalama: Array[1..100] of real;
şeklinde olmalıdır. Şimdilik bunları nasıl kullanacağımız fazla değinmeden geçelim çünkü diziler diye ayrı bir bölümde hepsini anlatacağım.
Kayıt (Record) tipli değişkenler:
Şimdiye kadar bir öğrencinin adı, notları ve ortalaması için ayrı değişkenler kullandık. Peki bunların hepsini bir ana değişkenin alt değişkenleri olarak tutsak daha kolay ve anlaşılır olmaz mı? Özellikle bu tip değişkenler dosyalama konusunda çok işimize yarayacak. Genel olarak tanımlaması şu şekildedir:
Type
kayit_tipi=Record
değişkenler...
end;
Var
kayit_adi = kayit_tipi;

Gördüğünüz gibi bu tip bir değişkeni tanımlamak için type etiketini kullanıyoruz ve yeni bir tip oluşturuyoruz ilk önce. Sonra bir değişkeni tipi bu olacak şekilde tanımlıyoruz. Hemen örnek bir program yazalım. Bunu kendi ellerinizle yazmalısınız (ben de hep öyle yapıyorum):

Program
uses crt;
type
ogrenci_tipi=Record
isim: string[40];
not1: byte;
not2: byte;
not3: byte;
orta: real;
end;
Var
ogrenci: ogrenci_tipi;
Begin clrscr;
write('İsminiz:');readln(ogrenci.isim);
write('1. Sınavın sonucu:');readln(ogrenci.not1);
write('2. Sınavın sonucu:');readln(ogrenci.not2);
write('3. Sınavın sonucu:');readln(ogrenci.not3);
ogrenci.orta:=(ogrenci.not1+ogrenci.not2+ogrenci.n ot3)/3;
write('Ortalamanız: ');write(ogrenci.orta);
readln;
end.
Gördüğünüz gibi kayıt tipindeki bir değişkenin alt değişkenini nokta ile ayırarak kayit_degiskeni.alt_degisken seklinde yazıyoruz. İsterseniz with deyimini kullanarak alt değişken isimlerini direk de kullanabilirsiniz:
Program
uses crt;
type
ogrenci_tipi=Record
isim: string[40];
not1: byte;
not2: byte;
not3: byte;
orta: real;
end;
Var
ogrenci: ogrenci_tipi;
Begin clrscr;
with ogrenci do begin
write('İsminiz:');readln(isim);
write('1. Sınavın sonucu:');readln(not1);
write('2. Sınavın sonucu:');readln(not2);
write('3. Sınavın sonucu:');readln(not3);
orta:=(not1+not2+not3)/3;
write('Ortalamanız: ');write(orta:5:2);
end;
readln;
end.

Bu iki program de birbirinin aynısı işlemleri yapar. With Türkçe'de "ile, beraber" demektir.Şimdilik bu record tipinin üzerinde fazla durmayalım. Dosyalar konusunda ayrıntılı olarak göreceğiz zaten.
En çok kullanılan değişken tiplerini gördük. Bir de set, yani küme tipi var. Ona da kısaca değinelim.
Set (Küme) Tipi:
Aynı tipte ve birbiriyle ilgili bilgilerin, verilerin oluşturduğu topluluğa küme denir. Mesela 0 ile 9 sayılarından bir küme oluşturabiliriz. Ama bu kümenin içinde "A" harfi geçemez. Çünkü "A" sayı değildir. Kümenin elemanları birbirinden virgül yardımıyla ayrılır. Mesela birkaç küme örneği verelim:
['Ali', 'Ahmet', 'Süleyman', 'Halil İbrahim']
[0,1,2,3,4,5,6,7,8,9]
['E', 'e', 'H', 'h', #27]

gibi kümeler olabilir. Eğer kümenin elemanları birbirini takip eden cinsten ise aralarına virgül koymak yerine ilkini yazıp ardından .. koyup sonuncusunu yazabiliriz. Mesela
[0..9]
['A'..'Z', 'a'..'z']

gibi. İlki olan [0..9] ile bir önceki örneklerde olan ve 0'dan 9'a kadar olan bütün tamsayıların yazıldığı örneğin hiçbir farkı yoktur. Kümeler böyle ama bunları Type bloğunda şöyle tanımlarız:
Type
harfler = Set of ['A'..'Z', 'a'..'z'];
rakamlar = Set of [0..9];
cevaplar = Set of ['EVET', 'HAYIR']

Bu şekilde tanımlanan kümelerin nasıl kullanılacağını sonraki konularda örneklerin içerisinde göreceğiz. Ayrıca kümeler üzerinde kesişim (*), Birleşim (+), Fark (-) ve ilişki (=, <>, <=, >=, in) işlemleri yapılabiir. Özellikle 'in' işleminden çok faydalanacağız. Kümelerin içerisinde aynı eleman yanlızca bir kez kullanılabilir ve öncelik sırası yoktur. Şimdi küme ile ilgili bir program yapalım. Şimdilik bunda anlamayacağınız yerler olabilir:
Program Kume_Denemesi;
Uses Crt;
Label

en_bas;
var
tus:char;
Begin
en_bas:
tus:=readkey;
Clrscr;
if tus in ['0'..'9'] then begin
writeln('Bastığınız Rakam: ',tus);
goto en_bas;
end else begin
clrscr;
writeln(tus,' bir rakam değil!');
end;
readln;
End.

Bu programı TP'da yazıp çalıştırdığın ve klavyenizde rakamlara basın. Bastığınıza rakam ekranda gözükecektir. Çıkmak için rakam hariç bir tuşa (herhangi bir harfe) basmalısınız. Programda daha öğrenmediğimiz komutlar var. Ama kalın yazılı olan yere dikkat ederseniz küme'nin en sık kullanıldığı yer göreceksiniz. Burada basılan tuşun 0 ile 9 arasında bir rakam olup olmadığı, başka bir değişle basılan tuşun 0'dan başlayıp 9'da biten elemanlardan oluşan bir kümenin içinde olup olmadığı kontrol ediliyor. Eğer doğru ise ekrana bu rakam yazılıyor değilse (yani bu şart yanlış ise) basılan tuşun bir rakam olmadığı yazılıyor ve enter'a basılması bekleniyor.
Sabitler:
Daha önce gördüğümüz tür olan değişkenlerin değerlerini program içerisinde değiştirebiliyorduk ya da başka işlemlere tabii tutabiliyorduk. Sabit türündeki verilerin ise değerini değiştiremeyiz, program boyunca (adından da anlaşılabileceği gibi) sabit kalırlar. Pek kullanılmamakla beraber bazen işe yarayabilir. Mesela matemaiksel bir işlem yapıyoruz ve bu işlemde de birçok yerde pi sayısını kullanıyoruz. Her seferinde 3,1415.. diye yazacağımıza bunu pi isimli sabit bir değişkene aktararak işimizi kolaylaştırabiliriz. Gerçi pi adlı sabit bir değişkeni pascal otomatik olarak oluşturur ama başka amaçlar için kullanabiliriz. Basit bir örnek verelim:
Program denemedir;
uses crt;
const
max=500;
min=10;
var
sayi:integer;
begin clrscr;
write(min,' ile ',max,' arası bir sayı giriniz....:');readln(sayi);
clrscr;
writeln('Yazdığınız Sayı ',sayi);
readln;
end.

Belki bu programda bize kolaylık sağlamadı ama eğer bu min ve max değerlerini programımızda 20 kere kullansaydık her seferinde değerini yazacağımıza akılda kalır bir şekilde min (minumum) ve max (maksimum) manasında iki sabit kullanmamız daha iyi olur. En büyük avantajı da mesela min ve max değerlerini değiştirdiğinizde bütün program içindekileri değiştirmenize gerek kalmaz. Aksi takdirde eğer el ile 10 ve 500 gibi yazsaydınız bu durumda hepsini tek tek değiştirmeniz gerekecekti. Tabii ki sadece sayı değil, string değişkenler de kullanabilir hatta işlem de yapabilirsiniz. İşte size örnek bir sabit bloğu tanımı:
Const
max = 200;
min = 0;
orta = (max + min) div 2;
web = "www.universiteli.net";
numara = ['0'..'9'];
harf = ['A'..'Z','a'..'z']
NumaraHarf = harf + numara;
ISIK_HIZI=300000;
A = chr(65);
Sabitlere de kısaca değindikten sonra tiplere geçelim. Zaten Pascal'da tip kavramını biliyoruz. Tipler konusunda da kendi tiplerimizi oluşturmaya çalışacağız.
Özel Tipler
Genelde kendi özel tiplerimizi kayıt tipi oluştururken kullanırız. Ama ilk önce basitten başlayalım. Mesela isimleri girebileceğimiz bir değişken olsun. Bir ismin en fazla 20 harf olabileceğini varsayarsak o zaman yeni bir tip yapabiliriz. Yeni bir tip yapalım ve bu tip 20 karakter içeren bir string olabilsin.
Type
str20=string[20];
Var
isim:str20;

dersek bundan sonra isim adlı değişkenimiz en fazla 20 karakterli olabilir. Ancak özel tipleri genelde bu şekilde değil de pointer, record gibi tiplerin kullanımında kullanırız. Record (kayıt) tipleri mutlaka type etiketiyle tanımlanmalıdır. Daha önce -record tipini anlatırken- yaptığımız uygulamayı yaptıysanız zaten type etiketinin kullanımını anlamış olmalısınız. Ayrıca type etiketi set (küme) tiplerinde de çok kullanılır. İlerde özel tiplerden daha çok yararlanacağız. Şimdilik ne olduğunu bilsek yeter.
Label:
Pascal'da programın akışını değiştirmek (ileriye atamak ya da başa döndürmek gibi) için label denilen etiketler kullanılır. Bu etilekin ismi sizin belirleyeceğiniz ve değişken ismindeki kurallara uygun herhangi bir isim olabilir. Labeller goto ifadesiyle birlikte kullanılır. Goto "git" anlamındadır ve programın içerisinde daha önceden tanımlanmış olan yere gidilmesini sağlar. Şimdi bir örnek yapalım, bu örnekle daha iyi anlayacaksınız:
Program Ornek1;
Uses crt;
Label
en_bas;
var
sayi: byte;
begin clrscr;
sayi:=1;
en_bas:
writeln(sayi);
sayi:=sayi+1;
if sayi<=20 then goto en_bas;
readln;
end.

Bu programı çalıştırırsanız ekrana 1'den 20'ye kadar olan sayıları yazar. Aslında bu programla döngü kavramına da ilk adımımızı atmış olduk. eğer bu şekilde label ve goto kullanmasaydık her sayıyı tek tek yazdırmak ve dolayısıyla 20 satır writeln; komutu kullanmak zorunda kalacaktık. Oysa sayi değişkeninin ilk değerini 1 yapıyoruz ve bundan sonra ekrana yazdırıyoruz, sonra sayı'yı 1 artırıyoruz ve sayı değişkeninin değerinin 20'den küçük veya eşit olup olmadıını kontrol ediyoruz. Eğer şu anki sayı 20'den küçük ya da 20'ye eşitse programın akışını en_bas etiketiyle tanımladığımız yere gönderiyoruz. Bu şekilde her seferinde sayı'yı 1 artırdığımızdan sayı 21 olunca program duruyor. Ama 21'i yazmıyor. Çünkü 21 olunca başa gitmiyor program. Bu goto ve label'i aslında algoritmayı anlatırken kullanmıştırk. Orada "eğer hava yağmurlu değil ise 4. adıma git" diye bir ifade kullanmıştık. İşte onun kod karşılığı budur. Label'i Label etiketinden sonra tanımlıyoruz ve kullanırken de boş bir satıra label_adi: yazarak kullanıyoruz. Bu arada if deyimini daha sonra anlatacağım. Bu örneği biraz daha geliştirelim ve 1'den 20'ye kadar olan sayıların karesini hesaplayan programı yapalım ama programdan 8'in karesini ekrana yazmamasını isteyelim. 8 hariç diğerleri yazsın. Programımız şöyle olacaktır:
Program Ornek2;
Uses crt;
Label
en_bas, atla;
var
sayi: byte;
begin clrscr;
sayi:=1;
en_bas:
if sayi=8 then goto atla;
writeln(sayi:2,' -> ',sayi*sayi);
atla:
sayi:=sayi+1;
if sayi<=20 then goto en_bas;
readln;
end.

Gördüğünüz gibi bu sefer iki adet label kullandık ve sayı'nın 8'e eşit olması halinde write'ln komutunun sonuna geçilmesini (ve bu durumda bu komutun çalışmamasını) sağladık. Programı satır satır incelerseniz ne kadar kolay olduğunu göreceksiniz. Bu şekilde döngü kurarak uzun işlerimizi kısalttık ama özel döngüleri görünce bu işlerin daha da kısalabileceğini göreceksiniz. Şimdi bir de hani algoritmalarda yaptığımız şemsiye hikayesini yapalım da adet yerini bulsun. İlk önce algoritmayı hatırlayalım:
1) Pencereden dışarıya bak.
2) Eğer hava yağmurluysa 4. adıma geç.
3) Şemsiyeni al.
4) Dışarı çık.
Bu problemi Pascal'a uygulayalım. Amabilgisayar'dan "pencereden dışarı bakmasını" isteyemeyeceğimize göre bunun yerine bir değişkenin değerine bakmasını isteyebiliriz. Program şöye olsun: Çalışsınca sizden "Y" ya da "D" harflerinden birisini girmenizi istesin. Eğer Y harfini gierseniz hava yağmurlu demek olsun ve şemsiye alınsın ve ekrana şemsiyeyi aldım yazsın, D girerseniz şemsiye alınmadı yazsın. Programı şöyle yapabiliriz:
Program Ornek3;
Uses crt;
Label
gidilecek_yer;
var
SemsiyeDurumu: string;
HavaDurumu: char;
begin clrscr;
SemsiyeDurumu:='Hava açık, şemsiye Alınmadı!';
writeln('Hava Nasıl Oralarda ( Y -> yağmurlu, D -> yağmurlu değil ) ?');
HavaDurumu:=readkey;
if HavaDurumu in['D','d'] then goto gidilecek_yer;
SemsiyeDurumu:='Hava yağmurlu, şemsiye Alındı!';
gidilecek_yer:
writeln('Sonuç: ',SemsiyeDurumu);
readln;
end.



Bu programı satır satır incelerseniz label'in kullanımını anlarsnız. Programı algoritmaya göre yaptık. Bu programı daha kısa olarak şöyle de yapabilirdik:
Program Ornek3_2;
uses crt;
var
hava:char;
begin clrscr;
writeln('Hava Nasıl Dostum ( Y -> yağmurlu, D -> yağmurlu değil ) ?');
hava:=readkey;
if hava in['Y','y'] then writeln('Hava yağmurlu, şemsiye alındı!')

else writeln('Hava açık, şemsiye alınmadı!');
readln;
end.

Gördüğünüz gibi daha kısa bir program oldu. Zaten programcının amacı daha kısa program yazmak değil midir? Öyledir. Ben yukardaki örneği label deyimini öğrenmek için verdim. Label'leri ilerde çok kullanacağız. Bu arada programlarımıza "in" ifadesini de kullandık. Hava değişkeninin değerinin y ve Y elemanlarını içeren bir kümenin içerisinde olup olmadığını kontrol etmek içindi bu. y ve Y kullanmamızın sebebiyse kullanıcının küçük y mi yoksa büyük Y mi yazacağını önceden bilmememizdendir. İyi bir programcı her ihtimali düşünmeli. Gerçi yukardaki örneklerde her ihtimali düşünmedik ama ilerde onları da düşüneceğiz.
Write/Writeln
Programlamanın en genel amacı kullanıcıdan bazı değerleri alıp birtakım -önceden programcı tarafından beirlenmiş- işlemlerden geçirilip sonuçta bulunan değeri ekrana yazmak olduğu için her programama dilinde kullanıcıdan veri alma ve ekrana veri yazma deyimleri vardır. Pascal'da kullanıcıdan read ya da readln komutlarıyla veri alınır ve ekrana write ya da writeln komutlarıyla yazılır.
Write/Writeln:
Ekrana birşeyler yazmak için kullanılır. Bu şey sabit bir yazı olabileceği gibi bir değişken de olabilir. Bu durumda değişkenin kendisinin adı değil, değeri yazılır. Ya da direkmen bir işlemin sonucu da yazdırılmak istenebilir. Hatta bunlardan iki ya da daha fazlasını da birlikte yazdırabiliriz. İlk önce ekrana sabit bir yazı (yazı diyoruz ama sayı ya da işaret de olabilir) yazdırmak için kullanımına bakalım. Bu durumda Write(ifade); gibi kullanılır. ifade yerine iki apostrof işareti arasında birşeyler yazılabilir. Örneğin write('www.universiteli.net'); gibi. writeln(ww.universiteli.net); gibi değil! Çünkü bir değişken adı değildir (ve olamaz da..). Bununla ilgili küçük bir uygulama yapalım:
Proram uygulama01;
uses crt;
begin clrscr;
writeln('Tayfun Erikan');
write('Web Sitesi:');
writeln('www.universiteli.net');
readln;
end.


Bu program herzaman aynı sonucu verir. Burda belki farketmişsinizdir write ile writeln'in farkını. Write istenen ifadeyi yazıp en sonunda bekler, writeln ise bir alt satırın başına gider ve orada bekler. Bekler dediğim şey imleçtir. Siz yazı yazarken yanıp sönen o şeye imleç denilir ve Pascal'da birşey yazmak istediğinizde imlecin bulunduğu yerden itibaren yazılır. Ekranın istediğimiz biryerine yazı yazdırmayı da anlatacağız. write ve writeln komutlarında bir değil de birden fazla ifade de verebilirsiniz:
Program uygulama02;
uses crt;
begin clrscr;
writeln('Tayfun Erikan');
writeln('Benim sitem:','www.universiteli.net');
readln;
end.
gibi. Gerçi burada pek işimize yaramıyor. Direkt olarak da yazdırabiliriz. Şimdi de bir değişkenin değerini yazdıralım. Bunu da write(değişken); şeklinde yaparız. Eğer write(değişken1, değişken2, değişken3); şeklinde 3 adet değişkeni yazdırırsak hepsi ard arda ve boşluk bırakılmadan yazılır.
program uygulama03;
uses crt;
var
ad, site: string;
sayi, karesi:longint;
begin clrscr;

sayi:=13;
karesi:=sayi*sayi;
ad:='Tayfun Erikan';site:='www.universiteli.net';
writeln(ad);
writeln('web sitesi ', site);
writeln(sayi,'->', karesi);
readln;
end.
Gördüğünüz gibi sabit ifade ile değişken de aynı write komutuyla kullanılabiliyor. Bu arada write('web sitesi ',site); ile write('web sitesi ', site); komutunun Pascal için hiçbir farkı yoktur. Yani -ilk başlarda da anlattığım gibi- Pascal'da boşuklar önemli değildir (tırnak içindekiler hariç). Mesela a:=b+c; ya da a := b + c; yazabilirsiniz. Bu sizin keyfinize kalmış. İkisi de aynı işi apar. Hatta
program uygulama04;
uses crt;
var
ad, site: string;
sayi:longint;
begin clrscr;

sayi:=13;
ad:='Tayfun Erikan';site:='www.universiteli.net';
writeln(ad);
writeln('web sitesi ', site);
writeln(sayi,'->',sayi*sayi);
writeln('15 x 3 = ', 15*3);
readln;
end.
Programa bir writeln daha ekledik. Gördüğünüz gibi writeln komutuyla işlemin sonucunu da yazdırabiliyoruz. Bunu da inceleyin. Eğer write ile bir sayı yazdıracaksanız sayılara özel olarak write(82); ile write('82'); aynı işi yapar ve sorun çıkartmaz. Ama write('Ahmet'); ile write(Ahmet); aynı değidir. Birincisinde ekrana Ahmet yazar ama ikincisinde Ahmet adlı bir değişkenin olup olmadığına bakar, eğer varsa değerini ekrana yazar, ancak böyle bir değişken daha önceden (var etiketi ile) tanımlanmamışsa program çalışmaz. Onun için tırnaklara dikkat edin.
Artık bir değişkenin değerini ya da herhangi birşeyi ekrana nasıl yazacağımızı öğrendik. Ancak write ve writeln komutunun bir önemli özelliği daha var. Sayısal bilgileri istenilen biçimde yazabilmesi. Özellikle elimizde birden çok sayısal bilgi varsa bunları alt alta yazarken hepsinin sağa dayalı olarak eşit hizaya yazılmasını isteyebiliriz. Ya da virgüllerin aynı hizaya gelmesini isteriz. Bunu write komutunu write(sayı:X:Y); şeklinde yazarız. Burada x ve y birer sayı olacak. X sayısal değişkenin için toplam ayrılacak alanı, y ise ondalık kısmı için ayrılacak alanı ifade ederi. Eğer yazılacak sayı amsayı ise y'yi kullanmadan yanlızca writeln(sayı:X); komutunu kullanırız. Ayrıca sadece writeln; komutunu parametresiz olarak böylece kullanırsan bir alt satırın başına geçer. Örnek olarak basit bir program yazalım:
Program Bicimli_Sayilar;
uses crt;
var
sayi1,sayi2,sayi3:integer;
sayi4,sayi5,sayi6:real;
begin clrscr;
sayi1:=19;
sayi2:=1923;
sayi3:=7;
sayi4:=3.1415;
sayi5:=192.31293;
sayi6:=928314.3;
writeln('Sayilari Bicimsiz yazdik:');
writeln;
writeln(sayi1,' ',sayi4);
writeln(sayi2,' ',sayi5);
writeln(sayi3,' ',sayi6);
writeln(923,' ',95.7);
writeln;
writeln('iste bu da Bicimlisi:');
writeln;
writeln(sayi1:4,' ',sayi4:12:5);
writeln(sayi2:4,' ',sayi5:12:5);
writeln(sayi3:4,' ',sayi6:12:5);
writeln(923:4,' ',95.7:12:5);
readln;
end.

Programı çalıştırırsanız neden biçimli yazdırmamız gerektiğini göreceksiniz. Ayrıca gördüğünüz gibi illa syı yerine değişken kullanmak mecbur değil. Direk olarak bir sayı da kullanabilirsiniz. Ayrıca gördüğünüzü bildiğim halde sayi1 değişkeninin sonundaki 1'in konumuzla ilgisi olmadığını söyleyelim. Bir de iki sayının arasına boşluk koymak için ' ' kullandığımıza dikkat edin. Bu iki apostorufun arasında bir boşluk var.
Read/Readln Komutu
Ekrana yazı yazdırmayı gördük. Şidmi de ekrandan (daha doğrusu ekran vasıtasıyla kullanıcıdan) bir veri (isim, yaş, telefon numarası gibi..) almaya bakalım. Bu işlem için Read ya da Readln (genellikle readln) komutu kullanılır. Read komutunu kullanırsanız kullanıcı çok hata yapar. En iyisi readln kullanmak. Ben bunu anlatayım. Kullanım şekli Readln(değişken); şeklindedir ve kullanıldığından kullanıcıdan birşeyler yazıp enter'a basmasını bekler. Enter'a basılınca kullanıcının yazdığı verileri parantez içerisine yazılan değişkene aktarır ve artık bu değişkenin değeri bu olur. Yani üstüne falan eklenmez. Eski değeri silinir ve yeni değeri kullanıcı ne girdiyse o olur. Genellikle write komutuyla yan yana (daha doğrusu ar arda) kullanılır. Çünkü kullanıcının ne girmesi gerektiğini ona söylememiz lazım. Örnek için basit program:
Program Oku_bakiim;
uses crt;
var
a:integer;
isim:string[40];
begin clrscr;
write('Bu program verilen bir sayinin karesini ve kubunu bulur');
writeln;
write('Bir Sayi Giriniz: ');readln(a);
write(a,' sayisinin karesi ',a*a,' ve kubu ',a*a*a,' olur.');
writeln;
write('Adinizi giriniz: ');
readln(isim);
clrscr;
Writeln('Gule gule ',isim);
Writeln('Programi bitirmek icin Entera basiniz...');
readln;
end.

Programı TP'da yazıp çalıştırın ve sonucuna bakın. Bu program write/writeln ve readln komutlarının anlaşılmasına yeterlidir. Zaten ilerde bu iki komutu çok kullanacağız. Belki farketmişsinizdir bu readln komutunun bazı yetersizlikleri var. Mesela kullanıcıdan bir sayı girmesini istiyoruz. Ama kullanıcı sayı olmayan buraya birşeyler de yazabilir ve biz bunu engelleyemeyiz. Bu durumda program hata verir. Bunu önlemek için kendi readln komutumuzu kendimiz oluşurmalıyız. Bunu ilerde göreceğiz.
Readkey
Yeri gelmişken ilerde çok kullanacağınız Readkey fonksyonuna deyinelim. Dediğim gibi readkey bir fonksyondur ve sonucu bir karekterdir. yani sadece readkey; diye bir komut kullanılamaz. Çünkü sonucu karakter dediğimizden mesela sonucu 'A' harfi ise A; diye bir komut olabilir mi? Ama a:=readkey; ("A" için a:='A'; gibi..) ya da write(readkey); (write('A'); gibi..) gibi kullanılabilir. Readkey ingilizcede okunan harf manasına gelir. Bu fonksyonu kullanırsak program kullanıcının bir tuşa basmasını bekler. Basılan tuşun değeri readkey fonsyonunun sonucu olur. Fonksyon kavramına daha sonra değineceğiz nasl olsa. Şimdilik bir kullanılışını anlatalım yeter. Daha önceden kullanıcıya Evet mi? Hayır mı? gibi bir soru sorarken readln(değişken); gibi bir komut kullanıyorduk. Bu durumda kullanıcı illa E'ye ya da H'ye basmak zorunda değildi. Ancak readkey komutuyla bunu sağlayabiliriz. En azından sadece 1 tek harfe basılmasının ardından (Enter'a basılmasını beklemeden) bir sonraki komuta geçilmesini sağlayabiliriz. Örnek:

Program Deneme;
Uses Crt;
Var
a:char;
Begin Clrscr;
writeln('Merhaba, Devam etmek için herhangi bir tuşa basınız...');
a:=readkey;
writeln('Tabrik ederim. Tuşa basmayı başardınız');
writeln('Programı bitirmek için bir tuşa daha ihtiyaç var..');
a:=readkey;
End.

Bu şekilde kullanmamızın belki faydası olmadı ama en azından readln; komutundan daha iyi. O zaman bir de basılan tuşu ekrana yazan programı yapalım. Aşağıdaki programı çalıştırıp bir harfe ya da rakama basın:
Program Denemedir;
Uses Crt;
Var
harf:char;
Begin Clrscr;
writeln('Bir Tuşa Bas hemen ya da birdaha gözüme gözükme!');
harf:=readkey;
clrscr;
writeln('Sizin bastığınız tuş: ', harf);
writeln('Programı bitirmek için bir tuşa basınız..');
harf:=readkey;
end.

Buralarda neden char tipinde değişken kullandığımızı anlamışsınızdır. Çünkü basılan yanlızca bir tek tuş. Şimdi char tipli değişkenin ne işe yaradığını daha iyi anlamış olduk. Şimdi de programdan çıkılması için mutlaka X'e basılmasını şart koşan bir program yapalım. Birkaç ders sonra bunu çok daha kısa yapacağız ama şimdilik bildiğimiz komutları kullanalım:
Program Deneme_3;
uses crt;
label
geri;
var
harf:char;
begin clrscr;
writeln('Merhabalar..');
writeln('Kusura bakmayin, programimizi erken kapatiyoruz..');
writeln('Programi bitirmek icin X harfine basiniz..');
geri:
harf:=readkey;
if not (harf in['x','X']) then goto geri;
writeln('Efferin, programi kapattın..');
end.

if deyimini bir sonraki derste anlattım. Şimdilik kafanızı yormayın. Dikkat etmeniz gereken label kullanımı ve readkey komutu olabilir. Özellikle label'e tekrar bakın, belki unutmuşsunuzdur. Şimdilik bu kadar yeter. İlerde zaten her programımızda kullanacağımız bir komut readkey...
GotoXY
Şimdiye kadar yaptığımız programlarda hep ekranın sol üst köşesinden başlayarak bilgileri yazdırdık. Ancak sizin de aklınıza "Yahu bu ekranın istediğimiz yerine birşeyler yazdıramaz mıyız?" sorusunuz geldiğini tahmin ediyorum. Pascal'da ekranın istenilen yerine gitmek için gotoxy komutu kullanılır. Gitmek'ten kastım imleci istenilen yere götürmektir. Zaten ekrana write ile birşeyler yazarken imlecin bulunduğu yerden itibaren yazıldığını söylemiştik.
Bu komutun kullanımı
gotoxy(X,Y);
şeklindedir. Burada X yerine kaçıncı kolona gidilmesi isteniyorsa o kolonun numarası, Y yerine ise kaçıncı satıra gidilmesi isteniyorsa o satırın numarası yazılır. Normal bir ekranda 80 kolon ve 24 satır (25'e çıkartılabilir) vardır. Gotoxy komutunu kullanırken buna dikkat etmelisiniz. Yani gotoxy(83,12); komutunu yazarsanız büyük olasılıkla istediğiniz görüntüyü elde edemezsiniz! Bu komut genelde write ifadesinden önce kullanılır. Zaten amacı da ekranın istenilen yerine yazı yazdırmak değil mi? Bir örnek yapalım:
Program git_bakalim;
uses crt;
begin clrscr;
gotoxy(30,13);write('www.universiteli.net');
readln;
end.

gotoxy(X,Y); komutunda X ve Y yerine değişken de koyabiliriz. Tabii ki bir tam sayı tipli değişken (byte, integer, longint.. gibi). Bu durumda değişkenin değeri neyse ona göre işlem yapılır. Mesela küçük bir program yapalım:
Program gid_hele;
uses crt;
var
x,y:byte;
ad:string;
begin clrscr;
write('Adınız: ');readln(ad);
write('X kordinatı: ');readln(x);
write('Y kordinatı: ');readln(y);
clrscr;
gotoxy(10,23);
write('Bu program Tolga Yüzüncü tarafından yapıldı!');
gotoxy(x,y);
write(ad);
readln;
end.
Gotoxy komutunu programlarımızın içinde sıkça kullanacağız.

15-07-2009 13:08:09
 
Karşılaştırma ve Karar verme deyimleri
Programlamanın en zevkli yanı birşeyleri karşılaştırıp sonucuna göre bir işlem yapmak ya da yapmamaktır diyebilirim. Aslında programlama da zaten budur. Programlamaya ilk başlarken algoritmalar konusunda bir örnek vermiştik. Orada "Eğer hava yağmurluysa şemyiseni al" demiştik. Bu işlemi şimdiye kadar öğrendiğimiz komutlarla yaptırmamız olanaksızdır.
Karşılaştırma ve karar verme işlemleri olmasa program ilk satırından itibaren satır satır çalışır ve en sonunda "End." komutuyla biter. Yani program içerisinde belirli şartlarda programın akışı değiştirilemez. Pascal'da (ve neredeyse bütün programlama dillerinde ve scriptlerinde) kontrol deyimi if..then..else şeklindedir. Ayrıca Pascal'da başka kontrol deyimleri de vardır. If...then...else deyiminin genel kullanımı:
if (şart ya da şartlar) then
şart doğruysa yapılacak işlem
else
şart yanlışsa yapılacak işlem

gibidir. Tabii ki hepsi bir satırda da kullanılabilir. Ayrıca şartın doğru olması (ya da yanlış olması) durumunda birden çok işlem yaptırılmak isteniyorsa bu işlemlerin hepsi begin ile end arasına şu şekilde yazılır:
if (şart ya da şartlar) then begin
şart doğruysa yapılacak işlemler
end else
şart yanlışsa yapılacak işlemler

end;
begin ve end;'i birazdan anlatacağım. Şimdi çok basit bir örnek yapalım:
Program Deneme;
Uses Crt;
Var
notu:integer;
Begin Clrscr;
write('Matematik Dersinden Aldığınız Notu Giriniz: ');Readln(notu);
clrscr;
if notu>69 then write('Aferin Geçtiniz!') else write('Malesef Kaldınız!');
write(readkey);
end.
Bu program sınavdan aldığınız notu belirli bir işlemden geçiriyor ve sonucuna göre birşeyler yazdırıyor. Şimdi biraz daha ayrıntılı görelim. if komutuna kadar olan herşeyi daha önce gördük. Readln komutuyla sayısal bir bilgi olan sınav sonucu notu değişkenine aktarılıyor. Ondan sonra ekran siliniyor. Sonra şu komut var:
if notu>69 then write('Aferin Geçtiniz!') else write('Malesef Kaldınız!');
İlk önce bu komutla ne yapılmak istendiğine bakalım. Amaç eğer notu değişkeninin değeri 69'dan büyükse ekrana 'Aferin Geçtiniz!', eğer değilse (yani notu değişkeninin değeri 69'a eşit ya da daha küçükse) ekrana 'Malesef Kaldınız' yazdırmaktan ibarettir.

Yani bu komutun Türkçe meali:
Eğer notu değişkeninin değeri 69'dan büyük ise Aferin Geçtiniz! yaz, değilse Malesef Kaldınız! yaz.
notu>69 ifadesini parantez içerisine de yazabilirsiniz. Zaten birden fazla şart varsa parantez kullanmak mecburidir. Dikkat edin write('Aferin Geçtiniz!') ifadesinde noktalı virgül yok. Neden? Çünkü komut daha bitmedi. Derslerin başında "Pascal'da her komutun sonuna noktalı virgül konulur" demiştim.
Programlamada notu>69 ifadesinin değeri ya TRUE (doğru) olur ya da FALSE (yanlış). Burada notu'nun değeri 69'dan büyükse bu şart TRUE, değilse FALSE olur. Eğer Şart true ise THEN ifadesinden sonraki işlemler, eğer şartın sonucu false ise ELSE ifadesinden sonraki işlemler yapılır. Biraz düşünürseniz burada aslında else deyimi kullanılmadan da program yapılabilir.
Program Deneme;
Uses Crt;
Var
notu:integer;
Begin Clrscr;
write('Matematik Dersinden Aldığınız Notu Giriniz: ');Readln(notu);
clrscr;
if notu>=70 then write('Aferin Geçtiniz!');
if notu<70 then write('Malesef Kaldınız!');
write(readkey);
end.
Burada şartı 69 yerine 70 yaptık. Birşey farketmez. Maksat değişiklik olsun. Bu arada eğer write(readkey); de ne diyorsanız bir önceki konuya göz atın. Gördüğünüz gibi
if (notu>=70) then write('Aferin Geçtiniz!');
if (notu<70) then write('Malesef Kaldınız!');
ile
if (notu>=70) then write('Aferin Geçtiniz!') else write('Malesef Kaldınız!');
ifadeleri aynı işi yapıyorlar. Tabii ki else kullanmak daha mantıklı. if deyimine genel olarak anladıysak (ve kendimiz de biraz örnek yaptıysak) şimdi karşılaştırma işlemlerine bir göz atalım:






İşlem
Anlamı
=
Eşit. Sağındaki ve solundaki değerler birbirine eşit ise sonuç doğru, değilse yanlış olur.
<>
Eşit değil. Sağındaki ve solundaki değerler eşit değilse sonuç doğru, eşitse sonuç yanlış olur. Bu işlem sayısal olmayan (yani alfasayısla olan) ifadelerde de kullanılabilir.
>
Büyüktür. Solundaki değer Sağındaki değerden büyükse sonuç doğru, değilse yanlış olur.
<
Küçüktür. Solundaki değer Sağındaki değerden küçükse sonuç doğru, değilse yanlış olur.
>=
Büyük eşit. Solundaki değer sağındaki değerden büyükse ya da eşit ise doğru, değilse yanlış olur.
<=
Küçük eşit. Solundaki değer sağındaki değerden küçük ya da eşit ise doğru, değilse yanlış olur.
in
İçerisinde. Solundaki değer sağındaki kümenin içerisinde mevcut ise değeri doğru, değilse yanlış olur.

Buradaki doğru (True) ya da yanlış (False) kavramlarını belirtmiştim. Program akışı bunlara göre belirlenir. Şimdiye kadar öğrendiklerimizle bir öğrencinin Matematik dersinden 100 üzerinden aldığı sınav notunu 5'lik sisteme çeviren programı yapalım. Beşlik sistemin ne olduğunu biliyorsunuzdur:
0-44 arası 1
45-54 arası 2
55-69 arası 3
70-84 arası 4
85-100 arası 5
şeklindedir. Buradan öğrencilerin 5 alamamasına kızan velilere duyurulur. Şimdi programımızı yazalım:
Program Denemedir;
Uses Crt;
Var
yuzluk, beslik:byte;
Begin Clrscr;
write('Matematik sınavının sonucu (0 ile 100 arası)..: ');readln(yuzluk);
if yuzluk<=44 then beslik:=1;
if (yuzluk>=45) and (yuzluk<=54) then beslik:=2;
if (yuzluk>=55) and (yuzluk<=69) then beslik:=3;
if (yuzluk>=70) and (yuzluk<=84) then beslik:=4;
if yuzluk>=85 then beslik:=5;
clrscr;
writeln('Yüz üzerinden.....: ',yuzluk);
writeln('Beş üzerinden.....: ',beslik);
readln;
end.

Gördüğünüz gibi artık öğrenciler her sınavdan sonra aldıkları notun 5'lik sistemde kaça denk geldiğini kara kara düşünmeyecekler. Açacaklar programı yazacaklar notlarını, bilgisayar hesaplayacak Bu arada bu and kelimesinin nereden ve neden geldiğini anlatacağım, şimdiden paniğe kapılmayın.


Bu arada şimdiye kadar yaptığımız programlarımızı EXE yaptınız mı bilmiyorum. Eğer hala denemediyseniz bunu yapın mesela. Açın programınızı ve ilk derslerde anlattığı gibi exe yapın. Muhtelemen exe dosyanız pascal'ın bulunduğu dizinde oluşacaktır. Ordan bulabilirsiniz. Exe dosyanız oluştuğu halde bulamıyorsanız Başlat menüsünden Bul/Dosya ve Klasörler seçeneğinden dosya adını yazarak arayabilirsiniz. Dosyanızı nasıl exe yapacağınızı unuttuysanız. Programı exe yapmayı başardıysanız Windows'ta çift tıklayarak çalıştırabilirsiniz artık. If then else kalıbına genel bir giriş yaptık. Şidmi devam edelim
if then else kalıbının genel olarak "if (şart ya da şartlar) then begin işlemler.. end else begin işlemler.. end;" şeklinde olduğunu söyledik. Yani if ile birden çok şartı da sınayabiliriz. Aslında başta if kalıbının mantıksal karşılaştırma olduğunu söylemek gerekirdi ama zaten sizin anladığınızı sanıyorum. Yani siz bu if kalıbını kullanınca bilgisayara bir mantıksal karşılaştırma yaptırıyorsunuz. Bir önceki örneğimizde if ile birlikte iki şart kullandık. Şartımız şöyle idi:
if (notu>=55) and (notu<=69) then beslik:=3;
Burada and kelimesiyle (Türkçesi "ve" demektir) yanlızca iki şartın da doğru olduğu durumlarda bu işlemi yapmasını söylüyoruz. (Bu arada tahmin ettiğiniz gibi else'in kullanımı zorunlu değil.) Yukardaki şartın Türkçesi şöyledir:


Eğer notu değişkeninin değeri 55'ten büyük ya da 55'e eşit VE notu değişkeninin değeri 69'dan küçük ya da 69'a eşit ise beslik değişkeninin değerini 3 yap.
Burada >= ve <= kullandığımızdan cümle biraz karışık oldu. Başka bir örneği Türkçe'ye çevirelim. Örneğin;
if (notu>54) and (notu<70) then beslik:=3;
Kalıbının Türkçe'si daha sade olur ve yukardaki örnekle aslında aynı işi yapar (Sayılara dikkat ederseniz bunu görürsünüz):
Eğer notu 54'den büyük VE 70'den küçük ise beslik değişkeninin değerini 3 yap.
Yani burada aslında bilgisayara notu değişkeninin değerinin 55 ile 69 arasında olduğu durumlardan bahsediyoruz. Zaten notu değişkeninin değeri 54'den büyükse ve 70'den küçükse bunlardan başka bir sayı olamaz. Peki ilk derslerimizde öğrendiğimiz Set (yeni Küme) tipinde bir veri kullanarak bunu daha kısa ve anlaşılır olarak yapamaz mıyız. Mesela bilgisayara direk olarak "Eğer notu 55 ile 69 arasındaysa beslik değişkeninin değerini 3 yap" diyemez miyiz? Deminki örnekte And kullanmıştık, burdada Türkçesi içerisinde, içinde anlamında olan in kelimesini kullanacağız. Yani notu değişkeninin değerinin "55 ile 69 arasındaki tüm sayıları kapsayan bir küme" içerisinde olup olmadığını kontrol edeceğiz. Nasıl mı? İşte böyle:
if notu in [55..69] then beslik:=3;
Gördünüz mü ne kadar kısa ve anlaşılır oldu! Burada kümemiz [55..69] 'dur. Bunu daha önce anlatmıştık. Ama birazdan in ifadesiyle kullanımını özel olarak ele alacağız. Şimdi and ve in gibi diğer ifadelerin hepsine bir göz atalım:
İfade
Anlamı
AND
Ve demektir. Arasına konulduğu iki (ya da daha fazla) şartın hepsinin doğru olduğu durumlarda sonuç doğru, aksi halde yanlış olur.
OR
Veya anlamındadır. Arasına konulduğu iki (ya da daha fazla) şartın en az birisinin doğru olduğu durumlarda sonuç doğru, aksi halde, yani hepsi yanlış ise sonuç yanlış olur.
NOT
Değil manasındadır. Bir ya da daha fazla şartın soluna konulduğunda şartların sonucunun tersini yapar. Yani sonuç true ise false, false ise true olur.

In ifadesi bunların içerisine girmiyor. Zaten onu bir önceki sayfadaki tabloda vermiştik. Ayrıca bir de az kullanılan xor var ama ben şimdiye kadar onu hiç kullanmadım. Gerekirse ilerde anlatırız. Anlamı "veya değil"dir.
Şimdi çok kullanılan in ifadesinde kullanabileceğimiz kümeleri anlatmanın yeri geldi. Hani "ilerde yeri gelince anlatacağız" demiştik ya işte o yer bu yer. Küme'nin ne olduğunu az-çok biliyorsunuzdur. Zaten öğrenciyseniz matematiğe her sene kümelerden başlanmasına ve "İngilizce bilenlerle Fransızca bilenlerin toplamı kaçtır" türündeki saçma sapan problemlere alışmışsınızdır. Pascal'da küme (Matematikte olduğu gibi) benzer türde verilerin oluşturduğu ve aynı verinin (yani Matematikteki tabiri ile elemanın) en fazla bir defa kullanılabildiği ve üzerinde kesişim, birleşim gibi birsürü işlemin yapılabildiği elamanların tümüne denir. Mesela Sınıfınızdaki öğrencilerden bir küme oluşturabilirsiniz. Ondan sonra bir program yaparsınız ve girilen bir ismin sizin sınıfınızın içerisinde olup olmadığını kontrol edebilirsiniz. Bunu in ile yaparız. in ifadesinin sağına bir kümse soluna da bir eleman konulur.
Eğer bu eleman kümenin içerisinde var ise sonuç doğru (true), yoksa haliyle sonuç da yanlış (false) olacaktır. Pascal'da kümenin elemanları kköşeli parantez içerisine yazılır. Örnek bir küme:
[1,2,3,4,5,6]
Bu küme 1'den 6'ya kadar olan tamsayılardan oluşuyor. Pascal'da bu tür sıralı olarak giden verileri daha kısa yazabilirsiniz. Mesela şu küme yukardaki le aynıdır:
[1..6]
Birden yüze kadar olan sayıları yapabileceğinizi düşününce eperyce bir kolaylık sağlar. Ama mesela kümseninin içerisinde bir de 9 bulunsun:
[1,2,3,4,5,6,9]
Bu durumda [1..9] yazarsanız olmaz, çünkü içerisinde 7 ve 8 de girer. Ama [1..6] yazarsanız da bu sefer 9 olmaz. O halde 9'u ayrıca yazmalısnız:
[1..6,9]
Hadi bir de kümemiz şöyle olsun:
[1,2,3,4,5,6,9,10,11,12]
Yani 1'den 12'ye kadar olan sayılardan 7 ve 8 yok. Bu durumda şöyle yapabiliriz:
[1..6,9..12]
Gördüğünüz gibi Pascal bize kolaylık sağlıyor. Hatta bu kümeyi iki küme şeklinde düşünüp ikisini toplasak da aynı olur. Burada toplamak birleştirmek manasındadır:
[1..6] + [9..12]
Tabii ki kümelerimiz sadece sayılardan oluşmayabilir. Harf ya da herhangi bir string ifade de olabilir. İşte size birkaç küme örneği:
['e','E','h','H']
['a','b','c','d','e','f','g','h','i']
['a'..'i']
['a'..'j','p','q','x'..'z']
['universite', 'www.universiteli.net','Ahmet','Osman','Nilgün']
Örnekleri siz de çoğaltabilirsiniz. Burada 2. örnekle 3. örneğin aynı olduğunu farketmişsinizdir. Şimdi bu kümeler üzerinde in metodunu kullanarak işlemler yapalım. Mesela ekrana "programdan çıkmak istiyor musunuz?" diye bir mesaj yazılsın ve eğer E tuşuna basılırsa programdan çıksın, h tuşuna basılırsa tekrar başa dönsün:



Program Denemedir;
Uses Crt;
Label
en_bas;
Var
a:longint;
tus:char;
Begin
a:=1;
en_bas:
Clrscr;
writeln('A nin su anki degeri: ',a);
a:=a+1;
writeln('Cikmak istiyor musunuz ( E -> Evet , H -> Hayir) ?');
tus:=readkey;
if tus in['h','H'] then goto en_bas;
end.

Gördüğünüz gibi burada h'ye basılıp basılmadığı kontrol ediliyor. Eğer basılmışsa başa gidiyor, başka bir tuşa basılmışsa program bitiyor. Eğer kullanıcının klavyesinin Caps Lock tuşu açıksa bastığı harf H, kapalıysa bastığı harf h (küçük h) olacaktır. Biz iki durumu da hesaba katıyoruz. Ama kullanıcı mesela s tuşuna basarsa da program biter. Bunu hesaba katmadık. İyi bir programcı herşeyi düşünür. Şu anda döngüleri bilmediğimizden kendi döngülerimizi label kullanarak goto ile hallediyoruz. İlerde bu işler çok daha kolay olacak. Ama merak edenler için sadece E'ye basılınca programdan çıkan programı yapalım:


Program Denemedir;
Uses Crt;
Label
en_bas,yanlis_tus;
Var
a:longint;
tus:char;
Begin
a:=1;
en_bas:
Clrscr;
writeln('A nin su anki degeri: ',a);
a:=a+1;
writeln('Cikmak istiyor musunuz ( E -> Evet , H -> Hayir) ?');
yanlis_tus:
tus:=readkey;
if not (tus in ['h','H','e','E']) then goto yanlis_tus;

if tus in['h','H'] then goto en_bas;
end.

Programa eklediğimiz kodları kalın yazdım. Burada not operatörünün (Pascal dilinde böyle deniliyor) de kullanımına bir örnek vermiş olduk. not'un sağındaki değer yanlış ise sonuç doğru oluyor. Yani normalde basılan tuş E,e,H,h'den birisi ise sonuç doğru oluyordu ama başına not koyunca eğer tuş e,E,h ya da H ise sonuç yanlış, değilse sonuç doğru oluyor. Bunu küme olmadan yaptığımızı düşünelim. Kodumuz çok uzun olurdu:
if (tus<>'e') and (tus<>'E') and (tus<>'h') and (tus<>'H') then goto yanli_tus;
Yani tuş'un tek tek olmaması gereken harfleri belirmiş oluyoruz. <> ifadesinin eşit değil manasında olduğunu söylemiştik. Bir önceki programa göre eklediğimiz yerin ne iş yaptığını gördük. tus değişkeninin değeri ['h','H','e','E'] kümesinin içinde olana kadar bir sonraki adıma geçmiyor ve yanlis_tus label'inin (etiketinin) bulunduğu yere gidiyor.
Kümeleri anladığımıza ve birkaç örnek de kandimiz yaptığımıza göre(!) diğer operatörlere ve if..then..else kalıbı ile yapılmış başka örneklere geçebiliriz. Ama önce Begin-End bloklarını anlatmalıyız.
Pascal yapısal bir programlama dilidir ve bloklardan oluşur. Sınırsız sayısa iç içe blok olabilir. Bir blok begin ile başlar ve end ile sona erer. Pascal için bu begin ile end arasına yazılan kodlar bir bütün olarak düşünülür. Zaten her programın begin ile başlayıp end ile bittiğini gördük.
Daha önce if deyimini kullanmayı gördük ama THEN ifadesinden sonra sadece bir işlem yaptırabiliyorduk. Eğer belli bir şarta bağlı olarak birden çok işlem yaptırmak istiyorsak bu işlemleri begin ile end arasına almamız lazım. Yani:
if (şart ya da şartlar) then Begin
işlem 1
işlem 2
işlem 3
...
...
End;
şeklinde kullanırız. Bu durumda şart doğru ise bu işlemler yapılır, yanlış ise işlemlerin hiçbirisi yapılmadan en alttaki end; kelimesinden sonraki işlemden başlayarak programın akışı devam eder. Bu kalıbı else ile birlikte kullanacaksak;
if (şart ya da şartlar) then Begin
işlem 1
işlem 2
işlem 3
End else Begin
işlem 1
işlem 2
işlem 3
...
...
End;
şeklinde kullanırız. Tabii bunun gibi birkaç tane end arda arda kullanılında hangisi hangi begin'in karışabilir, daha doğrusu bilgisayar kesinlikle karıştırmaz ama siz daha sonra bakınca karıştırabilirsiniz. Daha önceden programın içerisine açıklama oymaya kısaca deyinmiştik. Yeri gelmişken onu da anlatalım.
Genelde uzun programlar yaptıktan sonra program içerisinde ne yaptığınızı ya da hangi değişkenin ne işe yaradığını falan unutabilirsiniz. Ya da 1 yıl önce yaptığınız programı açtığınızda "Ya bu program ne işe yarıyor" diyebilirsiniz. İyi bir programcı programın önemli gördüğü yerlerine kısa açıklamalar koyar. Bunlara daha sonra baktığında ne yaptığını hatırlamak için. Bu açıklamaları { ile } arasına ya da (* ile *) arasına yazmalısınız. Ben genelde süslü parantezi tercih ediyorum. Bu iki parantezin içerisine yazılan hiçbirşey (program kodu bile yazsanız) pascal tarafından dikkate alınmaz ve derlenmez. Yani buraya istediğiniz herşeyi yazabilirsiniz. İlerde yapacağımız programlarda bu tip açıklamalara ihtiyaç oldukça yer vereceğiz. Şimdi basit bir örnek daha yapalım:
Program Ornek_program;
{Bu program bir sayının karesini ve kökünü bulmak için yapıldı.
Yapılıs tarihi: 05.06.2002 Saat: 01:48}
Uses Crt;
Label
en_bas;
Var
sayi,kare:longint;
kok:real;
Begin {Program Başlıyor}
en_bas: Clrscr;
writeln('Programdan çıkmak için 1000''den büyük bir sayı yazın');
write('1 ile 1000 arası bir sayı giriniz: ');
readln(sayi); {Sayı isteniyor}
if (sayi<1001) and (sayi>0) then begin
kare:=sayi*sayi; {Karesi hesaplanıyor}
kok:=sqrt(sayi); {Kökü bulunuyor}
{Sonuçlar yazılmaya başlıyor...}
writeln('Bu sayının karesi:', kare:10);
writeln('Bu sayının kökü..:', kok:16:5);
{...sonuçlar yazıldı}
readln; {Enter'a basılması bekleniyor}
goto en_bas;
end; {if deyiminin sonu}
end. {Programın Sonu}

Pascal'da ekrana apostrof işareti ( ' ) yazmak için iki tane apostrof işaretini yan yana yazarız ( '' gibi..). Programda "writeln('Programdan çıkmak için 1000''den büyük bir sayı yazın');" komutuna bakabilirsiniz. Tek yazarsak Pascal'ın özel işareti olduğu için bizi uyarır. Burada hem begin..end; kalıbına hem de açıklamaya örnek(ler) var. İnceleyiniz.
Şimdi and, or ve not ifadelerini tek tek ve birlikte kullanan örnekler yapalım. İlk önce and ile ilgili basit bir örnek yapalım. Bu programı and'in kullanımına örnek olması için yapıyoruz. Yoksa program pek bir işe yaramaz:
Program and_ornegi;
Uses Crt;
Var
sayi1, sayi2 : integer;
Begin Clrscr;
writeln('Aşağıya 1 ile 10 arası 2 sayı giriniz');
write('Birinci Sayı:');Readln(sayi1);
write('İkinci Sayı:');Readln(sayi2);
clrscr;
if (sayi1 in[1..10]) and (sayi2 in[1..10]) then writeln('Sayıları doğru girdiniz')
else writeln('Sayıları Yanlış Girdiniz...');
readln;
end.
Programı TP'da yazıp çalıştırın ve birkaç sayı girin. Gördüğünüz gibi ancak sayıların ikisi de 1 ile 10 arasındaysa sonuç doğru oluyor, aksi halde (sayıların birisi bile 1 ile 10'un dışında olsa) sonuç yanlış oluyor. Çünkü VE (and) kullandık. Peki bunun yerine sayılardan en az birisinin 1 ile 10 arasında olmasını istesek ne yaparız. O zaman or (veya) kullanırız:
Program and_ornegi;
Uses Crt;
Var
sayi1, sayi2 : integer;
Begin Clrscr;
writeln('Aşağıya 1 ile 10 arası 2 sayı giriniz');
write('Birinci Sayı:');Readln(sayi1);
write('İkinci Sayı:');Readln(sayi2);
clrscr;
if (sayi1 in[1..10]) or (sayi2 in[1..10]) then writeln('Sayıları doğru girdiniz')
else writeln('Sayıları Yanlış Girdiniz...');
readln;
end.
Bu programı çalıştırdığınızda iki sayıdan birisini 1 ile 10 arasında girerseniz, diğerini ne girerseniz girin sonuç doğru olur. Eğer ikisi birden 1 ile 10 arasında değilse sonuç yanlış olur. Peki şimdi de and ile or'u birlikte kullanarak kullanıcıdan 1,2,3,4,5,11 sayılarından birisini yazmasını isteyelim. Eğer bu yazılan iki sayı da bu sayıların içindeyse sonuçta doğru yazsın, birisi bile bu sayıların dışındaysa sonuçta yanlış yazsın:




Program and_ornegi;
Uses Crt;
Var
sayi1, sayi2 : integer;
Begin Clrscr;
writeln('Aşağıya 1,2,3,4,5,11 sayılarından birisi olmak şartıyla 2 sayı giriniz');
write('Birinci Sayı:');Readln(sayi1);
write('İkinci Sayı:');Readln(sayi2);
clrscr;
if ((sayi1 in[1..5]) or (sayi1=11)) and ((sayi2 in[1..10]) or (sayi2=11)) then writeln('Sayıları doğru girdiniz')
else writeln('Sayıları Yanlış Girdiniz...');
readln;
end.
Burada ilk önce sayi1'in 1 ile 5 arasında olup olmadığına bakılır. Eğer doğruysa zaten and kelimesinin solundaki iki şartı kapsayan şart doğru olur. Yani sayı ya 1 ile 5 arasındadır, ya da 11'dir. Eğer sayı1 1 ile 5 arasında değilse şart yanlış olur ama bir de or'un sağındakine bakılır. Eğer sayı 11'e eşitse bu şart doğru (true) olacağından yine genel şart doğru olur. Bu durumda and kelimesinin solundaki şart doğru olmuş olur. Eğer and'in solundaki iki şart da yanlış ise sonuç otomatikmen yanlış olur. Sağ taraf için de (sayi2 için) aynı işlemler yapıldıktan sonra eğer genel şart doğruysa sonuç doğru olur. Kendiniz birkaç örnek yaparak bunları görebilirsiniz.
Şimdi basit bir örnek daha yapalım. Bu program kullanıcıya bir toplama işlemi sorsun. Eğer kullanıcı sonucu doğru girerse "Tebrikler, bildiniz" yazsın, aksi halde doğru sonucu ekrana yazsın. Yani ilk defa ciddi bir program yapıyoruz
Program Toplama_Programi;
Uses Crt;
var
s1,s2:integer;
toplam:integer;
Begin Clrscr;
{Rastgele iki sayi seciliyor...}
randomize;
s1:=random(100);
s2:=random(100);
{...0 ile 99 arasinda rastgele 2 sayi secildi}
writeln('Asagidaki toplama isleminin sonucunu yaziniz...');
writeln;
write(s1,' + ',s2,' = ');readln(toplam);
if (toplam=s1+s2) then writeln('Tebrikler, bildiniz...')
else writeln('Yanlis Sonuc! Cevap ',s1+s2,' olmaliydi.');
readln;
end.

Gördüğünüz gibi if deyiminde şart olarak iki sayının toplamını da verebiliriz. Hatta başka işlemler bile yapabiliriz. Mesela şart olarak (toplam=(s1*21)/(s2+4)*11+9-s2*s1) gibi uzun bir aritmetik işlem birle yazabiliriz. Ayriyete eşittir işaretinin sağ ile solu yer değiştirebilir. ((s1*21)/(s2+4)*11+9-s2*s1=toplam) gibi. Buralarda parantezlere dikkat etmelisiniz. Şimdilik rastgele sayının nasıl bulunduğunu öğrenmedik. Onun için o kısımları kafanıza takmayın. Yukardaki örnekte and ya da or kullanmadık ama faydalı bir program olduğunu düşünüyorum. Not operatörü ise sonuç doğru ise yanlış, yanlış ise doğru yapar. Bununla ilgili bir program yapmıştık ama daha iyi anlaşılması için basit bir örnek daha yapalım. Bu program da 1 ile 5 arasında bir sayı yazılmasını istesin. Eğer sayı 1 ile 5 arasında ise doğru, değilse yanlış yazsın:

15-07-2009 13:08:45
 
Program deneme;
uses crt;
var
sayi:integer;
begin clrscr;
write('1 ile 5 arası bir sayı giriniz: ');readln(sayi);
if not (sayi in [1..5]) then writeln('Yanlış!') else writeln('Doğru.');
readln;
end.
Programlamada karşılaştırma ve (sonucuna göre) karar verme işlemleri çok önemli ve geniş kullanımlıdır. Diğer kullanım alanlarını görmeye devam edeceğiz. Ama önce şimdiye kadar pascal hakkında öğrendiklerimizin hepsini birden kullanan ve nihayet bir işe yarayan bir oyun yapalım. Bu oyunda bilgisayar 1 ile 1000 arasında rastgele bir sayı tutsun. Biz bir tahmin yapalım. Eğer tahminimiz bilgisayarın tuttuğu sayıdan küçükse ekrana ÇIK, küçükse İN yazılsın ve bu işlemler biz sayıyı doğru tahmin edene kadar sürsün. Hani bir oyun yapıyoruz ya -hiç gerek yok ama- bir de algoritmasını yapalım ki belki daha iyi anlaşılır. Algoritmamız şöyle olabilir:
1) Rastgele (1 ile 1000 arası) bir sayı tut.
2) Kullanıcıya bir sayı sor.
3) Eğer kullanıcının cevabı senin tuttuğun sayıdan büyükse ekrana "in" yaz.
4) Eğer kullanıcının cevabı senin tuttuğun sayıdan küçükse ekrana "çık" yaz.
5) Eğer kullanıcının cevabı senin tuttuğun sayıya eşitse ekrana "Aferin Bildin!" yaz.
6) Eğer kullanıcının cevabı senin tuttuğun sayıya eşit değilse 2. adıma git.
7) Programı bitir.
Bu algoritmayı kendinize göre yapabilirsiniz tabii. Zaten programcılığın en zevkli yanlarından birisi de aynı programı yapmak için çok fazla seçeneğiniz ve çözüm yolunuz olmasıdır. Şimdi de programı yazalım. Programımız şöyle olabilir:
Program Tahmin_et_bakalim;
uses crt;
label en_bas;
var
sayi, tahmin, ts : integer;
begin clrscr;
ts:=0;
randomize;
sayi:=random(1000)+1;
gotoxy(1,1);write('1 ile 1000 arasi bir sayi giriniz...');
gotoxy(1,5);write('İşlem: ');
en_bas:
gotoxy(13,3);write(' '); {Eski tahmini ekrandan siliyoruz}
gotoxy(1,3);write('Tahmininiz: ');readln(tahmin); {bir tahmin isteniyor}
ts:=ts+1; {Tahmin sayısı artırılıyor}

gotoxy(8,5);
if tahmin<sayi then write('Çık');
if sayi<tahmin then write('İn ');
if sayi=tahmin then begin
writeln('Aferin Bildin!');
writeln('Tahmin Sayısı: ',ts);
end else goto en_bas; {tahmin yanlışsa başa gidiliyor}


readln;
end.

Programı TP'da yazıp çalıştırın. İşte size güzel bir oyun! Programda asıl dikkat etmemiz gereken yerleri kalın yaptım. İsterseniz size bu oyunu geliştirelim ve bu sefer biz içimizden bir sayı tutalım, bilgisayar bulsun! O zaman aşağıdaki programı pascal'da yazıp çalıştırın ve sonra da satır satır inceleyin. Ama programı çalıştırdığınızda hile yapmayın. Yani aklınızdan tuttuğunuz sayı 430 ise ve program 420'yi tahmin ederse in demek yok! Ona göre. Bu programı Pascal'da elinizle yazın. Yani kopyala/yapıştır yapmayın. O zaman daha kolay öğrenirsiniz.
Program Tahmin_et_bakalim;
uses crt;
label en_bas;
var
tahmin, ts : integer;
alt,ust:integer;
tus:char;
begin clrscr;
writeln('Şimdi aklınızdan bir sayı tutun ve eğer benim söylediğim sayı');
writeln('sizin tuttuğunuz sayıdan küçükse çık anlamında "ç" harfine, büyükse');
writeln('in anlamındaki "i" harfine bir defa basın.');
writeln;
writeln('Not: Sayı 1 ile 100 arasında olmalı!');
writeln;
writeln('Hazırsanız Enter''a basın..');
readln;
clrscr;
alt:=1;
ust:=1000;
ts:=0;
gotoxy(1,1);write('Benim Tahminim...: ');
gotoxy(1,3);write('Ne yapıyım (i/ç).: ');
tahmin:=500;
en_bas:
gotoxy(20,1);write(tahmin);
gotoxy(20,3);
repeat
tus:=readkey;
until tus in['i','İ','ç','Ç','D','d'];
if tus in['i','İ'] then begin
ust:=tahmin;
tahmin:=(alt+ust) div 2;
end;
if tus in['ç','Ç'] then begin
alt:=tahmin;
tahmin:=(alt+ust) div 2;
end;
ts:=ts+1;
if tus in['d','D'] then begin
gotoxy(1,5);write('Aferin Bana!');
gotoxy(1,6);write('Tahmin Sayım: ',ts);
end else goto en_bas;
readln;
end.



Burada bilmediğimiz iki şey var. Birincisi repeat...until döngüsü. İkincisi div işlemi. Div (İngilizcesi division) bölmek manasındadır ve solundaki sayıyı sağındaki sayıya bölüm küsüratı atar. Yani mesela 6 div 3 = 2'dir ve 15 div 4 = 3'dür. Döngüler konusunu anlatacağız. Programın çalışma mantığı gayet basit. Ama yeni programlamaya başlayan birisine karışık gelebilir. Program siz in dediğinizde kendi kendine "Demek ki sayı bundan küçük, o zaman bundan sonra en fazla söyleyeceğim sayı bu olsun, yani üst limit bu olsun" diyor ve ust:=tahmin ifadesi ile de bunu yapıyor. alt'ın da mantığı aynı. Tahminini yaparken de alt ve ust değişkenlerini topluyor ve ikiye bölüyor. Programı çalıştırdığınızda farketmişsinizdir zaten. İlk tahmin hep 500 oluyor. Ondan sonra in derseniz 250, çık derseniz 750 oluyor... Tahmin sayısının nasıl hesaplandığı da gayet basit. Her sayı tahmininde tahmin sayısı bir artırılıyor.
İf kalıbını kullanırken hani dedik ya eğer şart (ya da şartlar) doğruysa işlem yapılır. Bir de programlama'ya başlarken veri tiplerinden bahsederken boolean diye bir tipi kısaca ele almıştık ve sonra anlatacağız demiştik. Şimdi boolean değişkenlerin kullanımına bakalım.
Daha önceden de dediğimiz gibi boolean değişkenin değeri ya TRUE (doğru) ya da FALSE (yanlış) olur. if ifadesinde de sonuç ya doğru ya da yanlış oluyordu. İşte if ifadesinde şart yerine boolean bir değişken kullanırsak program daha anlaşılır olabilir. Özellikle uzun programlarda çok işe yaradığını söyleyebilirim. İlk önce sadece nasıl kullanıldığına bakmak için bir örnek yapalım:
Program Mantiksal_Degisken;
uses crt;
var
YazilsinMi: boolean;
begin clrscr;
yazilsinmi:=true;
if yazilsinmi=true then write('Yazı Yazılıyor...');
readln;
end.

Aslında bu şekilde kullanıldığında pek bir anlamı kalmıyor. Boolean değişkenler özel olarak şöyle kullanılabilir:
Program Mantiksal_Degisken2;
uses crt;
var
YazilsinMi: boolean;
begin clrscr;
yazilsinmi:=true;
if yazilsinmi then write('Yazı Yazılıyor...');readln;
end.

Gördüğünüz gibi bir karşılaştırma yok. Burada if deyimine dikkat edin. Eğer yazilsinmi değişkeninin değeri true ise sonuç doğru oluyor ve yazılıyor, değeri false ise sonuç da yanlış (false) oluyor ve program hiçbirşey yapmadan kapanıyor. İsterseniz yazilsinmi:=true yerine yazilsinmi:=false yazıp tekrar deneyin. Genelde boolean değişkenlere böyle direkt olarak yazilsinmi:=true; gibi değer atanmaz. Şimdi birkaç farklı atama yöntemine bakalım. Aslına yazilsinmi:= ifadesinin sağına sonucu true ya da false olabilecek herşey yazılabilir. Mesela iki tane boolean değişkenimiz varsa ve birisinin adı a diğerinin b ise;
a:=b;
ya da
b:=a;
gibi işlemleri yapabiliriz. Ayrıca if ile kullandığımız bütün operatörleri (=, <, >, <>, in, and, or, not) burada da kullanabiliriz. Mesela yine a ve b boolean değişkenleri için;
a:= not a;
kullanırsak a'nın değerini tersine çevirmiş oluruz. Yani a önceden true ise artık false, önceden false ise artık true olmuştur. Tabii ki a:=not b; de kullanılabilir. Mesela sayi diye bir değişkenimiz olsun. Eğer bu değişkenin değeri 5 ise dogruMu adlı boolean değişkenimizin değerinin true, aksi halde false olmasını isteyebiliriz.
Program deneme;
uses crt;
var
sayi:integer;
dogruMu:boolean;
begin clrscr;
write('Bir sayı giriniz: ');readln(sayi);
dogruMu:= (sayi=5);
if dogrumu then writeln('Aferin doğru') else write('Malesef yanlış');
readln;
end.
Burada sayi'nin 5'e eşit olması halinde sonuç doğru (true), yoksa yanlış (false) olacaktır. Eğer sayının 1 ile 30 arasında olmasını istiyorsak dogrumu:=(sayi=5); satırını dogrumu:=(sayi in[1..30]) olarak değiştirebiliriz. Ya da sayının 3'e veya 8'e eşit olması durumunda sonucun doğru olmasını istiyorsak dogrumu:=(sayi=3) or (sayi=8); kullanabiliriz. Anlayacağınız if'deki şartlarda ne yapıyorsak burada da aynısını yapabiliriz. Mesela boolean bir değişken kullanarak 1 ile 30 arasındaki tek sayıları ekrana yazdıran bir program yapalım:
Program Mantiksal_Degisken3;

Uses Crt;
label
tekrar;
var
sayi:byte;
tekMi, devamMi:boolean;
begin clrscr;
tekMi:=true;
devamMi:=true;
sayi:=1;
tekrar:
if tekmi then writeln(sayi);
sayi:=sayi+1;
tekMi := not TekMi;
devammi:= not (sayi=30);
if devamMi then goto tekrar;
readln;
end. {Program Sonu}

Programı yazıp çalıştırdığınızda 1 ile 30 arasındaki tek sayılar ekrana sırayla yazılır ve Enter'a basılması beklenir. Sadece tek sayıların yazılmasını tekmi değişenini bir true bir false yaparak sağlıyoruz. True ise yazılıyor, false ise yazılmıyor. Ayrıca devammi değişkeni de sayının 30 olmadığı durumlarda doğru, 30 olduğu durumda yanlış olur. Ve yanlış olunca, yani sayı 30 olunca en sondaki if ifadesi doğru olur ve program sona erer.
Eğer şimdiye kadar anlamadığınız birşey yoksa ve kendiniz de biraz örnek yaptıysanız artık baya bir Pascal biliyorsunuz demektir. Şimdiye kadar iyi bir program yapamamamızın sebebi daha döngülere girmememizden kaynaklanıyor. if kalıbını anlattık ama Pascal'da sadece karar verme komutu if değildir. Bir de Case-of deyimi var ki bazı durumlarda if'e göre çok daha kısa kod ile aynı işi yapmanızı sağlar. Ayrıca kullanımı da çok basittir. Mesela bir değişkenimiz var ve bu değişkenin aldığı 10 tane değişik değer için 10 ayrı işlem yaptırmak istiyoruz. Bunu if ile yapmak hem çok uzun olur hem de hata yapma şansımız yüksek olur. Ama Case of kullanırsak çok daha anlaşılır ve kısa yapabiliriz. Case'in genel kullanımı şöyledir:
Case değişken of
değer 1 : işlem 1;
değer 2 : işlem 2;
değer 3 : işlem 3;
...
...
End;
Tabii yine if'de (ve Pascal'ın heryerinde) olduğu gibi birden çok işlem yaptıracaksak begin ile and arasına alırız. Şunun gibi:
Case değişken of
değer 1 : begin
işlemler...
end;
değer 2 : begin
işlemler...
end;
...
...
end;

Ayrıca birden çok değer için bir işlem yapılacaksa şöyle kullanılır:
Case değişken of
değer 1, değer 2, değer 3 : işlem 1;
değer 4 : işlem 2;
değer 5, değer 6 : işlem 3;
End;
Şimdi güzel bir program yapalım. Kullanıcıdan bir sayı istesin ve ekranda bir menü olsun. Seçime göre belirli işlemler yapılsın. Programı yazmaya başlayalım:



Program Mantiksal_Sorgulama3;
Uses Crt;
Label
en_bas;
var
sayi:longint;
secim:char;
cikis:boolean;
begin clrscr;
cikis:=false;
write('1 ile 1000 arası bir sayı giriniz: ');readln(sayi);
en_bas:
clrscr;
gotoxy(30,8);write('::: Menü :::');
gotoxy(30,10);write('[1] Sayının Karesini yaz');
gotoxy(30,11);write('[2] Sayının Karekökünü yaz');
gotoxy(30,12);write('[3] Sayının Kübünü yaz');
gotoxy(30,13);write('[4] Programdan çık');
gotoxy(20,18);write('Seçiminizin önündeki sayıya basınız');
gotoxy(30,15);write('Seçiminiz: ');
secim:=readkey;
case secim of
'1': begin
clrscr;
gotoxy(30,10);
write(sayi,'''nin Karesi= ',sayi*sayi);
secim:=readkey;
end;
'2': begin
clrscr;
gotoxy(30,10);
write(sayi,'''nin Karekökü= ',sqrt(sayi):10:4);
secim:=readkey;
end;
'3': begin
clrscr;
gotoxy(30,10);
write(sayi,'''nin Kübü= ',sayi*sayi*sayi);
secim:=readkey;
end;
'4': cikis:=true;
end; {Case'in sonu}
if (not cikis) then goto en_bas;
clrscr;
writeln('Güle Güle... writen by
end.

Gördüğünüz gibi secim:=readkey; komutuyla bir tuşa basılmasını bekliyor ve case secim of ile de bu tuşun '1', '2', '3' veya '4' olması durumunda yapılacak işlemler belirtiliyor. '4' olması durumunda cikis:=true ile cikis isimli boolean değişeknin değeri true oluyor. if (not cikis) then goto en_bas; ile de eğer cikis'in değeri false ise (ki '4'e basılmadıkça hep false olur, çünkü programın başında false yaptık) en_nas; labelinin olduğu yere gidiyor. Dolayısıyla da true olunca programdan çıkılmış oluyor. Artık programlarımızda menü yapmaya da bir örnek vermiş olduk. Tabii hareketli menü yapmayı da anlatacağız ama o daha çok ilerde.. Bu örnek karışık geldiyse konunun daha iyi anlaşılması için basit bir örnek daha yapalım:
Program Mantiksal_sorgulama;
Uses Crt;
var
sayi:longint;
begin clrscr;
write('Bir Sayı Giriniz: ');readln(sayi);
case sayi of
0..9: writeln('Bu sayı 1 basamaklıdır');
10..99: writeln('Bu sayı 2 basamaklıdır');
100..999: writeln('Bu sayı 3 basamaklıdır');
else writeln('Bu sayı 3''den çok basamaklıdır');
end;{Case'in sonu}
end.

Burda case ile birlikte else'in de kullanımını gördük. Eğer case ile belirttiğimiz hiçbir şart doğru değilse bir işlem yapmasını isteyebiliriz. Bu durumda bütün şartların sonuna else.. koyarız. Yine case kullanırken iki nokta üst üste ( işaretinin soluna araya virgül koyarak birden çok şart da koyabilirsiniz.

case sayi of
13, 17, 4, 10, 9: writeln('Bu sayı benim sevdiğim sayılardan birisidir!');
else writeln('Bu sayıları hiç sevmem ');
end;
gibi.. Case komutunu genelde bir değişkenin birden çok sonucuna göre farklı işlemler yaptırmak istediğinizde kullanabilirsiniz. Dikkat etmeniz gereken case degisken of kalıbında belirttiğiniz değişken ile alabileceği değerlerin aynı tipte olmasıdır. Yani değişken sayı tipindeyse herhalde değeri 'D' olamaz! Ya da char tipindeyse değeri 5 olamaz, '5' olabilir. İkisinin arasındaki farkı anlatmıştım. Önceki sayı, sonraki karakterdir.
Pascal'da (ve diğer bütün programlama dillerinde) iç içe istediğiniz kadar if kullanabilirsiniz. Mesela:
if a>b then begin
if a=0 then writeln('B 0''dan küçük');
if b=0 then writeln('A 0''dan büyük');
end; gibi olabilir. Ya da aşağıdaki 3 if deyimi aynı işi yapar:
1)
if a>1 then begin
if a<7 then writeln('A değişkeninin değeri 1 ile 7 arasındadır.');
end;
2)
if a>1 thenif a<7 then writeln('A değişkeninin değeri 1 ile 7 arasındadır.');
3)
if (a>1) and (a<7) then
writeln('A değişkeninin değeri 1 ile 7 arasındadır.');

Programcı siz olduğunuza göre (ve amaç problemi en basit ve kısa yoldan çözmek olduğuna göre) hangisini kullanacağınıza karar vermek size kalmış. 2. örnekte if a>1 then ifadesinden sonraki mavi yazılı yerin tamamı bir komuttur. Bunu daha önceden söylemiştik. Öyleyse then'den sonraki komut bu olabilir. Burada iç içe iki if kullanılmıştır.
Pascal'da olan iki karşılaştırma deyimini (if ve case) gördük. Bunlar üzerinde istediğiniz kadar iç içe ve birlikte kullanımlar yapabilirsiniz. Bol bol örnek yapmanızı tavsiye ederim. Son olarak if deyiminde (ve boolean değişkenlerde) kullanılan mantık işlemlerive göz atalım. Yani "doğru ve doğru" nun sonucu doğru, "doğru ve yanlış" ın sonucu yanlış, "yanlış veya doğru" nun sonucu doğru gibi.. Birkaç örnek yapalım ve bunları tablo olarak verelim ve en son da uzun bir örneği açıklayalım ki kafalarda soru işareti (?) kalmasın!
İşlem
Sonuç
(true and true)
True
(true and false)
False
(false and false)
False
(true or true)
True
(true or false)
True
(false or false)
False
not (true)
False
not (false)
True
not (not (false))
False
(true and true and false)
False
(false or true or false)
True
Yukardaki tabloya göre ne kadar karışık olursa olsun her işlem önce parantez içleri yapılarak basite indirgenip çözülebilir. Lise'deki mantık dersi iyi olan arkadaşlar daha kolay yapabilirler. Bilmeyenler için kelimelerin anlamını da toplu olarak birkez daha verelim:
Kelime (Deyim)
Türkçe Anlamı
TRUE
Doğru
FALSE
Yanlış
AND
Ve
OR
Veya
NOT
Değil
IF
Eğer
THEN
ise, öyle ise..
BEGIN
Başla
END
Son
ELSE
Değilse
Şimdi size biraz uzun ve karışık gelen bir problemin sonucunun true mi yoksa false mi olduğunu bulalalım:
if (((true and false) or (true or true)) and ((false or true) and (true or false) and (true and true))) or false then..
İlk önce parantez içerisinde başlayalım. İlk kalın olan yerin sonucu false olduğundan bunun yerine false koyup ikinci adıma geçelim:
if ((false or (true or true)) and ((false or true) and (true or false) and (true and true))) or false then..
Şimdi kalın olan yerin değerinin de true olduğunu biliyoruz. Onun yerine de true yazalım. Sonuç şöyle olur:
if ((false or true) and ((false or true) and (true or false) and (true and true))) or false then..
İşlem biraz kısaldı. Şimdi kalın olan yere bakalım. Değerinin true olduğunu biliyoruz. Son durum şöyle oldu:
if ((false or true) and (true and (true or false) and (true and true))) or false then..
Şimdiki kalın yazılı yerin değeri de true olduğundan yerine yazalım:
if ((false or true) and (true and true and (true and true))) or false then..
Bu seferki kalın yerin anlamı da true olduğundan son durum şu olur:
if ((false or true) and (true and true and true)) or false then..
Bu kalın yazılı yerin anlamı da true olur:
if (true and (true and true and true)) or false then..
Bu seferkinin anlamı da true olur. Çünkü 3'ü de doğrudur. Birisi yanlış olsa false olurdu. Sonuçta durum şöyle oldu:
if (true and true) or false then..
Artık işlem çok basit:
if (true or false) then..
Bu zaten tablomuzda direk verimişti Sonuç doğru (TRUE) olur:
if true then...
Demek ki ilk durumdaki if deyiminin sonucu true imiş ve eğer then'den sonra bir işlem varsa gerçekleşir. Tabii siz programlarınızda direk olarak true false diye yazmayacaksınız. Bunun yerine sonucu true ya da false olabilecek karşılaştırmalar (ya da boolean değişkenler) kullanacaksınız. Ayrıca size böyle şeyleri de düşünmeyeceksiniz aslında. Program bulacak sonucun ne olduğunuz. Ama siz programı yazarken ne istediğinizi bildiğinizden if kalıbını siz kuruacaksınız. Bu durumda bilgisayarın ne düşüneceğini ya da ne yapacağını bilmeniz iyi olur. Özellikle parantezlere dikkat edin. Eğer parantezler farklı olursa sonuc farklı olabilir.

Konu Kilitli

"PASCAL Programının Yapısı, KOMUTLARI" konusu hakkında etiketler
100 1laz aksi arasi artik asagidan ayni begin bilgisayarin bir calismiyor case cok const degildir degiskenler degistirme deyimler dili dilindeki div durumu durumunda edelim ekrana end esit function gectiniz girmesini hafiza halde hava htm icice ifadeleri ile ismi isteyen iyi kaldiniz kodlari komutu kose kullanicidan kullanilir kullanimi kume lara matrisin nereye notunu notunun olmasi olusturma ornegi ornek ornekler ornekleri pascal pascalda paskal program programi programim programin programlama programlar random Sabitler sag sarti sayi sayiyi seklinde sembolu set sorunu tahmin tersi tipler turbo tut tutan tutma ust ustu uyari veren veri verilen yapilarinin yapiniz yapisal yapisi yapisini yazan yazdirma yazi yazili yeni yil

Pascal Programlama Diline Giriş Önceki | Sonraki Cobol nedİr?




İletişim Bilgileri, Contact Us, Kullanım Sözleşmesi, Gizlilik