Delphim Kaynak Sitesi

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.

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.

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 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 karakterine kadar	#0 karakterine kadar
PAnsiChar	#0 karakterine kadar	#0 karakterine kadar Ansi karakterler
PWideChar	#0 karakterine kadar	#0 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ı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.

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:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 Procedure TForm1.Button1Click(Sender: TObject); Var a, b, c : Integer; d, e : Char; f, g, h : 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' 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ı 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:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 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:

1 2 3 4 5 6 7 8 9 10 11 12 13 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, 3, 1); dizi[1] := 150; dizi[2] := 85; liste[1] := 'Ahmet'; liste[2] := 'Mehmet'; ikilidizi[1,1] := 150; ikilidizi[1,2] := 85; ikilidizi[2,2] := 120;

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.

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 değişken tanımlamasına ve kullanımına aşağıdaki örnek verilebilir:

1 2 3 4 5 6 7 8 9 10 11 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 adresi 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 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.

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 ... Var Form1: TForm1; P: ^Integer; // P, Integer tipinde Pointer değişkendir. Global değişkendir. Implementation {$R *.dfm} Procedure TForm1.Btn1Click(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(Inttostr(Y)); // Y değişkeninin değeri memoya ekleniyor (17) memo1.Lines.Add(inttostr(P^)); // Pointerin gösterdiği adresin değeri (17) memo1.Lines.Add(Format('%p', [P])); // Pointer adresi değeri memoya ekleniyor (0012F5B4) memo1.Lines.Add(Format('%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(Inttostr(Y)); // (37) memo1.Lines.Add(inttostr(P^)); // (37) memo1.Lines.Add(Format('%p', [P])); // (0012F5BC) memo1.Lines.Add(Format('%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(Inttostr(Y)); // (27) memo1.Lines.Add(inttostr(P^)); // (27) memo1.Lines.Add(Format('%p', [P])); // (0012F5B8) memo1.Lines.Add(Format('%p', [@P])); // (00453B68) ...

Burada bulunan kodu dosya halinde sitenin kaynaklar sayfasında bulabilirsiniz.

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

1 2 3 4 5 6 7 Const SABIT1 = 100; SABIT2 = $BAD4; SABIT3 = 'Delphimweb'; SABIT4 = 'Delphi Sitesi'; SABIT5 : Byte = 25; SABIT6 : Integer = 150;

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

1 2 3 4 5 6 7 8 9 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. 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:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 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'; 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 IsimAl : string; constructor Create(i : string); 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.

1 2 3 4 5 6 7 8 9 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.

1 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.

1 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.

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

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.

1 2 3 4 Procedure EkranaYaz(Var x;integer; Var y:integer); Begin x := 100; y :=250; ...

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 tasarrufu sağlar. Bu yöntem aşağıdaki örneklerde görülebilir

9 ... 20 ... ... 29 30 31 32 33 34 35 36 37 38 39 40 ... 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; ...

1 2 3 4 5 6 7 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:

1 2 3 4 5 6 7 8 9 10 11 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:

1 2 3 4 5 6 7 8 9 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:

