Bu yazının amacı, JAVA dilinde bulunan ve grafiksel kullanıcı ara yüzü geliştirmekte kullanılan SWING kütüphanesine hızlı bir başlangıç yapmaktır.

Öncelikle Swing kütüphanesinin gelişiminden hızlıca bahsedelim. Swing kütüphanesi JAVA diline JDK 1.1 sürümünden sonra eklenmiştir. Daha önce AWT (Active Window Toolkit) ismi verilen bir kütüphane kullanmaktaydık ancak çok daha fazla ve gelişmiş özelliklerle gelen swing kütüphanesi neredeyse tamamen AWT yerine geçti denilebilir. AWT halen kullanılmakta, bunun en büyük sebebi JAVA’nın Visual Studio gibi geliştirme ortamlarından farklı olarak geçmişle uyumlu olmasıdır (back compatibility). Yani, örneğin 1997 yılında yazdığım bir kodu hala derleyip çalıştırabiliyorum.

AWT’nin bulunmasındaki diğer önemli bir faktör ise, Swing kütüphanesinin AWT üzerinde geliştirilmiş olmasıdır. AWT’den bu kadar bahsettikten sonra son olarak aynı projede hem AWT hem de Swing kullanmamanız gerektiğini, aksi halde ağır ve hafif bileşenlerin ekranda hatalı görüleceğini (heavy weighted, light weighted) söyleyerek Swing kütüphanesini anlatmaya başlayalım.

Swing kütüphanesi, javax altında bulunmaktadır ve bütün swing sınıfları (classes) javax.swing paketi ile başlar.

Örneğin, ekrana basit bir düğme koyarak uygulama geliştirmeye başlayalım.

Yukarıdaki kodun çıktısı, aşağıdaki şekilde bir pencereye yerleştirilmiş bir düğmeden (button) ibarettir:

Kodumuzda kullandığımız iki swing bileşeni olan JFrame ve JButton import edildikten sonra sınıfın bir JFrame olacağını, extedns JFrame yazıp JFrame sınıfını kalıtımla (inheritance) alarak belirtiyoruz.

Kodumuzda bulunan iki metottan ilki bir inşa fonksiyonu olup (constructor), this.add fonksiyon çağrılması ile JFrame içinde tanımlı olan add fonksiyonuna bir adet JButton parametre verilmiştir.

Klasik olarak swing kütüphanesinde, bir bileşenin diğer bileşenleri içinde barındırma özelliği bulunuyorsa (container) bu durumda add fonksiyonu, parametre olarak aldığı bileşeni, barındırıcı bileşene eklemektedir.

Kodun 5. satırında yapılan bu ekleme işleminde dikkat edilecek bir husus da, JButton bileşenini oluşturan ve new ile çağrılan yapıcı fonksiyonun (constructor) parametre olarak bir dizgi (string) almış olmasıdır. Bu dizgi, düğmenin üzerinde görülecek olan yazıdır.

Son olarak main fonksiyonunda, yeni tanımladığımız bu sınıftan bir nesne (object) oluşturarak bu objenin referansına sb ismini veriyoruz. Kodun 9. ve 10. satırlarında ise sırasıyla sb isimli bu nesneyi (ki artık JFrame özelliği taşıyan ve içerisinde bir buton olan nesnedir) paketliyoruz ve göstertiyoruz. Paketleme işlemini basitçe, bir pencerenin içerisindeki bileşenlerin sığacağı en ufak hali alması olarak düşünebilirsiniz. Gösterme işlemi ise bir bileşenin görünürlülüğünü (visibility) doğru yapmaktan ibarettir (true). Tersi şekilde görünürlülüğü yanlış (false) yapılarak bir bileşen gizlenebilir. Yine daha önceki sürümlerde bu işlem için sırasıyla show() ve hide() fonksiyonları da kullanılmaktaydı ancak JDK 1.3 sonrasında bu fonksiyonlar kaldırıldı.

Şimdi gelelim bu düğmenin tıklanması halinde eylemi algılamaya.

Yukarıdaki kodu yazıp denediyseniz tıklama eyleminin herhangi bir sonuç doğurmadığını görmüşsünüzdür. Bunun sebebi JAVA dilinde tanımlı olan herhangi bir eylemin sınıf içerisinde yer alamamasıdır.

JAVA dilinde eylemi üreten ve yakalayan nesneler farklı olabilir. Örneğin yukarıdaki örnekte düğmeyi tanımladığımız swingbuton isimli sınıf düğmeye tıklandığında devreye girebileceği gibi tamamen başka bir sınıf da devreye sokulabilir. Biz basit olsun diye ilk örneğimizde yine aynı sınıfta eylemi yakalayacağız. Bunun için öncelikle sınıfa bu özelliğin kazandırılması gerekir. JAVA dilinde bir sınıfın herhangi bir bileşen ile ilgili bir eylem yakalayabilmesi için ActionListener olması gerekir.

public class swingbuton extends JFrame implements ActionListener

şeklinde sınıfın tanımını değiştirerek bu sorunu çözebiliriz. Ancak, arayüzlerden (interface) hatırlanacağı üzere bir arayüzü (interface) sınıfa kazandırmanın (implements), bağlayıcı bir sonucu olmaktadır.

Kodumuzda yeni olan en büyük fark, sınıfta artık ActionListener arayüzünün implement edilmesidir. Bu arayüzün sınıfa uygulanması ile birlikte, sınıfta ” actionPerformed” isimli fonksiyonu bulundurma zorunluluğu ortaya çıkar. Nitekim yukarıdaki kodun 10-12. satırları arasında bu fonksiyon kodlanmış ve herhangi bir eylem olması halinde çalışacak olan bu fonksiyonun içerisinde ekrana “butona basıldı” mesajının yazılması sağlanmıştır.

Diğer bir ilave ise artık düğmenin bir eylem dinleyicisi olmasına olan ihtiyaçtır. Düğmemize basıldığında hangi sınıfın bu eylemi yakalacağını kodda belirtmemiz gerekir ki bu durum da 8. satırda kodlanmıştır.

Yukarıdaki kodun ekran çıktısı aşağıdaki şekildedir:

Birden fazla düğme bulunması halinde düğmeleri ayırt etmek için eylemin özel olarak koşullandırılması gerekir.

Kodun yeni halinde, düğmelerin tanımlandığı satırı sınıf geçerlilik alanına alarak actionPerformed fonksiyonu içerisinde hangi düğmeye tıklandığını kontrol edebiliyoruz. Bunun için parametre olarak gelen ActionEvent tipindeki e nesnesinin kaynağını okutan .getSource metodunu çağırıyor ve hangi nesneye eşit olduğunu sorguluyoruz.

Ayrıca kodda yapılan yeni bir ilave, birden fazla bileşeni aynı anda ekranda gösterebilmek için bir yayılım (Layout) eklenmesidir. Yukarıdaki kodda, 10. satırda bulunan komut, this ile ifade edilen JFrame nesnesinin yayılımının FlowLayout tipinde olacağını belirtmektedir. Bunun anlamı eklenen her bileşen, bir öncekinin sağına ilave edilecek, nihayet ekranda daha fazla sağa eklenecek yer kalmayınca aşağıya geçileceğidir.

Swing kütüphanesi kullanılarak mevcut bileşenler, yukarıda gösterildiği şekilde ekrana eklenip kullanılabileceği gibi, bileşenler üzerinde değişiklik yapılması da mümkündür. Örneğin bir swing bileşeni olan Jpanel üzerinde çizim yapmaya çalışalım:

Yukarıdaki kodda bulunan sınıf, Jpanel bileşenini miras almış ve bu bileşenin “paintComponent” isimli metodunun üzerine ezmiştir (override). Neticede Jpanel jf isimli Jframe’e eklenmiş ancak yeni çizim özellikleri ile görüntülenmiştir. Kodun ekran çıktısı aşağıdaki şekildedir:

paintComponet fonksiyonu yukarıda gösterildiği şekilde ezilerek (override) Graphics kütüphanesinden istenilen bir nesne, yukarıda gösterildiği şekilde ekrana eklenebilir.

Ayrıca JAVA’nın kuvvetli kütüphanelerinde birisi de Graphics2D kütüphanesidir. 2 boyutlu şekillerin bulunduğu kütüphane olarak tanımlayabileceğimiz bu kütüphane ile görsel pek çok işlem yapılabilir. Bu kütüphaneyi kullanmak için örnek kod aşağıda verilmiştir:

Yukarıdaki yeni kodda, paintComponent fonksiyonu altında, Graphics2D sınıfından türetilmiş bir nesne olan g2d nesnesine, şimdiye kadar kullandığımız ve klasik Graphics kütüphanesinin bir nesnesi olan g nesnesini tip inkılabı ile (type casting) atıyoruz. Bu sayede g2d nesnesinin fonksiyonlarını kullanabiliyoruz.

