Object Pascal

Object Pascalda değişkenler (Variable) ve değişken tipleri:

Delphide (Object Pascal) bilgileri hafızada saklamak için değişkenleri kullanır. C++ dilinde programın herhangi bir yerinde değişken tanımlaması yapılırken bu delphide (pascal dilinden dolayı) imkansızdır. Object Pascalda değişkenler Var bloğunda tanımlanırlar. Object Pascalda iki tip değişken tanımlanabir: Global ve local değişkenler. Global değişkenler tüm programda kullanılırlabilirler. Global değişkenleri tanımlamak için programın başında var bloğunun içinde yazılmaları gerekir. Local değişkenler ise sadece ilgili prosedür veya fonksiyonun (alt program) içinde kullanılabilen değişkenlerdir. Alt program dışında kullanılamazlar. Alt programa girerken oluşturulurlar, alt programdan çıkarken hafızadan silinirler.

Global ve local değişkenler

Programlar sayıları iki farklı şekilde (tamsayı ve reel sayı) saklayabilir ve kullanabilir.

Aşağıda Object Pascalda kullanılabilen tamsayı (integer) tipindeki değişkenler, alabildikleri değişken aralıkları ve formatları listelenmiştir:

Tip Aralık Format
Integer -2147483648..2147483647 işaretli 32-bit
Cardinal 0..4294967295 işaretsiz 32-bit
Shortint -128..127 işaretli 8-bit
Smallint -32768..32767 işaretli 16-bit
Longint -2147483648..2147483647 işaretli 32-bit
Int64 -2^63..2^63-1 işaretli 64-bit
Byte 0..255 işaretsiz 8-bit
Word 0..65535 işaretsiz 16-bit
Longword 0..4294967295 işaretsiz 32-bit
UInt64 0..2^64-1 işaretsiz 64-bit

Aşağıda Object Pascalda kullanılabilen gerçek (real) tipindeki değişkenler, alabildikleri değişken aralıkları,basamakları ve kapladıkları alanlar listelenmiştir:

Tip Aralık Gösterebildiği Basamak Kapladığı bayt
Real 5.0 x 10^-324 .. 1.7 x 10^308 15-16 8
Real48 2.9 x 10^-39 .. 1.7 x 10^38 11-12 6
Single 1.5 x 10^-45 .. 3.4 x 10^38 7-8 4
Double 5.0 x 10^-324 .. 1.7 x 10^308 15-16 8
Extended 3.6 x 10^-4951 .. 1.1 x 10^4932 19-20 10
Comp -2^63+1 .. 2^63 -1 19-20 8
Currency -922337203685477.5808 .. 922337203685477.5807 19-20 8

Boolean değişken tipi: İkili (True, False) tipinde değişkendir. Hafızada 1 bayt yer kaplar. True (Doğru) ve False (Yanlış) olmak üzere iki tip değer alabilir. Boolean’da değişkende değer Sıfır ise False, Sıfırdan farklı ise True şeklindedir. Windows ile uyum için 32 bitlik çeşiti de vardır (LongBool)

Variant değişken tipi: Genel kullanım için geliştirilmiş bir değişken tipidir. Tanımlanırken tipi yoktur. Tanımlandıktan sonra sayı (tam veya gerçek) veya yazı tipinde değer alabilir. Aldığı bilgiye göre tipi belirlenir. Bu değişken tipinin alabileceği tipler “varArray, varBoolean, varByRef, varCurrency, varDate, varDispatch, varDouble, varEmpty, varError, varInteger, varNull, varOleStr, varSingle, varSmallint, varString, varTypeMask, varUnknown, varVariant” şeklindedir. İlk tanımlanıp değer verilmediğinde variant değişkenin tipi varEmpty’dir. Variant değişkenlere bir tipde bilgi girip başka bir tipte okumak mümkündür.

Var
V1, V2, V3, V4, V5: Variant;
I: Integer;
D: Double;
S: string;

Begin
V1 := 1;  // integer
V2 := 1234.5678;  // real
V3 := 'Dm7Blog'; // string 
V4 := '1000'; // string 
V5 := V1 + V2 + V4;  // V5=2235.5678 (real)
I := V1; // I = 1 (integer)
D := V2; // D = 1234.5678 (real)
S := V3; // S = 'Dm7Blog' (string)
I := V4; // I = 1000 (integer)
S := V5; // S = '2235.5678' (string)
End;

Bir değişkenin hafızada kapladığı yeri bayt cinsinden öğrenmek için Sizeof fonksiyonu, en küçük değerini bulmak için Low fonksiyonu, en büyük değerini bulmak için High fonksiyonu kullanılabilir.

Aşağıda Object Pascalda kullanılabilen string (yazı saklamak için kullanılan değişkenler) tipindeki değişkenler, kapasiteleri, kapladıkları alanlar listelenmiştir:

String değişken tipi: Turbo ve Object Pascalda kullanılan string türüdür. Ansistring ile aynıdır. (Rad studio 2009’a kadar). Yazının uzunluğu ilk baytın içinde sayı olarak saklanır. Örneğin “Delphi” yazısı string olarak saklanırsa hafızada “6Delphi” şeklinde yerleştirilecektir.

Tip Kapasitesi Kapladığı bayt
ShortString Maksimum 255 karaktere kadar 2 den 256’a kadar (ilk bayt karakter sayısıdır)
AnsiString (LongString) Maksimum 2 GB’a kadar 2 Gb’a kadar Ansi karakterler
UnicodeString Maksimum 2 GB’a kadar 2 Gb’a kadar Unicode karakterler
WideString Maksimum 2 GB’a kadar 2 Gb’a kadar Unicode karakterler
PChar #0 (null) karakterine kadar #0 (null) karakterine kadar
PAnsiChar #0 (null) karakterine kadar #0 (null) karakterine kadar Ansi karakterler
PWideChar #0 (null) karakterine kadar #0 (null) karakterine kadar Unicode karakterler

PChar değişken tipi: Null terminated olarak adlandırılan bir string türüdür. Bu tür C++ dilinde ve Windows Api’lerinde kullanılır. Bu türdeki stringlerin sonunda #0 karakteri bulunur. Bu karakter stringin bittiği noktayı belirler.

Diğer string türleri ile Pchar arasında atamalar veya benzer işlemler (birleştirme gibi) yapılabilir. Rad Studio 2009’dan sonra PWideChar ile aynıdır.

PWideChar değişken tipi: Pchar gibidir. Unicode karakterler içindir.
PAnsiChar değişken tipi: Pchar gibidir. Ansi karakterler içindir.
AnsiChar değişken tipi: Byte değişken tipi ile aynı yer kaplar (1 bayt – 8 Bit). Byte 0..255 arasında sayı saklayabilirken Char 0 ile 255 arasında 256 karakter saklayabilir.

Byte ile Char benzemelerine rağmen birbirlerinin yerine kullanılamazlar. (C++ dilinde değişken tipleri birbirlerinin yerine kullanılabilir. Karakter yazılıp sayı okunabilir veya tersi olabilir)

Char değişken tipi: AnsiChar ile aynıdır. (Rad studio 2009’a kadar)

WideChar değişken tipi: (2 bayt – 16 Bit). Diğer Char tipinden farklı olarak Unicode desteği için 65536 karakter saklayabilir. Bu destek çeşitli dillerdeki farklı karakterlerin kullanılabilmesini sağlar. WideChar, AnsiChar’daki bütün karakterleri kapsar.

Not Delphinin 2009 sürümünden sonra Unicode uyumluluğu için String tipi UnicodeString, Char tipi ise WideChar tipine eşitlenmiştir. Bundan dolayı String içerisinde karakter işlemleri yaparken dikkat edilmelidir.

Object Pascalda değişken ismi seçerken dikkat edilmesi gereken bazı hususlar vardır:

Değişken ismi kesinlikle rakam ile başlayamaz. Fakat değişken ismi içerisinde veya sonunda rakam olabilir. Örneğin 5Elma değişken ismi olarak kullanılamaz fakat Elma5 veya El5ma olabilir

Değişken isminde özel karakterler yer alamaz. Örneğin Elma# veya El#ma değişken ismi olarak kullanılamaz. Özel karakterlerden bazıları şunlardır: # $ & ‘ ( ) * + , – . / : ;< = > @ [ ] ^ { }

Değişken ismi içerisinde boşluk karakteri yer alamaz. Örneğin El ma değişken ismi olarak kullanılamaz.

