Her Yönüyle C#’da Yığın (Stack) Sınıfı

Her Yönüyle C#’da Yığın (Stack) Sınıfı

Bu yazımızda önemli veri yapılarından olan yığın (Stack) veri yapılarına giriş yapacağız. Yığın veri yapılarının çalışma mantıklarını anladıktan sonra .NET sınıf kitaplıklarında yeralan Stack sınıfını C#’da nasıl kullanacağımızı inceleyeceğiz.

1. Yığın veri Yapısının Çalışma Şekli

Yığınlar genelde aynı tipten verilerin tutulduğu ve Son Giren İlk Çıkar (LIFO) çalışma mantğını kullanan veri yapıları olarak tanımlanır. Bir yığına en son giren eleman ilk olarak çıkar. Yığınları anlatırken en çok üst üste konmuş tabaklar veya herhangi bir nesne grubunda çok kullanılana benzetirler. Mesela bir masanın üstünde sıra ile üst üste konmuş birden fazla tabaktan birisine ihtiyacımız olursa önce en üsttekini alırız. Bu aldığımız tabakların en son konulanıdır.

Yığınların çalışma prensibini daha iyi kavramak için yandaki canladırmayı inceleyelim. Canlandırmada yığının dışında bulunan sayıları yığının içine koymak için “Yığını Doldur” düğmesine tıkladığımızda sırası ile 17, 23, 4, 55 ve 8’i yığına sokuyor. Yığın doluyken “Yığını Boşalt” düğmesine tıklayınca ise yığındaki sayıların yerleştirildikleri sıranın tersi sıra ile boşaltır. Bu durumda en son giren 8 sayısı ilk önce, sonra 55, sonra 4 ve bu sıra ile en son 17 sayısı yığından dışarı çıkar.

2. .NET Sınıf Kütüphanesi Yığın Sınıfı (Stack)

.NET sınıf kütüphanesinde yığın veri yapısını kullanmak için Stack sınıfını kullanırız. Normalde C ve C++ dillerinde yığın veri yapısını değişik veri türleri ve kendi tanımladığımız sınıflarla birlikte kullanmak zahmetli bir işti. (C’de sınıf kavramı yoktur!) Ama .NET ortamında yığınlarımız bize birçok konuda esneklikler sunarak programlamayı daha zevkli ve verimli hale getiriyor.

.NET’in yığın (Stack) sınıfını kullanmak için program kodunun baş tarafına using System.Collections; eklememiz gerekir. Buradan yığın sınıfı System.Collections isim alanında bulunuyor sonucunu da çıkartırız.

C# veya herhangi bir dilde yazılan yığın veri yapılarında Push(), Pop(), Peek() veya Top(), Clear() fonksiyonları ve Count, özelliği temel olarak bulunur. Temel fonksiyonların yanında Clone(), CopyTo(), ToArray(), Contains() ve Equals() metodları .NET’in yığın sınıfında yeralır.

Yığın sınıfının Push() metodu yığına yeni bir eleman ekler. Pop() metodu ile yığının en üstündeki elemanı yığından siler ve silinen elemanı geriye döndürür. Eğer yığının tepesindeki elemanı öğrenmek istersek Peek() medodu işimize yarar. Bu metod yığının tepesindeki nesneyi döndürür ama bu nesneyi yığından silmez.