Kodda, dikdörtgen ve daire şeklinde iki nesne ekrana eklenerek gösterilmiştir. Kodun çıktısı aşağıda verilmiştir:

Aynı ekranda hem çizim hem de bileşen (component) kullanan kod (Ahmet beyin sorusu üzerine ekliyorum):

Sorunumuz, aynı ekranda hem çizim yapabilmek, yani Graphics kütüphanesini kullanmak, hem de java’nın bileşenlerinin (örneğin düğme (buton) veya yazı alanı (text areat) gibi ) kullanabilmek.

Bunu yapan örnek bir kodu aşağıdaki şekilde kodlayabiliriz:

Kodda, öncelikle bir JPanel sınıfı oluşturuyoruz. Basitçe JPanel miras alan bir sınıfımız var, ismi cizim ve bu sınıf içerisinde, yukarıda da anlatılan paintComponent metodunun üzerine ezere (method overriding) Graphics kütüphanesini kullanıyoruz (örnek olarak bir çizgi çizdirilmiştir).

Ardından main fonksiyonumuzu içeren bir sınıf kodlanmıştır. Bu sınıf içerisinde x nesne atıfı (object referrer) ile gösterilen bir JFrame oluşturulmuş ve bileşen yayılımı (layout) GridLayout olarak ayarlanmıştır. Kabaca ekran 2×2 boyutlarında dört parçaya bölünmüştür. Javada bu yayılıma ekleme yapıldığında sol üst köşeden başlanarak bileşenler eklenir ve ilk satır bitince aşağıya geçilir.

Buna göre sırasıyla eklediğimiz bileşenler, c ismindeki ve cizim sınıfından türetilmiş bir JPanel, satır içinde (inline) olarak türetilmiş bir cizim nesnesi, üzerinde “deneme” yazan bir düğme (buton) ve içinde “www.bilgisayarkavramlari.com” yazılı bir yazı alanı (JTextArea).

Ekranın çıktısı aşağıdaki şekildedir:

Görüldüğü üzere, ekranda çizim içerikli iki panel ve iki adet swing kütüphanesinden bileşen eklenmiştir.

570 views

1. Bir masa lambasının 4 farklı durumu bulunabilmektedir. Kapalı, az ışık, orta ışık ve çok ışık seviyelerinde yanabilen bu lambayı nesne yönelimli olarak programlayınız. Herhangi bir insanın bu lambanın durumunu değiştirebilmesi ve lambanın mevcut durumunu görebilmesini sağlayınız. (JAVA dilinde sadece gerekli sınıfları yazınız) (10 puan)

   Masa lambasında durumu tutan bir değişkene ve bu durumu değiştiren bir metoda ihtiyaç duyulmaktadır. 4 farklı durum olduğu için en uygun değişken int tipidir.
   

   

   Yukarıdaki kod doğru olmakla birlikte, insan sınıfında yapıcı fonksiyon içerisinde masa lambası tanımlanmaması kabul edilebilir (insanın masa lambası olabilir ama her insanın masa lambası olmak zorunda değildir). Veya durumu döndüren fonksiyon (durumuBildir) değer döndürmek yerine ekrana durumu basabilir, veya String tipinde kapalı, az, orta ışık, çok ışık şeklinde değerler döndürebilir. Benzer şekilde yeniDurum fonksiyonu paramatre olarak int yerine String tipinde değer alabilir. Bu açıklamada olduğu üzere makul kabul edilebilecek değişken tipinde ve fonksiyon yapısında değişiklik olabilir.
   

    

2. Bir bankanın ATM cihazına gelen müşteriler, giriş (şifre yazarak), para yatırma, para çekme ve bakiye sorgulama işlemlerini yapabilmektedir. Bu sistemi nesne yönelimli olarak modelleyiniz, ihtiyaç duyuluyorsa ilave sınıfları da tanımlayınız. Her sınıfın metotlarını ve özelliklerini belirtiniz ve modelinizi JAVA dilinde kodlayınız. (30 puan)

   

       

3. Aşağıda verilen sınıfların özellik ve metotlarının isimlerini yazınız. Bu sınıflardan hangilerinin arasında ilişki olduğunu ve bu ilişkinin çeşidini yazınız.

   {çember, daire, nokta, şekil, doğru, kare, yamuk, piramit, küp, silindir }

   Yukarıdaki tanımınız ışığında, bir şekil vektörünü parametre olarak alıp bu vektördeki elemanların alanlarını hesaplayan fonksiyonu JAVA dilinde kodlayınız. (Bu sorudaki vektör kelimesi, java.util.Vector sınıfını ifade etmektedir, sorudaki hesaplama fonksiyonu dışında kod yazmanız gerekmemektedir ancak isterseniz sınıfların metotlarını ve özelliklerini kod yazarak da gösterebilirsiniz. Sınıflar arasındaki ilişkilerin isimlerini her durumda yazınız.) (50 puan)

    

   

   

    

   1. Aşağıdaki kod parçasının ekran çıktısını yazınız (10 Puan):

      int x = 6; // 110

      int y = 3; // 011

               // 101 = ^

               // 010 = 2

      // 111 = |

      System.out.println(x^y|2);

      if(++y == 3&& x<6 )

      System.out.println(y);

      System.out.println(y);

      Not: Bu sorunun cevabı hem “Thinking in JAVA” kitabında hem de “JAVA Tutorial” içeriğinde bulunmaktadır.

      7
      

      3
      

      Yukarıdaki ilk işlem x^y işlemidir ve ikilik tabanda XOR işlemi olarak çalışır. Bu durumad 6 = (110)₂ ve 3 = (011)₂ olarak çevrildikten sonra aralarında özel veya (xor) operatörü çalıştırıldığında, 101 sonucu bulunur. Ardından gelen tek boru (pipe) işlemi ise ikilik tabanda veya (or) işlemidir ve (101)₂ | (010)₂ şeklinde düşünülmelidir. Bu işlemin sağ tarafı 2 sayısının ikilik tabandaki karşılığıdır. Bu işlemin sonucu da (111)₂ olarak bulunur ki bu değer onluk tabanda 7 yapar.
      

      Ardından gelen if satırında önce x değerinin 6′dan küçük olup olmadığı kontrol edilir. Bu kontrol doğru değildir (false) dolayısıyla if satırındaki ikinci kısım çalışmaz. Yani y++ == 3 satırı çalışmaz. Bunun sebebi JAVA dilindeki kısa devre (short circuit) uygulamasıdır. Ve işlemi ile birbirine bağlı olan if kontrollerinde sol tarafın false dönmesi halinde sonuç flase olacağı için sağ tarafa bakılmaz. Ayrıca bu if satırının altında olan if bloğu da sonuç false olduğu için çalışmaz ve ikinci println fonksiyonu ekrana basılmaz.
      

      Son satırdaki println fonksiyonu ise y’nin orijinal değeri olan 3′ü ekrana basar.
      

       

   “Bilgisayarların, bilgisayar bilimindeki yeri, teleskopların, astronomi bilimindeki yerinden fazla değildir.” — Dijkstra
   

974 views

Gelen bir soru üzerine, C dilinde bir dosyanın içeriğini tersten ekrana basan kodu yazıp sitede yayınlıyorum.

Öncelikle algoritmamızı inşa edelim.

Ters almak gibi işlemler yapı olarak özyineli (recursive) fonksiyonlara çok uygundur. Genelde stack (yığın) yapısının kullanıldığı özyineli fonksiyonlar bilgiyi tutma ve ters çevirme (son giren ilk çıkar (LIFO) algoritması) için elverişli olurlar. Bu yüzden biz de bir özyineli fonksiyon kullanarak dosyamızdan karakter karakter değerleri okuyacak sonra da bunları ekrana basacağız.

Kodu aşağıda veriyorum:

Kodumuzdaki main fonksiyonu sadece dosyayı açmakta ve sonra ters fonksiyonunu çağırmaktadır. Dosya ters fonksiyonunda işlendikten sonra (ki bu işleme dosyayı tersten basmak olacak) dosya kapatılmakta ve program sonlandırılmaktadır.

Gelelim ters fonksiyonuna. Bu fonksiyon, dosya göstericisini (file pointer) parametre olarak alıp, dosya sonu olup olmadığını kontrol ediyor. Feof fonksiyonu, şayet dosyanın sonuna ulaştıysa, return; satırını çalıştıracak ve dolayısıyla fonksiyondan çıkılacak. Aslında bu durum bizim dosyamızın sonu ve dolayısıyla fonksiyonumuzun sonu ve dolayısıyla özyineleme yığınımızın (recursion stack) sonu olmaktadır.