1 2 3 4 5 6 7 8 9 10 11 12 {$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ı

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-String işlemlerinde ikinci yazıyı ilk yazının arkasına ekleme 10+20 30

- Çı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+2

Dec Bir veya birden fazla azaltma Dec(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

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:

1 2 3 4 5 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.

... 9 ... 20 21 22 23 24 25 26 27 ... 33 34 35 36 37 38 39 40 41 42 43 ... ... 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:

1 2 3 4 5 6 7 8 9 10 11 12 13 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:

1 2 3 4 5 6 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.

1 2 3 4 5 6 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:

1 2 3 4 5 6 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;

1 2 3 4 5 6 7 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.

1 2 3 4 5 6 7 8 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.

1 2 3 4 5 6 7 8 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.

1 2 3 4 5 6 7 8 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.

1 2 3 4 5 6 7 8 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);

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.

1 2 3 4 5 6 7 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.

1 2 3 4 5 6 7 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.

1 2 3 4 5 6 7 8 9 10 11 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.

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 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:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 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 := '';

2. DELPHIDE UNICODE KULLANIMI :

Rad Studio 2009 ve sonraki sürümlerde Delphi ve C++ Builder'a eklenen en önemli özellik Unicode (Evrensel Kod) desteğinin standart hale getirilmesidir. Bu sürümlerle yapılan programlar aksi bir tasarım yoksa otomatik olarak Unicode desteklidir. Bunun sebebi temel değişken tiplerinin değiştirilmiş olmasıdır. Örneğin Delphide aşağıdaki değişiklik olmuştur:

1 2 3 4 Type String = UnicodeString; Char = WideChar; PChar = PWideChar;

Yani standart tipler değiştirilmiştir. Eski standart tipleri kullanmak isteyenler String yerine AnsiString, Char yerine AnsiChar, PChar yerine PAnsiChar kullanacaklardır.

1 2 3 4 5 6 7 8 9 10 11 Var UChar: Char; UString: String; AChar: AnsiChar; AString: AnsiString; Begin UString := 'Bu bir unicode yazıdır'; UChar := UString[1]; AString := 'Bu bir ansi yazıdır'; AChar := AString[1]; end;

İki yazıda Türkçedir ve Türkçe windows yüklü bilgisayarda normal gözükürler. Fakat 'Bu bir ansi yazıdır' yazısındaki 'ı' harfleri başka bir dil yüklü bilgisayarda hatalı gözükecektir. Diğer yazıda görüntü problemi yoktur.

Unicode değişimi sadece karakterler için değildir. Delphi içinde Api çağıran komutlarda bundan sonra 'W' ile biten yani unicode fonksiyonları çağıracaktır. (bkz. Windows Api'leri ve Delphi ile Api Kullanma). Ayrıca bundan sonra değişken ve fonksiyon isimleri İngilizce harflere mahkum değildir. Yani isimler için Türkçe veya diğer dillerdeki harfler kullanılabilir.

Devam edecek...

3. DELPHIDE MESAJ PENCERELERİ :

ShowMessage: Basit anlamda kullanıcıyı bilgilendirme amaçlı kullanılabilen bir mesaj penceresidir. Sadece ekranda gösterilecek mesajı alan tek bir parametresi vardır. Pencerenin başlığı projeni ismidir. OK butonundan başka tıklama seçeneği yoktur. Mesaj penceresi ekranın ortasında gösterilir.

Kullanımı: ShowMessage('Ekranda gösterilecek mesaj metni');

ShowMessage('Delphimweb sitesine hoş geldiniz');

ShowMessagePos: ShowMessage ile kullanımı ve mantığı aynıdır. Tek farkı mesaj penceresinin konumunun parametre olarak verilebilmesidir.

Kullanımı: ShowMessagePos('Ekranda gösterilecek mesaj metni', x_koordinatı, y_koordinatı);

ShowMessagePos('Delphimweb sitesine hoş geldiniz', 300, 200);

ShowMessageFmt: ShowMessage ile kullanımı ve mantığı aynıdır. Tek farkı mesaj penceresinde gösterilecek metinde formatlama işlemi yapılabilmesidir. Formatlama mesaj metni içerisinde % işareti ve harfler ile yapılır.

Kullanımı: ShowMessageFmt('Ekranda gösterilecek mesaj metni ve gösterim formatları', [Değişkenler ve/veya değerler]);

ShowMessageFmt('Alinin yaşı %d, parası %m dir.', [10, 25.86]);

Formatlamada kullanılabilecek seçenekler ve anlamları:

%d	Desimal (integer)
%e	Bilimsel
%f	Onarılmış (Fixed)
%g	Genel
%m	Para (Money)
%n	Numara
%p	Pointer
%s	Yazı (String)
%u	İşaretsiz Desimal
%x	Onaltılı (Hexadecimal)

MessageDlg: Kullanıcıya seçme şansı veren pencereler açmak için kullanılan bir methoddur. Pencere açıldığı zaman üzerinde birden fazla button yerleştirilebileceği için, farklı düğmelerin seçilmesiyle de farklı işlemler yapılması sağlanabilir. Bunun için MessageDlg fonksiyonunun döndürdüğü integer değer değerlendirilmelidir. Düğme seçeneklerinin arasına virgül konur. Aşağıda bulunan tablolarda seçilebilecek değerler bulunmaktadır.

Kullanımı: Düğmedegiskeni := MessageDlg('Ekranda gösterilecek mesaj metni', mesaj penceresinin ikon çeşidi, [Düğme veya düğmeler], Aktif olacak düğme nosu);

Aşağıda MessageDlg penceresinin açılması ve çıkan sonucun değerlendirilmesi ile ilgili kod görülmektedir:

1 2 3 4 5 6 7 8 Procedure TForm1.Button1Click(Sender: TObject); Begin case (MessageDlg('Dosyayı kaydetmek istiyor musunuz?', mtconfirmation, [mbyes, mbno, mbcancel], 0)) of mryes: label1.Caption := 'Eveti seçtiniz'; mrno: label1.Caption := 'Hayırı seçtiniz'; mrcancel: label1.Caption := 'İptali seçtiniz'; end;End;

Mesaj Penceresi Ikon Seçenekleri	Görünecek ikon
mtWarning	Uyarı Ikonu
mtError	Hata Ikonu
mtInformation	Danışma, Bilgi Ikonu
mtConfirmation	Bilgilendirme Iconu
mtCustom	Genel

Mesaj Penceresi Düğme Seçenekleri	Pencerede bulunacak düğme
mbYes	'Yes' - Evet düğmesi
mbNo	'No' - Hayır düğmesi
mbOK	'OK' - Tamam düğmesi
mbCancel	'Cancel' - İptal düğmesi
mbAbort	'Abort' - İptal et düğmesi
mbRetry	'Retry' - Tekrarla düğmesi
mbIgnore	'Ignore' - Yoksay düğmesi
mbAll	'All' - Tümü düğmesi
mbNoToAll	'NoToAll' - Hepsine Hayır düğmesi
mbYesToAll	'YesToAll' - Hepsine Evet düğmesi
mbHelp	'Help' - Yardım düğmesi

Mesaj Penceresi Dönüş Değerleri	Seçilen düğme
mrYes	'Yes' - Evet düğmesi
mrNo	'No' - Hayır düğmesi
mrOK	'OK' - Tamam düğmesi
mrCancel	'Cancel' - İptal düğmesi
mrAbort	'Abort' - İptal et düğmesi
mrRetry	'Retry' - Tekrarla düğmesi
mrIgnore	'Ignore' - Yoksay düğmesi
mrAll	'All' - Tümü düğmesi
mrNoToAll	'NoToAll' - Hepsine Hayır düğmesi
mrYesToAll	'YesToAll' - Hepsine Evet düğmesi

MessageDlgPos: MessageDlg ile çalışması ve mantığı aynıdır. Tek farkı mesaj penceresinin konumunun parametre olarak verilebilmesidir.

Kullanımı: Düğmedegiskeni := MessageDlgPos('Ekranda gösterilecek mesaj metni', mesaj penceresinin ikon çeşidi, [Düğme veya düğmeler], Aktif olacak düğme nosu, x_koordinatı, y_koordinatı);

Sonuc := MessageDlgPos('Dosyayı kaydetmek istiyor musunuz?', mtconfirmation, [mbyes, mbno, mbcancel], 0 , 300, 200);

MessageBox: Kullanıcıya seçenekli mesaj penceresi açmak için kullanılır. En çok kullanılan ve en iyi sonucu veren methoddur. Windows'da diğer programlama dillerinin de kullandığı methoddur. Kullanımı diğer methodlara göre kolaydır. Pencere açıldığı zaman üzerinde birden fazla button yerleştirilebileceği için, farklı düğmelerin seçilmesiyle de farklı işlemler yapılması sağlanabilir. Bunun için MessageBox fonksiyonunun döndürdüğü integer değer değerlendirilmelidir. Pencere başlığı, ekranda ikon gösterilip gösterilmeyeceği gibi çeşitli ayarları vardır. Aşağıda bulunan tabloda genel seçeneklerde seçilebilecek ayarlar bulunmaktadır. Genel seçeneklerin arasına + işareti konur.

Kullanımı: DugmeDegiskeni := MessageBox('Ekranda gösterilecek mesaj metni', 'Pencere başlığı', Genel seçenekler);

Aşağıda MessageBox penceresinin açılması ve çıkan sonucun değerlendirilmesi ile ilgili kod görülmektedir:

1 2 3 4 5 6 7 8 Procedure TForm1.Button1Click(Sender: TObject); begin case (Application.messagebox('Dosyayı kaydetmek istiyor musunuz?', 'Dosya kaydetme sorusu', MB_YESNOCANCEL+ MB_ICONQUESTION+ MB_DEFBUTTON1)) of idyes: label1.Caption:='Eveti seçtiniz'; idno: label1.Caption:='Hayırı seçtiniz'; idcancel: label1.Caption:='İptali seçtiniz'; end;End;

MessageBox Genel Seçenekleri	Açıklaması
MB_OK	Sadece OK butonu
MB_OKCancel	OK ve Cancel (İptal) butonları
MB_YesNo	Yes (Evet) ve No (Hayır) butonları
MB_YesNoCancel	Yes (Evet), No (Hayır) ve Cancel (İptal) butonları
MB_RetryCancel	Retry (Tekrarla) ve Cancel (İptal) butonları
MB_AbortRetryIgnore	Abort(İptal), Retry (Tekrarla) ve Ignore (Yoksay) butonları
MB_ICONSTOP	Hata ikonu
MB_ICONQUESTION	Soru ikonu
MB_ICONINFORMATION	Bilgi verme ikonu
MB_ICONINFORMATION	Hata ikonu
MB_ICONEXCLAMATION	Uyarı ikonu
MB_ICONASTERISK	Bilgi verme ikonu
MB_ICONWARNING	Uyarı ikonu
MB_ICONERROR	Hata ikonu
MB_ICONMASK	Kullanıcı tanımlı ikon (Kullanıcının tanımlaması gerekmektedir)
MB_DEFBUTTON1	Birinci buton aktif (Varsayılan)
MB_DEFBUTTON2	İkinci buton aktif (En az iki buton olmalı)
MB_DEFBUTTON3	Üçüncü buton aktif (En az üç buton olmalı)
MB_DEFBUTTON4	Dördüncü buton aktif (En az dört buton olmalı)
MB_SYSTEMMODAL	Pencere her zaman en üstte
MB_APPLMODAL	Pencere arkada olabilir (Varsayılan)
MB_TASKMODAL	Pencere arkada olabilir
MB_RIGHT	Pencere metni sağa yaslanmış şekilde
MB_PRECOMPOSED	Pencere kapatma butonu solda
MB_COMPOSITE	Pencere kapatma butonu pasif (yok)

MessageBox Dönüş Değerleri	Seçilen Düğme
IDYES	'Yes' - Evet düğmesi
IDNO	'No' - Hayır düğmesi
IDOK	'OK' - Tamam düğmesi
IDCANCEL	'Cancel' - İptal düğmesi
IDABORT	'Abort' - İptal et düğmesi
IDRETRY	'Retry' - Tekrarla düğmesi
IDIGNORE	'Ignore' - Yoksay düğmesi

4. DELPHIDE DEĞER GİRİŞ PENCERELERİ :

InputBox: Basit anlamda kullanıcının bilgi girişi yapabileceği bir kutundan oluşan bilgi giriş penceresidir. Üç adet parametresi vardır. Birincisi pencere başlığı yazısı, ikincisi pencere içinde giriş için açıklama yazısı, üçüncüsü ise kutunun içinde varsayılan olarak gelecek değerdir. Bu parametreler boş olarak verilebilirler. Bu fonksiyon String tipinde dönüş değeri üretir. Değerlendirme yapmak için dönüşü diğer tiplere kullanıcı dönüştürmelidir.

Kullanımı: DegerDegiskeni := InputBox('Pencere Başlığı', 'Açıklama', 'Varsayılan değer');

sonuc := InputBox('Değer Girme Penceresi', 'Lütfen değer girin :', 'Önceden girili değer');

InputQuery: InputBox fonksiyonuna benzeyen fakat pencere üzerindeki Ok ve Cancel tuşlarına basılmasına göre farklı işlemler yapılabilmesini sağlayan bir fonksiyondur. Üç adet parametresi vardır. Birincisi pencere başlığı yazısı, ikincisi pencere içinde giriş için açıklama yazısı, üçüncüsü ise fonksiyonun dönüş değişkenidir. Bu parametrelerden ilk ikisi boş olarak verilebilirler. Bu fonksiyon Boolean tipinde dönüş değeri üretir ve ücüncü parametre olarak verilen değişkene girilen değeri yazar. Boolean tipindeki değişken eğer Ok tuşuna basılırsa True, Cancel tuşuna basılırsa False değeri alacaktır.

Kullanımı: İkiliDegisken := InputQuery('Pencere Başlığı', 'Açıklama', DegerDegiskeni);

1 2 3 4 5 6 procedure TForm1.Button1Click(Sender: TObject); var yazi : string; sonuc : boolean; begin sonuc := InputQuery('Değer Girme Penceresi', 'Lütfen değer girin :', yazi); if sonuc then label1.Caption := yazi; end;

5. DELPHIDE İSTİSNAİ DURUMLAR VE HATA YAKALAMA :

Bir bölme işleminde bölenin sıfır olması, sayısal çevirme işlemi yaparken çevrilecek değerin sayısal olmaması veya olmayan bir dosyanın açılmaya çalışılması gibi durumlar istisna durumlardır. Programcı programı yazılırken bu gibi istisna durumları da göz önüne almalıdır. Yazılan programda istisnai durumlar göre kodlar bulunmuyorsa program ya hata verip kapanacaktır veya istenmeyen hatalı işlemler yapacaktır.

Delphide bir prosedür veya foksiyon içerisinde oluşabilecek hataları (istisna durumları) yaklamak için try .. except ve try..finally blokları kullanılır.

Try .. Except Bloğu : Bu blokla hata olabilecek yer belirlenmekte ve hata durumunda ne yapılacağı kodlanmaktadır. Try ile Except arasına hata verebilecek kodlar yazılır. Except ile End arasına ise hata durumunda programın işleyeceği kodlar yazılır. Herhangi bir hata olmazsa Except ile End arasındaki kodlar hiç çalıştırılmaz.

Aşağıdaki uygulamada Edit1'in içerisindeki değer Button1'e basıldığında sayısal değere çevrilmektedir. Hata durumunda yapılacaklar ise Except bloğunda kodlanmştır:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 Procedure TForm1.Button1Click(Sender: TObject); Var sayi:integer; Begin Try sayi := StrToInt(Edit1.Text); // Sayısal çevirme işlemi yapılmaktadır. // Eğer Edit1 içerisine sayısal olmayan değer girilirse hata verecektir. Except // Hata olursa işletilecek kod(lar). Begin Showmessage('Lütfen sayısal değer girin...'); // Ekranda hata mesajı görüntüleniyor. Edit1.Text := ''; // Edit1'in içi siliniyor. Edit1.SetFocus; // Dönüşte kontrol Edit1'e veriliyor. End; End; End;

Delphide yazılı program denenirken hata durumunda aşağıdaki pencere gelecektir. Bu pencerede OK tuşuna basıldıktan sonra Delphide tekrar Run yapılarak Except bloğundaki kodların çalışması sağlanabilir. Bu sadece Delphi içerisinde geçerlidir. Program Exe haline getirilip Delphi dışında çalıştırıldığında hata durumuna Except bloğu direkt çalıştırılacaktır.

Yakalanan Hatanın Değerlendirilmesi : Hata yakalandığı zaman yakalanan hatanın da değerlendirilip duruma göre işlem yapılması gerekir. Aşağıda hatalı bir tarihin dönüştülmesi ve hatanın yakalanıp değerlendirilmesi ile ilgili kod bulunmaktadır. Detaylı bilgi için Delphi yardımında SysUtils kütüphanesinde Classes kısmına bakınız.

1 2 3 4 5 6 7 8 9 10 Const LF = #10; Var Gecicitarih : TDateTime; Begin Try Gecicitarih := StrToDateTime('99/99/1998'); // Çevirilecek tarih hatalı. İstisnai durum oluşacak. Except on E: EConvertError do ShowMessage(E.ClassName + LF + E.Message); // Do kelimesinden sonra programcı istediği mesajı verebilir veya kodu yazabilir.

Try .. Finally Bloğu : Bu blokla hata olabilecek yer belirlenmekte ve hata durumunda da, normal durumda da yapılacak işlemler kodlanmaktadır. Try ile Finally arasına hata verebilecek kodlar yazılır. Finally ile End arasına ise hem hata durumunda hem normal durumda çalıştırılacak kodlar yazılır. Bunun amacı normal çalışma sırasında çalıştırılacak kodların hata olduğu zaman da çalıştırılmasıdır. Yani hata olsa bile program sekteye uğramaz ve çalışmaya devam eder.

Hata olmazsa Try .. Finally ve Finally .. End arasındaki kodların hepsi çalıştırılacaktır. Hata durumunda ise çalışma Try bloğu içinde kesilir ve Finally bloğuna gider. Böylece kaynakların serbest bırakılması, dosyaların kapatılması gibi işlemler sekteye uğramaz. Aşağıda Try .. Finally kullanılmış kodlar görülmektedir.

1 2 3 4 5 6 7 8 Try Btmp := TBitmap.Create; // Bitmap nesnesi oluşturuluyor. // Hata olursa Finally'e kadar olan kodlar çalıştırılmayacaktır. .. // Diğer işlemler. .. Finally // Hata olsa da olmasa da buradaki kod(lar) çalıştırılacaktır. Btmp.free; End;

6. WINDOWS API'LERİ VE DELPHİ İLE API KULLANMA :

Programlama dilleri standart olarak kütüphanelere ve komutlara sahip olarak gelirler. Programcılar bu komutları kullanarak programlarını yazarlar. Fakat windows için program yazılan bir programlama dilinde bulunmayan komut veya fonksiyon için programcının yapabileceği iki seçenek vardır; Bu seçeneklerden birincisi asm dili veya programlama dilinin kendisini kullanarak yeni bir komut oluşturma ve kullanmadır. Bu zor ve zahmetli olan yoldur. İkincisi ise zaten var olan api fonksiyonunu tanımlayarak kullanmaktır. Windows api'leri daha önceden kodlanmış fonksiyonlardır. Windows ortamında donanım üzerinde işlem yapabilmek ve windows fonksiyonlarını kullanabilmek için Windows Api'leri kullanılmaktadır. Zaten programlama dillerinin kendileri de birçok komutları için apileri kullanmaktadır. Windows api'leri gruplandırılarak bir çok DLL ve EXE dosyasına konulmuştur. Api'lerden birini kullandığınızda Api'nin bulunduğu DLL sisteme daha önce yüklenmemişse önce bu DLL yüklenir ve Api çalıştırılır. Aşağıda bazı dosyalar ve içerdikleri api fonksiyonları ile ilgili liste bulunmaktadır:

Advapi32.dll	Şifre ve Kayıt dosyası işlemleri gibi gelişmiş bir çok Api.
Comdlg32.dll	Diyalog pencereleri ile ilgili Api'ler
Gdi32.dll	Grafik Api'leri
Kernel32.dll	Windows Çekirdek Api'leri
Netapi32.dll	32-bit Network Api'leri
Shell32.dll	32-bit Shell Api'leri
User32.dll	Kullanıcı arabirimi Api'leri
Winmm.dll	Multimedia Api'leri

Windows'un api fonksiyonlarının listesini ve fonksiyonlar ile ilgili bilgi almak için 2004 yılında üretilmiş olan ücretsiz ApiViewer 2004 programını kullanılabilir. Bu program internetten kolayca bulunabilir. Program uzun süredir güncellenmemesine rağmen yeterince detaylıdır. Ayrıca API Monitor programı ile hangi programların hangi api'leri çağırdığını yakalamak çok kolaydır. Bu program da internetten kolayca bulunabilir. Apiler ile detaylı bilgi için Win32.hlp (Microsoft Win32 Programmer's Reference) dosyası internetten indirilip bakılabilir.

Delphi'de Api fonksiyonlarını kullanmak son derece kolaydır. Delphi ile gelen Windows ve ShellApi gibi Unitler sayesinde Api fonksiyonlarını Delphi fonksiyonuymuş gibi kullanmak mümkündür. Bu unitlerde Windows'un yüzlerce api fonksiyonu tanımlıdır. Bu unitlerin olduğu Windows.pas ve ShellApi.pas kod dosyalarında Api fonksiyonları hakkında birçok bilgi bulunabilir. Programcılar hazır tanımlanmış bu api fonksiyonlarını kullanabileceği gibi yenilerini de tanımlayabilir. Windows'un Api fonksiyonları C++ dili ile yazılmıştır. Bu nedenle bu fonksiyonları Delphi'ye uyarlamak gerekmektedir. Bu son derece basit bir işlemdir. C++ dilindeki programları ve api fonksiyonlarını çevirmek için Diyezon.com sitesindeki "C / C++ 'dan Delphi'ye Kod Çevirme Klavuzu" makalesine bakabilirsiniz. Delphinin Messagebox komutu (Delphide mesaj pencereleri konusuna bakınız) aslında Windows'un User32.dll dosyasındaki MessageBoxA Api fonksiyonunun çağrılmasından başka birşey değildir. Windows.pas dosyasında aşağıdaki tanımlar bulunmaktadır:

Interface kısmında:

function MessageBox(hWnd: HWND; lpText, lpCaption: PWideChar; uType: UINT): Integer; stdcall;
function MessageBoxA(hWnd: HWND; lpText, lpCaption: PAnsiChar; uType: UINT): Integer; stdcall;
function MessageBoxW(hWnd: HWND; lpText, lpCaption: PWideChar; uType: UINT): Integer; stdcall;

Implementation kısmında:

function MessageBox; external user32 name 'MessageBoxA';
function MessageBoxA; external user32 name 'MessageBoxA';
function MessageBoxW; external user32 name 'MessageBoxW';

Görüldüğü gibi tanımlama iki farklı yere eklenen iki satırla yapılmaktadır. Tanımlamada parametrelerin (fonksiyonun parametreleri, dönüş parametresi) tipleri ve sayıları orjinal api fonksiyonla aynı olmak zorundadır. Tanımlama yapılırken buna dikkat edilmelidir.

Parametre tiplerinin C++ ile uyumlu olması açısından Delphi için gerekli tip tanımlamaları (SHORT, DWORD, UINT, HWND, BOOL vb) windows.pas dosyasında bulunmaktadır. Örneğin C++ deki DWORD tipinin karşılığı Delphide Longword'dur. Tanımlama yaparken Longword kullanılabileceği gibi windows.pas'taki tamımlamalar sayesinde C++'deki gibi DWORD kullanılabilir.

Burada dikkat edilecek olursa user32.dll dosyasının içindeki fonksiyonun ismi MessageBox değil MessageBoxA ve MessageBoxW'dir. Bunun sebebi Windows işletim sisteminin farklı dilleri desteklemesidir. Sondaki 'A' harfi ANSI, 'W' harfi ise UniCode fonksiyonları göstermektedir. MessageBox fonksiyonu MessageBoxA fonksiyonuna tanımlıdır.

Delphinin 2009'dan önceki sürümlerindeki Api kullanan fonksiyonlar sonu A ile biten fonksiyonlarına tanımlı iken Delphi 2009'da Unicode desteği için fonksiyonlar sonu W ile biten unicode fonksiyonlarına tanımlanmıştır.

7. DELPHIDE DLL OLUŞTURMA VE KULLANMA :

Dll (Dynamic Link Library) yani dinamik bağlantı kütüphaneleri Windows'un en önemli özelliklerinde birisidir. Bir Dll dosyası .exe gibi çalıştırılabilir bir programın çalışma anında çağırabileceği fonksiyonları barındırmaktadır. Yani DLL programların bağlantı kurabileceği fonksiyonların bulunduğu kütüphanelerdir. Dll fonksiyonlarını program tarafından çağırıldığında windows dosyayı hafızaya yükler. Hafızadaki Dll gerekli olmadığında windows tarafından hafızadan silinir. Windows Api fonksiyonlarının çoğu windows dizininde dll dosyalarında saklanır. Api kullanımı çoğunlukla Dll kullanımıdır.

DLL dosyaların avantajı sık kullanılan kodların her programda tekrar tekrar yazılması yerine bir Dll dosyasına konması ve bütün programların o dosyayadaki fonsiyonları kullanabilmesidir. Bu hem program boyutu bakımından hem de hafıza kullanımı bakımından avantaj sağlar. Dll dosyaların dezavantajı ise dosya kayıpsa veya sürümü yanlışsa (Farklı programlar aynı dll dosyasının farklı sürümlerini kullanabilir) program fonksiyonları çağırması esnasında hata oluşacaktır.

İsteyen her programcı kendi Dll dosyalarını oluşturabilir ve onları programlarında kullanabilir. Delphi ile Dll dosyası oluşturmak çok kolaydır. Metin olarak hazırlanan Dll taslağı derlenir ve aynı dizinde Dll dosyası otomatik oluşur. Bu işlem Exe programın derlenip çalıştırılması gibidir. Delphide File menüsünden New->Others... ve gelen diyalogdan "Dll Wizard" seçilerek boş dll taslağı otomatik oluşturulur. Taslak aşağıdaki gibidir:

1 2 3 ... 11 12 13 14 15 16 17 18 19 20 Library Project1; { Important note about DLL memory management: ShareMem must be the ... using PChar or ShortString parameters. } Uses SysUtils, Classes; {$R *.res} Begin End.

Görüleceği gibi taslağın başlangıç kısmında açıklama vardır. Bu açıklamada Dll hafıza yönetimi, ShareMem uniti ve BORLNDMM.DLL dosyasının kullanımı anlatılmaktadır. Bu açıklama ileri Dll programlaması içindir. Taslağa aşağıdaki düzenleme ve eklemeler yapılarak ilk Dll taslağı oluşturalım:

1 2 3 ... 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 Library TestDll; { Important note about DLL memory management: ShareMem must be the ... using PChar or ShortString parameters. } Uses SysUtils ,Classes, Dialogs; // Dialogs uniti Showmessage fonksiyonu için ekleniyor {$R *.res} Procedure DllMesaj; export; // Kullanılacak Dll fonksiyonun kendisi Begin ShowMessage('Herkese merhabalar'); End; Exports DllMesaj; // Dll dosyasının dışarıda kullanılacak fonksiyonları Begin End.

Dllmesaj prosedürü eklenmiş ve Exports kısmına prosedür ismi yazılarak dışarıdan çağrılabilmesi sağlanmıştır. Dışarıdan çağrılması istenen bütün fonksiyonların isimleri bu kısımda aralarında virgül olacak şekilde yazılır. Yazım işlemi bittikten sonra taslak "Testdll.dpr" ismi ile kaydedilir ve Project menüsünden "Build all projects" seçilerek dll dosyası derlenir. Projenin kaydedildiği yerde "Testdll.dll" dosyası otomatik oluşmalıdır. Böylece ilk Dll dosyasını oluşturmuş olduk. Aşağıdaki uygulamaların çalışabilmesi için projelerin kaydedildiği yere "Testdll.dll" dosyası kopyalanmalıdır.

Dll dosyalarındaki fonksiyonlar iki şekilde kullanılabilir. Statik kullanımda fonksiyonlar yazılan program içinde tanımlanır ve bu tanımlar değişitirilemez. Eğer Dll dosyanın adı değişirse, kayıp olursa veya yeri değişirse yazılan program kesinlikle çalışmayacaktır. Statik tanımlama ve kullanım aşağıdaki şekildedir:

21 22 23 24 25 26 27 28 29 30 31 32 ... Procedure DllMesaj; external 'Testdll.dll'; // Statik tanımlama implementation {$R *.dfm} Procedure TForm1.button1Click(Sender: TObject); Begin DllMesaj; // Dll fonksiyonun kullanımı End; ...

Dinamik kullanımda fonksiyonlar yazılan program içinde tanımlanmazlar. Fonksiyonlar kullanılacakları zaman tanımlanırlar. Dll dosya ve/veya fonksiyonların var olup olmadıkları kullanmadan önce test edilebilir. Eksik olmaları durumunda yazılan program durdurulmadan hata mesajı ile eksik durum belirtilebilir. Dinamik tanımlama ve kullanım aşağıdaki şekildedir:

... 9 10 ... 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 ... ... Type TFonksiyon = procedure; // Fonksiyonu kullanabilmek için gerekli tip tanımlaması ... Var Form1 : TForm1; Fonksiyon : TFonksiyon; // Fonksiyonu kullanabilmek için gerekli değişken tanımlaması Implementation {$R *.dfm} Procedure TForm1.button1Click(Sender: TObject); Var DLLHandle: THandle; Begin Try DLLHandle := loadLibrary ('testdll.dll'); If DLLHandle <> 0 then Begin @fonksiyon := getProcAddress (DLLHandle, 'DllMesaj'); if addr ( fonksiyon ) <> nil then Begin // Eğer yüklenen dll içinde istenen fonksiyon mevcutsa Fonksiyon; // Dll fonksiyonun kullanımı End else showMessage ('Fonksiyon bulunamadı...'); // Dll içinde fonksiyon bulunamadı mesajı ver End else showMessage ('DLL bulunamadı...'); // DLL bulunamadı veya yüklenemedi mesajı ver Finally FreeLibrary (DLLHandle); // DLL ile iş bitince tekrar hafızadan kaldır End; End; ...

Burada bulunan kodları dosya halinde sitenin kaynaklar sayfasında bulabilirsiniz.

8. DELPHIDE ASM KULLANIMI :

Programlar hangi dille yazılırsa yazılsın derleyiciler komutları asm'ye çevirmektedir. Fakat bazı durumlarda (çok hızlı çalışmanın gerekmesi, kodun çok sayıda çağrılması) direkt olarak asm kullanmak gerekir. Delphide asm komutlarını kullanmak ve asm program yazmak çok basittir. Aşağıda delphide yazılmış kod ve asm karşılığı görülmektedir:

1 2 3 4 5 6 7 8 9 Function Ikiylecarp(Sayi: Integer): Integer; Begin Result := Sayi * 2; End; Function IkiylecarpAsm(Sayi: Integer): Integer; Asm Add eax, eax // Result := Sayi * 2; 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’ı ile geliyor ve tekrar çıktı olarak eax olarak çıkıyor. Bu register çağırımı, Delphi'de 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.

9. DELPHIDE EN SIK KULLANILAN KOMUTLAR :

Inttostr fonksiyonu: (SysUtil) (String içerikli komut)

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

1 2 3 4 Var yazi: String; sayi: Integer; Begin sayi := 1453; yazi := Inttostr(sayi);

Floattostr fonksiyonu: (SysUtil) (String içerikli komut)

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. Kullanımları şu şekildedir: Sonuç := Floattostr(Sayı) veya Sonuç := Floattostr(Sayı, FormatŞekli). İkinci kullanım için format şekli sistemden okunabilir veya programcı tarafından belirlenebilir.

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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 // İ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: (SysUtil) (String içerikli komut)

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. Kullanımları şu şekildedir: Sonuç := Floattostrf(Sayı, ÇıkışŞekli, BasamakSayısı, OndalıkBasamakSayısı) veya Sonuç := 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.

1 2 3 4 5 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)

1 2 3 4 5 6 // İ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: (SysUtil) (String içerikli komut)

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. Kullanımları şu şekildedir: Sonuç := Formatfloat(ÇıkışŞekli, Sayı) veya Sonuç := Formatfloat(ÇıkışŞekli, Sayı, FormatŞekli). İkinci kullanım için format şekli sistemden okunabilir veya programcı tarafından belirlenebilir.

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 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: (SysUtil) (String içerikli komut)

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. Detaylı bilgi için "Delphide İstisnai Durumlar Ve Hata Yakalama" konusuna bakınız. Kullanımı şu şekildedir: Sonuç := Strtoint(Yazı);

1 2 3 4 Var yazi: String; sayi: Integer; Begin yazi := '1453'; sayi := Strtoint(yazi);

Strtointdef fonksiyonu: (SysUtil) (String içerikli komut)

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. Kullanımı şu şekildedir: Sonuç := Strtointdef(Yazı, Varsayılan Sayı);

1 2 3 4 Var yazi: String; sayi: Integer; Begin yazi := '1453'; sayi := Strtointdef(yazi, 1000);

Strtofloat fonksiyonu: (SysUtil) (String içerikli komut)

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. Detaylı bilgi için "Delphide İstisnai Durumlar Ve Hata Yakalama" konusuna bakınız. Kullanımı şu şekildedir: Sonuç := Strtofloat(Yazı); veya Sonuç := Strtofloat(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.

1 2 3 4 Var yazi: String; sayi: Extended; Begin yazi := '123,456'; sayi := Strtofloat(yazi);// Sonuc = 123,456 (Türkçe format ayarlı bilgisayarda)

1 2 3 4 5 6 7 // İ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: (SysUtil) (String içerikli komut)

Girilen yazıyı (string) Extended tipinde sayıya çevirmek için kullanılır. Eğer yazı içerisinde hatalı karakterler varsa atalı karakterler varsa hata döndürmez, fonksiyonla verilmiş varsayılan değeri geri döndürür. Kullanımı şu şekildedir: Sonuç := Strtofloatdef(Yazı, Varsayılan sayı); veya Sonuç := 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.

1 2 3 4 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: (System) (Karakter içerikli komut)

Parametre ile girilen Ascii (0-255 arası) değerinin karakter karşılığını bulmak için kullanılan fonksiyondur.

1 2 3 4 5 6 7 // 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: (System) (Karakter içerikli komut)

Parametre ile girilen karakterin ascii karakter numarası karşılığını bulmak için kullanılan fonksiyondur.

1 2 3 4 5 6 7 // 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;