using System;
using System.Collections; // Stack sınıfı bu isim alanı içinde bulunur.
class YiginSinifi1
{
      public static void Main(string[] args)
      {
            // Stack sınıfından yigin nesnemizi tanımlıyoruz.
            Stack yigin = new Stack();

            // Yigini değişik değerlerde dolduruyoruz..
            yigin.Push(12);
            yigin.Push(5);
            yigin.Push(23);
            yigin.Push(34);
            yigin.Push(70);
            yigin.Push(8);

Console.WriteLine(“Yığımızın ilk hali…”);
ElemanlariYaz(yigin);

            // Yigininin tepesinden bir sayı aldık
            // ve bunu sayi değişkenine atayıp ekrana yazdıralım
            int sayi = (int) yigin.Pop();
            Console.WriteLine(“\n Yığından {0} sayısını aldık”, sayi);

            // Yigininin tepesinden bir sayı daha aldık
            // ve bunu sayi değişkenine atayıp ekrana yazdıralım
            sayi = (int)yigin.Pop();
            Console.WriteLine(“\n Yığından {0} sayısını aldık”, sayi);

            // Şimdi ise Yigininin tepesindeki sayıya bir bakalım
            // bu sayıyı yığından çıkarmıyoruz.. Sadece ne olduğuna bakıyoruz..
            sayi = (int) yigin.Peek();
            Console.WriteLine(“\n Yığının tepesindeki sayı şu anda : {0}”, sayi);

Console.ReadLine();

}

      public static void ElemanlariYaz(Stack yigin)
      {
            object obj = new Object();
            Stack yeniYigin = (Stack)yigin.Clone();

            if(yigin.Count!=0)
            {
                  while(yeniYigin.Count>0)
                  {
                       obj = yeniYigin.Pop();
                       Console.WriteLine(“\t”+ obj.ToString());
                  }
            }
            else Console.WriteLine(“Yığın boş…!”);
      }
}

Yukarıdaki programda önce Stack sınıfından yigin isimli bir nesne oluşturuyoruz. Sonraki altı satırda yığınımıza 12, 5, 23, 34, 70 ve 8 tamsayılarını Push() metodu ile ekliyoruz. EkranaYaz() ismini verdiğimiz static fonksiyonumuz (bu fonksiyon tam olarak optimize edilmiş bir fonksiyon değil! ) ile yığınımızda bulunan elemanları ekrana yazdırıyoruz. Daha sonra yığından iki tane elemanı Pop() metodu yardımıyla alıyor ve herbirini ekrana yazdırıyoruz. Programın son kısmında ise Peek() metodunu kullanarak yığının en üstündeki elemanın ne olduğunu öğreniyoruz.

Yığın sınıflarında bulunan diğer iki temel fonksiyonlar olan Count özelliği ve Clear() metodlarıdır. Bunlardan Count, yığın nesnesinde bulunan elemanların sayısını geriye döndüren bir özelliktir. Özellikler C# dilinde sınıflarda bulunan üye değişkenlerin değerlerini öğrenmemize ve onların değerlerini değiştirmemize yarayan bir tür fonksiyonlardır. Count özelliği eleman sayısını int tipinde döndürür ve sadece okunabilen (readonly) yapıdadır. Özellikler program içinde çağrılırken parantezleri kullanmayız. Eğer yigini boşaltmak/temizlemek istersek Clean() metodu işimizi yarayacaktır. Clean() metodu hiçbir parametre almaz ve hiçbir şey döndürmez. Herhangi bir yığın nesnesinin içinde bir elemanın olup olmadığını anlamak için Contains() metodu kullanılır. Bu metod aranacak nesneyi alır ve geriye true veya false değerlerini döndürür. İsterseniz aşağıdaki programda Contains() ve Clear() metodları ile Count özelliklerini nasıl kullanabileceğimizi görelim:

            // Yığınımıza yeni elemanlar ekliyoruz.
            yigin.Push(“Ahmet”);
            yigin.Push(“Sefer”);
            yigin.Push(“Cemal”);
            yigin.Push(“Onur”);
            yigin.Push(“Aziz”);

            // Yığında kaç tane eleman bulunduğunu bulup yazalım.
            int elemanSayisi= yigin.Count;
            Console.WriteLine(“\nYığınımızdaki eleman sayısı: {0}”, elemanSayisi);

            // Yığındaki elemanlar.
            Console.WriteLine(“\nYığındaki elemanlar: “);
            ElemanlariYaz(yigin);

            //Contains() metodunun kullanımı:
            if(yigin.Contains(“Sefer”))
                  Console.WriteLine(“\nYığında Sefer elemanı var…”);
            else
                  Console.WriteLine(“\nYığında Sefer elemanı yok…”);