Fonksiyonun geri kalanında işlem gayet basit bir şekilde fscanf ile dosyadan okumak ve ardından tekrar ters fonksiyonunu çağırmak ve sonra da okunan karakteri ekrana basmak şekline ilerler.

Buradaki kritik nokta, ters fonksiyonunu, ekrana karakter basmadan çağırmaktır. Şayet kodun 11. ve 12. satırları yer değiştirecek olsaydı, yani önce ekrana basıp sonra ters fonksiyonunu çağıracak olsaydık, bu durumda dosyanın içeriği olduğu gibi ekrana basılacaktır. Biz bunun yerine o andaki okunan karakteri bekletiyoruz ve sonraki karakteri basması ve ters çevirmesi için yeniden fonksiyona veriyoruz. Bu işlem dosya sonuna kadar gidiyor. Nihayet dosya sonuna erişilince özyineli yığınımız (recursion stack) toparlanmaya başlıyor ve bu toparlanma sırasında ekrana karakterleri basarak ilerliyor.

Yukarıdaki kod, Dev-CPP ile test edilmiş ve çalışmaktadır. Örneğin girdi.txt dosyası olarak aşağıdaki içerikte bir dosyayı verirsek:

Programın çıktısı aşağıdaki şekilde olur:

533 views

Quiz soruları ve çözümleri aşağıdaki şekildedir:

1. Bir oylama için program yazmanız isteniyor. Oylamaya katılan 5 aday bulunuyor ve bu adayların numarası (1′den 5′e kadar bir sayı) oy pusulasına yazılarak oy kullanılıyor. Programınızda 10 adet oyu okuyup ekrana adayların aldıkları oy miktarını basan bir program yazınız. Kullanılan oyun 1-5 arasında olmaması halinde problemi istisna yakalama ile çözünüz.

Çözüm

Oylama programında basitçe her oyun tutulduğu bir oy pusulası ve bir de oy verilen adaylar olacağını düşünebiliriz. Bu durumda oy pusulası ve aday isimli iki adet sınıf tanımlayıp bu sınıfların kodlamasını aşağıdaki şekilde yapabiliriz.

Yukarıdaki kodda, aday bilgisi tutuluyor. Programımızda olması gereken bilgi, adayın numarası ve oy sayısıdır. Biz de bu bilgileri tutan iki adet değişken tanımlıyor ve bu değişkenlerin getter/Setter fonksiyonlarını kodluyoruz. Ayrıca sınıfın inşa fonksiyonunda (constructor), başlangıç olarak oy sayısını 0 yapıyoruz. Son olarak adayların oy sayısını arttıran bir metot yukarıdaki kodun sonunda yer almaktadır. Basit bir arttırma işlemidir.

Oy pusulasını tutan kod ise aşağıdaki şekilde kodlanmıştır:

Yukarıdaki kodda, görüldüğü üzere, oy pusulasında sadece kime oy verildiği bilgisi tutulmuştur. Bu bilgiyi kapsülleme gereği getter ve setter fonksiyonları ile erişilebilir halde sınıfta kodluyoruz.

Son olarak kodumuzu test etmek için bir main fonksiyonu yazalım:

Oy okuma işlemi için “oyoku” isimli fonksiyon yazılmıştır. Bu fonksiyonun özelliği, oyları okurken yanlış bir oy girilmesi durumunda, (oyların 1 ile 5 arasında olacağını hatırlayınız) bir istisna fırlatmasıdır. Bu istisna, try bloğu içerisinden çağrıldığı yerde yakalanır ve kodun 27nci satırında bulunan catch bloğu ile ekrana bir hata mesajı basılır. Şayet oy başarılı bir şekilde okunabilirse, bu durumda ilgili oy pusulasına (ki toplam 10 adet pusula bulunuyor) oy değeri kaydedilir. Şayet bir istisna burada oluşmamışsa kodun 25. Satırına geçebiliriz. İstisna oluşması durumunda kodun 25. Satırı hiç çalışmadan catch bloğuna gidilir.

Kodumuzun 25. satırında, adayların tutulduğu nesne dizisinin (object array) ilgili elemanının (hangi elemana oy verildiyse) oy miktarını 1 arttıran oysayisiniArttir() fonksiyonu çağrılır.

Son olarak kodun 31-33 satırları arasında, adayların oy durumları ekrana basılır.

Yukarıdaki kodda bulunan ve kendi istisnamız olan hatalioy sınıfını aşağıdaki şekilde kodlayabiliriz:

1. Bir banka yazılımı için aşağıdaki özelliklerle program yazmanız isteniyor. Sistemde tutulacak veriler:
   1. Hesap sahibinin ismi
   2. Hesap numarası
   3. Bakiye
   4. Hesap tipi (vadeli / vadesiz)

Yukarıdaki hesap bilgileri için aşağıdaki işlemleri yapmanız isteniyor:

1. Hesapların ilk değer olarak bakiyesinin 0 atanması gerekir.
2. Hesaba para yatırılabilir
3. Hesaptan para çekilebilir
4. Hesap bilgisi görüntülenebilir (sahibinin ismi, numarası, tipi ve bakiyesi)

1. 2. Sorudaki programınızı, 10 müşteriye hizmet verebilecek şekilde genişletin.
2. 2. Sorudaki programınızı, hesap hareketleri görüntülenecek şekilde genişletin. Buna göre bir hesap hareketinin, tarihi, saati, miktarı ve hesap numarası bulunur.

Çözüm:

Yukarıdaki sorunun çözümü için basitçe bir hesap nesnesi oluşturmamız yeterli olacaktır. Yukarıdaki 4. soru için hesap hareketlerini tutan ilave bir sınıfa daha ihtiyacımız olacak. Öncelikle, hesapların tutulduğu bir hesap sınıfını programlayarak başlayalım.

Soruda tanımlandığı üzere, her hesap için hesapno, bakiye , hesap tipi ve hesap sahibi bilgilerini tutuyoruz. Ayrıca hesap hareketlerinden oluşan ilave bir dizi, her hareketi ayrıca kayıt altına alıyor.

Hesap sınıfımızın constructor fonksiyonunda, hesap bakiyesini 0 olarak atıyoruz.

Ayrıca sınıfımızdaki hesap hareketlerini tutan dizinin kaçıncı elemanında olduğumuz bilgisi, hhsayisi isimli değişkende durmaktadır. Bu değişken de henüz hesap hareketi olmadığı için 0 olarak atanıyor.

Sırasıyla hesap sınıfındaki metotların kodlamasını inceleyelim:

Yukarıda, hesap detaylarını ekrana basan fonksiyon verilmiştir. Fonksiyondaki 21nci satırda bulunan cout komutu ile ekrana hesabın temel 3 bilgisi bastırılmıştır. Ardında hesabın tipi yazıya çevrilerek bastırılmıştır. Hesap tipini tutmak için kullanılan int tipi, kullanıcı açısından anlamsız olabilir o yüzden yazıya çevirme işlemi yapılır.

Son olarak 27-30 satırları arasında, hesap hareketlerini bastırmak için, mevcut hesap hareketi sayısını tutan değişken kadar dönen döngü içerisinde her hesap hareketinin miktarı basılmaktadır.

Bu çıktının örneği aşağıda verilmiştir.

Yukarıdaki ekran görüntüsünde, örnek olarak bir hesabın detayları basılmış ve bu hesapta yapılan hesap hareketleri altında gösterilmiştir.

Hesap hareketi olarak kabul edilebilecek iki temel işlem para çekmek ve para yatırmak işlemleridir. Bunların kodlamasını aşağıda anlatalım:

Para çekme işlemi, belirtilen miktar kadar bakiyeyi azaltmamaktadır. Bu işlem sırasında öncelikle miktarın yeterli olup olmadığı kontrol edilir. Şayet miktar yeterli bulunursa bakiye azaltılır, şayet yeterli bulunmazsa bu durumda bir istisna (exception) fırlatılır. Burada fırlatılan istisna, proje kapsamında bizim tanımladığımız yetersizBakiye istisnasıdır.

Yetersi bakiye istisnası, basit bir şekilde bakiye bilgisini de içinde saklayan bir sınıf (class) olarak tasarlanabilir:

Hesap hareketlerinin içerisine, ayrıca miktar konulurken -1 değeri ile çarpılmaktadır. Bunun anlamı, hesap hareketinin eksi değer olarak tutulmasıdır.

Benzer kodlama, para yatırma fonksiyonunda da kullanılmaktadır. Yatırılan miktar, hesap hareketlerine işlendikten sonra, bakiye değeri parametre olarak verilen miktar kadar arttırılmaktadır.

