C++ Değişkenleri: Tanımlama, İlk Değer Atama ve Kapsam Açıklaması

Değişken Nedir

Değişken, bir değeri tutan, isimlendirilmiş bir bellek parçasıdır. C++'ta her değişkenin - tanımladığınızda seçilen - sabit bir türü vardır ve bu tür asla değişmez. C++'ı statik tipli yapan şey budur: derleyici, program çalışmadan önce her değişkenin türünü bilir ve yanlış türde bir değer saklayan kodu derlemeyi reddeder.

Bir tanımlamanın üç parçası vardır: tür, isim ve (neredeyse her zaman) bir başlangıç değeri.

#include <iostream>
#include <string>
using namespace std;

int main() {
    int age = 30;
    string name = "Ada";
    bool isActive = true;

    cout << name << " is " << age << ", active: " << isActive << "\n";
    return 0;
}

int age = 30; ifadesini "age adında bir int oluştur ve içine 30 koy" diye okuyun. Noktalı virgül ifadeyi sonlandırır; tıpkı yorumlar sayfasının her ifade için gösterdiği gibi. isActive'in 1 olarak yazdırıldığına dikkat edin: bool, varsayılan olarak 1/0 şeklinde görünür; veri türleri sayfası bunun üzerine inşa edilir.

İlk Değer Atama vs. Atama

Bu ikisi benzer görünür ama farklı işlemlerdir ve bu fark, bu sayfadaki en önemli fikirlerden biridir.

İlk değer atama, bir değişkene tanımlamanın bir parçası olarak ilk değerini verir. Atama ise zaten var olan bir değişkenin değerini değiştirir.

#include <iostream>
using namespace std;

int main() {
    int score = 95;   // ilk değer atama - ilk değer, tanımlamada verilir
    score = 100;      // atama - var olan bir değişkeni değiştirme
    score = score + 5;

    cout << score << "\n";
    return 0;
}

İlk değer atamadan tanımlayıp sonra atama yapabilirsiniz, ama dikkatli olun:

#include <iostream>
using namespace std;

int main() {
    int score;     // tanımlandı ama şu an çöp değer içeriyor
    score = 95;    // artık gerçek bir değeri var
    cout << score << "\n";
    return 0;
}

Bu çalışır, çünkü score'a okumadan önce atama yaptık. Tehlikeli olan versiyon onu önce okumaktır - bir sonraki bölümde ele alınıyor.

İlk Değer Atanmamış Değişken Tuzağı

Bu, birçok başka dilde bulunmayan klasik C++ tuzağıdır. Tanımlanmış ama hiç değer verilmemiş yerel bir değişkeni okumak tanımsız davranıştır: değişken, o bellekte tesadüfen ne varsa o baytları içerir.

int score;             // ilk değeri atanmadı
std::cout << score;    // tanımsız davranış - çöp yazdırır, ya da "çalışır", ya da çöker

Derleyici bunu sorunsuzca derler. 0 yazdırabilir, 32766 yazdırabilir ve her çalıştırmada ya da her makinede farklı davranabilir - bu da bu tür hataların izini sürmeyi tam bir kâbusa çevirir. İki savunma:

• Her zaman tanımlamada ilk değer verin. int score = 0; hiçbir maliyeti olmadan tüm sorunu ortadan kaldırır.
• Uyarıları açın. -Wall -Wextra ile derlemek, derleyicinin birçok ilk değer atanmamış okumayı, sizi ısırmadan önce işaretlemesini sağlar.

Her yerel değişken için ilk seçeneği tercih edin: onu oluşturduğunuz anda mantıklı bir başlangıç değeri verin.

İlk Değer Atama Biçimleri: =, () ve {}

C++ size bir başlangıç değeri yazmanın birkaç yolunu sunar. Çoğunlukla aynı işi yaparlar, ancak küme parantezli ilk değer atamanın bilmeye değer fazladan bir güvenlik özelliği vardır.

#include <iostream>
using namespace std;