// Yığını boşaltalım.
yigin.Clear();

            // Yığını boşalttıktan sonra kaç tane eleman bulunduğunu bulup yazalım.
            elemanSayisi= yigin.Count;
            Console.WriteLine(“\nYığınımızdaki eleman sayısı: {0}”, elemanSayisi);

Console.ReadLine();
}

      public static void ElemanlariYaz(Stack yigin)
      {
            object obj = new Object();
            Stack yeniYigin = (Stack)yigin.Clone();

Hemen üstteki programdan önceki programda yığınımıza int tipinden nesneler (c#’ta primitive türler dahil herşey nesnedir!) yerleştirmiştik. Bu örnekte ise string sınıfına ait nesneleri yığınımıza ekledik ve onlar üzerinde işlemler yaptık. Yani yığın sınıfımız herhangi bir nesneyi tutabilecek yetenekler sabit. İster temel veri türleri olsun (int, byte, double veya bool) ister kendi tanımladığımız veri türleri olsun yığın sınıfımıza ekleyip çıkartabiliriz.

Yukarıdaki programda yigin olarak oluşturduğumuz ve yığın sınıfındaki nesnemize beş tane veriyi ekliyoruz. Sonra yığında kaç tane eleman olduğunu bulmak için Count özelliğinden faydalanıyoruz. Yığındaki elemanları yazdırmak için ElemanlariYaz() sabit fonksiyonumuzu kullanıyoruz. Contains() metodunu kullanımına örnek olması amacıyla if deyimi içinde yigin.Contains(“Sefer”) sorgusunu yapıyoruz. Eğer Sefer elemanı yığında mevcutsa ekrana yığında olduğunu, yoksa yığında olmadığını yazdırıyoruz. Programın geriye kalan kısmında yığını boşaltmak için Clear() metodunu kullanıyoruz,yığındaki eleman sayısını tekrar bulup bunu yazdırıyoruz. Eğer tekrar ElemanlariYaz() fonksiyonunu kullansaydık. “Yığın Boş..!” uyarısını alırdık!

.NET sınıf kütüphanesinde bulunan Yığın (Stack) sınıfının getirdiği kolaylıklar yukarıdakilerden daha fazladır. Mesela herhangi bir yığın nesnemizi başka bir yığının içine kopyalayabiliriz. Bir yığını başka bir yığına kopyalamak için Clone() metodunu kullanabiliriz. Ayrıca bir yığın nesnesini herhangi bir dizinin içine kopyalamak için ToArray() metodu kullanılabilir. İki tane yığının birbirlerine eşit olup olmadığını öğrenmek için Equals() metodu hemen yardımımıza yetişir. Burada şunu belirtmekte yarar var: Equals() metodu sanal (virtual) bir fonksiyon olup c#’daki tüm nesnelerin türediği System.Object nesnesine aittir.

Bu makalede inceleyeceğimiz son program aşağıdadır. Bu programla Clone(), Equals() ve ToArray() metodlarını programlarımız içinde ne şekilde kullanacağımızı öğrenebiliriz.

            // Yığınımıza yeni elemanlar ekliyoruz.
            yigin1.Push(“Ahmet”);
            yigin1.Push(“Sefer”);
            yigin1.Push(“Cemal”);
            yigin1.Push(“Onur”);
            yigin1.Push(“Aziz”);

            //İkinci yığınımızı tanımlıyor ve yigin1’in
            // bir kopyasını yigin2’ye koyuyoruz..
            Stack yigin2= (Stack)yigin1.Clone();

// yigin1’den bir eleman çıkartıyoruz.
yigin1.Pop();

            //yigin1 ve yigin2 nesnelerimizin en üstteki
            // elemanlarına bir bakalım:
            Console.WriteLine(” Peek of Yığın2: “+ yigin2.Peek());
            Console.WriteLine(” Peek of Yığın1: “+ yigin1.Peek());

//yigin1 ve yigin2 eşit mi? Bir bakalım:
Console.WriteLine(“\n yigin1 ve yigin2 eşit? –> “+ yigin1.Equals(yigin2));

//yigin2’yi kopyalamak için yeni bir dizi oluşturalım:
Array arr = new Array[5];

// yeni oluşturduğumuz diziye yigin2’yi kopyalayalım:
arr = yigin2.ToArray();

            // arr nesnesinin elemanları:
            Console.WriteLine( “\n\n arr nesnesinin elemanları:\n”+
                                     “\n\t”+arr.GetValue(0)+
                                     “\n\t”+arr.GetValue(1)+
                                     “\n\t”+arr.GetValue(2)+
                                      “\n\t”+arr.GetValue(3)+
                                      “\n\t”+arr.GetValue(4)    );

Console.ReadLine();
}

      public static void ElemanlariYaz(Stack yigin)
      {
            object obj = new Object();
            Stack yeniYigin = (Stack)yigin.Clone();

Yazımızda bilgisayar programlama alanında en önemli veri yapılarından biri olan yığınların (Stack) nasıl çalıştıklarını ve .NET sınıf kütüphanesinde bulunan Stack sınıfını ve metodlarının nasıl işimize yarayacak şekilde kullanabileceğimizi öğrendik. Umarım bu yazının size gerçek manada yararı olur.

C#’ta Gösterici(Pointer) Kullanmak – I

Göstericiler(Pointer) alt seviye programlama için olmazsa olmaz yapılardır. Göstericiler nesnelerin bellekte tutuldukları adresleri saklayan veri yapılarıdır. Bu makalede C#’ta kullanımı çok fazla gerekli olmayan göstericilerin nasıl kulanıldıklarını inceleyeceğiz. Bu yazı göstericiler hakkında temel bilgilere sahip olduğunuzu varsaymaktadır.

.NET’ in altyapısında gösterici kavramı sıklıkla kullanılırken göstericilerin açıkca kullanımı programcılar için gizlenmitir. Bunun nedeni gösterici kullanımının programlardaki görülemeyen hatalara sıkça yol açabilmesidir. Özellikle dili yeni öğrenenler için gösterici hataları içinden çıkılmaz bir hale gelebilmektedir. C#’ta göstericiler yerine referans değişkenleri mevcuttur. Referanslar heap bellek bölgesindeki nesnelerin başlangıç adresini tutar. Ancak bu adresin değerine kesinlikle ulaşamayız. Oysa C ve C++ dillerinde stack bölgesindeki değişkenlerin de adreslerine erişbilmemiz mümkündür. Üstelik değişkenlerin adreslerini örneğin 0x965474 şeklinde elde etmemiz bile mümkündür. C ve C++ programcılarına pek yabancı gelmeyecektir bunlar, ancak programlama dünyasına C# ile giren biri için göstericilere neden ihtiyaç duyabileceğimiz pek anlamlı gelmeyebilir. Şunu da söyeleyelim ki çok istisnai durumlar dışında göstericilere ihtiyacımız olmayacak, peki bu istisna durumlar nelerdir?

Geriye Uyumluluk(Backward Compatibility) : COM ve WinAPI’deki fonksiyonlar gibi sık sık gösterici kullanan fonksiyonları C# ile programlarımızdan çağırabilmek için parametre olarak gösterici alan fonksiyonlara gösterici göndermemiz gerekebilir. Eğer C# ta gösterici kullanımına izin verilmemiş olsaydı tür uyumsuzluğu yüzünden gösterici kullanan eski COM ve DLL’lere erişebilmemiz mümkün olamazdı.
Performans : C ve C++ dillerinin günümüze kadar çok popüler olmasının altında yatan nedenlerden biri de belleğe direkt erişimi sağladığı içinperformansın inanılmaz derecede yükselmesidir. Bizim için performansın çok önemli olduğu yerlerde gösterici kullanmamızdan daha doğal birşey olamaz.
Alt Seviye İşlemler : Donanım arayüzleri ile direkt bir ilişki içerisinde olacak programlarda göstericilerin kullanımı mecburi gibidir. Bazen de belleğe kullanıcıların direkt erişebilmesi gereken programlar olabilir. Bu durumlarda da göstericilerden faydalanabiliriz.

Bütün bunların yanında gösterici kullanmanın bir çok sıkıntıyıda beraberinde getireceği kesindir. Öncelikle kullanımının zor olması ve kestirilmesi zor olan hatalara yol açabilmesi bu sıkıntıların en başında gelenidir. Zaten C#’ta gösterici kullanacağımız zaman kodu unsafe(güvensiz) anahtar sözcüğü ile işaretlememiz gerekir. Aksi halde program derlenemeyecektir. Normal bir metot içinde gösterici kullanımı yasaklanmıştır.

Şimdi de unsafe anahtar sözcüğünün kullanımına örnekler verelim.

1-) unsafe olarak işaretlenen sınıfların bütün metotlarında gösterici kullanabiliriz.

unsafe class Sınıf
{

}

2-) Normal bir metot içinde herhangi bir bloğu unsafe olarak aşağıdaki gibi işaretleyip dilediğimiz gibi gösterici kullanabiliriz. unsafe bloklarının dışında ise gösterici kullanamayız.