Hesap hareketlerinin detayı için sınıf kodlamasını aşağıdaki şekilde yazabiliriz:

Bu sınıf, basit bir şekilde hesapta yapılan işlemleri tutmak için tasarlanmıştır. İlgili üyelerin getter / setter fonksiyonlarının yazılması yeterlidir.

Quiz sorularının kodlarını indirmek için tıklayınız.

437 views

Gelen bir soru üzerine (Ayşenur Doğan sormuş), iki farklı dosya okuyup, okunan dosyalardaki verileri iki farklı bağlı listeye koyan kodu yazmaya çalışalım.

Öncelikle bağlı listemizin düğüm yapısını tanımlayalım. Tek yönlü bir bağlı liste işimizi çözecektir. Dolayısıyla sadece next isimli bir gösterici (pointer) koyarak her düğümün (node) bir sonraki düğüme bağlanmasını sağlıyoruz.

Ayrıca her düğümde en fazla 100 karakter uzunluğunda bir dizgi (string) tutuyoruz. Dosyadaki her kelime bu dizginin içerisine yerleştirilecek.

Ardından klasik olarak dosya aşma işlemini yapıyoruz:

Yukarıdaki kodda görüldüğü üzere, iki dosya göstericisi (file pointer) tanımlanmıştır. Ayrıca dosyaların isimlerinin kullanıcıdan okunması için dosya1 ve dosya2 isimli iki dizgi (string) tanımlanarak kullanıcıdan dosya isimleri okunmuştur.

Okunan dosyaların açılamaması halinde hata mesajı verilerek çıkılmıştır.

Sıra bağlı listelerin (linked list) tanımlanmasında:

Yukarıdaki kodda, iki adet bağlı liste, daha önceden tanımladığımız dugum yapısı(struct) uygun olarak birer düğümü gösterecek şekilde hafızaya yerleştiriliyor. Ayrıca bağlı listemiz tek yönlü olduğu için (singular) listenin ilk elemanını kaybedemeyiz. Bu yüzden listenin üzerinde hareket edecek olan bir iter değişkeni tanımlıyoruz (literatürde iterator olarak geçer). Yani listenin son elemanını sürekli olarak iter, ilk elemanını ise liste ile başlayan değişkenler tutuyor. Şimdilik hafızadaki bağlı liste görüntüsü aşağıdaki şekildedir:

Yukarıdaki şekilde görüldüğü üzere, hafızada (RAM) iki adet liste, bu iki listenin içinde de birer adet boş düğüm (node) ve her düğümü gösteren ilave birer iter değişkeni bulunmaktadır.

Gelelim dosyadan okuyup listenin içerisine değerleri atan koda:

Kodumuz basitçe, dosyanın sonuna gelinip gelinmediğini kontrol eden bir while döngüsü içerisinde çalışıyor. Yani kodun 31 ve 41 numaralı satırlarında yapılan kontrol, ilgili dosya göstericisinin, dosya sonuna ulaşıp ulaşmadığını kontrol etmekte ve ulaşmadığı sürece döngü devam etmektedir.

Her iki döngü için de geçerli olmak üzere, bir geçici isimli dizgi (string) tanımlanarak dosyadan geçici olarak bu dizgiye okuma işlemi yapılmıştır. Ardından strcpy isimli string.h kütüphanesinde bulunan fonksiyon ile, okunan bu dizgi, o anda iter tarafından gösterilen düğüme konulur. İter göstericisinin sonraki düğümünde yer açılır ve iter bu yeni boş düğümü gösterir.

Örneğin dosyadan okunan ilk kelime “bilgisayar” olsun. Bu durumda bağlı liste yapısı aşağıdaki şekilde olacaktır:

Görüldüğü üzere, iter göstericisi tarafından gösterilen kutuya bir değer eklenip, yeni boş bir kutu, next ile gösterilen boş alanda açılmakta ardından iter bu boş kutuyu göstermektedir. Örneğin anlaşılması açısından bir de “kavramları” kelimesini okuduğumuzu düşünelim:

Yukarıda görüldüğü üzere her seferinde, iter tarafından gösterilen düğüme, okunan dizgi (string) yerleştirilmekte ve yeni iter tarafından gösterilen düğümün sonrasına (next) boş bir düğüm konulmakta ve iter bu yeni düğümü gösterilecek şekilde ilerletilmektedir.

Her şey bittikten sonra, bağlı listelere okunan değerleri ekrana bastırıyoruz:

Listelerin başını tutan liste1 ve liste2 isimli değişkenleri gösterecek şekilde iter değişkenlerini başa çekiyoruz. Buradaki amaç yine listenin ilk elemanını kaybetmeden bastırma işlemini yaptırmaktır. İter değişkenleri, listenin ilk elemanlarını gösterdikten sonra, gösterdikleri düğümlerin değerlerini ekrana basıp sonraki düğüme (next node) ilerletilmektedir.

Kodun ekran çıktısı aşağıdaki şekildedir:

Kodun tamamı ve yukarıdaki örnek çıktıda kullanılan iki dosyayı indirmek için taıklayınız.

1,000 views

Bu yazının amacı, bir C sorusunun çözümünü açıklamaktır. Sorumuz basitçe n x n boyutlarındaki bir matrisin (soruyu basitleştirmek için n sayısını tek sayı olarak kabul edeceğiz) içerisine aşağıdakine benzer şekilde ardışık sayıları sarmal olarak yerleştirmek.

Örnek 3×3 boyutlarındaki matris:

5×5 boyutlarındaki örnek matris:

7×7 boyutlarındaki örnek matris:

Yukarıdaki matrislere bakıldığında, sayısal olarak bazı özellikler bulunabilir. Bizim amacımız yukarıdaki problemi, 2 boyutlu problemden tek boyutlu probleme indirgemektir. Bunun sebebi diziler üzerinde işleme yapan en önemli enstrümanımız olan döngülerin tek boyutlu olarak çalışmasıdır. Burada iç içe yazılan iki döngünün iki boyutlu çalıştığı iddia edilebilir ancak bu durumda bile aslında yapılan iş, tek boyutlu bir taramanın, ikinci döngü ile (dıştaki döngü ile) tekrarlanmasıdır. Yani döngüler, yetenek olarak tek boyutlu, doğrusal hareket sağlar.

Bu tespitten sonra yukarıdaki problemi çözmek için sayısal özellikler bulmaya ve problemi tek boyutlu problem haline getirmeye çalışıyoruz.

İlk tespitimiz, 2 boyutlu bir matris içerisine ardışık sayıları yerleştirmek dolayısıyla matrisin ortasındaki sayının, matris boyutunun karesi olacağını biliyoruz. Örneğin 7×7 boyutlarındaki matris için ortada 49 , veya 5×5 boyutlarındaki matris için ortadaki değerin 25 olması gibi.

Ayrıca ortaya kadar olan köşegenleri bulursak tek boyutlu seriler oluşturmuş oluruz.

Örneğin aşağıdaki renklendirilmiş değerlerden başlayan ve sağa doğru giden tek boyutlu seriler, 1′er 1′er artan değerlerdir:

Bu değerlerden başlayarak sağa doğru giden seri aşağıdaki şekilde işaretlenebilir:

Amacımız, bu seriyi veren ve yukarıdaki şekilde, kırmızı renkle işaretlenmiş seri başlarını veren formülü bulmak.

Serimizde bulunan sayılar:

1, 25, 41, 49

Bu sayıların arasında bir bağlantı bulmamız gerekiyor. Sayıları tersten yazar ve aralarındaki farkları bulursak:

49, 41, 25, 1 ve aralarındaki farklar : 8 , 16, 24 şeklinde giden seridir. Bu serinin özelliği 8′in katları olmasıdır.

Benzer durum diğer boyutlardaki matrisler için de geçerlidir. Örneğin matris 9×9 boyutlarında olsaydı:

81, 73, 57, 33, 1 ve aralarındaki farklar: 8, 16, 24, 32 şeklinde olacaktı.

Benzer şekilde diğer köşegen değerlerini de bulalım:

Mavi renkle işaretli köşegen değerlerini veren formülü inceleyelim :

19, 37, 47, 49 , bu sayıları ters sıralarsak : 49, 47, 37, 19 ve aralarındaki farklar: 2, 10, 18 şeklinde ilerlemektedir. Bu sayılar arasındaki fark da dikkat edilirse 8 ‘dir.

Benzer şekilde matris boyutu 9×9 olsaydı, 81, 79, 69, 51, 25, ve aralarındaki farklar: 2, 10, 18, 26 şeklinde olacaktı. Bu sayılardan başlayarak ilerleyen tek boyutlu dizilerimiz aşağıdaki şekilde olacaktı:

