C++ Scope (Kapsam) ve Yaşam Döngüsü

C++ programlarında her değişkenin bir kapsamı (scope) ve bir yaşam döngüsü (lifetime) vardır. Kapsam, değişkenin programın hangi bölümünde erişilebilir olduğunu; yaşam döngüsü ise ne kadar süre bellekte var olacağını belirler. Bu konular, özellikle fonksiyonlar, döngüler ve bellek yönetimi açısından oldukça önemlidir.

1. Kapsam (Scope) Nedir?

Kapsam, bir değişkenin tanımlandığı alanı ifade eder. C++’ta değişkenlerin erişilebilirliği, tanımlandıkları süslü parantez blokları ({ }) ile sınırlıdır.

Yerel (Local) Kapsam

Bir fonksiyonun veya bloğun içinde tanımlanan değişkenler sadece o blok içinde geçerlidir.

#include <iostream>
using namespace std;

int main() {
    int sayi = 10; // yerel değişken
    cout << sayi << endl;
}
// sayi artık burada erişilemez

Yukarıdaki örnekte sayi değişkeni yalnızca main() fonksiyonu içinde kullanılabilir.

2. Blok (Block) Seviyesinde Kapsam

C++’ta her süslü parantez çifti ({ }) kendi kapsam alanını oluşturur. Bu, döngüler veya koşul ifadelerinde sıkça kullanılır.

int main() {
    int a = 5;

    if (a > 0) {
        int b = 10;  // sadece bu if bloğu içinde geçerli
        cout << a + b << endl;
    }

    // cout << b; // Hata! b bu kapsamda yok
    return 0;
}

Not: Aynı isimli değişkenler farklı bloklarda tanımlanabilir. Ancak içteki blokta tanımlanan değişken dıştakini “gizler”.

int x = 5;

int main() {
    int x = 10; // dıştaki x gizlenir
    cout << x << endl; // 10
    return 0;
}

3. Global (Küresel) Kapsam

Tüm fonksiyonların dışında tanımlanan değişkenler global değişken olarak adlandırılır. Bu değişkenlere programın her yerinden erişilebilir.

#include <iostream>
using namespace std;

int sayac = 0; // global değişken

void Artir() {
    sayac++;
}

int main() {
    Artir();
    Artir();
    cout << "Sayaç: " << sayac << endl; // 2
    return 0;
}

Global değişkenler dikkatli kullanılmalıdır çünkü programın herhangi bir yerinde yanlışlıkla değiştirilebilirler.

4. static Anahtar Kelimesi ve Yaşam Döngüsü

Bir değişkenin yaşam süresini değiştirmek için static anahtar kelimesi kullanılabilir. static değişkenler sadece bir kez oluşturulur ve program sonuna kadar bellekte kalır.

#include <iostream>
using namespace std;

void Say() {
    static int sayac = 0; // sadece bir kez oluşturulur
    sayac++;
    cout << "Fonksiyon " << sayac << ". kez çağrıldı." << endl;
}

int main() {
    Say();
    Say();
    Say();
    return 0;
}

Çıktı:

Fonksiyon 1. kez çağrıldı.
Fonksiyon 2. kez çağrıldı.
Fonksiyon 3. kez çağrıldı.

static değişken, fonksiyon çağrıları arasında değerini korur. Bu, sayaç veya önbellek gibi durumlar için kullanışlıdır.

5. Kapsam Çözümleme Operatörü (::)

Aynı isimli global ve yerel değişkenler olduğunda, global değişkene erişmek için kapsam çözümleme operatörü (::) kullanılır.

#include <iostream>
using namespace std;

int x = 100; // global değişken

int main() {
    int x = 10; // yerel değişken
    cout << "Yerel x: " << x << endl;
    cout << "Global x: " << ::x << endl; // global x’e erişim
    return 0;
}

Çıktı:

Yerel x: 10
Global x: 100

6. Otomatik ve Statik Yaşam Döngüsü

7. Örnek Uygulama: Sayaç Karşılaştırması

Aşağıdaki örnekte automatic ve static değişkenlerin farkı gösterilmiştir.

#include <iostream>
using namespace std;

void Sayac() {
    int otomatik = 0;
    static int kalici = 0;

    otomatik++;
    kalici++;

    cout << "Otomatik: " << otomatik 
         << " | Statik: " << kalici << endl;
}

int main() {
    Sayac();
    Sayac();
    Sayac();
    return 0;
}

Çıktı:

Otomatik: 1 | Statik: 1
Otomatik: 1 | Statik: 2
Otomatik: 1 | Statik: 3

Görüldüğü gibi, otomatik değişken her çağrıda sıfırdan başlarken, statik değişken değerini korur.

8. TL;DR

İlişkili Makaleler