Uzun zaman oldu ancak ilgilenebildim.. Şimdi kod şu oldu;

// Bu bir hesap makinası çalışmasıdır.. Henüz program çalışma aşamasındadır.
//
// Şu andaki hataları.
// --------------------
// 4 işlem şu an için eh işte çalışmaktadır. ancak henüz son aşamaya gelmemiştir
// Hesap makinası bu haliye sadece tamsayılarda işlem yapmaktadır.
// Hata kontrol mekanizmalarının bazıları programda varmış gibi gözüksede henüz çalışmamaktadır.
//  "," düğmesi henüz çalışmamaktadır.
// "," "-"  "/" ve "=" işlemleri henüz çalışmamaktadır.
// Ardarda farklı işlemler tıklandığında henüz çalışmamaktadır.

import gtk.Main;
import gtk.MainWindow;
import gtk.VBox;
import gtk.Grid;
import gtk.Label;
import gtk.Entry;
import gtk.Button;
import std.stdio : writeln;
import std.string : format;
// import std.algorithm : canFind;
import std.conv;

class Pencere : MainWindow {
// const işlemDüğmeleri = [ "+", "-", "*", "/", "=", "Sil", "Geri", "Kapat", "", "," ];
	long hafıza;
	long hafızaÇarpmaBölme=1;
	bool ekranTazele=false;
   VBox kutu;
   Entry ekran;
	Grid kalbur;
   Label etiket1;
   Button[] düğmeler;
	alias Tıklamaİşlevi = void delegate(Button);

   this() {
       super("İlkel Hesap Makinası..");

		// düğmelerin isim ve konumlalarını tutan DüğmeBilgisi adında bir yapı tasarlanıyor..
       struct DüğmeBilgisi {
			string isim;
			uint sıra;
			uint üstboşluk;
			uint genişlik;
			uint yükseklik;
			Tıklamaİşlevi işlev;
		}

		// bu yapıdan düğmeBilgileri adında nesnemizi oluşturuyoruz.
		DüğmeBilgisi[] düğmeBilgileri = [
				{ "Sil"  , 0, 0, 1, 1,&Sil},
				{ "Geri" , 1, 0, 1, 1,&Geri},
				{ ""	 , 1, 0, 1, 1,&Boş },
				{ "Kapat", 3, 0, 1, 1,&Kapat },
				{ "7"    , 0, 1, 1, 1,&Rakam },
				{ "8"    , 1, 1, 1, 1,&Rakam },
				{ "9"    , 2, 1, 1, 1,&Rakam },
				{ "/"    , 3, 1, 1, 1,&Bölme },
				{ "4"    , 0, 2, 1, 1,&Rakam },
				{ "5"    , 1, 2, 1, 1,&Rakam },
				{ "6"	 , 2, 2, 1, 1,&Rakam },
				{ "*"	 , 3, 2, 1, 1,&Çarpma },
				{ "1"	 , 0, 3, 1, 1,&Rakam },
				{ "2"	 , 1, 3, 1, 1,&Rakam },
				{ "3"	 , 2, 3, 1, 1,&Rakam },
				{ "-"	 , 3, 3, 1, 1,&Çıkarma },
				{ "0"	 , 0, 4, 1, 1,&Rakam },
				{ ","	 , 1, 4, 1, 1,&Virgül },
				{ "="	 , 2, 4, 1, 1,&Eşittir },
				{ "+"	 , 3, 4, 1, 1,&Toplama },
		];

		// Görsel bileşenlerin nesnelerini oluşturuyoruz
       kutu = new VBox(false, 2);
       kalbur = new Grid();
       ekran = new Entry();


       // Bileşen Ayarları..
       setSizeRequest(250, 230);
       move(200, 120);
       ekran.setAlignment(1);
		kalbur.setRowHomogeneous(true);
       kalbur.setColumnHomogeneous(true);
		kutu.packStart(ekran, false, false, 0);
       kutu.packEnd(kalbur, true, true, 0);

		// düğmeler nesnelerimizi oluşturup düğme isimlerini bunlara atıyoruz Ayrıca düğmeleri ekrana, daha önceden
		// tanımladığımız düğmeBilgileri yapısına göre yerleştiriyoruz..
       foreach (d; düğmeBilgileri) {
           düğmeler ~= new Button(d.isim);
           kalbur.attach(düğmeler[$-1], d.sıra, d.üstboşluk,d.genişlik,d.yükseklik);
           düğmeler[$-1].addOnClicked(d.işlev);
       }

		// görsel bileşenleripenceremize ekleyip tümünün ekranda görünmesini sağlıyoruz
       add(kutu);
       showAll();
   }