Son serimiz aşağıda işaretlenen seridir:

Serimiz: 49, 45, 33, 13 şeklinde ilerlemektedir ve farklar: 4, 12, 20 şeklinde ilerlemektedir.

Şimdi, yukarıda incelediğimiz bu 4 durum için döngüleri yazmaya başlayalım. İlk durum için kodumuz aşağıdaki şekilde olur:

    int kat = 0;

    int fark = 0;

    for(int i = n/2 ;i>=0;i–){

        a[i][i] = n*n-fark;

        kat++;

        fark = fark + kat*8;

            for(int j = i+1;j<n-i;j++){

                a[i][j]=a[i][j-1]+1;

            }

    }

Yukarıdaki kodda, dikkat edilirse, bir fark değişkeni, sürekli olarak n*n değerinden çıkarılıyor. Buradaki değer a dizisinin [i][i] adresine yerleştiriliyor. Bu değer normalde, dizinin köşegen değeridir. Bu döngüdeki i değişkeni n/2 değerine kadar ilerlemektedir, dolayısıyla köşegenin yarısına kadar ilerleyen döngü, tam olarak 2 boyutlu dizinin ortasında bitmektedir.

Hesaplanan köşegen değerlerinden başlanarak, satırları dolduran döngü ise içerde yer almaktadır. Burada basitçe, hesaplanan her köşegen değerinden başlayarak satır değerlerini dolduran döngü yazılmıştır.

İkinci döngümüz aşağıdadır:

for(int i = n/2 ;i>0;i–){

         for(int j = i;j<n-i+1;j++){

                a[j][n-i]=a[j-1][n-i]+1;

            }

    }

Bu döngü, bir öncekine göre oldukça basittir çünkü önceki döngüde hesaplanan köşegen değerlerini devam ettirmektedir. Kısacası yeniden köşegen değeri hesaplanmadığı için, mevcut değerler üzerinden işlem yapılmakta ve tek boyutlu hareket tekrarlanmaktadır.

Üçüncü olarak alt satırları yazan döngümüzü kodlayalım:

    kat = 2;

    fark = 0;

    for(int i = n/2 ;i>0;i–){

        fark = fark +kat;

        a[n-i][i-1] = n*n-fark;

        kat = kat+8;

            for(int j = i;j<n-i+1;j++){

                a[n-i][j]=a[n-i][j-1]-1;

            }

    }

Hatırlanacağı üzer bu döngü, 2 den başlayarak 8′er 8′er artan döngüydü. Dolayısıyla kat değişkenini bu sefer 2 den başlatıp, ters köşegeni dönen döngüyü yazıyoruz. İçerideki döngümüz, sütun değerlerini yukarıdan aşağıya doğru dolduruyor. Burada ters köşegen için i+j=n formülünü hatırlayalım. Dolayısıyla a[j-i][j] değeri ters köşegeni vermektedir.

Son olarak ortanın solundaki kolonları dolduran döngülerimizi yazıyoruz:

    for(int i = 0 ;i<n/2;i++){

            for(int j = i+2;j<n-i;j++){

                a[n-j ][i]=a[n-j+1][i]+1;

            }

    }

Bu son döngü yapısında, dış döngümüz, köşegen yarısına kadar ilerlerken, içerideki döngümüz sütunları doldurmaktadır. Bu döngüyü yukarıda yazılan ikinci döngünün (ortanın sağındaki değerleri dolduran döngünün) tersi olarak düşünmek mümkündür. Bu dördüncü döngü için de başlangıç değerleri zaten hesaplanmıştır.

Kodun örnek çıktıları aşağıda verilmiştir:

7×7 boyutları için :

9×9 boyutları için:

Kodun tamamını indirmek için tıklayınız

230 views

Bu yazının amacı, tictactoe oyununu nesne yönelimli olarak kodlamak ve bu sırada, aşağıdaki konuları açıklamaktır.

1. Nesnelerden oluşan bir dizi kullanımı (Object Array)
2. Kapsülleme (Encapsulation)
3. İstisna yakalama (Exception Handling)

Kodumuz basitçe, oynanan her hamleyi 3×3 boyutlarında, iki boyutlu bir dizide tutacaktır. Ayrıca oyunun kazanılması durumunda bir istisna oluşturulacak ve bu istisnanın yakalanması ile, oyun sona erecektir.

Bu problemin çözümü için, aşağıdaki şekilde bir nesne dizisi tasarlıyoruz:

Yukarıdaki şekilde, 3×3 boyutlarında görülen tablo üzerindeki hamleler ayrı birer nesnede tutulmak istenmiştir. Dolayısıyla her hamleyi tutan bir nesne ve bu hamlelerin tanımlandığı bir sınıfa ihtiyacımız bulunuyor.

Bu sınıfı aşağıdaki şekilde kodlayabiliriz.

Hamle.h dosyası

class hamle{

private:

    int sembol; // x:1 veya o:2 değeri

public:

    int getSembol();

    void setSembol(int);

    hamle(int);

    hamle();

};

Kodda bulunan sembol değişkeni, basitçe hamlenin X veya O olmasını belirliyor. Şayet oynanan hamle X ise, değer olarak 1, O ise değer olarak 2 veya boş hamle ise, yani henüz tablonun bu alanına oynanmamış ise 0 değerini tutuyor.

Kapsülleme işlemi için bu değişkeni private tanımlıyor ve getter/setter metotlarını oluşturuyoruz. Ayrıca sınıfımızı kullanacak kişiler için bir adet int parametresi alan yapıcımız (constructor) bulunuyor.

Son olarak boş yapıcı (default constructor) tanımlıyoruz ki, tablo içerisine hamleleri boş olarak yerleştirdiğimizde, boş hamleleri belirten 0 değerini sembol değişkenine atayabilelim.

Bu sınıfın metotları aşağıdaki şekilde kodlanabilir:

Hamle.cpp dosyası:

#include
“hamle.h”

int hamle::getSembol(){

    return sembol;

}

void hamle::setSembol(int sembol){

    this->sembol =sembol;

}

hamle::hamle(int sembol){

    this->sembol= sembol;

}

hamle::hamle(){

    sembol = 0;

}

Her hamleyi tutmaya yarayan yukarıdaki koda ilave olarak bu hamlelerin oynandığı konumları tutan bir tahta sınıfı kodlamamız gerekiyor.

class Tahta{

private:

    hamle tahta[3][3];

    int sira;

public:

    Tahta();

    void oyna(int x,int y, int sira);

    void oyna(int x,int y);

    void bas(void);

    int kazandi();

};

.Yukarıdaki kodda görüldüğü üzere, 3×3 boyutlarında bir tahta, her elemanı hamle sınıfından değerler tutacak şekilde tanımlanmış. Bu tahta dizisine (array) erişmek için oyna metodu bulunuyor. Basitçe, tahta üzerinde bir adrese herhangi bir hamle konulabilmesi için oyna fonksiyonundaki x ve y değerlerinin verilmesi gerekiyor.

Ayrıca oyna metodu üzerine yükleme (overloading) ile iki farklı şekilde tanımlanmış (polymorphism). Bu sayede, kodumuzu kullanan diğer programcılar, isterlerse o andaki sırayı belirleyerek oynayabilecekler (örneğin istedikleri bir adrese, özel olarak X veya Y değeri koyabilecekler) veya sıradaki hamleyi (örneğin sıra X’te ise doğrudan X değeri) verilen adrese konulabilecek.

Yukarıda, tanımı verilen sınıfın kodlaması aşağıdaki şekildedir:

Tahta::Tahta(){

    sira = 1;

}

İnşa metodunun (constructor method) içerisinde, ilk sıranın kimde olduğunu belirtmek için sira değişkenine 1 değeri konulmuştur. Bunun anlamı, şayet programcı özel olarak bir sıra belirtmezse, ilk hamlenin X tarafından yapılacağıdır.

void Tahta::oyna(int x,int y,int sira){

    if(tahta[x][y].getSembol()==0){

            tahta[x][y] = hamle(sira);

        }

        else

            cout << “bu koordinata sembol yerlestirilmistir”<<endl;

}

Tahta üzerinde yapılan hamlelerin koordinatları oyna fonksiyonuna verilmektedir. Yukarıdaki oyna fonksiyonu, aldığı x ve y değerlerine, verilen sıradaki sembolü yerleştirir. Buna göre yeni bir nesne oluşturulup verilen x,y koordinatlarındaki dizi içerisine yerleştirilmektedir.

Aynı fonksiyonu aşağıdaki şekilde üzerine yüklenmesi mümkündür.

