C++ const ve Sabitler: const, constexpr ve consteval

Sabitler Neden Vardır

Bir sabit, ayarladıktan sonra asla değiştirmemeye söz verdiğiniz bir değerdir. Bir şeyi const olarak işaretlemek aynı anda iki iş yapar: niyetinizi kodu okuyan herkese belgeler ve derleyicinin bu niyeti zorlamasını sağlar — değeri değiştirmeye çalışan herhangi bir satır, sessiz bir çalışma zamanı hatası yerine bir derleme hatası hâline gelir.

auto anahtar sözcüğü derleyicinin bir değişkenin türünü çıkarmasını sağlarken, const o değişkenle ne yapabileceğinizi kısıtlar. İkisi serbestçe birleşir: const auto limit = 100; salt okunur bir int'tir.

Bir const Değer Tanımlama

const'u türün önüne koyun. Bir const değişken aynı satırda başlatılmak zorundadır, çünkü daha sonra ona atama yapmanıza izin verilen bir an yoktur.

#include <iostream>
using namespace std;

int main() {
    const int maxUsers = 100;
    const double pi = 3.14159;

    cout << "Max users: " << maxUsers << "\n";
    cout << "Pi: " << pi << "\n";

    // maxUsers = 200; // hata: salt okunur değişkene atama
    return 0;
}

Atamanın yorumunu kaldırın ve program derlenmeyecektir — derleyici "assignment of read-only variable" hatasını verir. Asıl amaç tam olarak budur: hata, program henüz çalışmadan önce yakalanır.

C'den taşınan yaygın bir acemi alışkanlığı #define MAX_USERS 100'dür. Bundan kaçının. Bir makro, türü olmayan ve kapsama saygı göstermeyen kör bir metin değiştirmesidir, bu yüzden bir hata ayıklayıcıda incelenemez ve kafa karıştırıcı hata mesajları üretir. Bir const (veya constexpr) değişkeni, diğer her şey gibi tür denetiminden geçer ve kapsamlıdır.

const ile constexpr

Her iki anahtar sözcük de size değiştirilemeyen bir değer verir, ancak farklı sorulara yanıt verirler. const şunu söyler: "bu, ayarlandıktan sonra asla değişmez". constexpr ise daha güçlü olanı söyler: "bu, derleme zamanında hesaplanabilir" — ve constexpr olan her şey otomatik olarak const'tur.

#include <iostream>
using namespace std;

int main() {
    int n = 5;
    const int a = n;          // OK: çalışma zamanı değeri, sadece salt okunur
    constexpr int b = 10;     // OK: derleme zamanında bilinir
    // constexpr int c = n;   // hata: n bir derleme zamanı sabiti değil

    int grid[b];              // geçerli: dizi boyutu bir derleme zamanı sabiti olmalı
    cout << "Array length: " << sizeof(grid) / sizeof(grid[0]) << "\n";
    cout << a << " " << b << "\n";
    return 0;
}

Pratik kural: değer sabit bir literal ya da derleyicinin yapabileceği bir hesaplama olduğunda (dizi boyutları, tampon uzunlukları, switch etiketleri, şablon argümanları) constexpr'e başvurun. Değer çalışma zamanında belirlenip sonradan değişmemesi gerektiğinde — örneğin bir fonksiyon argümanının const kopyası gibi — düz const kullanın.

C++20'den beri ayrıca, derleme zamanında çalışması zorunlu olan fonksiyonlarda kullanılan consteval de vardır:

consteval int square(int x) { return x * x; }
constexpr int area = square(8); // derleme sırasında hesaplanır

Bir constexpr fonksiyon derleme zamanında çalışabilir; bir consteval fonksiyon her zaman çalışmak zorundadır, aksi takdirde bu bir hatadır.

İşaretçiler ve const: Sağdan Sola Okuyun

const'un insanları yanılttığı yer burasıdır, çünkü anahtar sözcük *'ın iki yanından birinde durabilir ve iki anlam birbirinin tam tersidir. Püf noktası, bildirimi sağdan sola okumaktır.

#include <iostream>
using namespace std;

