Aslında yazılım literatüründe her ne kadar Türkçe kelimeler ile anlaşmak güç ve anlamsız olsa da işaretçi olarak adlandırdığımız Pointerları bir kez daha tanıyalım ve C# için daha önceki makalelerimde yer verdiğim bir kaç konu ile bağdaştıralım.

Pointer Kavramı

Pointer kavramının ne olduğuna gelirsek, aslında uygulama içersinde her ne kadar farketmesek de RAM ile ilgili bütün işlerimizde yer alan bu kavram en kısa şekilde değer olarak başka bir değişkenin adresini tutan değişkenler diyebiliriz.
Zaten pointerları diğer değişkenlerden ayırt eden en büyük özellik de budur. Yani değişkenler bir değer taşırken, pointerlar değere sahip olan herhangi bir değişkenin adresini değer olarak taşılar.

Daha iyi bir şekilde kavramak için küçük bir örnek yapalım,
{
       int burak = 50;
}
Yukarıdaki gibi bir kod bloğu ile burak adına sahip bir integer değişken tanımladık. Ram'da ki adresini tamamiyle atıyor ve aşağıdaki gibi bir görünüm çiziyorum,

Peki & (Ampersand) eki kullanıyoruz ?

C ve C++ da ve unsafe kod kullanımında herhangi bir değişkenin bellek üzerindeki adrese erişimimizi & (Ampersand) eki ile gerçekleştiririz. Yukarıdaki kod bloğunun devamında printf fonksiyonu ile burak ve &burak değerlerini yazdıracak olursanız, 50 ve bu değerin bellekteki adresinin ekrana yazıldığını görebilirsiniz.

Konumuz daha fazla dağılmadan devam edelim ve son kod bloğu ile Ram üzerinde ki görünümü simüle edelim,

Gördüğünüz üzere ptr adlı pointer değişkeninin içeriği yani aldığı değer, içeriği 50 olan burak adlı değişken ile aynı.
Yani artık adresini aldığımız bu değişkene direkt olmadan ulaşabiliriz.

* (Indirection) eki ile adrese ulaşım

Buraya kadar herşey yolunda gibi gözüküyor. Bir değişken tanımladık. İçeriğini girdik ve bir pointer tanımlayarak bu değişkeni adresledik. Peki artık değişkeni değil de pointerımızı kullanarak içeriğini nasıl okuyup, yazacağız ?
İşte tam bu durumda tıpkı tanımlamada olduğu gibi yardımımıza * yani Indirection eki koşuyor.

1
2
3
4
5
6
int main()
{
    int burak = 50;
    int *ptr = &burak;
    printf("Direkt erisim : %d\nIndirect erisim : %d\nAdresi : ",burak,*ptr,ptr);
}

Ekran çıktımızın ilk 2 satırı 50 ve son satırı ise burak değişkeninin adresi yani ptr'nin içeriği olacaktır.
Burayıda özetleyecek olursak Indirection eki kendinden sonra gelen değeri bir adres olarak alır ve Memory üzerinde bu değeri bularak değerini getirir.

Pointer ile Memory Tasarrufu

Küçük bir senaryo düşünelim. Yine bir sayı tanımlayalım ve bir metot yardımıyla bu sayının çeşitli işlemlerden geçmesini sağlayalım. 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
int main()
{
    int Process(int number);
    void WrongProcess(int number);
    int burak = 50;
    WrongProcess(burak); // Hiç bir degisiklik olmayacaktir
    printf("%d",Process(burak));
}
 
int Process(int number)
{
    //Some actions...
    return number * 10;
}
 
void WrongProcess(int number)
{
    number *= 10;
}

Yukarıdaki kod bloğunda 2 adet harici metot tanımladım. Her ikisinin de amacı parametre olarak gelen değerin 10 ile çarpılması. İkisi arasındaki tek fark ise Process methodu gelen parametre üzerindeki işlemleri yaptıktan sonra aynen geri döndürürken, WrongProcess hayallerimizdeki ancak işe yaramayacak bir metot olarak diğer parametreyi 10 ile çarpıyor fakat geri döndürme gibi bir işlem yapmıyor çünkü her ne kadar parametre olarak tanımladığımız değişkeni göndersek de metot tetiklendiği anda bu değişkeni kullanmayacak, bunun yerine bunu bit bit kopyalarak başka bir değişken tanımlayacaktır ve tanımladığı bu değişken üzerine işlem gerçekleştirecektir fakat geri döndürme gibi bir işlem yapmadığımız için de değişikliğe uğramış son haline ulaşmamız mümkün olmayacaktır.

Son söylediğim söz Process metotu içinde geçerli. Bu metotda tetiklendiği anda number adlı bir değişken tanımlayacak ve tüm işlemleri bunun üzerinden yapacak ve geriye bu değeri döndürecektir. Evet istediğimiz sonucu elde ettik fakat uygulamamız da sık sık bu işlemi tekrarladığımızı düşünürsek her seferinde elimizdeki değişken bit bit kopyalanacak, memory dolup taşacak ve haliyle uygulamada çatlaklar oluşmaya başlayacak.

İşte tam bu noktada ihtiyacımız olan tek şey işleme sokmak üzere metota yollayacağımız bir değişken kopyalanmak yerine ve metotdan return edilmesi yerine, direk erişilebilsin ve işlemlerden geçirilebildikten sonra yeni değeriyle uygulamaya devam edebilsin.
Aslında bu ihtiyacımızı sadece bir pointer ile gerçekleştirebiliriz. 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
int main()
{
    int ProcessByPointer(int *number);
    int burak = 50;
    int *ptr = &burak;
    ProcessByPointer(ptr);
    printf("%d\n%d",*ptr,burak);
}
 
void ProcessByPointer(int *number)
{
    //Some actions...
    *number = *number * 10;
}

İşte senaryomuz için biçilmiş bir kod bloğu görüyoruz :)
ProcessByPointer metotuda dikkat edecek olursak geriye bir dönüş sağlamıyor ve parametre olarak da bir değişken yerine pointer alıyor. Biz de 50 değerine sahip olan burak adlı değişkeni adresleyen ptr adlı pointerı bu metota yollayarak gelen değerin adresine ulaşıyor ve adresteki değeri 10 ile çarpıyoruz. Uygulama bir sonraki satıra atlıyor ve printf ile ekrana 2 satır sayı yazdırıyoruz ve istediğimiz sonuç gibi her ikiside 500 değerine sahip oluyor.

Bundan yaklaşık 1 ay önce C# Ref ve Out Anahtar Kelimeleri adlı makalem de aslında temelini bu konuyu baz almış bir konuyu işledik. C# da ise pointer yerine değişkenin referans tipi olarak gönderilmesini sağlıyorduk. Bu makaleye buradan ulaşabilirsiniz.

Veri yapıları konusuna ilerleyen zamanlarda devam etme dileğiyle, esen kalınız :)