Object Pascal için ayrılmış komutlar değişken ismi olarak kullanılamaz. Örneğin Not Object Pascalda kullanılan bir komuttur. Değişken ismi olarak kullanılamaz.

Object Pascalda büyük-küçük harf ayrımı yoktur. Değişken ismi tanımlarken büyük veya küçük harfler beraber kullanılabilir. Örneğin Elma, elma, ELMA, ELma isimleri aynı değişkeni göstermektedir.

Object Pascalda değişken ismi içerisinde Türkçe harf (ç, Ç, ğ, Ğ, ı, İ, ö, Ö, ş, Ş, ü, Ü) kullanılamaz. Örneğin ‘Sonuç’ değişken ismi olarak kullanılamaz onun yerine ‘Sonuc’ kullanılmalıdır. (Delphi 2009’dan sonra Türkçe veya diğer diller kullanılabilir)

Değişkenlere değer atanması iki nokta üstüste ve eşittir “:=” kullanılır. Sadece eşittir “=” karşılaştırma işlemleri içindir. Değişkenler tanımlanırken bir başlangıç değeri atanabileceği gibi bir değişkenin değeride diğerine aktarılabilir. Karakter (char) ve yazı (string) değer atanırken başlangıç ve bitişte tek tırnak kullanılır. Tamsayı (integer) değişkenlerde “+” operatörü toplama yaparken, Yazı (String) değişkenlerde ise yazılar ardarda eklenir. Eğer yazı içinde tırnak kullanılması gerekiyorsa bunun için tırnak yazılacak yere 2 tane tek tırnak yazılır. Aşağıda değişkenlere değer atama örnekleri görülmektedir:

Procedure TForm1.Button1Click(Sender: TObject);
Var  a, b, c : Integer;
 d, e : Char;
 f, g, h, i : String;

Begin
 a := 10;
 b := a; // b = 10
 c := a + b; // c = 20
 c := $25; // c = 37 (hexadecimal 25)

 d := 'A';
 e := #66; // e = #66 = 'B' karakteri
 f := e + d; // f = BA
 g := 'DENEME'; // g = DENEME
 g[1] := d; // g = AENEME
 g[2] := e; // g = ABNEME
 f := 'Deneme';
 g := ' yazısı';
 h := f + g; // h =  Deneme yazısı

 h := 'Delphi''de veritabanı'; // h = Delphi'de veritabanı
 
 i := #68#101#108#112#104#105; // i = Delphi
End;

Object Pascalda Tarih ve Zaman tipleri :

Değişken olmamalarına rağmen tarih ve zaman bilgilerini saklamak için double değişken tipinde tanımlanmış tipler vardır. Bu tipler kullanılarak tarih, zaman veya ikisi birden saklanabilir veya saklanan bilgi üzerinde işlem yapılabilir. Tarih ve zaman tipleri aşağıdadır :

TDate Sadece Tarih saklamak için kullanılır
TTime Sadece Zaman saklamak için kullanılır
TDateTime Tarih ve zaman saklamak için kullanılır

Object Pascalda Dizi Değişkenler (Arrays) :

Dizi değişkenler bir değişken tipinin birden fazla kullanılması gereken yerlerde kullanılan değişkenlerdir. Object Pascalda dizi değişkenlerin tanımlanması ve kullanılması çok kolaydır. Değişkenlerin dizi olarak tanımlanması programı hızlandıracağı gibi, kod satırlarının da kısalmasını sağlayacaktır. Sabit ve değişken uzunluklu olmak üzere iki çeşit dizi mevcuttur.

Sabit uzunluklu dizi değişken, tanımlandığı anda boyutunun belirlenmesi şeklinde tanımlanabilir. Belirtilen bu boyut programın içerisinden kesinlikle değiştirilemez. Aşağıda sabit uzunluklu dizi değişken tanımlamaları ve kullanımları görülmektedir:

Var
 dizi : Array[0..10] of Integer; // 0 ile 10 arasında 11 elemanlı integer tipinde dizi değişken tanımlandı
 liste : Array[1..5] of String; // 1 ile 5 arasında 5 elemanlı string tipinde dizi değişken tanımlandı
 ikilidizi : Array[0..2, 0..1] of Integer;
 // 3 x 2 = 6 elemanlı integer tipinde iki boyutlu dizi değişken tanımlandı
 ikilidizi2 : Array[0..2] of Array[0..1] of Integer;
 // Yine 3 x 2 = 6 elemanlı integer tipinde iki boyutlu dizi değişken tanımlandı
Begin
 dizi[1] := 150; dizi[2] := 85;
 liste[1] := 'Ahmet'; liste[2] :='Mehmet';
 ikilidizi[0,0] := 150; ikilidizi[0,1] := 85; ikilidizi[2][1] := 120;
 ikilidizi2[0,0] := 150; ikilidizi2[0][1] := 85; ikilidizi2[2,1] := 120;

Normal değişkenler için geçerli kurallar Dizi değişkenler için de geçerlidir. Değişken dizileri tek, iki veya üç boyutlu olabilir. Dizi başlangıç ve bitiş numarası istenildiği seçilebilir. Program yazılırken verilen dizi başlangıç ve bitiş değerlerine dikkat edilmelidir.

Değişken uzunluklu (Dinamik) dizi değişkenler ise boyutları sabit olmayan sonradan değiştirilebilen dizi değişkenlerdir. Normal değişkenler için geçerli kurallar Dinamik dizi değişkenler için de geçerlidir. Dinamik dizi değişkenleri tek, iki veya üç boyutlu olabilir. Aşağıda Dinamik dizi değişken tanımlaması ve kullanımı görülmektedir:

Var
 dizi : Array of Integer; // Integer tipinde dinamik dizi değişken tanımlandı
 liste : Array of String; // String tipinde dinamik dizi değişken tanımlandı
 ikilidizi : Array of Array of Integer;
 // Integer tipinde iki boyutlu dinamik dizi değişken tanımlandı
Begin
 SetLength(dizi, 11);
 SetLength(liste, 5);
 SetLength(ikilidizi, 4, 3);
 dizi[1] := 150; dizi[2] := 85;
 liste[1] := 'Ahmet'; liste[2] := 'Mehmet';
 ikilidizi[1,1] := 150; ikilidizi[1,2] := 85; ikilidizi[3,2] := 120;
 Memo1.Lines.Add('dizinin eleman sayısı :');
 Memo1.Lines.Add(inttostr(Length(dizi))); // 11
 Memo1.Lines.Add('listenin eleman sayısı :');
 Memo1.Lines.Add(inttostr(Length(liste)));  // 5
 Memo1.Lines.Add('ikilidizinin eleman sayısı :');
 Memo1.Lines.Add(inttostr(Length(ikilidizi))); // 4
 Memo1.Lines.Add(inttostr(Length(ikilidizi[0])));  // 3

Dinamik diziler kullanılmadan önce SetLength komutu ile dizi boyutu tanımlanmalıdır. Çünkü tanımlanmamış dizi boyutu 0’dır. Dinamik dizilerin boyutu tanımlandıktan sonra SetLength komutu ile boyutları değiştirilebilir. Yalnız yeni boyut eskisinden küçük olursa bilgi kaybı olacaktır. Bir dizideki eleman sayısını öğrenmek için Length komutu kullanılabilir. Dizinin 2. boyutundaki eleman sayısını öğrenmek için dizinin 0. elemanı ile Length komutu kullanılır.

Object Pascalda Pointer tipi değişkenler ve Pointer işlemleri:

Pointer değişken tipleri 4 bayt yer kaplayan (32 bit hafıza adresini saklayabilecek şekilde) ve hafızadaki değişkenler üzerinde işlem yapmak için kullanılan değişkenlerdir. Değişken ve tip tanımlamalarının pointer değişkeni tanımlanıp kullanılabilir. Pointer değişkenler hafızada kapladığı alan bakımından Integer değişkenlere benzetilebilir. Fakat pointer değişkenler değişken değeri olarak hafıza adresi saklarlar. Windows işletim sistemi rastgele hafıza adresleri üzerinde işlem yapmaya izin vermemektedir. Fakat programcı kendi programındaki tanımladığı değişkenler üzerinde Pointerleri kullanarak her türlü işlem yapabilir. Pointer değişkenin hafızada saklandığı kendi adresi vardır, ayrıca pointer değişken değer olarak başka bir adres saklar. Bu iki adres birbirine karıştırılmamalıdır. Pointer işlemlerinde pointerin tanımlanması kullanılabilmesi için yeterli değildir. Pointerin göstereceği adres pointere atanmalıdır. Pointer işlemlerinde en sık yapılan hata budur. Pointer işlemler için aşağıdaki operatörler kullanılır:

