PureBasic 3 - Bilinmesi gereken konular

Structure (yapı)

Structure, farklı tiplerden değişken tiplerini bir çatı altında toplayarak, gruplandırmayı sağlayan bir veri türü yapısıdır. Bu yapı, bize program yazarken çok yardımcı olur.

Structure Personel
  isim.s
  yas.l
EndStructure
OpenConsole()
Dim personeller.Personel(2)
For x = 0 To 2
  With personeller(x)
    \yas = x + 30
    \isim = "Erol"
  EndWith
Next
For x = 0 To 2
  PrintN("yas: " + Str(personeller(x)\yas))
  PrintN("isim: " + personeller(x)\isim)
Next
Delay(4000)

Burada iki elemanlı Personel isminde bir yapı tanımlandı. Sonra bu yapıya dayanan üç elemanlı, personeller isminde bir array (dizi) oluşturuldu. With (ile) komutu sayesinde personeller(x) i sürekli yazmak gerekmiyor.

Prosedürler

Bir programda aynı kodları tekrarlamaktansa bir prosedür oluşturulur.

Procedure.l karesi(x.l)
  ProcedureReturn x*x
EndProcedure
OpenConsole()
PrintN(Str(karesi(2)))
Delay(2000)

Karesi(x.l) prosedürü oluşturuldu. Prosedüre PrintN() komutuyla long tipinde 2 sayısı gönderiliyor. Prosedürden geri dönecek sayı tipi ise Procedure.l ile yine long olarak tanımlanmış. Ekrana 4 basar. İlginçtir, 64-bit sistemlerde integer 8 byte yer kaplarken, long 4 byte yer kaplar. Bir değişkenin hafızada ne kadar yer kapladığını SizeOf() komutuyla öğrenebilirsiniz.

Prosedürün parametrelerinde opsiyonel değerler kullanılabilir. Program, Debug penceresine 1,2,3 basar.

Procedure ParametreGoster(a.l, b.l, c.l = 3)
  Debug a
  Debug b
  Debug c
EndProcedure

ParametreGoster(1, 2)

Scope (faaliyet alanı)

Procedure scope()
  x = 5
  PrintN(Str(x))
EndProcedure
OpenConsole()
x = 2
scope()
PrintN(Str(x))
Delay(2000)

Prosedür içinde x=5 iken, prosedür dışında x=2 yazmaktadır. İsimleri aynı olmasına rağmen bu değişkenler tamamen farklıdır. Prosedür içinde bulunan x in faaliyet alanı prosedür sonlanınca biter. Prosedür dışından, prosedür içinde bulunan değişken görülemez. Program, ekrana 5 ve 2 basar. Değişkenin faaliyet alanı, Shared (paylaşımlı), Global (tüm programda geçerli) gibi komutlarla değiştirilebilir.

Static

Procedure BirArtir()
  Static a.l
  a + 1
  Debug a
EndProcedure
For x.l = 1 To 5
  BirArtir()
Next x

Prosedür, EndProcedure ile sonlandığında içindeki değişkenler hafızadan silinir. Prosedür, değişkeni hatırlasın istiyorsak, değişken önüne Static kelimesi konulur. Program, Debug penceresine 1,2,3,4,5 basar.

Prosedüre dizi göndermek

Dim ulkeler.s(2)
ulkeler(0) = "Türkiye"
ulkeler(1) = "Almanya"
ulkeler(2) = "Hollanda"

Procedure DiziGoster(Array dizim.s(1))
  For x.l = 0 To 2
    Debug dizim(x)
  Next x
EndProcedure

DiziGoster(ulkeler())

Prosedüre örneğin parametre olarak long tipinde bir değişken yollarsak, değişken, prosedüre değer olarak aktarılır. Prosedüre dizi gönderirsek, dizinin kendisi değil, hafızadaki başlangıç adresi gider. Böylece, prosedür içinde dizi elemanları gerekirse değiştirilebilir. Parametre olarak (Array dizim.s(1)) yazılmasının anlamı, prosedüre dizi yollanacağı ve dizinin bir boyutlu olduğu belirtilmiş oluyor. Benzer şekilde, List veya Map de prosedüre parametre olarak yollanabilir. Bu durumda da parametrenin başına List veya Map kelimelerini yazmak gerekir.

Declare (ilan etmek)

Program yazarken, prosedürü tanımlamadan önce, prosedürü çağırırsak derleyici hata verecektir. Bu nedenle önce prosedürü tanımlarsak hata almayız. Ama yok ben prosedürü sonra tanımlamak istiyorum dersek Declare ile programın başında bu prosedürü ilan ederiz.

OpenConsole()
Declare.l karesi(x.l)
PrintN(Str(karesi(2)))
Procedure.l karesi(x.l)
  ProcedureReturn x*x
EndProcedure
Delay(2000)

Rekürsif prosedür

Kendi kendini çağıran prosedüre denir. Programda örneğin 4 girdiğimizde, sonuç 4x3x2x1 yani 24 çıkacaktır.

OpenConsole()
Procedure.l fak(n.l)
  If n <= 1
    ProcedureReturn 1
  Else
    ProcedureReturn n * fak(n-1)
  EndIf
EndProcedure
Print("Bir sayı giriniz: ")
n = Val(Input())
PrintN("Faktoriyel sonucu: " + Str(fak(n)))
Delay(2000)

Programı farklı dosyalara bölmek

Bir konuyla ilgili prosedürleri ayrı bir kaynak dosyada bulundurmak isteyebiliriz. Bu dosyayı XIncludeFile komutu ile ana programa dahil ederiz. Aşağıdaki iki programı aynı klasöre kaydedin.

harici.pb

Procedure harici()
  PrintN("Ben harici prosedürüm")
EndProcedure

ana_program.pb

XIncludeFile "./harici.pb"
OpenConsole()
harici()
Delay(2000)

Pointer (işaretçi)

Procedure degistir(*ptr2)
  PokeL(*ptr2, 6)
EndProcedure
x = 5
OpenConsole()
PrintN(Str(x))
*ptr = @x
degistir(*ptr)
PrintN(Str(PeekL(*ptr)))
Delay(2000)

Bir değişkenin önünde * varsa, onun pointer olduğunu gösterir. Değişken, RAM de yerleştirildiğinde bir adrese sahiptir. *ptr=@x ile x değişkeninin adresi işaretçi değişkenine aktarılıyor. Prosedüre bu adres gönderiliyor. Prosedür içinde bu adrese PokeL komutu ile 6 değeri yazılıyor. PeekL, bir adresteki değeri okumak için kullanılır. Böylece ekrana 5 ve 6 yazılacaktır.

Enumeration (numaralandırma)

Her birine sayısal değerlerin atandığı ve birer birer numaralandırılan bir sabitler bloğuna ihtiyacınız varsa Enumeration kullanabilirsiniz. Sonraki yazıda göreceğimiz GUI (görsel arayüz) veya Windows Forms programlamada her bir kontrolün bir kimlik numarasına ihtiyacı oluyor. Bu noktada, programın okunurluğunu artırmak için Enumeration kullanılabiliyor.

Enumeration
  #ZERO
  #ONE
  #TWO
  #THREE
EndEnumeration
Debug #ZERO
Debug #ONE
Debug #TWO
Debug #THREE

Debug penceresine 0,1,2,3 yazar. Enumeration yanına bir sayı yazarsanız, numaralandırma o sayıdan başlıyor. Bu sayının yanına birde örneğin Step 10 yazarsanız, numaralandırma 10 ar 10 ar artarak yapılıyor. (Enumeration 100 Step 10 gibi)