berzahx 1
berzahx
aslan6474 1
aslan6474
Reklam vermek için turkmmo@gmail.com

C Programlamada Göstericiler (Pointers): A'dan Z'ye Kapsamlı Rehber

  • Konuyu başlatan Konuyu başlatan Agora Metin2
  • Başlangıç tarihi Başlangıç tarihi
  • Cevaplar Cevaplar 0
  • Görüntüleme Görüntüleme 10
imagee901b4708a2f3b6d.jpg


Sisteminizde çalışan bir programın tanımladığı her bir değişken, bellekte belirli bir konumda saklanır ve bu konumun kendisini tanımlayan sayısal bir adresi bulunur. Gösterici (pointer) adını verdiğimiz kavram, özünde bu adres sayılarını bünyesinde barındıran özel bir değişkenden ibarettir. Mantık tamamen bu temele dayanır; dildeki diğer tüm detaylar bu yapının getirdiği kurallar ve kullanım şekilleridir.

C dilinde gösterici yapısının bu derece hayati olmasının temel nedeni, fonksiyonlara iletilen argümanların her zaman bir kopyasının oluşturulmasıdır. Örneğin, bir fonksiyona doğrudan 7 değerini gönderdiğinizde, fonksiyon bu kopyayı dilediği gibi değiştirebilir ancak çağıran taraftaki asıl değişken bundan etkilenmez. Fakat fonksiyona değerin kendisi yerine bellekteki adresini iletirseniz, fonksiyon o adrese erişerek orijinal veriyi güncelleyebilir. C programlama dilinde karşılaştığınız diziler, metinsel ifadeler, dinamik bellek yönetimi ve karmaşık veri yapıları tamamen bu çalışma mekanizması üzerine inşa edilmiştir.

Bellek Mimarisi, Adresler ve Değişkenlerin Konumlandırılması

Kodunuzda int score = 42; şeklinde bir bildirim yaptığınızda, derleyici bellek alanından belirli sayıda bayt ayırır ve bu alana erişebilmeniz için belirlediğiniz ismi atar. Ayırılan bu alanın sistem tarafında sayısal bir adresi mevcuttur. Belleği yan yana dizilmiş numaralı binalardan oluşan uzun bir cadde gibi düşünebilirsiniz: score etiketi sizin kullanabileceğiniz insani bir isimken, 0x7ffd4c2a gibi adresler makinenin bu veriye ulaşmasını sağlayan kapı numaralarıdır.

Bu adres bilgisine erişmek istediğimizde & operatöründen faydalanırız:

C:
#include <stdio.h>

int main(void) {
    int score = 42;
    double ratio = 1.5;
    char grade = 'A';

    printf("score = %d  adresi %p\n", score, (void *)&score);
    printf("ratio = %.1f adresi %p\n", ratio, (void *)&ratio);
    printf("grade = %c  adresi %p\n", grade, (void *)&grade);

    return 0;
}

Kodu çalıştırdığınızda her değişkenin farklı bir adrese sahip olduğunu görürsünüz. Çünkü her değişken bellekte ayrı alanları kaplar ve bu adres değerleri programın her çalıştırılışında değişiklik gösterebilir. Bu değişkenlik nedeniyle kodlarınızda hiçbir zaman sabit adres değerleri kullanmamalısınız. Kodda yer alan (void *) tür dönüşümü oldukça önemlidir; %p biçimlendiricisi standart olarak void * tipinde bir veri bekler. Farklı bir gösterici türünü doğrudan geçirmek teknik açıdan standart dışı durumlara yol açabileceği için bu dönüşümü alışkanlık haline getirmek gerekir.

Adreslerin sürekli değişiyor olması bir problem teşkil etmez. Çünkü uygulamalarınızda adresi oluşturan sayının kaç olduğuyla değil, o adresin temsil ettiği veriye erişebilmekle ilgilenirsiniz.

Gösterici (Pointer) Tanımlama

Bir gösterici değişkeni tanımlanırken, işaret edeceği verinin tipi belirtilir:

C:
int    *p;      // p, bir int'in adresini tutabilir
double *q;      // q, bir double'ın adresini tutabilir
char   *name;   // name, bir char'ın adresini tutabilir