int NormalMetot(int a, string str)
{
unsafe
{

}
}

3-) Normal bir metodu unsafe olarak işaretleyip sadece o metodun içinde de gösterici kullanabiliriz.

unsafe int NormalMetot(int a, string str)
{

}

4-) Bir sınıfın üye değişkenlerinden biri unsafe olarak işaretlenip gösterici olarak bildirilebilir. Ancak bir metot içerisinde yerel bir gösterici tanımlanamaz. Yerel bir gösterici tanımlamak için unsafe olarak işaretlenmiş metod yada blok kullanılır.

class Sınıf
{
unsafe char *ptr;
}

Gösterici Tanımlama ve Gösterici Operatörleri

Göstericiler aşağıdaki gibi tanımlanabilir.

char* ptr1, ptr2;
int* ptr3;

ptr1 ve ptr2 char türden bir gösterici iken ptr3 int türden bir göstericdir. Bir göstericide iki bileşen vardır. Bu bileşenlerden birincisi adres bileşenidir. Adres bileşeni nesnenin bellekte bulunduğu başlangıç adresidir. İkinci bileşen ise tür bileşenidir. Bu bileşen ise ilgili adresteki nesneye ulaşmak istediğimizde bellekten ne kadarlık bilgili okunacağını sağlar. Örneğin int türden bir adresteki bilgiyi okumak istediğimizde 4 byte’lık bir bilgi okunacaktır, aynı şekilde char türden bir gösterici ise 2 byte’lık bir bilgi okunacaktır.