int main() {
    int x = 1, y = 2;

    const int* p1 = &x;   // const int'e işaretçi: yeniden yönlendirilebilir, *p1 düzenlenemez
    p1 = &y;              // OK
    // *p1 = 5;           // hata: *p1 const'tur

    int* const p2 = &x;   // int'e const işaretçi: *p2 düzenlenebilir, yeniden yönlendirilemez
    *p2 = 99;             // OK
    // p2 = &y;           // hata: p2 const'tur

    const int* const p3 = &x; // const int'e const işaretçi: ikisine de izin yok

    cout << *p1 << " " << *p2 << " " << *p3 << "\n";
    return 0;
}

int* const p2'yi sağdan sola okuyun: "p2, int'e bir const işaretçidir". const int* p1'i şöyle okuyun: "p1, const int'e bir işaretçidir". Bunu yanlış anlarsanız, değiştirilebilir sandığınız bir şeyi değiştiremeyeceğinizi söyleyen bir hatayla kafanız karışarak gerçekten zaman kaybedersiniz.

Pratik bir tuzak: asla bir const'un adresini alıp, alttaki nesneyi değiştirmek için const'u cast ile kaldırmayın. Orijinal nesne gerçekten const ise bunu yapmak tanımsız davranıştır ve derleyici değerin asla değişmediğini varsaymakta serbesttir — "yazma" işleminiz basitçe yok sayılabilir.

Fonksiyon Parametresi Olarak const Referanslar

const'un en yaygın günlük kullanımı, büyük nesneleri kopyalamadan referansla geçirmektir. Bir const& parametre kopyalamayı önler ve fonksiyonun çağıranın argümanını değiştirmeyeceğine söz verir.

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

// String'in bir kopyası yapılmaz ve onu yanlışlıkla değiştiremeyiz.
void greet(const string& name) {
    // name += "!"; // hata: name const'tur
    cout << "Hello, " << name << "!\n";
}

int main() {
    string user = "Ada";
    greet(user);
    greet("Grace"); // const& geçici bir literale de bağlanır
    return 0;
}

const& ile geçirme, birkaç bayttan büyük herhangi bir parametre için varsayılan seçimdir (string'ler, vektörler, kendi sınıflarınız). Ayrıca fonksiyonun "Grace" gibi bir geçici değeri kabul etmesini de sağladığına dikkat edin — düz, const olmayan bir referans bir geçiciye bağlanamaz, bu yüzden buradaki const'u kaldırmak o ikinci çağrıyı reddederdi.

const Üye Fonksiyonlar

Bir sınıf yazdığınızda, nesneyi değiştirmeyen herhangi bir metodu sondaki bir const ile işaretleyin. Metodu const örnekler ve const& parametreler üzerinde çağrılabilir kılan şey budur — bu olmadan, kendi nesnenizi bir const tutamaç üzerinden okuyamazsınız.

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

class Account {
    double balance = 0;
public:
    void deposit(double amount) { balance += amount; } // değiştirir -> const değil
    double getBalance() const { return balance; }       // salt okunur -> const
};

int main() {
    Account a;
    a.deposit(50);

    const Account& ref = a;        // salt okunur bir görünüm
    cout << ref.getBalance() << "\n"; // yalnızca getBalance() const olduğu için çalışır
    // ref.deposit(10);            // hata: deposit() const değil
    return 0;
}

Salt okunur metotları const olarak işaretleme disiplinine const correctness denir. Bunu erken doğru yapın — const olması gereken bir metodu eklemek kolaydır, ancak büyük bir kod tabanına sonradan const eklemek acı vericidir, çünkü const referans üzerinden gelen her çağıran buna bağımlıdır.

Sıradaki: Operatörler

Artık değerleriniz const ile kilitlenebildiğine göre, sonraki adım onlarla bir şeyler yapmaktır. Operatörler sayfası aritmetik, karşılaştırma, mantıksal ve atama operatörlerini kapsar — tam sayı bölmesi etrafındaki tuzaklar, operatör önceliği ve const'un, kullanmanıza izin verilmeyen atama operatörleriyle nasıl etkileştiği dâhil.