^ Yeni pointer tipi tanımlamak için kullanılır P: ^Integer; // P Integer tipinde bir pointer
^ Pointerin atandığı adresteki bilgiyi okumak için kullanılır Y := P^; // Y değişkenine P pointerinin gösterdiği adresteki bilgi atanıyor
@ Pointere adres atamak için kullanılır P := @X; // P pointerine X’in adresi atanıyor
Addr Pointere adres atamak için kullanılır P := Addr(X); // P pointerine X’in adresi atanıyor. @ operatörü ile aynıdır

Pointer değişken tanımlamasına ve kullanımına aşağıdaki örnek verilebilir:

Var
 X, Y: Integer; // X ve Y Integer değişkenlerdir
 P: ^Integer;  // P, Integer tipinde Pointer değişkendir
Begin
 X := 17; // X değişkenine 17 değeri verilmektedir
 P := @X; // P Pointerine X değişkeninin hafıza adresi (0012F5B4) değer olarak verilmektedir.
 // Buradan sonra P pointeri üzerindeki işlemler X değişkeni içinde geçerlidir
 Y := P^; // Y değişkeni P Pointerinin Gösterdiği adresteki değere (X değişkeni) eşitlenmektedir
 // X değişkeni ile Y değişkeni aynı değere (17) sahiptir
end;

Pointerler pointer tipinde olabilecekleri gibi başka değişkenlerin pointerleri olarakta tanımlanabilirler. Genelde pek bir fark olmaz çünkü sonuçta pointer 4 bayt yer kaplamaktadır ve 32 bit hafıza adresi saklayacaktır. Pointerler ilk tanımlandıklarında nil (0) değerine sahiptirler. Bundan dolayı sabit bir değişken hafıza adresine eşitlenmedikleri sürece üzerlerindeki işlemler hataya sebep olacaktır. Aşağıdaki uygulamada tanımlanmış dizi değişkene pointer ile ulaşım ve elemanlarının değerleri arasında pointer ile dolaşma yapılmaktadır. Ayrıca dizi değişken elemanların adresleri ve pointerin kendi adresi görüntülenmektedir.

Var
 Form1: TForm1;
 P: ^Integer; // P, Integer tipinde Pointer değişkendir. Global değişkendir.

Implementation
{$R *.dfm}

Procedure TForm1.Button1Click(Sender: TObject);
Var
 X:array [1..3] of Integer; // X Integer dizi değişkendir
 Y: Integer; // Y Integer değişkendir
Begin
 memo1.Clear;
 X[1] := 17;  X[2] := 27;  X[3] := 37; // X dizisinin elemanlarına 3 farklı değeri verilmektedir
 
 P := @X; // P Pointerine X değişkeninin adresi değer olarak verilmektedir
 Y := P^; // Y değişkeni P Pointerinin Gösterdiği adresteki değere (X değişkeni) eşitlenmektedir
 // X[1] değişkeni ile Y değişkeni aynı değere (17) sahiptir
 memo1.Lines.Add('Y değeri: '+Inttostr(Y)); // Y değişkeninin değeri memoya ekleniyor (17)
 memo1.Lines.Add(Format('X[1] değişken adresi: %p', [@X[1]])); // X[1] değişken adresi değeri memoya ekleniyor (0012F5B4)
 memo1.Lines.Add('Pointerin değişkeninin (Y) değeri: '+inttostr(P^)); // Pointerin gösterdiği adresin değeri (17)
 memo1.Lines.Add(Format('Pointerin değişkeninin (Y) adresi: %p', [P])); // Pointer adresi değeri memoya ekleniyor (0012F5B4)
 memo1.Lines.Add(Format('Pointerin kendi adresi: %p', [@P])); // Pointer kendi adresi değeri memoya ekleniyor (00453B68)
 memo1.Lines.Add('');

 Inc(P, 2); // Pointer adresi 2 artılıyor. Integer olduğu için hafıza değeri 8 bayt artıyor
 Y := P^; // Y değişkeni P Pointerinin Gösterdiği adresteki değere (X değişkeni) eşitlenmektedir
 // X[3] değişkeni ile Y değişkeni aynı değere (37) sahiptir
 memo1.Lines.Add('Y değeri: '+Inttostr(Y)); // (37)
 memo1.Lines.Add(Format('X[3] değişken adresi: %p', [@X[3]])); // X[3] değişken adresi değeri memoya ekleniyor (0012F5BC)
 memo1.Lines.Add('Pointerin değişkeninin (Y) değeri: '+inttostr(P^)); // (37)
 memo1.Lines.Add(Format('Pointerin değişkeninin (Y) adresi: %p', [P])); // (0012F5BC)
 memo1.Lines.Add(Format('Pointerin kendi adresi: %p', [@P])); // (00453B68)
 memo1.Lines.Add('');

 Dec(P); // Pointer adresi 1 azaltılıyor. Integer olduğu için hafıza değeri 4 bayt azalıyor
 Y := P^; // X[2] değişkeni ile Y değişkeni aynı değere (27) sahiptir
 memo1.Lines.Add('Y değeri: '+Inttostr(Y)); // (27)
 memo1.Lines.Add(Format('X[2] değişken adresi: %p', [@X[2]])); // X[2] değişken adresi değeri memoya ekleniyor (0012F5B8)
 memo1.Lines.Add('Pointerin değişkeninin (Y) değeri: '+inttostr(P^)); // (27)
 memo1.Lines.Add(Format('Pointerin değişkeninin (Y) adresi: %p', [P])); // (0012F5B8)
 memo1.Lines.Add(Format('Pointerin kendi adresi: %p', [@P])); // (00453B68)

Burada bulunan kodu ve uygulamayı dosya halinde kaynaklar sayfasından indirmek için tıklayınız. Aynı sayfada daha fazla koda ve uygulamaya ulaşabilirsiniz.

Object Pascalda Sabitler (Const) :

Sabitler program yazılırken belirlenen, program çalışması sırasında değiştirilemeyen bildirimlerdir. Sabitler, numerik ve karakter olmak üzere iki çeşittir. Numerik sabitler 0..9 arasında rakamlarla veya $ işareti ile başlamak zorundadır. Hexadecimal sayıların başında genel olarak $ işareti olmalıdır. (Örneğin BAD4 yerine $BAD4 şekilde). Karakter sabitlerinin ise başına ve sonuna tek tırnak eklenmelidir. Sabit belirlenirken tipide belirtilebilir.

Sabit ismi tanımlarken uyulması gereken kurallar değişken ismi için gerekli kurallar ile aynıdır. Sabit ismi için genel olarak tümü büyük harf olması tercih edilir. Zorunlu değildir fakat sabitleri değişkenlerden ayırmayı kolaylaştırır. Aşağıda tanımlanmış birçok sabit örneği görülmektedir:

Const
 SABIT1 = 100;
 SABIT2 = $BAD4;
 SABIT3 = 'Dm7blog.wordpress.com';
 SABIT4 = 'Programlama Sitesi';
 SABIT5 = Chr(123)+' Süslü Parantez karakterleri '+Chr(125); 
 // { Süslü Parantez karakterleri } 
 SABIT6 : Byte = 25;
 SABIT7 : Integer = 150;
 GUNLER : array[1..7] of string = ('Pazartesi', 'Salı', 'Çarşamba', 'Perşembe', 'Cuma', 'Cumartesi', 'Pazar');

Sabitler sonradan değiştirilemez. Fakat {$J+} veya {$WRITEABLECONST ON} direktifleri ile sabitlerini sonradan değiştirilebilmesi sağlanabilir. {$J-} veya {$WRITEABLECONST OFF} direktifleri ile ise sabitlerin sonradan değiştirilememesi sağlanır

Object Pascalda Etiketler (Label) ve Goto Komutu :

Basic’te program kodunda bir noktadan diğer bir noktaya geçiş için Go to komutu kullanılır. Go to komutu kullanışlı olmasına rağmen çok sık kullanılması durumunda spagetti kod denilen karışık, takip edilmesi ve anlaşılması zor programlar ortaya çıkmaktadır. Object Pascalda gelişmiş döngü komutları (Repeat … Until(); veya While () do …;) bulunmaktadır. Bu komutlar ile istenilen döngüler kolayca oluşturulabilir. Ayrıca Basic’te bulunan Go to komutuna karşılığı Object Pascalda da bulunmaktadır.