& operatörü

Adres operatörü olarak bilinen bu operatör değişkenlerin veya nesnelerin bellekte bulundukları adresleri elde etmek için kullanılır. Bu operatör hangi tür değişkenle kullunılırsa o türden bir gösterici üretilir.

* operatörü

İçerik operatörü olan *, bir adresteki bilgileri elde etmek için kullanılır. Aşağıdaki programda bu iki operatörün kullanımına bir örnek verilmiştir.

using System;

class Class1
{
     unsafe static void Main()
     {
          int* ptr1;
          char* ptr2;

          int a = 50;
          ptr1 = &a;
          int Adres = (int)ptr1;
          Console.WriteLine(“{0:X}”,Adres);

          char ch = ‘A’;
          ptr2 = &ch;
          *ptr2 = ‘B’;
          Console.WriteLine(ch);
     }
}

Bu programı derleyebilmek için komut satırı derleyicisene programın içinde unsafe bloğunun olduğunu belirtmemiz gerekir. Bunun için komut satırına

csc /unsafe KaynakKod.cs

yada

csc -unsafe KaynakKod.cs

yazarak programı derleyebilirsiniz. Eğer Visual Studio.NET kullanıyorsanız projeye sağ tıklayıp proje özelliklerine gelip Build kısmından “Allow unsafe code blocks” kısmını true olacak şekilde değiştirin.