void Tahta::oyna(int x, int y){

        if(tahta[x][y].getSembol()==0){

            tahta[x][y] = hamle(sira);

            sira %=2;

            sira++;    

            if(kazandi()==1)

                throw kazanma(1);

            else
if(kazandi()==2)

                throw kazanma(2);

        }

        else

            cout << “bu koordinata sembol yerlestirilmistir”<<endl;

}

Yukarıdaki ikinci haliyle oyna fonksiyonu, sadece x ve y değerleri almaktadır. Bu sayede, sınıf içerisinde bulunan sıraya göre hamle yapılmaktadır. Elbette her hamleden sonra sıranın değiştirilmesi gerekiyor. Bunun için sıra değişkeninin 2ye bölümünden kalan alınıp değeri bir arttırılıyor (sıra değerinin 0 olamayacağını, 0 değerinin oynanmamış alanları temsil ettiğini hatırlayınız).

Yukarıdaki kodda bulunan özel bir durum ise, kazanma koşulunu kontrol etmektedir. Şayet X kazandıysa 1 veya O kazandıysa 2 kontrolü yapılıp ilgili istisna (exception) fırlatılmaktadır.

Bu işlem sırasında kendi yazdığımız istisna sınıfını (exception class) kullanıyoruz. Yani yukarıdaki kodda bulunan kazanma sınıfı bizim kodladığımız bir sınıf. Bu sınıfın kodu aşağıda verilecek.

Son olarak Tahta sınıfında, kazandi kontrolü yapılması için aşağıdakine benzer bir kod yazılabilir:

int Tahta::kazandi(){

    if((tahta[0][0].getSembol()==1 &&tahta[0][1].getSembol()==1 &&tahta[0][2].getSembol()==1 )

        ||(tahta[1][0].getSembol()==1 &&tahta[1][1].getSembol()==1 &&tahta[1][2].getSembol()==1 )

        ||(tahta[2][0].getSembol()==1 &&tahta[2][1].getSembol()==1 &&tahta[2][2].getSembol()==1 )

        ||(tahta[0][0].getSembol()==1 &&tahta[1][0].getSembol()==1 &&tahta[2][0].getSembol()==1 )

        ||(tahta[0][0].getSembol()==1 &&tahta[1][0].getSembol()==1 &&tahta[2][0].getSembol()==1 )

        ||(tahta[0][1].getSembol()==1 &&tahta[1][1].getSembol()==1 &&tahta[2][1].getSembol()==1 )

        ||(tahta[0][2].getSembol()==1 &&tahta[1][2].getSembol()==1 &&tahta[2][2].getSembol()==1 )

        ||(tahta[0][0].getSembol()==1 &&tahta[1][1].getSembol()==1 &&tahta[2][2].getSembol()==1 )

        ||(tahta[0][2].getSembol()==1 &&tahta[1][1].getSembol()==1 &&tahta[2][0].getSembol()==1 ))

        return 1;

    else
if((tahta[0][0].getSembol()==2 &&tahta[0][1].getSembol()==2 &&tahta[0][2].getSembol()==2 )

        ||(tahta[1][0].getSembol()==2 &&tahta[1][1].getSembol()==2 &&tahta[1][2].getSembol()==2 )

        ||(tahta[2][0].getSembol()==2 &&tahta[2][1].getSembol()==2 &&tahta[2][2].getSembol()==2 )

        ||(tahta[0][0].getSembol()==2 &&tahta[1][0].getSembol()==2 &&tahta[2][0].getSembol()==2 )

        ||(tahta[0][0].getSembol()==2 &&tahta[1][0].getSembol()==2 &&tahta[2][0].getSembol()==2 )

        ||(tahta[0][1].getSembol()==2 &&tahta[1][1].getSembol()==2 &&tahta[2][1].getSembol()==2 )

        ||(tahta[0][2].getSembol()==2 &&tahta[1][2].getSembol()==2 &&tahta[2][2].getSembol()==2 )

        ||(tahta[0][0].getSembol()==2 &&tahta[1][1].getSembol()==2 &&tahta[2][2].getSembol()==2 )

        ||(tahta[0][2].getSembol()==2 &&tahta[1][1].getSembol()==2 &&tahta[2][0].getSembol()==2 ))

        return 2;

    else

        return 0;

}

Yukarıdaki bu kod, 16 ayrı kazanma koşulunu kontrol etmektedir. Kazanan kişinin 1 veya 2 olmasına göre de sonucu döndürmektedir.

Yukarıdaki ikinci oyna metodunda bulunan istisna sınıfı ise aşağıdaki şekilde kodlanabilir:

class kazanma{

private:

    int kim;

public:

    kazanma(int x){

        kim = x;

    }

    int getKim(){

        return kim;

    }

};

Son olarak, yukarıdaki kodlarımızı çalıştıracak olan main fonksiyonunu aşağıdaki şekilde kodlayalım:

#include
“hamle.h”

#include
“tahta.h”

#include
<iostream>

#include
<conio.h>

using
namespace std;

int main(){

    Tahta t = Tahta();

    try{

        for(int i =0;i<9;i++){

            int x,y;

            cin>>x;

            cin>>y;

            t.oyna(x,y);

            t.bas();

        }

    }catch(kazanma k){

        t.bas();

        if(k.getKim()==1)

            cout << “kazanan: X” << endl;

        else

            cout << “kazanan: O” << endl;

    }

    getch();

}

Yukarıdaki kodda, 9 hamlenin yapıldığı bir for döngüsü bulunuyor. Bu döngü içerisinde, kullanıcıdan x ve y değerleri okunuluyor ve ardından bu okunan değerlere Tahta sınıfından tanımlanan t değişkeni ile oynanıyor. Burada kullanılan oyna fonksiyonu, sırayı almamaktadır. Dolayısıyla Tahta sınıfındaki tanımlı olan sırayı kullanmakta ve bu sıra otomatik olarak her hamleden sonra değiştirilmektedir.

Ayrıca bu döngü içerisindeki oynama işlemi sırasında herhangi bir taraf kazanacak olursa, kazanan kişi için bir istisna fırlatılacak ve bu fırlatılan istisna, yukarıdaki kodda bulunan catch bloğu ile yakalanacaktır. Burada yakalanan istisna, bizim tanımladığımız kazanma sınıfından olduğu için, sınıfın içerisinde tutulan kimin kazandığı bilgisini alıp buna göre uygun kazanma mesajını ekrana basabiliyoruz.

Kodun tamamına buradaki bağlantıyı tıklayarak erişebilirsiniz.

274 views

Sitede gelen bir soru üzerine bu yazıyı yazmaya karar verdim. Bilgisayar dilleri (makine işlemeli diller, machine processing languages) tasnif edilirken, visual basic gibi görsel tasarıma dayalı diller üst seviye dil (high level langauge) olarak kabul edilirler. Hatta hiç kod yazmadan program üretilmesine izin verdiği için visual basic’i bir dilden çok görsel geliştirme ortamı olarak kabul eden (basic’i dil ancak visual basic’i bir geliştirme ortamı) tasnifler söz konusudur.

Göstericiler (pointers) ise tam tersine düşük seviyeli dillerde daha çok ihtiyaç duyulan ve programın geliştirildiği bilgisayarın hafızasına (ram) doğrudan erişim yapan yapılardır. Dolayısıyla tanım itibariyle visual basic ve gösterici (pointer) kavramları birbiri ile uyuşmazlar. Ancak .Net teknoloji ile birlikte nesne yönelimli programlama (object oriented programming) yapısı kazanan adeta kabuk değiştiren visual basic ile gösterici kullanımı ihtiyacı artmıştır.

Nesne yönelimli dillerin çoğunda (örn. JAVA) doğrudan gösterici kullanımı bulunmaz. Bunun yerine nesne atfı ismi verilen (object referrer) yapılar kullanılır ve bu yapılar aslında birere göstericidir.

Visual basic de nesne yönelimli programlama ile birlikte bu nesne atıflarını içermiş ve artık gösterici yapısını nesne yönelimli olarak içermiştir ancak biz bu yazı kapsamında, nesne yönelimli programlanın bize sunduğu bu imkanı bir kenara bırakarak, saf visual basic dilinde göstericileri nasıl kullanabileceğimizi irdeleyeceğiz.

Konuyu aşağıdaki örnek üzerinden anlamaya çalışalım.

Yukarıda, C dilinde yazılmış basit bir gösterici kodu bulunmaktadır. Kodumuzun 7. Satırında p isimli bir tam sayı göstericisi (integer pointer) tanımlanmış, 8 . satırda bu göstericinin gösterdiği yerde 1 tam sayı konulacak bir yer hafızada ayrılmış (memory allocation) ve 9. Satıda bu göstericinin gösterdiği adrese 10 değeri konulmuştur.