	void Rakam(Button düğme)  {
		writeln("Tıklama oldu ",düğme.getLabel()," Tıklandı");  // Kontrol...
		if (ekranTazele) {
			ekran.setText(to!string(""));
		}
		ekran.setText(ekran.getText() ~ düğme.getLabel());
		ekranTazele=false;
	}

	void Toplama(Button düğme)  {
		writeln("Çıkarma Tıklandı ",düğme.getLabel());  // Kontrol...
		ekran.setText(to!string((to!long(ekran.getText()))+hafıza));
		hafıza=to!long(ekran.getText());
		ekranTazele=true;
	}

	void Çıkarma(Button düğme)  {
       writeln("Çıkarma Tıklandı ",düğme.getLabel());  // Kontrol...
	}


	void Çarpma(Button düğme)  {
		writeln("Çarpma Tıklandı ",düğme.getLabel());  // Kontrol...
		ekran.setText(to!string((to!long(ekran.getText()))*hafızaÇarpmaBölme));
		hafızaÇarpmaBölme=to!long(ekran.getText());
		ekranTazele=true;
	}


	void Bölme(Button düğme)  {
		writeln("Bölme Tıklandı ",düğme.getLabel());  // Kontrol...
	}


	void Eşittir(Button düğme)  {
		writeln("Eşittir Tıklandı ",düğme.getLabel());  // Kontrol...
	}


	void Sil(Button düğme)  {
		writeln("Sil Tıklandı ",düğme.getLabel());  // Kontrol...
		ekran.setText("");
	}


	void Geri(Button düğme)  {
		writeln("Geri Tıklandı ",düğme.getLabel());  // Kontrol...

		if(ekran.getText()=="")  {
			ekran.setText("");
		}

		else if(((to!long(ekran.getText()))/10)==0)  {
			ekran.setText("");
		}

		else {
			ekran.setText(to!string((to!long(ekran.getText()))/10));
		}
	}


	void Boş(Button düğme)  {
		writeln("Boş Tıklandı.. O da neyse.. ",düğme.getLabel());  // Kontrol...
	}


	void Virgül(Button düğme)  {
		writeln("Virgül Tıklandı ",düğme.getLabel());  // Kontrol...
	}


	void Kapat(Button düğme)  {
		writeln("Kapat Tıklandı ",düğme.getLabel());  // Kontrol...
		Main.quit();
	}

}


void main(string[] args)
{
	Main.init(args);
	Pencere pencere= new Pencere();
	Main.run();
}

programın başında nelerin çalışmadığı yorumlama satırlrında yazılı. Açıkçası şimdilik benim için en büyük problem şu gözüküyor; diyelimki 25+78+32+23... yazdınız bunlarda sıkıntı yokken 25+78-32.. yazdığınızda düğme tıklandığı anda işlemi temsil eden işleve gittiğinden o işlevde son tıklanan işleme göre hareket ediyor.. Sanırım anlatmayı pek beceremedim biraz daha açıklayayım;
25 yazıp + ya tıkladığınızda Topla() işlevimize program gidiyor doğal olarak ardından 78 yazıp - ye tıkladığımızda yine doğal olarak - yi temsil eden Çıkarma() işlevine gidiyor bu durumda önceki "+" yani Topla() işlevinde yapılması gereken işlev yapılmamış oluyor :-)

Bu noktada sizden sadece gidişat konusunda yorum beklemekteyim.. Hani açıkçası birkaç saat uğraşmama rağmen bu sorunun belini kıramadım henüz.. Birde bu tür sorular sormam saçma mı oluyor yada bu şekilde değilde başka türlümü bir yöntem uygulasam soru sormak için bu konuda da hiç çekinmeden olumlu / olumsuz eleştirilerinizide beklemekteyim.