Yazılan int *p; ifadesini "*p bir int türüdür" biçiminde okuyabilirsiniz. Yani p göstericisinin işaret ettiği adrese ulaşıldığında bir tamsayı elde edilir. Bu mantık, C dilindeki karmaşık tüm gösterici tanımlarını rahatça anlamanızı sağlar.

* sembolünün konumu derleyici için önem taşımaz, tercih tamamen sizin kodlama stilinize kalmıştır: int* p, int *p veya int * p tanımlarının tamamı aynı anlama gelir. Ancak C ekosisteminde genellikle int *p kullanımı tercih edilir. Bunun pratik nedeni şudur:

C:
int* a, b;   // a int'e göstericidir; b DÜZ bir int'tir, gösterici değil
int *a, *b;  // ikisi de göstericidir - * tipe değil isme bağlanır

Buradaki * işareti veri tipine değil, doğrudan yanındaki değişken ismine bağlıdır. Sembolü değişken adının yanında tutmak bu ayrımı açıkça görmenizi sağlar.

Temel Operatörler: & ve *

Gösterici işlemlerinin temeli, birbiriyle zıt çalışan iki operatöre dayanır:

• &x - Adres alma operatörü. x değişkeninin bellekte bulunduğu konumu getirir.
• *p - Adrese erişim (dereference) operatörü. p göstericisinde kayıtlı adrese giderek orada saklanan veriyi sunar.

C:
#include <stdio.h>

int main(void) {
    int age = 30;
    int *p = &age;     // p artik age'in adresini tutuyor

    printf("age      = %d\n", age);
    printf("&age     = %p\n", (void *)&age);
    printf("p        = %p\n", (void *)p);      // ayni adres
    printf("*p       = %d\n", *p);             // 30 - o adresteki deger

    *p = 31;           // gosterici UZERINDEN yaz
    printf("age artik = %d\n", age);           // 31 - ozgun degisti

    return 0;
}

Örnekteki son iki satır göstericilerin varlık sebebini özetler. age değişkenine doğrudan yeni bir değer atanmadığı halde değeri değişmiştir. Çünkü *p = 31 komutu, "p adresinin gösterdiği hafıza hücresine 31 değerini yaz" anlamına gelir ve bu konum age değişkeninin tam kendisidir.

Bu durumun bellekteki görünümü şu şekildedir:

Kod:
      p                        age
 +------------+           +----------+
 | 0x7ffd1c40 | --------> |    31    |
 +------------+           +----------+
 0x7ffd1c38'de            0x7ffd1c40'ta

 p    -> 0x7ffd1c40 adresi
 *p   -> orada saklanan int, 31
 &age -> 0x7ffd1c40, p'nin tuttugu adresin ayni
 &p   -> 0x7ffd1c38, p'nin kendisinin yasadigi yer

Görselin son satırına dikkat ederseniz, göstericinin kendisi de bellekte bir alan kaplayan değişkendir ve doğal olarak onun da bir adresi bulunur. Bu durum tutarlı bir mimarinin sonucudur ve göstericiyi gösteren göstericilerin (int **) çalışma prensibini oluşturur.

& ve * işlemleri birbirinin etkisini sıfırladığı için *&age ifadesi doğrudan age değerini, &*p ifadesi ise p adresini verir.

Gösterici Tiplerinin Önemi

Bir gösterici temelde yalnızca bir adres sayısı tutar. Peki derleyici neden bu adresin bir int mi yoksa double mı gösterdiği bilgisine ihtiyaç duyar? Bunun iki temel sebebi vardır:

1. Bellekten kaç baytlık veri okunacağı. Bir int * adresi okunduğunda genelde 4 bayt çekilirken, double * adresinde 8 bayt okunur. Tip belirtilmezse *p işlemi belirsizleşir.
2. Okunan baytların nasıl işleneceği. Bellekteki aynı bit dizilimi tamsayı olarak ayrı, kayarmaklı sayı (float) olarak çok daha ayrı bir değere karşılık gelir.

Buna karşın, gösterici değişkeninin kendi kapladığı alan işaret ettiği verinin tipine göre değişmez; çünkü adres boyutları sabittir:

C:
#include <stdio.h>