int main() {
    int a = 5;     // kopyalama ile ilk değer atama
    int b(5);      // doğrudan ilk değer atama
    int c{5};      // küme parantezli (tekdüze) ilk değer atama - C++11 ve sonrası

    cout << a << " " << b << " " << c << "\n";
    return 0;
}

{} kullanmanın nedeni, daraltıcı dönüşümleri (narrowing) reddetmesidir: sessizce veri kaybettirecek atamaları. = ile kesirli bir değer sessizce kırpılır; {} ile derleyici sizi durdurur:

int x = 3.9;    // derlenir - x sessizce 3 olur (.9 atılır)
int y{3.9};     // derleme hatası - double'dan int'e daraltmaya izin verilmez

Bunu derleme zamanında yakalamak tam olarak istediğiniz şeydir. Yaygın bir modern alışkanlık, bu ekstra kontrol için varsayılan olarak {} kullanmak ve yalnızca kopyalama ile ilk değer atama daha doğal okunuyorsa = kullanmaktır.

İsimlendirme Kuralları ve Gelenekleri

C++ birkaç katı kural dayatır, ardından herkes bunların üzerine gelenekler ekler. Kurallar: bir isim harf, rakam ve _ içerebilir; rakamla başlayamaz; ayrılmış bir anahtar sözcük olamaz (int veya return gibi); ve büyük/küçük harfe duyarlıdır (age ve Age iki farklı değişkendir). Bir alt çizgiyi takip eden büyük harfle başlayan ya da art arda iki alt çizgi içeren isimlerden kaçının; bunlar uygulamaya (implementation) ayrılmıştır.

Çoğu C++ kodunun izlediği gelenekler:

• Değişkenler snake_case veya camelCase kullanır - birini seçin ve tutarlı kalın: item_count ya da itemCount.
• İsimler değeri tanımlamalıdır: c değil count; x değil user_email.

#include <iostream>
using namespace std;

int main() {
    int item_count = 3;
    double price_per_item = 4.50;
    double total_price = item_count * price_per_item;

    cout << "Total: " << total_price << "\n";
    return 0;
}

Açık isimler süs değildir; gelecekteki sizin kodu nasıl okuyacağıdır. total_price = item_count * price_per_item, t = c * p'nin asla başaramayacağı bir şekilde kendi kendini açıklar.

Değişken Kapsamı

Bir değişken yalnızca tanımlandığı blok - yani { ... } - içinde var olur ve kapanış parantezinde yok edilir. Bu, onun kapsamıdır (scope). Bir döngü ya da if bloğu içinde tanımlanan bir değişken, dışarıdan görünmezdir:

#include <iostream>
using namespace std;

int main() {
    int total = 0;

    for (int i = 1; i <= 3; i++) {
        int square = i * i;   // 'square' yalnızca bu döngü gövdesinin içinde yaşar
        total += square;
    }

    cout << "Total: " << total << "\n";
    // cout << square;   // hata - 'square' burada kapsam dışında
    return 0;
}

Hem i hem de square döngüye aittir ve döngü bitince yok olur; total ise dıştaki blokta tanımlandığı için varlığını sürdürür. İçteki bir blok ayrıca dıştaki bloktan gelen bir ismi gölgeleyebilir (shadow): aynı isme sahip yeni bir değişken, içteki blok kapanana kadar dıştakini geçici olarak gizler. Bu sık karşılaşılan bir kafa karışıklığı kaynağıdır, bu yüzden iç içe kapsamlar arasında isimleri yeniden kullanmaktan kaçının.

Pratik çıkarım: her değişkeni ona ihtiyaç duyan en küçük blokta tanımlayın ve orada ilk değerini verin. Dar kapsam, dikkatiniz için yarışan daha az isim ve bir değeri atandığı yerden uzakta okuma olasılığının daha az olması demektir.

Sonraki: Veri Türleri

Bu sayfadaki her değişken bir türle başladı - int, double, string, bool. Bir sonraki sayfa C++'ın veri türlerini ayrıntılı olarak ele alıyor: temel türler ve boyutları, işaretli ve işaretsiz tam sayılar, float ile double, char ve iş için doğru türü nasıl seçeceğiniz.