Programla ilgili Kendi düşüncemide aktarayım size.. Bence sorunun çözüm özeti şu; tıklama dört işlem buton tıklaması olduğunda ilk seferde bu işlemi bir yere alıp ardından ikinci sefer dört işlem buton tıklamasında önceki işlemi yapan işleve yönlenmesi gerekiyor..
Bunu aslında başarmam çok zor değil ancak her dört işlem tıklamasında program kendi işlem işlevine gittiğinden bunu halledemiyorum (Şimdilik :#: ) Belkide dörtişlem tıklaması olduğunda işlemin kendisini temsil eden işlevlere değilde öncelikle bir ayrı işleve yönlendirme yapsam ve ardından ordan işlem işlevlerine gidebilsem sanırım bu iş olur gibi geliyor bana
(dört işlem buton tıklaması= + ya basıldıysa Topla() işlevi çağrılıyor, * ya basılınca Çarpma() işlevi çağrılıyor )

--
[ Bu gönderi, http://ddili.org/forum'dan dönüştürülmüştür. ]

Bi yandan da diyorum acaba bukadar uğraşmak yerine girilen rakam ve dört işlemleri bir diziye okutsam ardından rakam ve stringlere göre işlemleri yaptırsam v.s.... Yahu insanın aklına bin tane fikir geliyor :scared: doğruları bulmak sanırım başta iyi bir sağlam temel arından tecrübe gerektiriyor ;-)

--
[ Bu gönderi, http://ddili.org/forum'dan dönüştürülmüştür. ]

Ben şöyle bir şey yaptım.

import gtk.Main;
import gtk.MainWindow;
import gtk.VBox;
import gtk.Grid;
import gtk.Label;
import gtk.Entry;
import gtk.Button;
import std.stdio : writeln;
import std.string : format;
import std.array: split;

import std.regex;
import std.conv;
import kuyruk;

class Pencere : MainWindow
{
   int rakam1,rakam2,işlem;
   string hafıza1,hafıza2;
   VBox kutu;
   Entry giriş1;
   Grid kalbur;
   Label etiket1;
   Button[] düğmeler;
   alias Tıklamaİşlevi = void delegate(Button);
   ÇiftUçluKuyruk sayılar, işleçler;
   int okumaKafası;

   this()
   {
       sayılar = ÇiftUçluKuyruk();
       işleçler = ÇiftUçluKuyruk();
       okumaKafası = 0;

       super("Hesap Makinesi");
       struct DüğmeBilgisi
       {
           string isim;
           uint sıra;
           uint üstboşluk;
           uint genişlik;
           uint yükseklik;
           Tıklamaİşlevi işlev;
       }

       DüğmeBilgisi[] düğmeBilgileri = [
           { "Sil"  , 0, 0, 1, 1, null },
           { "Geri" , 1, 0, 1, 1, null },
           { ""     , 1, 0, 1, 1, null },
           { "Kapat", 3, 0, 1, 1, null },
           { "7"    , 0, 1, 1, 1,&Rakam },
           { "8"    , 1, 1, 1, 1,&Rakam },
           { "9"    , 2, 1, 1, 1,&Rakam },
           { "÷"    , 3, 1, 1, 1,&Dörtİşlem },
           { "4"    , 0, 2, 1, 1,&Rakam },
           { "5"    , 1, 2, 1, 1,&Rakam },
           { "6"     , 2, 2, 1, 1,&Rakam },
           { "×"     , 3, 2, 1, 1,&Dörtİşlem },
           { "1"     , 0, 3, 1, 1,&Rakam },
           { "2"     , 1, 3, 1, 1,&Rakam },
           { "3"     , 2, 3, 1, 1,&Rakam },
           { "-"     , 3, 3, 1, 1,&Dörtİşlem },
           { "0"     , 0, 4, 1, 1,&Rakam },
           { ","     , 1, 4, 1, 1,null },
           { "="     , 2, 4, 1, 1,&Eşittir },
           { "+"     , 3, 4, 1, 1,&Dörtİşlem },
                                        ];

       kutu = new VBox(false, 2);
       kalbur = new Grid();
       giriş1 = new Entry();
       setSizeRequest(250, 230);
       move(200, 120);
       giriş1.setAlignment(1);
       kalbur.setRowHomogeneous(true);
       kalbur.setColumnHomogeneous(true);
       kutu.packStart(giriş1, false, false, 0);
       kutu.packEnd(kalbur, true, true, 0);

       add(kutu);


       foreach (d; düğmeBilgileri)
       {
           düğmeler ~= new Button(d.isim);
           kalbur.attach(düğmeler[$-1], d.sıra, d.üstboşluk,d.genişlik,d.yükseklik);
           düğmeler[$-1].addOnClicked(d.işlev);
       }

       showAll();
   }
   void Rakam(Button düğme)
   {
       auto ekran = giriş1.getText();
       giriş1.setText(ekran ~ düğme.getLabel());
   }

   void Dörtİşlem(Button düğme)
   {
       auto okunan = giriş1.getText[okumaKafası .. $].length;
       writeln("Okunan karakter sayısı ", okunan);
       auto okunandeğer = giriş1.getText[okumaKafası .. $];
       writeln("Okunan değer ", okunandeğer);
       sayılar ~= to!int(okunandeğer);
       //işleçler ~= düğme.getLabel();

       okumaKafası = okumaKafası + cast(int)okunan + 1;
       writeln("Okuma kafası ", okumaKafası);

       giriş1.setText(giriş1.getText ~ düğme.getLabel());

   }

   void Eşittir(Button düğme)
   {

   }


}

void main(string[] args)
{
   Main.init(args);
   Pencere pencere= new Pencere();
   Main.run();
}

Bu çift uçlu kuyruğu da bu derste buldum (http://ddili.org/ders/d/islec_yukleme.html)

Kolaylık olması açısından onun kodunu da paylaşayım:

import std.stdio;
import std.string;
import std.conv;

struct ÇiftUçluKuyruk
{
private:

   /* Elemanlar bu iki üyenin hayalî olarak uç uca
    * gelmesinden oluşurlar. Ancak, 'baş' ters sırada
    * kullanılır: İlk eleman baş[$-1]'dir, ikinci eleman
    * baş[$-2]'dir, vs.
    *
    *   baş[$-1], baş[$-2], ... baş[0], son[0], ... son[$-1]
    */
   int[] baş;    // baş taraftaki elemanlar
   int[] son;    // son taraftaki elemanlar

   /* Belirtilen konumdaki elemanın hangi dilimde olduğunu
    * bulur ve o elemana bir referans döndürür. */
   ref inout(int) eleman(size_t konum) inout {
       return (konum < baş.length
               ? baş[$ - 1 - konum]
               : son[konum - baş.length]);
   }

public:

   string toString() const {

       string sonuç;

       foreach_reverse (eleman; baş) {
           sonuç ~= format("%s ", to!string(eleman));
       }

       foreach (eleman; son) {
           sonuç ~= format("%s ", to!string(eleman));
       }

       return sonuç;
   }

   /* Not: Sonraki bölümlerde göreceğimiz olanaklardan
    * yararlanıldığında toString() çok daha etkin olarak
    * aşağıdaki gibi de yazılabilir: */
   version (none) {
       void toString(void delegate(const(char)[]) hedef) const {
           import std.format;
           import std.range;

           formattedWrite(
               hedef, "%(%s %)", chain(baş.retro, son));
       }
   }

   /* Başa eleman ekler. */
   void başınaEkle(int değer) {
       baş ~= değer;
   }

   /* Sona eleman ekler.
    *
    * Örnek: kuyruk ~= değer
    */
   ref ÇiftUçluKuyruk opOpAssign(string işleç)(int değer)
           if (işleç == "~") {
       son ~= değer;
       return this;
   }

   /* Belirtilen elemanı döndürür.
    *
    * Örnek: kuyruk[konum]
    */
   inout(int) opIndex(size_t konum) inout {
       return eleman(konum);
   }

   /* Tekli işleci belirtilen elemana uygular.
    *
    * Örnek: ++kuyruk[konum]
    */
   int opIndexUnary(string işleç)(size_t konum) {
       mixin ("return " ~ işleç ~ "eleman(konum);");
   }

   /* Belirtilen elemana belirtilen değeri atar.
    *
    * Örnek: kuyruk[konum] = değer
    */
   int opIndexAssign(int değer, size_t konum) {
       return eleman(konum) = değer;
   }

   /* Belirtilen değeri belirtilen işlemde kullanır ve sonucu
    * belirtilen elemana atar.
    *
    * Örnek: kuyruk[konum] += değer
    */
   int opIndexOpAssign(string işleç)(int değer, size_t konum) {
       mixin ("return eleman(konum) " ~ işleç ~ "= değer;");
   }

   /* Uzunluk anlamına gelen $ karakterini tanımlar.
    *
    * Örnek: kuyruk[$ - 1]
    */
   size_t opDollar() const {
       return baş.length + son.length;
   }
}

--
[ Bu gönderi, http://ddili.org/forum'dan dönüştürülmüştür. ]

Ali hocanın yazdığı kuyruğu diğer türlerle çalışacak şekilde değiştirdim.

import std.stdio;
import std.string;
import std.conv;

struct ÇiftUçluKuyruk(T)
{
private:

   T[] baş;
   T[] son;

   ref inout(T) eleman(size_t konum) inout {
       return (konum < baş.length
               ? baş[$ - 1 - konum]
               : son[konum - baş.length]);
   }

public:

   string toString() const {

       string sonuç;

       foreach_reverse (eleman; baş) {
           sonuç ~= format("%s ", to!string(eleman));
       }

       foreach (eleman; son) {
           sonuç ~= format("%s ", to!string(eleman));
       }

       return sonuç;
   }

   version (none) {
       void toString(void delegate(const(char)[]) hedef) const {
           import std.format;
           import std.range;

           formattedWrite(
               hedef, "%(%s %)", chain(baş.retro, son));
       }
   }


   void başınaEkle(T değer) {
       baş ~= değer;
   }

   ref ÇiftUçluKuyruk opOpAssign(string işleç)(T değer)
           if (işleç == "~") {
       son ~= değer;
       return this;
   }

   inout(T) opIndex(size_t konum) inout {
       return eleman(konum);
   }

   T opIndexUnary(string işleç)(size_t konum) {
       mixin ("return " ~ işleç ~ "eleman(konum);");
   }

   T opIndexAssign(T değer, size_t konum) {
       return eleman(konum) = değer;
   }

   T opIndexOpAssign(string işleç)(T değer, size_t konum) {
       mixin ("return eleman(konum) " ~ işleç ~ "= değer;");
   }

   size_t opDollar() const {
       return baş.length + son.length;
   }
}

Kod kısmı da şu şekilde oldu. Şimdi sayıları bir kuyruğa, işleçleri bir kuyruğa atıyor. En azından atması lazım :-)

import gtk.Main;
import gtk.MainWindow;
import gtk.VBox;
import gtk.Grid;
import gtk.Label;
import gtk.Entry;
import gtk.Button;
import std.stdio : writeln;
import std.string : format;
import std.array: split;

import std.regex;

import std.conv;
import kuyruk;

class Pencere : MainWindow
{
   int rakam1,rakam2,işlem;
   string hafıza1,hafıza2;
   VBox kutu;
   Entry giriş1;
   Grid kalbur;
   Label etiket1;
   Button[] düğmeler;
   alias Tıklamaİşlevi = void delegate(Button);
   ÇiftUçluKuyruk!int sayılar;
   ÇiftUçluKuyruk!string işleçler;

   int okumaKafası;


   this()
   {
       sayılar = ÇiftUçluKuyruk!int();
       işleçler = ÇiftUçluKuyruk!string();
       okumaKafası = 0;


       super("Hesap Makinesi");
       struct DüğmeBilgisi
       {
           string isim;
           uint sıra;
           uint üstboşluk;
           uint genişlik;
           uint yükseklik;
           Tıklamaİşlevi işlev;
       }

       DüğmeBilgisi[] düğmeBilgileri = [
           { "Sil"  , 0, 0, 1, 1, null },
           { "Geri" , 1, 0, 1, 1, null },
           { ""     , 1, 0, 1, 1, null },
           { "Kapat", 3, 0, 1, 1, null },
           { "7"    , 0, 1, 1, 1,&Rakam },
           { "8"    , 1, 1, 1, 1,&Rakam },
           { "9"    , 2, 1, 1, 1,&Rakam },
           { "÷"    , 3, 1, 1, 1,&Dörtİşlem },
           { "4"    , 0, 2, 1, 1,&Rakam },
           { "5"    , 1, 2, 1, 1,&Rakam },
           { "6"     , 2, 2, 1, 1,&Rakam },
           { "×"     , 3, 2, 1, 1,&Dörtİşlem },
           { "1"     , 0, 3, 1, 1,&Rakam },
           { "2"     , 1, 3, 1, 1,&Rakam },
           { "3"     , 2, 3, 1, 1,&Rakam },
           { "-"     , 3, 3, 1, 1,&Dörtİşlem },
           { "0"     , 0, 4, 1, 1,&Rakam },
           { ","     , 1, 4, 1, 1,null },
           { "="     , 2, 4, 1, 1,&Eşittir },
           { "+"     , 3, 4, 1, 1,&Dörtİşlem },
                                        ];

       kutu = new VBox(false, 2);
       kalbur = new Grid();
       giriş1 = new Entry();
       setSizeRequest(250, 230);
       move(200, 120);
       giriş1.setAlignment(1);
       kalbur.setRowHomogeneous(true);
       kalbur.setColumnHomogeneous(true);
       kutu.packStart(giriş1, false, false, 0);
       kutu.packEnd(kalbur, true, true, 0);

       add(kutu);


       foreach (d; düğmeBilgileri)
       {
           düğmeler ~= new Button(d.isim);
           kalbur.attach(düğmeler[$-1], d.sıra, d.üstboşluk,d.genişlik,d.yükseklik);
           düğmeler[$-1].addOnClicked(d.işlev);
       }

       showAll();
   }
   void Rakam(Button düğme)
   {
       auto ekran = giriş1.getText();
       giriş1.setText(ekran ~ düğme.getLabel());
   }

   void Dörtİşlem(Button düğme)
   {
       auto okunan = giriş1.getText[okumaKafası .. $].length;
       writeln("Okunan karakter sayısı ", okunan);
       auto okunandeğer = giriş1.getText[okumaKafası .. $];
       writeln("Okunan değer ", okunandeğer);
       sayılar ~= to!int(okunandeğer);
       auto işleç = düğme.getLabel();
       işleçler ~= işleç;

       okumaKafası = to!int(okumaKafası + okunan + işleç.length);
       writeln("Okuma kafası ", okumaKafası);

       writeln("Sayılar ", sayılar);
       writeln("İşleçler ", işleçler);

       giriş1.setText(giriş1.getText ~ düğme.getLabel());

   }

   void Eşittir(Button düğme)
   {

   }

}

void main(string[] args)
{
   Main.init(args);
   Pencere pencere= new Pencere();
   Main.run();
}

--
[ Bu gönderi, http://ddili.org/forum'dan dönüştürülmüştür. ]

müthiş bilgiler geldi..
Erdem hocam çok iyi anlatmışsın ancak bir süre mola verip bu konuları sindirmem lazım çünkü bir tık seviyemin üzerinde hafiften..

Ali hocam sizin bahsettiğiniz yöntemde süper..
bu bilgilerden sonra biraz mola verip hem D öğrenmeye devam edecek hemde programı artık çalışır vaziyette yapıp paylaşacağım o zamana kadar bu konu şimdilik beklemede olacak ..
çok çok teşekkürler hazine değerindeki farklı bilgiler için :blush:

--
[ Bu gönderi, http://ddili.org/forum'dan dönüştürülmüştür. ]

Ben mesajı yollayana kadar sen kodu yollamışsın Erdem hocam :-)
ben yarın deneyeceğim artık eksik kalan yerleri varsa yukardaki mesaja ek olarak onu tamamlarım artık ;-)

--
[ Bu gönderi, http://ddili.org/forum'dan dönüştürülmüştür. ]

Ya da işte diyelim

'2452 * (3 * 6 + 1) * 6 / 235'

gibi bir ifadeyi ilkönce işleyip

'['2452', '', '(', '3', '', '6', '+', '1', ')', '*', '6', '/', '235']'

sonra sonucunu hesaplatmak daha mantıklı olabilir.

'1189.4808510638297'

--
[ Bu gönderi, http://ddili.org/forum'dan dönüştürülmüştür. ]

Anlaşılan, işlemin işlem tuşuna basıldığında yapılması yanlış oluyor. Hesap makinesinin iki bilgi saklaması gerekiyor:

• İlk değer
• İşlem

Hesabı, eşittir veya bir işlem tuşuna basıldığında bu sakladığı bilgiyi kullanarak yapması gerekiyor.

Ek bilgi olarak, bu hesap makinesi alışık olduğumuz gibi, infix gösterimde çalışıyor. Yani, işlem iki değerin arasına yazılıyor: 2 + 3. İşlemin sonradan yazıldığı postfix gösterimi daha kolaydır: 2 3 +. Postfix'te değerler önce yığıta yazılır (ek bir push düğmesiyle), işlem geldiğinde iki değer çekilir ve hesap yapılır: 2, push, 3, push, +. +'nın hesap olarak yaptığı da şunun benzeridir a=pop, b=pop, a+b.

Ali

--
[ Bu gönderi, http://ddili.org/forum'dan dönüştürülmüştür. ]

Programın son hali şu şekilde oldu. Bu iletide (http://ddili.org/forum/post/13263) bahsettiğim yığıtı kullanıyor.

Tabi bu programda benim düşünceme göre girilen matematiksel ifadeyi işlemek daha güzel olabilirdi.

import gtk.Main;
import gtk.MainWindow;
import gtk.VBox;
import gtk.Grid;
import gtk.Label;
import gtk.Entry;
import gtk.Button;
import std.stdio : writeln;
import std.string : format;
import std.array: split;

import std.regex;

import std.conv;
import yığıt;

class Pencere : MainWindow
{
   int rakam1,rakam2,işlem;
   string hafıza1,hafıza2;
   VBox kutu;
   Entry giriş1;
   Grid kalbur;
   Label etiket1;
   Button[] düğmeler;
   alias Tıklamaİşlevi = void delegate(Button);
   TamsayıYığıt sayılar;
   DizgeYığıt işleçler;

   int okumaKafası;


   this()
   {
       sayılar = new TamsayıYığıt();
       işleçler = new DizgeYığıt();
       okumaKafası = 0;


       super("Hesap Makinesi");
       struct DüğmeBilgisi
       {
           string isim;
           uint sıra;
           uint üstboşluk;
           uint genişlik;
           uint yükseklik;
           Tıklamaİşlevi işlev;
       }

       DüğmeBilgisi[] düğmeBilgileri = [
           { "Sil"  , 0, 0, 1, 1, null },
           { "Geri" , 1, 0, 1, 1, null },
           { ""     , 1, 0, 1, 1, null },
           { "Kapat", 3, 0, 1, 1, null },
           { "7"    , 0, 1, 1, 1,&Rakam },
           { "8"    , 1, 1, 1, 1,&Rakam },
           { "9"    , 2, 1, 1, 1,&Rakam },
           { "÷"    , 3, 1, 1, 1,&Dörtİşlem },
           { "4"    , 0, 2, 1, 1,&Rakam },
           { "5"    , 1, 2, 1, 1,&Rakam },
           { "6"     , 2, 2, 1, 1,&Rakam },
           { "×"     , 3, 2, 1, 1,&Dörtİşlem },
           { "1"     , 0, 3, 1, 1,&Rakam },
           { "2"     , 1, 3, 1, 1,&Rakam },
           { "3"     , 2, 3, 1, 1,&Rakam },
           { "-"     , 3, 3, 1, 1,&Dörtİşlem },
           { "0"     , 0, 4, 1, 1,&Rakam },
           { ","     , 1, 4, 1, 1,null },
           { "="     , 2, 4, 1, 1,&Eşittir },
           { "+"     , 3, 4, 1, 1,&Dörtİşlem },
                                        ];

       kutu = new VBox(false, 2);
       kalbur = new Grid();
       giriş1 = new Entry();
       setSizeRequest(250, 230);
       move(200, 120);
       giriş1.setAlignment(1);
       kalbur.setRowHomogeneous(true);
       kalbur.setColumnHomogeneous(true);
       kutu.packStart(giriş1, false, false, 0);
       kutu.packEnd(kalbur, true, true, 0);

       add(kutu);


       foreach (d; düğmeBilgileri)
       {
           düğmeler ~= new Button(d.isim);
           kalbur.attach(düğmeler[$-1], d.sıra, d.üstboşluk,d.genişlik,d.yükseklik);
           düğmeler[$-1].addOnClicked(d.işlev);
       }

       showAll();
   }
   void Rakam(Button düğme)
   {
       auto ekran = giriş1.getText();
       giriş1.setText(ekran ~ düğme.getLabel());
   }

   void Dörtİşlem(Button düğme)
   {
       auto okunan = giriş1.getText[okumaKafası .. $].length;
       writeln("Okunan karakter sayısı ", okunan);
       auto okunandeğer = giriş1.getText[okumaKafası .. $];
       writeln("Okunan değer ", okunandeğer);
       sayılar.ekle(to!int(okunandeğer));
       auto işleç = düğme.getLabel();
       işleçler.ekle(işleç);

       okumaKafası = to!int(okumaKafası + okunan + işleç.length);
       writeln("Okuma kafası ", okumaKafası);

       giriş1.setText(giriş1.getText ~ düğme.getLabel());

   }

   void Eşittir(Button düğme)
   {
       auto okunan = giriş1.getText[okumaKafası .. $].length;
       writeln("Okunan karakter sayısı ", okunan);
       auto okunandeğer = giriş1.getText[okumaKafası .. $];
       writeln("Okunan değer ", okunandeğer);
       sayılar.ekle(to!int(okunandeğer));

       while(!işleçler.boşMu())
           işlemYap();
       auto sonuç = sayılar.çıkar();
       giriş1.setText(to!string(sonuç));
       okumaKafası = 0;
       sayılar.ekle(sonuç);
       //writeln("Okuma kafası", okumaKafası);
       //writeln("Sonuç ", sonuç);

   }

   void işlemYap()
   {
       auto sonuç = hesapla(sayılar.çıkar(), sayılar.çıkar(), işleçler.çıkar());
       sayılar.ekle(sonuç);
   }

   auto hesapla(int ilk, int ikinci, string işleç)
   {
       //writeln("İşleç:", işleç);

       if (işleç == "+")
           return ilk + ikinci;
       else if (işleç == "-")
           return ilk - ikinci;
       else if (işleç == "×")
           return ilk * ikinci;
       else if (işleç == "÷")
       {
           return ikinci / ilk;
       }

       return 0;
   }

}

void main(string[] args)
{
   Main.init(args);
   Pencere pencere= new Pencere();
   Main.run();
}

--
[ Bu gönderi, http://ddili.org/forum'dan dönüştürülmüştür. ]

Ondalık sayılarla da doğru şekilde çalışabilmesi için double sayı türü kullandım. Tamsayı yığıt tanımlaması da
'alias TamsayıYığıt = Yığıt!double;' şeklinde değişti.

import gtk.Main;
import gtk.MainWindow;
import gtk.VBox;
import gtk.Grid;
import gtk.Label;
import gtk.Entry;
import gtk.Button;
import std.stdio : writeln;
import std.string : format;
import std.array: split;

import std.regex;

import std.conv;
import yığıt;

class Pencere : MainWindow
{
   int rakam1,rakam2,işlem;
   string hafıza1,hafıza2;
   VBox kutu;
   Entry giriş1;
   Grid kalbur;
   Label etiket1;
   Button[] düğmeler;
   alias Tıklamaİşlevi = void delegate(Button);
   TamsayıYığıt sayılar;
   DizgeYığıt işleçler;

   int okumaKafası;


   this()
   {
       sayılar = new TamsayıYığıt();
       işleçler = new DizgeYığıt();
       okumaKafası = 0;


       super("Hesap Makinesi");
       struct DüğmeBilgisi
       {
           string isim;
           uint sıra;
           uint üstboşluk;
           uint genişlik;
           uint yükseklik;
           Tıklamaİşlevi işlev;
       }

       DüğmeBilgisi[] düğmeBilgileri = [
           { "Sil"  , 0, 0, 1, 1, null },
           { "Geri" , 1, 0, 1, 1, null },
           { ""     , 1, 0, 1, 1, null },
           { "Kapat", 3, 0, 1, 1, null },
           { "7"    , 0, 1, 1, 1,&Rakam },
           { "8"    , 1, 1, 1, 1,&Rakam },
           { "9"    , 2, 1, 1, 1,&Rakam },
           { "÷"    , 3, 1, 1, 1,&Dörtİşlem },
           { "4"    , 0, 2, 1, 1,&Rakam },
           { "5"    , 1, 2, 1, 1,&Rakam },
           { "6"     , 2, 2, 1, 1,&Rakam },
           { "×"     , 3, 2, 1, 1,&Dörtİşlem },
           { "1"     , 0, 3, 1, 1,&Rakam },
           { "2"     , 1, 3, 1, 1,&Rakam },
           { "3"     , 2, 3, 1, 1,&Rakam },
           { "-"     , 3, 3, 1, 1,&Dörtİşlem },
           { "0"     , 0, 4, 1, 1,&Rakam },
           { ","     , 1, 4, 1, 1,null },
           { "="     , 2, 4, 1, 1,&Eşittir },
           { "+"     , 3, 4, 1, 1,&Dörtİşlem },
                                        ];

       kutu = new VBox(false, 2);
       kalbur = new Grid();
       giriş1 = new Entry();
       setSizeRequest(250, 230);
       move(200, 120);
       giriş1.setAlignment(1);
       kalbur.setRowHomogeneous(true);
       kalbur.setColumnHomogeneous(true);
       kutu.packStart(giriş1, false, false, 0);
       kutu.packEnd(kalbur, true, true, 0);

       add(kutu);


       foreach (d; düğmeBilgileri)
       {
           düğmeler ~= new Button(d.isim);
           kalbur.attach(düğmeler[$-1], d.sıra, d.üstboşluk,d.genişlik,d.yükseklik);
           düğmeler[$-1].addOnClicked(d.işlev);
       }

       showAll();
   }
   void Rakam(Button düğme)
   {
       auto ekran = giriş1.getText();
       giriş1.setText(ekran ~ düğme.getLabel());
   }

   void Dörtİşlem(Button düğme)
   {
       writeln("Buraya geldik");
       auto okunan = giriş1.getText[okumaKafası .. $].length;
       writeln("Okunan karakter sayısı ", okunan);
       auto okunandeğer = giriş1.getText[okumaKafası .. $];
       writeln("Okunan değer ", okunandeğer);

       /+
          Burayı 'Unexpected ',' when converting from type string to type
          double' hatasından dolayı ekledim
       +/
       import std.algorithm;
       import std.string;

       if (canFind(okunandeğer, ','))
       {
           writeln("Buldum");
           okunandeğer = okunandeğer.replace(",",".");
           writeln("Değiştikten sonra ", okunandeğer);
       }



       sayılar.ekle(to!double(okunandeğer));

       auto işleç = düğme.getLabel();
       işleçler.ekle(işleç);

       okumaKafası = to!int(okumaKafası + okunan + işleç.length);
       //writeln("Okuma kafası ", okumaKafası);

       giriş1.setText(giriş1.getText ~ düğme.getLabel());

   }

   void Eşittir(Button düğme)
   {


       auto okunan = giriş1.getText[okumaKafası .. $].length;
       writeln("Okunan karakter sayısı ", okunan);
       auto okunandeğer = giriş1.getText[okumaKafası .. $];
       writeln("Okunan değer ", okunandeğer);
       sayılar.ekle(to!double(okunandeğer));

       while(!işleçler.boşMu())
           işlemYap();
       auto sonuç = sayılar.çıkar();
       giriş1.setText(to!string(sonuç));
       okumaKafası = 0;
       sayılar.ekle(sonuç);
       writeln("Okuma kafası", okumaKafası);
       writeln("Sonuç ", sonuç);

   }

   void işlemYap()
   {
       auto sonuç = hesapla(sayılar.çıkar(), sayılar.çıkar(), işleçler.çıkar());
       sayılar.ekle(sonuç);
   }

   auto hesapla(double ilk, double ikinci, string işleç)
   {
       //writeln("İşleç:", işleç);

       if (işleç == "+")
           return ilk + ikinci;
       else if (işleç == "-")
           return ilk - ikinci;
       else if (işleç == "×")
           return ilk * ikinci;
       else if (işleç == "÷")
       {
           return ikinci / ilk;
       }

       return 0;
   }

}

void main(string[] args)
{
   Main.init(args);
   Pencere pencere= new Pencere();
   Main.run();
}

--
[ Bu gönderi, http://ddili.org/forum'dan dönüştürülmüştür. ]