int main(void) {
    int    i = 1;
    double d = 2.0;
    char   c = 'x';

    int    *pi = &i;
    double *pd = &d;
    char   *pc = &c;

    printf("sizeof(int)     = %zu, sizeof(pi) = %zu\n", sizeof i, sizeof pi);
    printf("sizeof(double)  = %zu, sizeof(pd) = %zu\n", sizeof d, sizeof pd);
    printf("sizeof(char)    = %zu, sizeof(pc) = %zu\n", sizeof c, sizeof pc);

    return 0;
}

64-bit mimariye sahip sistemlerde her üç gösterici değişkeni de 8 bayt yer kaplar; ancak gösterdikleri tipler sırasıyla 4, 8 ve 1 bayt boyutundadır. *p erişimini ve gösterici aritmetiğini anlamlı kılan unsur, tanımlanan veri tipidir.

Farklı gösterici tiplerini birbirine direkt atamaya çalışmak derleyici uyarısına/hatasına yol açar. Örneğin pi = &d; gibi bir işlem, bir double değerin 4 baytını okuyarak bunu tamsayı gibi yorumlamanıza ve hatalı sonuçlar almanıza neden olur.

Pratik Bir Örnek: swap() Fonksiyonu

C derslerinde sıklıkla gösterilen aşağıdaki fonksiyon, göstericilerin neden gerekli olduğunu anlamak için harika bir örnektir:

C:
#include <stdio.h>

void broken_swap(int a, int b) {
    int temp = a;
    a = b;
    b = temp;
    printf("  broken_swap icinde: a = %d, b = %d\n", a, b);
}

int main(void) {
    int x = 1, y = 2;
    printf("once:  x = %d, y = %d\n", x, y);
    broken_swap(x, y);
    printf("sonra: x = %d, y = %d\n", x, y);
    return 0;
}

Fonksiyon verileri takas ettiğini belirten mesajlar verse de, main içerisindeki ana değerlerin hiç değişmediği görülür. Nedeni şudur: broken_swap fonksiyonu x ve y değerlerinin yalnızca kopyalarını almıştır. Kendi içindeki kopyaları başarıyla takas etmiş, ancak fonksiyonun çalışması bittiğinde bu geçici kopyalar bellekten silinmiştir.

Gerçek değişim için fonksiyona adresleri iletmek gerekir:

C:
#include <stdio.h>

void swap(int *a, int *b) {
    int temp = *a;   // a'daki degeri oku
    *a = *b;         // b'nin degerini a'nin degiskenine yaz
    *b = temp;
}

int main(void) {
    int x = 1, y = 2;
    printf("once:  x = %d, y = %d\n", x, y);

    swap(&x, &y);    // degerleri degil ADRESLERI gecir

    printf("sonra: x = %d, y = %d\n", x, y);
    return 0;
}

Bu senaryoda da a ve b birer kopyadır, ancak bunlar adreslerin kopyasıdır. Bir adresin kopyası da aynı belleği işaret eder. Dolayısıyla *a ifadesi, fonksiyon nereden çağrılırsa çağrılsın doğrudan x değişkeninin asıl adresine ulaşır.

Dışarıdaki veriyi güncellemesi gereken tüm C fonksiyonlarında bu yaklaşım kullanılır. C dilinde doğrudan referans ile aktarım (pass-by-reference) bulunmadığından, gösterici parametreleri kullanılarak adrese erişim sağlanır. Standart kütüphanedeki scanf fonksiyonunun & simgesine ihtiyaç duymasının sebebi de tam olarak budur:

C:
int n;
scanf("%d", &n);   // scanf n'nin içine yazabilmeli, o yüzden n'nin adresine ihtiyacı var

Fonksiyonlardan Birden Fazla Değer Döndürme

C dilinde bir fonksiyon return ile yalnızca tek bir değer geri gönderebilir. Birden fazla sonuç almak istediğinizde göstericilerden yararlanarak ek sonuçların yazılacağı adresleri fonksiyona iletebilirsiniz:

C:
#include <stdio.h>

// basarida 0 dondurur ve her iki sonucu gostericiler uzerinden yazar
int divide(int numerator, int denominator, int *quotient, int *remainder) {
    if (denominator == 0) {
        return 1;              // basarisizlik; ciktilara dokunma
    }
    *quotient  = numerator / denominator;
    *remainder = numerator % denominator;
    return 0;
}