Kodun 10. Satırında göstericinin adresi (hafızada nereyi gösterdiği ) ve gösterdiği yerdeki değerler ekrana basılmış ve 11. Satırda gösterici için ayrılan hafıza bölmesi serbest bırakılmıştır (free).

Yukarıdaki bu kodun çalışan hali aşağıda verilmiştir:

Şimdi yukarıdaki bu basit C dili ile yazılmış gösterici kodunu Visual Basic dili ile kodlamaya çalışalım.

Yukarıdaki kodu inceleyecek olursak, yapı olarak bir form yükleme fonksiyonuna yazılmış kodumuz, p ve hHeap isimli iki adet Long tipinde değişken tanımlayarak başlıyor. Buradaki p değişkenini bir gösterici olarak kullanacağız. Dikkat edilmesi gereken husus, p değişkeninde gösterici mantığında olduğu üzere bir hafıza bölmesinin adresinin tutulmasıdır. Yani C dilinde olan p göstericisinde nasıl hafızanın bir adresi tutuluyorsa, visual basic örneğinde de hafıza adresini tutmaya çalışacağız.

Öncelikle çalışan programımızın yani işlemin (process) çalıştığı alanı tutan hHeap isimli değişkenimizden HeapAlloc fonksiyonu ile (C dilindeki malloc benzeri) hafızada bir alan ayırması yapılıyor.

Bu ayırma sırasında 0′dan başlanarak 2 boyutunda ayırma işlemi yapılmıştır. 2 sayısı, visual basic dilindeki bir tamsayının (integer) hafızada kapladığı alan boyutudur.

Sonuçta kodun 22. Satırı itibariyle, p isminde bir değişken ve bu değişkenin içinde, hafızada bize ayrılmış 2 byte uzunluğunda bir alanın adresi bulunmaktadır.

Ardından 23. Satırda böyle bir adres ayrımı başarılı olduysa, artık bu adres alanına bir integer değer koymayı deneyebiliriz.

24. satırda i isimli bir tam sayı değişkeni tanımlanıyor, 25. Satırda bu değişkene sayısal olarak 10 değeri konuluyor ve sonunda 26. Satırda, p göstericimizin gösterdiği adrese, i değişkenin içindeki değer konuluyor. Bu sırada CopyMemoryWrite fonksiyonu kullanılmıştır. Bu fonksiyon kernel32 dinamik kütüphanesi içinde bulunan RtlMoveMemory fonksiyonudur. Dolayısıyla bu fonksiyonu kullanmak için aşağıdakine benzer bir şekilde kodun başında tanım yapılmalıdır:

Private Declare Sub CopyMemoryWrite Lib “kernel32″ Alias _
“RtlMoveMemory” (ByVal Destination As Long, _

ByVal Source As Long, ByVal Length As Long)

Ardından j isimli bir değişken tanımlanarak, p göstericimizin gösterdiği hafıza alanına daha önceden (kodun 26. Satırında) yazdığımız değeri okumaya çalışıyoruz. Bunun içinde yine kernel32.dll kütüphanesinden tanımladığımız fonksiyonumuzu kullanıyoruz.

Sonuç bir mesaj kutusu içerisinde gösteriliyor ve nihayetinde 31. Satırda bu ayrılan hafıza alanı serbest bırakılmaktadır.

Visual basic ile yazılan bu kodun tamamını bu bağlantıdan indirerek deneyebilirsiniz.

421 views

Kısaca üçgenin her parçası, üç adet alt üçgen oluşturacak şekilde bölünür.

Örneğin aşağıdaki eşkenar üçgeni ele alalım:

Bu üçgenin üç köşesinde üç ayrı üçgen oluşturarak işlemimize başlayabiliriz.

Yukarıdaki şekilde görüldüğü üzere 3 adet siyah eşkenar üçgen oluştu. Bu üçgenlerin her birisini ilk başta ele aldığımız üçgen gibi bir adım daha ilerleyerek üç parçaya bölmeye çalışalım:

Görüldüğü üzere bölme işlemi sonucunda her alt üçgeninin üç köşesinde, ilk adımda yapılan işleme benzer şekilde 3 ayrı üçgen oluşturulmuştur.

Bu işlem sonsuza kadar devam ettirilebilir. Ancak bilindiği üzere bilgisayar bilimlerinde sonsuz yoktur. Dolayısıyla bu işlem için bir limit belirlenir ve belirlenen limite kadar işlem devam ettirilir.

Sierpinski üçgeninin kodlanması

Yukarıda anlatılan üçgeni, Scheme dilinde programlamaya çalışalım. Bu kodlama sırasında PLT Scheme kullanılacaktır.

Öncelikle gerekli olan bazı bilgilerimizi hatırlayalım. Çizim için draw.ss teachpackinin yüklü olması gerekiyor.

Bunun için Language menüsünden Add Teachpack seçeneğini seçip draw.ss paketini yüklüyoruz.

Ardından basit bir üçgenin scheme ile nasıl çizileceğine bakalım.

Ne yazık ki üçgen çizen hazır bir fonksiyonumuz bulunmuyor. Bunun için üçgeni oluşturan üç ayrı doğruyu ayrı ayrı çizdiren bir fonksiyonu bizim yazmamız gerekiyor.

(define (draw-triangle a b c)( and (draw-solid-line a b)(draw-solid-line b c)(draw-solid-line c a)))

Yukarıdaki draw-triangle fonksiyonu üç ayrı nokta almaktadır. Bu noktaları birleştiren üç ayrı doğruda fonksiyon içerisinde çizilmektedir. Bilindiği üzere draw-solid-line fonksiyonu verilen iki nokta arasında bir doğru çizer. Bu noktalar make-posn yapısında olmalıdır. Örneğin çizim ekranında (ki ekranın sol üst köşesi 0,0 olarak kabul edilir) 100, 150 koordinatlarından 200, 250 koordinatlarına bir doğru çizmek istiyorsak aşağıdaki şekilde komut vermemiz gerekir:

(draw-solid-line (make-posn 100 150) (make-posn 200 250))

Üçgen çizen fonksiyonumuz olduğuna göre artık sirepinski üçgenini kodlamaya geçebiliriz.

Kodumuzu yukarıdaki şekilde yazabiliriz. Kodda dikkat edilirse üçgen çizimi sırasında orta nokta bulma yöntemi kullanılmıştır. Buradaki amaç, üçgenin köşelerinde 3 ayrı üçgen elde etme işlemi sırasında üçgenin kenarlarının orta noktalarının birleştirilmesi ile bir ters üçgen oluşturulması olarak düşünülebilir.

Yukarıdaki şekilde de gösterildiği üzere alsında kenarların orta noktalarını birleştiren bir üçgen çizilmektedir.

İşte üçgeni meydana getiren 3 nokta ve bu noktaların oluşturduğu 3 doğru için orta noktalar bulunmakta ve bulunan bu orta noktaları birleştiren yeni bir üçgen çizilmektedir. Bu noktaları bulan kodumuz, yukarıda verilen mid-point fonksiyonudur. Bu mid-point fonksiyonu da, aritmetik ortalama kullanarak, nokta koordinatlarını toplayıp ikiye bölmekte ve bu işlem için yine yukarıdaki kodda verilen mid fonksiyonunu kullanmaktadır.

Ardından üçgenin 3 alt üçgeni yeniden sierpinski üçgeni çizen fonksiyonumuzu yeni noktalar ile verilmektedir.

Sierpinski üçgeninde dikkat edilirse, üçgeni oluştran 3 nokta (a b ve c) dışında ilave olarak bir n parametresi kullanıyoruz. Bu parametrenin amacı, fonksiyonun belirli bir yerde durmasıdır. Bu sayede kullanıcı, işlemimizin kaç adım gidilebileceğini parametre olarak girebilmekte ve belirtilen adım dolduğunda işlem durmaktadır.

Yukarıdaki kodun çalıştırılması aşağıdaki şekilde olabilir:

Görüldüğü üzere, üçgenin içerisine çizileceği üç nokta belirlenmiştir. Burada noktaları belirlerken, üçgenin eşkenar üçgen olması için ufak bir hesaplama yapılmıştır. Çizim tuvalimiz, 400 400 olarak verilmiş yani bize ekranda 400e 400 pixellik (imgecik) bir alan açılmaktadır. Bu alanı nispeten ortalayan bir üçgende A B ve C noktalarının birleştirilmesi ile teşekkül etmiş olur.

Son olarak sierpinski üçgenini çizen özyineli (recursive) fonksiyonumuzu bu üç noktanın koordinatları ve 10 adım gidileceğini belirten 10 sabit sayısı ile çağırıyoruz.

