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.

• İ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.
• Pascal'da aynı satırda en fazla 126 karakter uzunluğunda yazı yazabilirsiniz. Daha uzun olursa yine TP sizi uyarır.
• Pascal'da  bir satırda birden çok komut kullanabilirsiniz. Her komutun sonuna koyduğumuz noktalı virgül sayesinde pascal bu komutları birbirinden ayırabilir.
• 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.
• 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.

• 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:

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:

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.

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 www.universiteli.net

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.not3)/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 www.universiteli.net

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ü www.universiteli.net 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.