int main(void) {
    int q, r;

    if (divide(17, 5, &q, &r) == 0) {
        printf("17 / 5 = %d, kalan %d\n", q, r);
    } else {
        printf("sifira bolunemez\n");
    }

    if (divide(17, 0, &q, &r) != 0) {
        printf("ikinci cagri beklendigi gibi basarisizlik bildirdi\n");
    }

    return 0;
}

Bu yapıda ana durum bilgisi return ile dönerken, esas veriler gösterici parametreleri üzerinden aktarılır. Bu kalıp C standart kütüphanelerinde ve işletim sistemi seviyesindeki kodlarda oldukça yaygındır.

Çift Göstericiler (Pointer to Pointer)

Göstericiler de bellekte yer kaplayan birer değişken olduğuna göre, onların da adresini almak mümkündür. Bu tür adreslerin tipi "göstericiyi gösteren gösterici" olarak adlandırılır:

C:
#include <stdio.h>

int main(void) {
    int  value = 7;
    int  *p  = &value;
    int **pp = &p;

    printf("value = %d\n", value);
    printf("*p    = %d\n", *p);
    printf("**pp  = %d\n", **pp);   // iki sicrama izle

    **pp = 8;                       // ta ote uca uzanip yaz
    printf("value artik %d\n", value);

    return 0;
}

Kod:
  pp              p               value
+------+       +------+        +------+
| &p   | ----> | &val | -----> |   8  |
+------+       +------+        +------+

İki yıldızlı (**) gösterici yapılarıyla sıklıkla; bir fonksiyonun, çağıran taraftaki bir göstericinin işaret ettiği adresi değiştirmesi gerektiğinde (örneğin bellek tahsis fonksiyonlarında) veya komut satırı argümanlarını temsil eden char *argv[] parametrelerinde karşılaşırsınız.

Gösterici Kullanımında Sık Yapılan 4 Hata

Başlangıç değeri atanmamış gösterici kullanmak: İçine adres bilgisi yazılmamış bir gösterici, bellekte o an rastgele bulunan çöp verileri adres olarak kabul eder. Bu göstericiye erişmeye çalışmak sistemde bilinmeyen bir bellek alanını okumaya veya bozmaya çalışmak anlamına gelir.

C:
int *p;      // p çöp tutuyor
*p = 10;     // tanımsız davranış - muhtemelen bir çökme

Tüm göstericilerinizi tanımlarken geçerli bir adresle ya da NULL değeriyle başlatmayı alışkanlık edinin.

*p ile p ifadelerini karıştırmak: p = 5; yazdığınızda göstericinin işaret ettiği adresi 5 olarak ayarlarsınız (ki bu genellikle hatalıdır); *p = 5; yazdığınızda ise göstericinin işaret ettiği bellek hücresine 5 değerini kaydedersiniz. Derleyici ilk durum için uyarı verecektir, bu uyarıları mutlaka dikkate alın.

scanf kullanımında & operatörünü unutmak: scanf("%d", n) yazımı, n değişkeninin mevcut değerini bir adresmiş gibi fonksiyona gönderir. Program derlense bile çalışma anında hatalı bellek erişimlerine sebep olur.

Yerel (local) değişkenlerin adresini fonksiyon dışına döndürmek: Fonksiyonun çalışması tamamlandığında yerel değişkenler bellekten silinir. Dönüştürülen adres, artık var olmayan geçici bir alana ait olur.

C:
int *bad(void) {
    int local = 42;
    return &local;   // çağıran sarkan bir gösterici alır
}

Fonksiyon tamamlandıktan sonra da yaşaması gereken verileriniz varsa, dinamik bellek ayırma yöntemlerini tercih etmelisiniz.

Sonraki Adımlar

Gösterici konusu yalnızca adres saklamaktan ibaret değildir. Bir göstericiye sayı ekleyip çıkarmak, onun verinin boyutu kadar bellekte ilerlemesini sağlar ki bu konu "gösterici aritmetiği" olarak adlandırılır. Ayrıca C dilinde dizi isimleri, dizinin ilk elemanını gösteren birer göstericiye dönüşür. Bu nedenle diziler ve göstericiler birbiriyle tamamen entegre konulardır. Bu iki konuyu da incelediğinizde C dilinin bellek mantığını tamamen kavramış olacaksınız.
 

Şu an konuyu görüntüleyenler (Toplam : 0, Üye: 0, Misafir: 0)

Geri
Üst