Object Pascalda Goto komutu ile gidilecek etiketler önceden tanımlanmak zorundadır. Etiket ismi tanımlarken uyulması gereken kurallar değişken ismi için gerekli kurallar ile aynıdır. Aşağıda etiket tanımlama ve Goto komutunun kullanımı ile ilgili örnek kod görülmektedir:

Procedure TForm1.Button1Click(Sender: TObject);
Var a : byte;
Label Etiket1;
Begin
 a : = 0;
Etiket1:
 a : = a + 1;
 if a > 5 then Goto Etiket1;
end;

Burada kodda Button1 tuşuna basılması durumunda a değişkeni önce sıfır değeri almaktadır. Önceden tanımlanmış olan Etiket1 isimli etiket ve Goto komutu yardımı ile bir döngü oluşturulmuştur. Bu döngü içerisinde a değişkeninin değeri artırılmaktadır. Döngünün devamı a değişkeninin 5 değerinden küçük olmasına bağlıdır. Kontrol if komutu ile yapılmaktadır. Goto komutu ile döngü sağlanmıştır. Döngünün devamını sağlayan şart devam ettikçe program satırı Etiket1 ile Goto komutu arasında devamlı olarak çalışacaktır.

Object Pascalda Tip Tanımlamaları :

Type, Object Pascalda bulunmayan yeni tipler tanımlamak için kullanılır. Type ile yeni değişken, sınıf, küme ve yapılar oluşturulabilir. Kullanımı şu şekildedir: Type YeniTipÇeşiti = Tip . Tip tanımlarken uyulması gereken kurallar değişken ismi için gerekli kurallar ile aynıdır. Aşağıda tip tanımlama ceşitleri ve tip tanımları görülmektedir:

Type
 Kelime10 = String[10]; // Özel bilgi tipi tanımlamaları
 Dizi15 = Array[1..15] of Integer;
 Matris5x5 = Array[1..5, 1..5] of Integer;

 Adres = Record // Kayıt (record) tipi tanımlaması
  AdSoyad : String[25];
  Telefon : String[15];
 End;

 Sayi = 0..100; // Aralık bilgi tipi tanımlamaları
 Karakter = 'A'..'Z';
 Hafta = (Pazartesi, Sali, Carsamba, Persembe, Cuma, Cumartesi, Pazar);
 Haftaici = Pazartesi..Cuma; 
 // Hafta tipi tanımlı olduğu için 
 // Haftaici = Pazartesi, Sali, Carsamba, Persembe, Cuma
 HaftaSonu = (Cumartesi=6, Pazar=7);

 PInteger = ^Integer; //Pointer tipi tanımlaması

 Ad = Set of Char; //Küme tipi tanımlamaları
 Deger = Set of Sayi;
 Deger1 = Set of 0..150;
 Karakterler = Set of 'A'..'Z';

 TNesne = class //Nesne tipi tanımlama 
  private
   isim : string;
  public
   function IsimVer : string;
   procedure IsimAl(s : string);
   destructor Destroy; virtual;
   constructor Create;
 End;

Object Pascalda Alt Programlar (Procedure ve Function) :

Aynı kodun birden fazla işletileceği durumlarda, işletilecek kodun tek bir yerde tanımlanıp gerekli yerlerden kullanılması sağlanabilir. Bu tanımlamaya alt program denir. Alt programların kullanılabilmesi için çeşitli şartlar ve seçenekler vardır:

Her alt programın bir ismi vardır. Alt program isimleri değişkenler için geçerli kurallara tabidir.
Alt programlar asıl programdan veya başka bir alt programdan çağrılabilirler.
Alt programlar istenilirse çalışmak için dışardan parametre veya parametreler (değişken) alabilir. Bu değişkenler normal veya dizi değişken olabilir.
Alt programlar -herhangi bir sınıf (class) için tanımlanmamışlarsa- çağrıldıkları program satırının veya alt programın satır olarak üstünde olmalıdırlar.
Alt programlar -herhangi bir sınıf (class) için tanımlanmamışlarsa- başka bir unitin içinde kullanılabilmeleri için bulunduğu unitin içerisinde Interface ile Implementation satırları arasında isim olarak tanımlanmalıdırlar. Harici kütüphanelerin içindeki alt programların isimleri de burada tanımlanır.

Interface
 Function Topla(x, y:integer):integer;
 Procedure Kontrol(fn:string; tp:byte);external 'Readlib.dll';
Implementation
 Function Topla(x:integer; y:integer):integer;
Begin
 result := x+y;
End;

Alt programların dışarıdan aldıkları parametrelerin alt program içerisinde değiştirilmemesi isteniyorsa parametre değişkeninin başına Const eklenmelidir.

function Topla(Const x;integer; Const y:integer):integer;
Alt program tipleri iki çeşittir:

Procedure (Prosedür): Sonlandığında herhangi bir değer döndürmeyen alt programlardır. Procedure kelimesi ile başlarlar.

Procedure EkranaYaz(x;integer; y:integer);

Function (Fonksiyon): Sonlandığında değer döndüren alt programlardır. Function kelimesi ile başlarlar. Döndürmesi istenen tip fonksiyonun sonunda tanımlanır. Tek bir değişken döndürebilirler. Bu değişkenler normal veya dizi değişken olabilir. Fonksiyonun sonunda result değişkenine döndürülecek değer(ler) eşitlenir.

Function Topla(x, y:integer) : integer;

Not Alt programlardan Function bir değer döndürmek için kullanır. Birden fazla değer döndürülmesi gereken yerlerde ise Var kelimesi kullanılır. Tanımlama için değer döndürmesi gereken değişkenin başına Var yazılmalıdır, değer döndürmesi için ise Var kelimesi kullanılan değişkene alt program içerinde değer atanması yeterlidir.

Procedure EkranaYaz(Var x;integer; Var y:integer);
Begin
 x := 100; y :=250;
...

Not Eğer alt programlara büyük miktarda bilgi gönderilmesi gerekiyorsa alt programa değişken değerinin kopyasını göndermek yerine değişkenin adresi (pointer) gönderilebilir. Bu şekilde gönderilen alt program içindeki işlemler doğrudan gönderilen değişken üzerine yapılmış olur. Bu yöntem Windows programlarında (Api fonksiyonlarında) çok sık kullanılır. Hafıza ve zaman tasarrufu sağlar. Bu yöntem aşağıdaki örneklerde görülebilir:

Type
PInteger = ^Integer; // Altprogramda Integer pointer kullanımı için gerekli tanımlama
...
Procedure Altprogram1(x : PInteger);
Begin
 x^ := x^ + 3; // Gönderilen pointer değeri 3 artırılıyor
End;

Procedure TForm1.Button1Click(Sender: TObject);
Var i : Integer;
Begin
 i := 2; // i değişkeninin değeri 2
 Altprogram1( @i );
 // i değişkeninin pointer adresi Altprograma parametre olarak gönderiliyor
 // i değişkeninin değeri 5
End;
Procedure TForm1.Button1Click(Sender: TObject);
Var temp_klasor: array[0..MAX_PATH] of char;
Begin
 GetTempPath(SizeOf(temp_klasor), @temp_klasor);
 // GetTempPath api fonksiyonuna temp_klasor parametresi pointer olarak gönderilmektedir
 ShowMessage(temp_klasor);
End;

Alt Programların Birbirini Çağırması:

Delphide üst kısımda yazılmış bir alt program alt kısımda bulunan başka bir alt programı çağıramaz.
Bu çağırma işleminin yapılabilmesi için altta bulunan alt programın üst kısımda tanıtılması gerekir. Bunun için forward kelimesi kullanılır. Nesneler içinde tanımlanmış alt programlarda bu sorun yoktur. Aşağıda birbirini çağırabilen altlı üstlü iki alt program bulunmaktadır:

Procedure Altprogram2; forward;

Procedure Altprogram1;
Begin
 Altprogram2;
End;

Procedure Altprogram2;
Begin
 Altprogram1;
End;

Alt Programlarda Aşırı Yükleme:

Delphi aynı isme sahip farklı parametreli birden fazla alt program tanımlanmasına izin vermektedir. Bu olaya (Overload) Aşırı Yükleme denir. Delphi çalışırken kod içerisinde hangi alt programı kullanacağına parametre sayılarına ve tiplerine bakarak karar verir. Birden fazla aynı isimli alt programı aşırı yüklemeli tanımlamak için her bir alt programın başlık kısmına Overload; kelimesi eklenmelidir. Aşağıda aynı isme sahip iki alt program aşırı yükleme yapılarak tanımlanmıştır:

Function Bol(X, Y: Real): Real; overload;
Begin
 Result := X / Y;
End;

Function Bol(X, Y: Integer): Integer; overload;
Begin
 Result := X div Y;
End;

Burada alt program Real tipinde değişkenler kullanılarak çağrılıyorsa birincisi, Integer tipinde değişkenler kullanılarak çağrılıyorsa ikincisi kullanılır. Tanımlama yapılırken alt programların parametre tiplerinde, sayılarında farklılık yoksa Delphi hata verecektir.

Alt Programların Kendi Kendini Çağırma (Recursive) şeklinde kullanılması:

Tanımlanmış olan fonksiyon, kod bloğu içerisinde, kendi kendisini çağırıyorsa bu tip fonksiyonlara “Rekürsif” fonksiyon denir. Aşağıdaki faktöriyel hesaplayan örnek fonksiyonda, bu yapıya ait kullanım şekli görülmektedir:

{$J+} // Sabitlere yazılabilmesini sağlıyor

Function faktoriyel(sayi : Integer):Double;
Const Toplamlar : Double = 1;
Begin
 if sayi>1 then Toplamlar := sayi * faktoriyel(sayi-1);
 //Fonksiyon kendi kendini çağırıyor
 Result := Toplamlar;
 Toplamlar := 1;
End;

Sonuc := faktoriyel(5); //Alt programın çağırılması

Not Alt programların kendi kendine çağırmaları şeklinde kullanılmaları kodlama açısından birçok faydalar sağlar. Fakat alt programlar çağrıldıklarında çağıran yere geri dönebilmeleri için dönecekleri adres Stack denilen hafızada saklanır. Bu sebeple bir alt programın sürekli kendini çağırması Stack Taşması (Stack Overflow) hatasına sebep olacaktır.

Object Pascalda Operatörler :

Object Pascalda matematiksel ve string işlemlerde kullanan operatörler aşağıda tablo halinde verilmiştir:

Operatör Görevi Örnek Sonuç
+ Toplama 10+20 30
+ String işlemlerinde ikinci yazıyı ilk yazının arkasına ekleme ‘Del’+’phi’ Delphi
Çıkarma-Fark 10-20 -10
Negatifini alma -(10) -10
* Çarpma 10*20 200
/ Bölme 20/10 2
Mod Mod-Bölüm kalanı 10 Mod 3 1
Div Tam Bölüm 10 Div 3 3
Inc Bir veya birden fazla artırma Inc(a, 2) a=a+2
Dec Bir veya birden fazla azaltma Dec(a) a=a-1

Object Pascalda mantıksal ve karşılaştırma işlemlerinde kullanan operatörler aşağıda tablo halinde verilmiştir:

Operatör Görevi Örnek
Not Mantıksal Değil(Not) işlemi-Karşılaştırmada sonucun tersini verme Not(x)
And Mantıksal Ve(And) işlemi-Karşılaştırmada iki sonucunda doğru olması durumunda doğru olma x AND y
Or Mantıksal Veya(Or) işlemi-Karşılaştırmada iki sonuçtan herhangi birisinin doğru olması durumunda doğru olma x OR y
Xor Mantıksal ÖzelVeya(Xor) işlemi x XOR y
Shl Mantıksal Sola kaydırma (Shl) x SHL y
Shr Mantıksal Sağa kaydırma (Shr) x SHR y

Object Pascalda Koşul işlemlerde ve Atamada kullanan operatörler aşağıda tablo halinde verilmiştir:

Operatör Görevi Örnek
:= Atama. Soldaki değişkene sağdaki değeri atama A:=10
= İki koşulun eşit olması kontrolü A=B
<> İki koşulun farklı olması kontrolü A<>B
< İlk koşulun ikincisinden küçük olması kontrolü A<B
> İlk koşulun ikincisinden büyük olması kontrolü A>B
<= İlk koşulun ikincisinden küçük-eşit olması kontrolü A<=B
>= İlk koşulun ikincisinden büyük-eşit olması kontrolü A>=B
in İlk değerin ikinci kümede olması kontrolü A in [1, 2, 3]

Object Pascalda Begin End Bloğu :

Object Pascalda döngüler, karşılaştırma ifadeleri gibi duruma göre komutların çalıştırıldığı yerler bulunmaktadır. Döngü veya karşılaştırma ifadeleri bir tane komut ile kullanılabilir. Fakat bazı durumlarda birden fazla komutun bir ifade için işletilmesi gerekebilir. Bu durumlar için Begin End bloğu kullanılır. Begin End bloğu içerisine istenildiği kadar komut konulabilir ve döngü, karşılaştırma ifadeleri bu bloğu tek bir komutmuş gibi kullanır. Begin end bloğu program içerisinde istenildiği kadar kullanılabilir. Begin end komutu içerisine tek komut konulması hataya sebep olmaz fakat kodun okunmasını zorlaştırır. Aşağıda Begin end bloğu kullanımış örnek görülmektedir:

for s := 1 to 10 do
Begin
 a := a + b;
 c := a / 5;
End; 
//For döngüsü Begin end bloğu içerisindeki komutları tek bir komut gibi işlemektedir.

Object Pascalda With Do Bloğu :

Nesne ve Record tipleri gibi tanımlamalarda kodu basitleştirmek ve okunmasını kolaylaştırmak amacıyla With Do bloğu kullanılır. Aynı ifade tekrar tekrar yazılmak yerine With Do ile bir sefer yazılır ve blok içerisindeki her ifade için geçerli olur. Aşağıda With do kullanımına ait örnek bulunmaktadır:

Type
TOgrenci = Record
 isimsoyad : string[20];
 numara : Integer;
End;

Var
Form1: TForm1;
Ogrenci1, Ogrenci2 : TOgrenci;

Procedure TForm1.Button1Click(Sender: TObject);
Begin
 Ogrenci1.isimsoyad := 'ahmet';
 Ogrenci1.numara := 123;
 
 With Ogrenci2 Do
 Begin
  isimsoyad := 'mehmet';
  numara := 345;
 End;
End;

Object Pascalda Döngüler :

Döngüler yazılım dilleri içerisinde çok önemli yer tutan komutlardır. Arka arkaya bir çok kez işletilmesi gereken kodların bulunduğu durumlarda, veya belirlenen şartın gerçekleşmesine veya gerçekleşmemesine kadar işletilmesinde döngüler kullanılır. Object Pascalda üç çeşit döngü vardır:

For to ve For downto döngüleri: Bu döngü ile bir başlangıç ile bir bitiş arasındaki fark kadar bir blok çalıştırılır. İki farklı For döngüsü vardır. Bunlar başlangıcın bitişten küçük olduğu For to döngüsü ve başlangıcın bitişten büyük olduğu For downto döngüsüdür. Bu döngülerdeki başlangıç ve bitiş değerleri sabit sayılar olabileceği gibi değişkenlerde kullanılabilir. Yalnız değişkenlerin değeri değiştirilirken başlangıcın bitişten farkına göre döngü seçilmelidir. Aksi halde program hata verecektir. (C++ dilinde böyle bir sorun yoktur). Aşağıda For to ve For downto döngüleri hakkında örnekler görülmektedir:

For s := 1 To 10 do EkranaYaz;
 //EkranaYaz, For to döngüsü içerisinde 1 den 10 a kadar toplam 10 defa çağrılıyor.

 For s := 10 Downto 1 do EkranaYaz;
 //EkranaYaz, For downto döngüsü içerisinde 10 dan 1 e kadar toplam 10 defa çağrılıyor.

 Bs := 5; Bt := 8;
 For s := Bs To Bt do EkranaYaz;
 //EkranaYaz, For to döngüsü içerisinde 5 den 8 e kadar toplam 3 defa çağrılıyor.

 Bs := 8; Bt := 3;
 For s := Bs Downto Bt do EkranaYaz;
 //EkranaYaz, For downto döngüsü içerisinde 8 den 3 e kadar toplam 5 defa çağrılıyor.

Repeat Until döngüsü: Object Pascalda kullanılan döngülerden biride Repeat until döngüsüdür. Bu döngüde Repeat ile until arasındaki blok Until kelimesinden sonraki kontrol şartı yanlış oldukça çalışacaktır. Yani Untildeki karşılaştırma doğru çıkana kadar döngüden çıkılmaz. Bu döngüde kontrol sonda yapıldığı için döngüden hemen çıkılsa bile döngü içerisindeki kod en az bir defa çalıştırılacaktır. Buna dikkat edilmelidir. Eğer ters karşılaştırma yapılması isteniyorsa yani şart oluştuğunda döngüden çıkılması isteniyorsa döngü Not operatörü ile kullanılabilir. Aşağıda Repeat until döngüsüne iki ayrı örnek verilmiştir:

a := 0; c := 0;
Repeat
 a := a + 1;
 c := a + 5;
Until (a>=5);
//Repeat until döngüsünde a değişkeni 5'ten küçük oldukça döngü çalışacaktır.
a := 0; c := 0;
Repeat
 a := a + 1;
 c := a + 5;
Until Not(a<5);
//Repeat until döngüsünde a değişkeni 5'ten küçük oldukça döngü çalışacaktır.

While do döngüsü: Object Pascalda kullanılan döngülerden biri de While do döngüsüdür. Bu döngüde While ile do arasında şart, do’dan sonraki blokta çalıştırılacak döngü bulunur. While ile do arasındaki kontrol şartı doğru oldukça döngü çalışacaktır. Yani While do’da karşılaştırma yanlış çıkana kadar döngüden çıkılmaz. Bu döngüde kontrol başta yapılmaktadır. Eğer ters karşılaştırma yapılması isteniyorsa yani şart oluşmadığında döngüden çıkılması isteniyorsa döngü Not operatörü ile kullanılabilir. Aşağıda While do döngüsüne iki ayrı örnek verilmiştir:

a := 0; c := 0;
While(a < 5) do //While do döngüsünde a değişkeni 5'ten küçük oldukça döngü çalışacaktır.
Begin
 a := a + 1;
 c := a + 5;
End;
a := 0; c := 0;
While Not(a >= 5) do
//While do döngüsünde a değişkeni 5'ten küçük oldukça döngü çalışacaktır.
Begin
 a := a + 1;
 c := a + 5;
end; 

Döngü Yönlendirme Komutları :

Döngü kodlarınızın işletilmesi anında, belirlenmiş olan şartın (veya şartların) gerçekleşmesi durumunda, döngüden veya alt programdan çıkmak veya tekrar başa (döngünün başına) dönmek istenebilir. Bu tip durumlar için Object Pascalda çeşitli komutlar vardır:

Continue komutu : Bir döngü içerisinde belirli bir şartın sağlanması durumunda, döngünün içerisindeki diğer kodları işlenmeden tekrar döngü başına dönülmesini sağlayan komuttur. Burada for döngüleri için sayaç değişkeni değeri artacaktır. Continue komutun amacı belirli şartlarda döngü içerisindeki belirli komutların işlenmemesi ve döngüye işlenmiş gibi devam edilmesidir.

a := 0; c := 0;
Repeat
 a := a + 1;
 if a = 3 then Continue;
 {Döngü içerisinde a değişkeni 3 değeri aldığında
 alttaki komutlar işlenmeden döngü başına dönülecektir.}
 c := a + 5;
Until (a>=5);

Break komutu : Bir döngü içerisinde belirli bir şartın sağlanması durumunda, döngünün içerisindeki diğer kodları işlenmeden döngü dışına çıkılmasını sağlayan komuttur. Break komutun amacı belirli şartlarda döngü içerisindeki belirli komutların işlenmemesi ve döngüden çıkılmasıdır.

a := 0; c := 0;
Repeat
 a := a + 1;
 if a = 3 then Break;
 {Döngü içerisinde a değişkeni 3 değeri aldığında
 alttaki komutlar işlenmeden döngüden çıkılacaktır.}
 c := a + 5;
Until (a>=5);

Exit komutu : Bir döngü içerisinde belirli bir şartın sağlanması durumunda, döngünün içerisindeki diğer kodları işlenmeden hem döngü dışına hem alt program dışına çıkılmasını sağlayan komuttur. Exit komutunun kullanılması için döngü illa gerekli değildir. Alt programlarda da aynı amaçla kullanılabilir.

a := 0; c := 0;
Repeat
 a := a + 1;
 if a = 3 then Exit;
 {Döngü içerisinde a değişkeni 3 değeri aldığında
 alttaki komutlar işlenmeden döngüden ve alt programdan çıkılacaktır.}
 c := a + 5;
Until (a>=5);

Halt komutu : Belirli bir şartın sağlanması durumunda, diğer kodların işlenmeden program dışına çıkılmasını sağlayan komuttur. İstenirse program çıkışında işletim sisteminin kullanımı için bir çıkış değeri ile kullanılabilir.

a := 0; c := 0;
Repeat
 a := a + 1;
 if a = 3 then Halt(1);
 {Döngü içerisinde a değişkeni 3 değeri aldığında programdan çıkılacaktır.
  Program çıkışında işletim sistemi kullanımı için 1 değeri üretilecektir.}
 c := a + 5;
Until (a>=5);

Not Application nesnesinin Terminate komutu Halt ile benzer çalışmaktadır. Herhangi bir döngü içerisinde Halt kullanılırsa direkt program sonlanır. Fakat Application.Terminate kullanılırsa ancak döngü bittikten sonra program sonlanır. Application.Terminate ile programın direkt sonlanması istenirse Application.Terminate komutu Exit komutu ile birlikte kullanılmalıdır.

Sleep komutu : Özellikle döngülerde çok hızlı işleyen kodları izleyebilmek veya zaman kazanmak amaçlı kullanılan bir komuttur. Parametre olarak girilen değer “milisaniye” (Saniyenin binde biri) cinsindendir.

a := 0; c := 0;
Repeat
 a := a + 1;
 c := a + 5;
 Sleep(100);
 //Döngü içerinde her çalışmada 100 milisaniye program beklemektedir.
Until (a>=5);

Application.ProcessMessages komutu : Yazılan döngüler yoğun işlemlere sahipse ve döngünün bitirilmesi uzun sürüyorsa program donacaktır ve işletim sistemin hiçbir mesajına cevap veremeyecektir. Bu durumda program Windows Görev Yöneticisinde “Cevap vermiyor” şeklinde görünecektir ve kullanıcının hiçbir isteğine karşılık veremeyecektir. Program taşınamaz, küçültülüp, büyültülemez, kapatılamaz, ekran görüntüsü tazelenemez. Bu duruma engel olmak için döngü içerisine Application.ProcessMessages komutu eklenmelidir. Bu komut döngüyü kısa bir süre durduracak ve windows mesajlarının işlenmesini sağlayacaktır. Bu komutun tek sakıncası döngüyü yavaşlatmasıdır.

a := 0; c := 0;
Repeat
 a := a + 1;
 c := a + 5;
 Application.ProcessMessages;
 //Döngü içerinde her çalışmada windows mesajlarına bakılması sağlanmaktadır.
Until (a>=35000);

Object Pascalda Karşılaştırma İşlemleri :

Program yazılırken belirli durumlarda belirli komutların işlenmesi veya işlenmemesi gerekir. Bunun için bütün programlama dilleri karşılaştırma komutu içerir. Object Pascalda If Then ve If Then Else komutları ile karşılaştırma işlemleri yapılır:

If Then ile karşılaştırma işlemi: Bu karşılaştırma komutuyla bir şart doğru olduğunda bir komutun işlenmesi sağlanır. If ile Then arasına karşılaştırma işlemi yazılır. Karşılaştırma işlemi için karşılaştırma operatörleri kullanılır. Then kelimesinden sonra ise işlenecek tek komut yazılır ve ; işareti ile blok bitirilir. Then kelimesinden sonraki komut şart sadece doğru olduğunda çalışacaktır. Then kelimesinden sonra birden fazla komut çalışması isteniyorsa Begin End bloğu kullanılmalıdır. Eğer şart yanlış olduğunda çalıştırma isteniyorsa If ile Then arasındaki karşılaştırma işleminin başında Not operatörü kullanılabilir.

If a = 5 Then c := 0; // a değişkeni 5'e eşit olduğunda c := 0 komutu işlenecektir.

If a = 5 Then
Begin
 c := 0; d := 5;
End; // a değişkeni 5'e eşit olduğunda c := 0 ve d := 5 komutları işlenecektir.

If Not(a = 5) Then c := 0;
 // a değişkeni 5'den farklı olduğunda c := 0 komutu işlenecektir.

If a < > 5 Then c := 0; // a değişkeni 5'den farklı olduğunda c := 0 komutu işlenecektir.