Programı çalıştırdığınızda ekrana a değişkeninin adresi ve B karekteri yazılacaktır. Adres bilgisini ekrana yazdırmadan önce göstericide tutulan adresi normal bir türe nasıl dönüştürdüğümüze dikkat edin. Bunu yapmamızın sebebi Consol.WriteLine() metodunun gösterici parametres alan versiyonunun olmamasıdır.

C#’ta tür güvenliğinin ne kadar önemli olduğunu vurgulamak için aşağıdaki deyimleri örnek verebiliriz.

int* ptr1;
*ptr1 = 50;

Bu deyimleri içeren bir program derlenemeyecektir. Çünkü ptr1 göstericisinde hangi adresin tutulduğu belli değildir. Bu yüzden adresi belli olmayan bellek bölgesine bir değer yerleştirmek imkansızdır. C ve C++ dillerinde bu kullanım tamamen geçerlidir. Ama gelin bir de bunun sakıncasına bir göz atalım. ptr1 göstericisi tanımlandığında ptr1 de rastgele bir adres değeri bulunmaktadır. Bu adreste rastgele bir adres olduğu için o an bellekte çalışan kendi programımızdaki bir değişkenin adresi bile olabilir. Yada sistemde çalışan başka bir prosesteki elemanların adresleri olabilir. Kaynağını bilmediğimiz bir adresteki değeri * operatörü ile değiştirdiğimizde hiç tahmin edemeyeceğimiz çalışma zamanı hataları alabiliriz. İşin kötüsü adresler rastgele olduğu için programımızın test aşamasında bu hatalar oluşmayabilir. Adresler nasıl rastgele ise hataların oluşması da rastgeledir. Programımız piyasada iken böyle bir hatanın farkına varılması iş maliyetlerini ne kadar artırdığını siz tahmin edin artık. Bütün bu dezavantajlar göstericilerin asla gereksiz olduğu anlamına gelmemelidir. Sadece göstericileri kullanırken daha dikkatli davranmamız gerektiğinin göstergesidir.

Göstericiler arasında tür dönüşümleri mümkündür. Örneğin int türden bir gösterici char türden bir göstericiye aşağıdaki gibi dönüştürülebilir.

char* ptr1
int* ptr2;

ptr1 = (char*)ptr2

Aynı şekilde bir gösterici de tamsayı türlerine dönüştürülebilir. Adresler tam sayı türünden birer sayı oldukları için bunu yapabilmemiz son derece normal bir durumdur. Bir önceki çalışan programda da Console.WriteLine() metodu ile ekrana yazmak istediğimiz nesnenin adresini tamsayı türlerinden birini çevirdiğimizi hatırlayın. Örneğin aşağıdaki deyimleri içeren bir program derlenemeyecektir.

char* ptr1
char ch = ‘A’;
ptr1 = ch;

Console.WriteLine(ptr1)

Göstericilerle ilgili diğer önemli yapı ise void göstericilerdir. void olan göstericilerde tür bilgisi saklanmamaktadır. void göstericilere herhangi bir türden gösterici atanabilir. void göstericiler daha çok eskiden yazılmış API fonksiyonlarında void parametre alan fonksiyoları programlarımız içerisinden çağırmak için kullanılır. void göstericilerin kullanımına aşağıda bir örnek verilmiştir.

int* ptr1;
void * x;
x = ptr1;

sizeof operatörü

sizeof operatörü temel türlerin ve yapıların bellekte ne kadar alan kapladıklarını verir. Örneğin sizeof(int) = 4, sizeof(char) = 2 ‘ dir. sizeof operatörünü sınıflar için kullanamayız ancak tanımlayacağımız yapılar için kullanabiliriz.

Bu yazının sonuna geldik. Bir sonraki yazımızda yapı göstericileri tanımlamayı sınıflar ile göstericiler arasındaki ilişkiyi, gösterici aritmetiğini inceleyip örnek bir gösterici uygulaması yapacağız.