Sonuç olarak ekrana çizilen görüntü aşağıdaki şekildedir:

Yukarıdaki şekilde, 10 adım ilerlenmiş ve 10 adım sonunda detaylı bir görüntü oluşmuştur. Örneğin aynı üçgeni 3 parametresi ile, yani 3 adım ilerleyecek şekilde çağırsaydık:

Yukarıda verilen biraz daha ilkel halini görecektik.

657 views

Soru 1) Bir dosyaya isminizi yazdırınız.

Çözüm 1) dosyaya ismimizi yazdıran kodu aşağıdaki şekilde yazabiliriz:

Yukarıdaki kodda dikkat edilecek bir husus, dosyanın “r” değil “w” şekliyle açılması ve dosyanın mutlaka kapatılmasıdır. Bilindiği üzere kapatılmayan dosyalara yazıldığından kesin olarak emin olamayız ve dosya kapatılmadıysa içerisine bilgi yazılmamış olabilir.

Yukarıdaki kod çalıştırıldıktan sonra aynı dizin içerisinde “dosya.txt” isimli bir dosya oluşturulur ve bu dosyanın wordpad benzeri bir programla açılması durumunda içinde ismimizin yazdığını görebiliriz.

Soru 2) Klavyeden okunan bir sayının asal çarpanlarını ekrana basan kodu yazınız.

Çözüm 2)

Yukarıdaki kodda görüldüğü üzere önce bir sayı okunmuş (kodun 7. Satırı) ardından bir döngü içerisinde, 2′den başlayarak bütün sayılara bu girilen sayıyı bölme denenmiştir. For döngüsünün (8. Satır) koşulu, sayının 1′den büyük olmasıdır. Dolayısıyla sayı 1 olunca yani bütün asal sayılara bölümü tamamlanınca çalışma duracaktır.

Yukarıdaki kodda bulunan iç döngü (9. Satırdaki while döngüsü) ise bir asal sayının birden fazla kere bölme ihtimaline karşı yazılmıştır. Örneğin 60 girdisi için 2 asal sayısı, 2 kere bölebilir. Bu durumda bir sonraki asal sayı ile deneme yapılmadan önce, şu anda bölmeyi denediğimiz asal sayı ile bölünmeyinceye kadar deneme yapıyoruz.

Kodun 11. Satırında ise, denediğimiz sayının, girilen sayıyı tam bölmesi durumunda bölerek sayıyı küçültüyor ve başarılı olarak bölebildiğimiz bu sayıyı bir çarpan olarak ekrana yazıyoruz.

Kodun örnek çalışması aşağıdaki şekildedir.

Soru 3) Bir dizgideki kelime sayısını ekrana bastıran kod yazınız.

Çözüm 3)

Soruda, girilen bir dizgideki (String) kelime sayısının saydırılması istendiği için, dizginin scanf ile okunması mümkün değildir. Bilindiği üzere scanf tek bir kelime okur ve bu durumda işe yaramaz. Birden fazla kelimenin boşlukları ile okunması istenen durumda gets fonksiyonu kullanılabilir. Yukarıdaki kodun 6. Satırında da bu şekilde dizgi okunmuştur. Ardından dizgide bulunan boşluklar dizgi sonuna kadar saydırılmıştır. Dizgi sonu kontrolü 8. Satırda bulunan for döngüsünde yapılırken, dizgi içerisinde o anda bakılan karakterin boşluk karakteri olup olmadığı 9. Satırdaki if kontrolü ile yapılmıştır. Şayet boşluk karakteri ise, kelimesayısı değişkeni 1 arttırılmıştır.

Basitçe hesaplanacağı üzere, bir dizgideki boşluk sayısı, kelime sayısından 1 eksik olur. Bu problemin çözümü için kelimesayısı değişkeni 0 yerine 1′den başlatılmıştır.

Kodun çalışan hali aşağıda verilmiştir.

Soru 4) Bir dizgideki en uzun kelimeyi bularak ekrana bastıran kodu yazınız

Çözüm 4)

Yukarıdaki kod, 3. Sorudaki koda benzer şekilde, dizgi sonuna kadar bütün karakterleri kontrol etmekte ve boşluk karakterlerinde kodun 15. Satırında bulunan if kontrolüne girmektedir. Bu kodda farklı olan bir özellik, iki adet karakter göstericisi (character pointer) ile dizgi üzerinde işaretleme yapılmasıdır.

Bu göstericilerden kelimebasi isimli gösterici, o ana kadar bulunan en uzun kelimeyi göstermekte, yenikelime göstericisi ise, üzerinden geçilen son kelimeyi göstermektedir.

Kodun çalışmasını aşağıdaki şekilde anlayabiliriz:

Yukarıda gösterildiği üzere, ilk başta iki gösterici de dizginin ilk karakterini göstermektedir. Ayrıca kelimeboyu ve yeniboy değişkenlerinin değeri 0′dır.

Ardından kodumuz döngü içerisinde karakter karakter ilerlemekte ve ilk boşluğu gördüğü anda aşağıdaki şekilde yeni kelim değişkeni hareket ettirilmektedir.

İlk boşluğa gösterici hareket ettirildikten sonra boşluğa kadar olan harf sayısı sayılmakta ve yeniboy 3 olmaktadır.

Tekrar bir boşluk karakterine kadar göstericimiz hareket eder:

Bulduğumuz yeni kelimenin boyu 4 olduğu ve şimdiye kadar bulduğumuz en uzun kelimeden daha uzun olduğu için kelimebasi göstericisini ilerletiyor ve yukarıdaki şekilde bulunan yeni kelimenin ilk karakterine atıyoruz, ayrıca yenikelime göstericisi, mevcut konuma ilerletiliyor ve bir sonraki kelimenin aranmasında kullanılıyor.

Yeni bulunan kelime boyu, o ana kadar bulunan kelime boyundan daha küçük olduğu için kelimebasi değişkenimiz hala o ana kadar bulunmuş en uzun kelimeyi göstermeye devam ediyor.

Bir önceki örnekte olduğu gibi, bulunan yeni kelimenin boyutu, ilk kelimeden büyük olmadığı için değişkenimiz ilerlemiyor.

Son olarak bulduğumuz yeni kelimenin boyu, şimdiye kadar bulunan kelimelerden uzun olduğu için, göstericiyi ilerletiyor ve kelimebasi olara bu kelimenin ilk harfini gösteriyoruz. Sonuçta dizgi sonuna kadar giderken, anlık olarak bir kelimenin boyutu değişkende tutuluyor, bir kelimenin boyutunun bu değişkende tutulan boyuttan daha uzun olması durumunda bu kelimeyi gösteren bir gösterici işaretleniyor ayrıca bu yeni kelimenin boyutu, elimizde o ana kadar bulunan en uzun kelime boyutu olarak tutuluyor.

Kodun çıktısı aşağıdaki şekildedir:

Soru 5) Kullanıcıdan bir sayı okuyarak, okunan bu sayı boyutlarında bir kare matrisi, her hücresine, en yakın kenara olan uzaklığı ile doldurunuz.

Çözüm 5)

Soruda her hücreye, en yakın kenara olan uzaklık yazılması istenmiş, bu durumda örneğin 5×5 boyutunda bir matris için aşağıdaki şekilde veri girilmesi gerekir:

Görüldüğü üzere kenar değerlerine 1 , bir içerdeki hücrelere 2 ve en ortadaki hücreye 3 yerleştirilmesi istenmiş.

Bu dorunun çözümünde sadece döngüler kullanılarak bir döngünün kenara olan uzaklığı hesaplanıp ekrana yazdırılabilir. Bu yöntemin çözümü aşağıdaki şekildedir:

Yukarıdaki kodda görüldüğü üzere, her hücre için, hücrenin kenara olan 4 farklı uzaklığı hesaplanmıştır. Bu değerlerden iki tanesi, koordinatları olan i ve j değerleridir ki bu değerler, sol kenara ve üst kenara olan uzaklık olarak düşünülebilir.

Ayrıca sağ kenar ve alt kenara olan uzaklıkların hesaplanması kodun 20. Ve 21. Satırlarında bulunan a ve b değişkenleri ile yapılmıştır. Matrisin boyutundan koordinat çıkarılmış ve 1 ilave edilmiştir.

Sonuçta elimizde 4 farklı kenara olan 4 farklı uzaklık bulunmaktadır. Bizden istenen bu uzaklıklardan en küçüğünü ekrana basmamız. Bu durumda kodun 4-13 satırları arasında bulunan ve verilen 4 sayıdan en küçüğünü döndüren fonksiyonu çağırarak bu 4 uzaklıktan en küçüğünü bulabiliriz.

Kodun çalışan hali aşağıdaki şekildedir:

2,800 views