If Then Else ile karşılaştırma işlemi: Bu karşılaştırma komutuyla bir şart doğru olduğunda bir komutun yanlış olduğunda ise başka bir komutun işlenmesi sağlanır. If ile Then arasına karşılaştırma işlemi yazılır. Karşılaştırma işlemi için karşılaştırma operatörleri kullanılır. Then kelimesinden sonra şart doğru olduğunda, Else kelimesinden sonra ise şart yanlış olduğunda çalışacak komut yazılır ve ; işareti ile blok bitirilir. Then ve/veya Else kelimelerinden sonra birden fazla komut çalışması isteniyorsa Begin End bloğu kullanılmalıdır. Eğer şart yanlış olduğunda çalıştırma isteniyorsa If ile Then arasındaki karşılaştırma işleminin başında Not operatörü kullanılabilir.

If a = 5 Then c := 0 Else c :=10;
// a değişkeni 5'e eşit olduğunda c := 0, yanlış olduğunda c := 10 komutu işlenecektir.

If a = 5 Then
Begin
 c := 0; d := 5;
End Else
Begin
 c := 10; d := 0;
End; { a değişkeni 5'e eşit olduğunda c := 0 ve d := 5, yanlış olduğunda c := 10 ve d := 0 komutları işlenecektir.}

If a = 5 Then c := 0 Else
Begin
 c := 10; d := 0;
End; { a değişkeni 5'e eşit olduğunda c := 0 komutu, yanlış olduğunda c := 10 ve d := 0 komutları işlenecektir.}

If a = 5 Then
Begin
 c := 0; d := 5;
End
Else d := 0; { a değişkeni 5'e eşit olduğunda c := 0 ve d := 5 komutları, yanlış olduğunda d := 0 komutu işlenecektir.}

Case of yapısı ile karşılaştırma işlemi: If karşılaştırma operatörleri ile sadece bir karşılaştırma yapılabilmektedir. Birden fazla karşılaştırma yapılabilmesi için her karşılaştırma için If operatörlü ifade yazılması gerekir. Bu da program kodunun uzamasına ve karışık olmasına sebep olur. Case yapısı bu durumlar için kullanılır. Eğer bir degişken birden fazla değer ile karşılaştırılacaksa Case operatörü kullanılır. Kullanımı aşağıdaki şekildedir:

Case a of
 1..5: Label1.Caption := 'Düşük';
 6..9: Label1.Caption := 'Yüksek';
 0, 10..99: Label1.Caption := 'Sınırların dışında';
else
 Label1.Caption := '';
end;

// Aynı işi yapan kodun If else ile yazılması

if a in [1..5] then
 Label1.Caption := 'Düşük'
else if a in [6..10] then
 Label1.Caption := 'Yüksek'
else if (a = 0) or (a in [10..99]) then
 Label1.Caption := 'Sınırların dışında'
else Label1.Caption := '';

Delphi’de Asm Kullanımı

Programlar hangi dille yazılırsa yazılsın derleyiciler kodları makine koduna çevirmektedir. Fakat kodun çok hızlı çalışmanın gerekmesi, çok sayıda çağrılması gibi bazı özel durumlarda doğrudan Makine kodu ile programlama çok zor olduğu için ona en yakın olan Asm kodu kullanmak gerekir. Delphide asm komutlarını kullanmak ve asm program yazmak çok basittir. Fakat Asm kullanımı için Asm’ye hakim olmak gerekir. Yapılacak bir hata programın çökmesine veya yanlış çalışmasına neden olacaktır. Aşağıda delphide yazılmış kod ve asm karşılığı görülmektedir:

Function Ikiylecarp(Sayi: Integer): Integer;
Begin
 Result := Sayi * 2;
End;

Function IkiylecarpAsm(Sayi: Integer): Integer;
Asm
 Add eax, eax // Result := Sayi * 2 = Sayı + Sayı;
End; // Ret

Asm komutu yazmak için “Asm” kelimesi ile koda başlanır, “End” kelimesi ile asm kod bitirilir. Buradan görüldüğü gibi “Sayi” parametresi, eax register’ı (yazmaç) ile geliyor ve tekrar çıktı olarak eax olarak çıkıyor. Bu register çağırımı, Delphi’de varsayılan (default) olarak kullanılır. Burada yapılan işlem çok basittir. 2 ile çarpmak için, değişkenin kendisini kendisi ile toplatılıyor. End (Ret) ile de tekrar çalışma satırına dönülür.

Object Pascalda sık kullanılan bazı komutlar :

Inttostr fonksiyonu : Girilen integer tipindeki sayıyı String tipinde yazıya çevirmek için kullanılır. Yazı := Inttostr(Sayı); Kullanımı şu şekildedir :

Var yazi: String; sayi: Integer;
Begin
 sayi := 1453;
 yazi := Inttostr(sayi);

Floattostr fonksiyonu : Girilen noktalı Extended tipindeki sayıyı String tipinde yazıya çevirmek için kullanılır. Sonuç yazısını formatlı şekilde almak mümkündür. Yazı := Floattostr(Sayı) veya Yazı := Floattostr(Sayı, FormatŞekli). İkinci kullanım için format şekli sistemden okunabilir veya programcı tarafından belirlenebilir. Kullanımları şu şekildedir :

Var yazi: String; sayi: Integer;
Begin
 sayi := 123.456;
 yazi := Floattostr(sayi); 
 // Sonuc = 123,456 (Türkçe format ayarlı bilgisayarda)

// İkinci kullanım örneği :
Var s: string; fs: TFormatSettings;
Begin
 GetLocaleFormatSettings(0, fs); // Sistem formatlama ayarı okunuyor
 s := Floattostr(123.456, fs);
 // Sonuc = 123,456 (Sistemi Türkçe format ayarlı bilgisayarda) (1055)

GetLocaleFormatSettings fonksiyonu : Sistemin klavye, tarih, saat vb biçim ayarlarını okumak için kullanılır. Bu değerler farklı dillere sahip sistemlerde farklı olabilir. Örneğin İngilizce bir sistemde ondalıklı sayılar nokta ile gösterilirken; Türkçe bir sistemde virgül ile gösterilir. 0 parametresi ile o anki sistemin değerleri okunur. Amerikan sistemi için 1033, Türkçe sistemi için 1055 parametresi girilir. Kullanımı şu şekildedir :

// İkinci kullanım örneği :
Var s: string; fs: TFormatSettings;
Begin
 GetLocaleFormatSettings(0, fs); // Sistem formatlama ayarı okunuyor
 s := Floattostr(123.456, fs);
 // Sonuc = 123,456 (Sistemi Türkçe format ayarlı bilgisayarda)

 GetLocaleFormatSettings(1033, fs); // Amerikan sistem formatlama ayarı okunuyor (1033)
 s := Floattostr(123.456, fs); 
 // Sonuc = 123.456 (Amerikan format ayarı)

 GetLocaleFormatSettings(1055, fs); // Türkçe sistem formatlama ayarı okunuyor (1055)
 s := Floattostr(123.456, fs); 
 // Sonuc = 123,456 (Türkçe format ayarı)

 fs.DecimalSeparator := '#';
 s := Floattostr(123.456, fs); 
 // Sonuc = 123#456 (Kullanıcı format ayarı)

FloattostrF fonksiyonu : Girilen noktalı Extended tipindeki sayıyı String tipinde yazıya çevirmek için kullanılır. Sonuç yazısının formatını ve çıkış şeklini (parasal, üstel, 1000’erli ayrılmış, genel) ayarlamak mümkündür. Yazı := Floattostrf(Sayı, ÇıkışŞekli, BasamakSayısı, OndalıkBasamakSayısı) veya Yazı := Floattostrf(Sayı, ÇıkışŞekli, BasamakSayısı, OndalıkBasamakSayısı, FormatŞekli). İkinci kullanım için format şekli sistemden okunabilir veya programcı tarafından belirlenebilir. Kullanımları şu şekildedir :

Var yazi: String; sayi: Integer;
Begin
 sayi := 123.456;
 yazi := Floattostrf(sayi, ffCurrency, 20, 2);
 // Sonuc = 123,46 TL (Türkçe format ayarlı bilgisayarda)
// İkinci kullanım örneği:
Var s: string; fs: TFormatSettings;
Begin
 GetLocaleFormatSettings(0, fs); 
 // Sistem formatlama ayarı okunuyor
 s := Floattostrf(123.456, ffCurrency, 20, 2, fs);
 // Sonuc = 123,46 TL (Sistemi Türkçe format ayarlı bilgisayarda)
Çıkış Şekli Açıklaması
ffCurrency Parasal Format için kullanılır
ffNumber Binlik ayıraç uygulanmış halde gösterilir
ffFixed Ondalıklı Formatta gösterilir
ffExponent Sayı üstel olarak gösterilir
ffGeneral Üstel veya normal gösterim

Formatfloat fonksiyonu : Girilen noktalı Extended tipindeki sayıyı String tipinde yazıya çevirmek için kullanılır. Bu komutun FloattostrF komutundan farkı çıkış şeklinin programcı tarafından istenidiği gibi ayarlanabilmesidir. Yazı := Formatfloat(ÇıkışŞekli, Sayı) veya Yazı := Formatfloat(ÇıkışŞekli, Sayı, FormatŞekli). İkinci kullanım için format şekli sistemden okunabilir veya programcı tarafından belirlenebilir. Kullanımları şu şekildedir :

Var sayi : extended; yazi : string;
begin
 sayi := 1234.567;

// Sayı formatlama
 yazi := FormatFloat('#####', sayi); // sonuç = 1235
 yazi := FormatFloat('00000', sayi); // sonuç = 01235
 yazi := FormatFloat('0' , sayi); // sonuç = 1235
 yazi := FormatFloat('#,##0', sayi); // sonuç = 1.235 (Türkçe formatlı sistemde)
 yazi := FormatFloat(',0' , sayi); // sonuç = 1.235 (Türkçe formatlı sistemde)

// Basamaklı sayı formatlama
 yazi := FormatFloat('0.####', sayi); // sonuç = 1234,567 (Türkçe formatlı sistemde)
 yazi := FormatFloat('0.0000', sayi); // sonuç = 1234,5670 (Türkçe formatlı sistemde)

// Bilimsel sayı formatlama
 yazi := FormatFloat('0.0000000E+00', sayi);
 // sonuç = 1,2345670E+03 (Türkçe formatlı sistemde)
 yazi := FormatFloat('0.0000000E-00', sayi);
 // sonuç = 1,2345670E03 (Türkçe formatlı sistemde)
 yazi := FormatFloat('#.#######E-##', sayi);
 // sonuç = 1,234567E3 (Türkçe formatlı sistemde)

// Yazı içeren formatlama
 yazi := FormatFloat(' "Bulunan = " 0.0', sayi);
 // sonuç = Bulunan = 1234,6 (Türkçe formatlı sistemde)

// Negatif sayıları formatlama
 yazi := FormatFloat('0.0', -1234.567); // sonuç = -1234,6 (Türkçe formatlı sistemde)
 yazi := FormatFloat('0.0 "Pozitif";-0.0 "Negatif";0.0 "Sıfır" : ', 1234.567);
 // sonuç = 1234,6 Pozitif (Türkçe formatlı sistemde)
 yazi := FormatFloat('0.0 "Pozitif";-0.0 "Negatif";0.0 "Sıfır" : ', -1234.567);
 // sonuç = -1234,6 Negatif (Türkçe formatlı sistemde)
 yazi := FormatFloat('0.0 "Pozitif";-0.0 "Negatif";0.0 "Sıfır" : ', 0.0);
 // sonuç = 0,0 Sıfır (Türkçe formatlı sistemde)
Karakterler Anlamları
0 Basamağı kesinlikle gösterir, ilgili basamak yoksa 0 gösterir
# Basamak varsa gösterir yoksa göstermez
, Binlik ayırıcıyı gösterir
. Ondalık ayırıcıyı ve basamakları gösterir
E+ Bilimsel gösterimde pozitif olsa bile üstel işareti gösterir
E- Bilimsel gösterimde negatif işaret varsa üstel işareti gösterir
; Pozitif, negatif ve sıfır sayılar için farklı formatlar kullanılabilmesini sağlar
‘ ‘ veya ” “ Formatlama içerisine yazı eklenebilmesini sağlar

Strtoint fonksiyonu : Girilen yazıyı (string) Integer tipinde sayıya çevirmek için kullanılır. Eğer yazı içerisinde hatalı karakterler varsa EConvertError hatası döner. Sayı := Strtoint(Yazı); Kullanımı şu şekildedir :

Var yazi: String; sayi: Integer;
Begin
 yazi := '1453';
 sayi := Strtoint(yazi);

Strtointdef fonksiyonu : Girilen yazıyı (string) Integer tipinde sayıya çevirmek için kullanılır. Strtoint fonksiyonuna benzer fakat hatalı karakterler varsa hata döndürmez, fonksiyonla verilmiş varsayılan değeri geri döndürür. Sayı := Strtointdef(Yazı, Varsayılan Sayı); Kullanımı şu şekildedir :

Var yazi: String; sayi: Integer;
Begin
 yazi := '1453abc';
 sayi := Strtointdef(yazi, 1000);
 // sayi = 1000

Strtofloat fonksiyonu : Girilen yazıyı (string) Extended tipinde sayıya çevirmek için kullanılır. Eğer yazı içerisinde hatalı karakterler varsa EConvertError hatası döner. Sayı := Strtofloat(Yazı); veya Sayı := Strtofloat(Yazı, FormatŞekli). İkinci kullanım için format şekli sistemden okunabilir veya programcı tarafından belirlenebilir. Yazı girilirken sistemin sayı formatlama ayarları göz önüne alınmalıdır. Kullanımı şu şekildedir :

Var yazi: String; sayi: Extended;
Begin
 yazi := '123,456';
 sayi := Strtofloat(yazi);
 // Sonuc = 123,456 (Türkçe format ayarlı bilgisayarda)
// İkinci kullanım örneği:
Var s: extended; fs: TFormatSettings;
Begin
 GetLocaleFormatSettings(0, fs); // Sistem formatlama ayarı okunuyor
 s := Strtofloat('123,456', fs);
 // Sonuc = 123,456 (Sistemi Türkçe format ayarlı bilgisayarda)
end;

Strtofloatdef fonksiyonu : Girilen yazıyı (string) Extended tipinde sayıya çevirmek için kullanılır. Eğer yazı içerisinde hatalı karakterler varsa karakterler varsa hata döndürmez, fonksiyonla verilmiş varsayılan değeri geri döndürür. Sayı := Strtofloatdef(Yazı, Varsayılan sayı); veya Sayı := Strtofloatdef(Sayı, Varsayılan Sayı, FormatŞekli). İkinci kullanım için format şekli sistemden okunabilir veya programcı tarafından belirlenebilir. Yazı girilirken sistemin sayı formatlama ayarları göz önüne alınmalıdır. Kullanımı şu şekildedir :

Var yazi: String; sayi: Extended;
Begin
 yazi := '123,456';
 sayi := Strtofloatdef(yazi, 3.14);
 // Sonuc = 123,456 (Türkçe format ayarlı bilgisayarda)

Chr fonksiyonu : Parametre ile girilen sayı değerinin karakter karşılığını bulmak için kullanılan fonksiyondur. Karakter := Chr(Sayı); Kullanımı şu şekildedir :

// Buton1'e tıklandığında ilk 127 karakter noları 
// ve karakterler memo içerisine yazılıyor
Procedure TForm1.Button1Click(Sender: TObject);
Var s: Byte;
Begin
 For s := 0 to 127 do
  Memo1.Lines.Add(Chr(s)+' = '+IntToStr(s));
End;

Ord fonksiyonu : Parametre ile girilen karakterin karakter numarası karşılığını bulmak için kullanılan fonksiyondur. Sayı := Ord(Karakter); Kullanımı şu şekildedir :

// Edit1'e yazı yazıldığında basılan tuşun 
// karakter nosu label1'e yazılıyor
procedure TForm1.Edit1KeyPress(Sender: TObject; var Key: Char);
Begin
 label1.Caption := IntToStr(Ord(Key));
 edit1.Clear;
End;
Reklamlar

Bir Cevap Yazın

Aşağıya bilgilerinizi girin veya oturum açmak için bir simgeye tıklayın:

WordPress.com Logosu

WordPress.com hesabınızı kullanarak yorum yapıyorsunuz. Çıkış  Yap / Değiştir )

Twitter resmi

Twitter hesabınızı kullanarak yorum yapıyorsunuz. Çıkış  Yap / Değiştir )

Facebook fotoğrafı

Facebook hesabınızı kullanarak yorum yapıyorsunuz. Çıkış  Yap / Değiştir )

Google+ fotoğrafı

Google+ hesabınızı kullanarak yorum yapıyorsunuz. Çıkış  Yap / Değiştir )

Connecting to %s