Bu sayfadaki yazılar
Sayfanın metni
Sayfa 25
b : set of [1..2]+[7..9]; {1,2,7,8,9} c : set of [1..10] - [5..10] {1,2,3,4}
Daha güzeli, bu küme işlemlerini program içinde de yapabilmemiz. Bu arada mantıksal sonuç veren IN, =, <>, <= ve >= işlemlerini kullanabiliyoruz. Diyelim bir sayınız var ve bu sayının 1 ila 20 arasında bir asal sayı olup olmadığını kontrol edeceğiz.
var a : integer; begin
readln (a); if a in [2,3,5,7,11,13,17,19] then writeln ('ASAL');
end.
Veya bir karakter girildi, bu karakter acaba harf mi, değil mi?
var a: Char; begin
readln(a); if a in ['a'..'z','A'..'Z'] than write (a);
end
Daha bunlarla işimiz bitmedi, şimdilik biraz ara verelim. Tek ve çok boyutlu diziler bilgisayarda her zaman kullanılır. Bunları tanımlamak için ARRAY kullanılacaktır. Hemen örnek:
var a : Array [1 ..10,1 ..10] of integer;
Basic'te karşılığı Dim a(10,10) olan bir komut. Bu değişken ile 100 adet tamsayı tutabiliyoruz. Bunlara erişebilmek için a[n][m] ifadesi kullanılır. Son olarak dosya tipini tanıtmam gerekiyor. Genelde kullanılan bilgilerin bir yerlere aktarılması gerekir. Bu iş için en uygunu dosyalar kullanmaktır. Bir değişkeni dosya değişkeni olarak tanımlamak mümkün.
var f: file of char;
İçeriği karakterlerden oluşacak olan bir dosya değişkeni olur. Konuyu fazla derinleştirmeden, hemen zevkli bir başka konuya geçelim.
Dikkat edin, deminden beri değişkenleri tanımlamak için kullanılan tipleri inceliyoruz. Niye Tamsayılar'a integer diyelim, niçin kafama göre tipler tanımlamayalım diyorsanız, tam yerine geldiniz. Hatırlayın Pascal'ın blokları arasında Type kısmı vardı. Burada kendinize istediğiniz tipi tanımlayabilirsiniz. Sıkı durun örnek geliyor:
type Tamsayi = integer; var a : tamsavi:
f: file of tamsayi;
Bir ikinci örnekte, daha önce anlatılan kümeleri ve Array'leri de işin içine katalım:
type matris = Array [1..100,1..100] of in- teger;
Rakam = '0'..'9'; Pozitif = L.Maxint;
{Dikkat edelim şu an değişken değil, değişken tipi tanımlıyoruz. Bu tiplerde değişkenleri var kısmında tanımlamamız şart.}
Var a:matris; n:rakam; p:pozitif
Nasıl ama ??? Şimdi iyi bir bomba. Tip tanımlarken parantez içinde sıralı olarak yazacağımız değerler tanımlayabiliriz:
Type Ay = (Ocak, subat, mart, nisan, mayis, haziran, temmuz, agustos, eylül, ekim, kasim, aralik); Tatil = haziran..eylül; var simdiki_ay : ay; begin if simdiki_ay = Ocak then writeln ('Ocak soguktur.'); end. Belki anlatması saçma olacak ama, ilk olarak ismi ay olan bir tip tanımlıyoruz. Bu tipin alacağı değerler ocak ila aralık arasında (Bu değerler sıralıdır, yani ocak < şubat) yer alıyor. Daha sonra ismi simdiki_ay olan bir değişken tanımlıyoruz. Bu değişken artık ay ile tanımlanan değerleri alabilir. Pekala simdiki_ay isimli değişkenin değeri şubat olabilir. Komik görünse de, bu tür tipleri tanımlamanın birçok yararı oluyor. Bir ikinci tip özelliği, değişik tipte değişkenleri içeren tipler oluyor. Bunlar RECORD sözcüğü ile tanımlanıyor. Önce örnek:
type' Sanal_sayi = RECORD
Reel : real; Sanal: real; END; var a : Sanal şayi begin a.reel := 25.765 a.sanal := 12.87 end. Görüldüğü üzere, burada bir sanal sayı tipi tanımlanmış. Bu tip iki adet reel sayı- dan oluşuyor. Bu türde tanımlanan bir de- ğişkenin alt bölümlerine ulaşabilmek için, değişken isminin sonuna . konuyor, işte kapsamlı bir örnek:
program Telefon defteri; type
Numara = record
isim : string [20]; soyisim : string [40]; numara : Long; end; Defter = array [1..100] of numara;
var kayıt: numara; T_Defteri : Defter; f: file of Defter;
begin
T_Defteri [1].isim :='F.Kağan' T_Defteri[1].soyisim:= Gurkaynak end.
gibi. Dikkat ederseniz, değişkenleri girmek zahmetli oluyor. Onun da bir kolayı var elbet. Geçen ay anlattığımız WITH bloğunu kullanarak, yukarıdaki örnekte,
begin WITH T_Defteri[1]DO Begin
isim :='F.Kağan' soyisim :=' Gurkaynak' End; End.
yapısı kullanılabilir. İngilizce biliyorsanız, bu tür tanımları ve değişkenleri kullanarak roman yazar gibi program yazabiliyorsunuz. Son örnekte dikkat ederseniz f değişkenini defter türünü içeren bir dosya olarak tanımladık. Dosya komutlarını kullanarak bir hamlede bütün kayıtları diskete aktarabilme olanağımız var.
Güzel, artık neredeyse tüm değişkenleri, nasıl tanımlandıklarını ve tarafımızdan nasıl tanımlanabileceklerini öğrendik. Ancak Pascal ile hala fazla bir şeyler yapabiliyor değiliz. Sebebi basit. Kullanabilecek emirlerimiz yok. Şu an öğrendiklerimizle bırakın güzel bir program yazmayı, ekrana basit bir nokta bile koymaktan aciziz. Emirleri nereden öğreneceğiz? İlk olarak Pascal'ın standart emirleri var. Bundan sonra Amiga'nın sistem emirleri geliyor. Yaklaşık 1000 kadar emir size yeterli olacaktır. Bunlar da yetmezse emirlerinizi kendiniz tanımlıyorsunuz. Procedure ve Function'lar olarak tanımladığınız emirleri bir araya getirip toplayabiliyorsunuz. Bu tür toplamalara ve özel şekline UNIT adı veriliyor. Bir UNIT, bir programa benzemesine rağmen, sadece procedure ve function'lar içerir. Bir unit hazırladıktan sonra, yeni yazdığınız programlarda o unit'te tanımladığınız fonksiyonları kullanabilirsiniz. Bunun için tanım kısmına sadece gereken unit'i eklemeniz yeter:
Uses Kagan_in_Uniti; Diyelim, bu unit'te 10 adet emir var. Artık programınızı yazarken bu emirleri kullanabiliyorsunuz. Nasıl Unit oluşturacağınız konusuna ise ileride değineceğim. Daha program bile yazamadan Unit kullanmak ayıp olur doğrusu.
Gelecek ay bir Amiga Pascal programcısı olmak için gerekenleri öğreneceksiniz. O zamana dek hoş olun, öyle kalın.
Klavyeyle gezinmek için ← ve → tuşları.
Sayfa 24
Saygılar, esenlikler... Merhabalar, Pascal konulu yazı dizimizin üçüncüsüne geldik. Artık bu dile yabancı olanlarımız bile, Pascal hakkında az çok şey biliyor sayılırlar. Bu ayki yazımızda Pascal'ın bazı özelliklerini, Pascal'da tanımlanabilen tipleri ve bunların uygulamalarını, son olarak da Unit kavramını inceleyeceğiz.
Geçen yazımızda değişkenlerin nasıl tanımlandığını görmüş ve:
var a,b : Integer; şeklinde örnekler de vermiştik. Burada a ve b değişkenleri, program içinde integer diye adlandırılan tamsayı tipinde sayılar olacak şekilde tanımlanıyordu. Pascal'da bu tür standart bazı tanımlar var. Bu standartları sırayla görelim.
INTEGER: -32768 ve 32767 arasında kalan tamsayı değerlerini alabilir. İyi programlamayla birçok işlem bu değişkenler yardımıyla yapılabilir. Ancak integer olarak tanımlanmış bir sayı, mesela 100000 değerini alamaz. Aynı şekilde Integer sadece tamsayı değerleri alır. 5.8735 gibi bir sayı, Integer olarak sadece 5'ten ibarettir.
LONGINT veya LONG: Integer tipinin bir numara büyüğü olan LONGINT -2147483648 ila 2147483647 sayıları arasındaki tamsayı değerlerini alabilir. Ne var ki, Integer tipinin iki katı kadar yer kaplar.
SHORTINT veya SHORT: Hafızada sadece 1 byte yer kaplayan bu değişken -128 ila 127 arasındaki değerleri alır. Ufak döngüler, yazı koordinatları gibi ufak değerler için kullanılabilir.
CARDINAL veya WORD: Integer'dan farkı, negatif değerler alamamasıdır. 0 ila 65535 arasındaki tamsayı değerlerini alabilir.
SHORTCARD veya BYTE: Negatif değerler alamayan, sadece 0 ila 255 arasındaki tamsayı değerlerini alabilen ve az hafıza kaplayan bir değişken.
REAL: Hafızada çok yer kaplayan, ancak ondalık sayıları 7 haneye kadar içerebilen değişken türü. Üst sınırı artı eksi 8*10^38 kadardır. Hemen küçümsemeyin bu tür ile 2.876542 * 10^18 gibi sayılar kullanabiliyorsunuz. (2876542000000000000)
LONGREAL veya DOUBLE: Hafızada 8 byte yer kaplar ancak Real ile yetinemeyen insanları tatmin edebilecek bir aralığı var. 15 haneli hesap doğruluğu ve 10^308'e kadar da sınırı var. Yukarıda sıralanan tipler, sayılar ile ilgiliydi. Bu tiplerin temel olarak tamsayılar ve ondalık sayılar olarak iki gruba ayrıldığına dikkat edin. Kick Pascal, bir alt gruba sığamayan bir değişkeni kendiliğinden bir üst gruba atmaya çalışır. Sayılar ile daha önce belirttiğim tüm matematiksel işlemleri yapabilirsiniz. Ancak ileride göreceğimiz, Sinüs, tanjant gibi bazı fonksiyonlar sadece reel sayılarla çalışırlar.
BOOLEAN: Mantıksal işlemlerin babası George Boole'un adından ismini alan bu değişkenin iki değeri olabilir: True (Doğru) veya False (Yanlış). Bu değerler arasında False < True ilişkisi geçerlidir. Bu değişken mantıksal işlemlerde kullanılır. Mantıksal işlemler olan AND, OR, NOT ve XOR ile işlemlere girer ve en önemlisi IF döngülerinde kullanılır.
var cevap : boolean; begin
cevap := true; IF cevap then writeln ('Cevap doğru');
end.
Belki biraz komik gelecek ama, cevap := (5>2); gibi işlemler de mümkün. Tabii bu tür işlemlerin sabit sayılar ile pek bir kullanışlılığı yok. Ancak değişkenler kullanılarak çok işe yarayabiliyorlar. Örneğin bir sayının (x) a'dan küçük, b'den büyük olmasını ve c'ye eşit olmamasını istiyoruz.
cevap := (x < a) AND (x > b) AND (x <> c); Örnekler çoğaltılabilir. Fazla alışık olmasanız bile, bu değişkenlerin size ne kadar kolaylık sağlayabileceğini fark ederek programlarınıza dahil etmenizi öneririm.
CHAR: ' ' veya " " arasında bir adet yazı karakteri temsil edebilen bir değişkendir.
STRING [n]: n adet Char'dan oluşan bir dizi satır'a verilen isim. Bu tür bir değişken ile isimleri tutabilirsiniz. Eğer n sayısını belirtmezseniz, 80 alınır. n sayısını 255'in üzerine çıkaramıyoruz.
POINTER'lar: Hatırlayın, dedik ki, bir değişken hafızada belirli bir yer kaplar (Örneğin String [80] hafızada 80 byte yer kaplar). Çok kullanılan bir yöntem, eğer kullandığımız değişken 4 byte'tan fazla yer kaplıyorsa, değişkeni doğrudan kullanmak yerine, o değişkenin hafızada nerede olduğunu belirten bir Pointer kullanmaktır. Her değişkenin bir pointer türünü tanımlayabiliriz. Bunun için tek yapacağımız değişken tipinin önüne ^ koymak. Bu değişkeni kullanabilmek için ise, pointer'ın sonuna ^ koymak. Anlaşıldı, en iyisi bir örnek üzerinde konuşmak.
Var i: integer; p : ^integer; begin i:= 21243;
1.0 Pascal ve Amiga versiyonları, Pascal ile neler yapılabilir? 2.0 Pascal'ın genel yapısı: Tanımlar, bloklar, Procedure ve fonksiyonlar 3.0 Pascal dili özellikleri, tip tanımları, unitler. 4.0 Amiga ile iletişim: Library kullanımı, Amiga'ya has komutlar. 5.0 Gelişmiş programcılık: teknikler, başka sistemlere veya sistemlerden aktarmalar.
p:= ^i; writeln (i); writeln (p^); end.
İster inanın ister inanmayın, ekrana iki defa 21243 yazılacaktır. Önce ne yaptığımıza bir bakalım. İlk olarak i değişkenini integer olarak tanımladık. Daha sonra p değişkenini integer gösteren bir pointer olarak tanımladık. Programda ise, önce i'ye bir değer atadık. Daha sonra p değerini i'nin hafızadaki adresine eşitledik. Dikkat edin: p değişkeni i sayısını değil, i sayısının değerinin hafızada nerede olduğunu tutuyor. Son satırda rahatça görüyoruz ki, sadece p'yi kullanarak i sayısının değerini bulabiliyoruz. Bunun için p^ kullanıyoruz. Bu ifade artık hafızada bir yer göstermiyor, daha çok o yerde bulunan değeri veriyor. Bu genel pointer tipleri dışında, bir de ptr ile tanımlanan bir pointer. Bu pointer ile hafızada yer ayırmak ve dinamik değişkenler yaratmak mümkün olacak (sabredin yahu).
Kümeler: Hadi bakalım, şu ana dek Basic Basic diyenler tüm şanslarını kaybettiler. Zira Pascal'ın en eğlenceli yerine geldik. Bir değişkeni, değerlerinin sınırları ile de belirleyebilirsiniz. Örneğin değişken sadece 1 ila 100 değerini mi alacak? Hemen yapalım:
var a:1..100;
Aradaki iki nokta, bir küme belirlemek için kullanılıyor. Çok dikkat edin, a'yı sadece 1 ve 2 değerlerini alacak şekilde tanımlamak için bile,
var a:1..2;
demeniz gerekiyor. Kümeler, bu kadar basit değil. Kümeleri aralarında işlemler yaparak da tanımlayabiliriz. Her şeyden önce kümeleri parantezlere alıyoruz. Bir değişkeni verilen bir küme elemanlarını içerecek şekilde tanımlamak için ise, SET OF kullanıyoruz. Aşağıda bazı tanımlar var, yanlarında bu tanıma giren kümeyi yazdım:
var a:setof[1..8]*[5..12]; {5,6,7,8}
AMIGA&PASCAL