Referanslar ve Pointer vs Referans

C++'ta bir değişkene "takma ad" verebilirsin. Bu takma ada referans (reference) denir. Referans, pointer'a benzer ama çok daha basit ve güvenlidir. Bu derste referansları öğrenecek, sonra pointer ile arasındaki farkları net bir tabloyla karşılaştıracağız.

Referans Nedir?

Referans, mevcut bir değişkenin alternatif adıdır. Yeni bir değişken oluşturmaz — sadece var olan değişkene yeni bir isim verir.

Lakap Analojisi

Arkadaşın Mehmet'in lakabı "Memo" olsun. "Mehmet gel" de desen, "Memo gel" de desen aynı kişi gelir. İkisi de aynı insanı ifade eder — biri asıl isim, diğeri takma ad.

Referans da böyle çalışır. Orijinal değişken ve referans, bellekte aynı yeri gösterir. Birini değiştirirsen diğeri de değişir — çünkü zaten aynı şey.

#include <iostream>
using namespace std;

int main() {
    int x = 42;
    int& ref = x;  // ref, x'in referansi (takma adi)

    cout << "x:   " << x << endl;    // 42
    cout << "ref: " << ref << endl;  // 42

    ref = 100;  // ref uzerinden degistir
    cout << "x:   " << x << endl;    // 100 — x de degisti!

    x = 200;    // x uzerinden degistir
    cout << "ref: " << ref << endl;  // 200 — ref de degisti!

    return 0;
}

x:   42
ref: 42
x:   100
ref: 200

ref ve x aynı bellek hücresini paylaşır. Hangisini değiştirirsen değiştir, ikisi de güncellenir.

Referans Tanımlama Kuralları

Referans tanımlarken & sembolünü kullanırız. Ama pointer'daki & (adres alma) ile karıştırma — burada & tipin parçası:

int x = 10;
int& ref = x;      // ref, x'in referansi
double y = 3.14;
double& dRef = y;   // dRef, y'nin referansi

Üç Kritik Kural

1. Referans tanımlanırken mutlaka başlatılmalı:

int& ref;        // HATA! Referans bossa olamaz
int& ref = x;   // OK

2. Referans başka bir değişkene yeniden bağlanamaz:

int a = 10, b = 20;
int& ref = a;    // ref artik a'ya bagli
ref = b;         // Bu ref'i b'ye baglamaz! a'ya b'nin degerini (20) atar
cout << a;       // 20

3. Referans null olamaz:

int& ref = nullptr;  // HATA! Referans null olamaz

Bu üç kural, referansları pointer'dan çok daha güvenli yapar.

Fonksiyonlarda Referans Kullanımı

Referansların en yaygın kullanım alanı fonksiyon parametreleridir. Bir değişkeni fonksiyona referansla geçirirsen, fonksiyon orijinal değişkeni değiştirebilir.

Değer ile Geçirme (Pass by Value)

void arttir(int x) {
    x++;  // Kopya uzerinde islem — orijinali etkilemez
}

int main() {
    int sayi = 10;
    arttir(sayi);
    cout << sayi;  // 10 — degismedi!
}

Referans ile Geçirme (Pass by Reference)

#include <iostream>
using namespace std;

void arttir(int& x) {
    x++;  // Orijinal degisken uzerinde islem
}

int main() {
    int sayi = 10;
    arttir(sayi);
    cout << sayi << endl;  // 11 — degisti!

    return 0;
}

Fark sadece parametredeki & işareti. Ama sonuç tamamen farklı: fonksiyon artık orijinal değişkenle çalışıyor.

İki Değişkeni Takas Etme

#include <iostream>
using namespace std;

void takasEt(int& a, int& b) {
    int gecici = a;
    a = b;
    b = gecici;
}

int main() {
    int x = 5, y = 10;
    cout << "Once  -> x: " << x << ", y: " << y << endl;

    takasEt(x, y);
    cout << "Sonra -> x: " << x << ", y: " << y << endl;

    return 0;
}

Once  -> x: 5, y: 10
Sonra -> x: 10, y: 5

Pointer versiyonuyla karşılaştır — referans versiyonu çok daha temiz. &x, *a gibi sembollerle uğraşmıyorsun.

const Referans

Bir referansı const yaparsan, o referans üzerinden değeri değiştiremezsin. Bu, "bakabilirsin ama dokunma" demektir.

#include <iostream>
using namespace std;

void yazdir(const int& deger) {
    cout << "Deger: " << deger << endl;
    // deger = 99;  // HATA! const referans degistirilemez
}

int main() {
    int x = 42;
    yazdir(x);

    return 0;
}

const Referans Neden Önemli?

Büyük nesneleri fonksiyona geçirirken iki sorun var:

1. Kopyalamak yavaş — 1MB'lık bir struct'ı her seferinde kopyalamak istemezsin.

2. Referans ile geçirmek hızlı ama fonksiyon değeri değiştirebilir — bu istenmeyen bir yan etki olabilir.

const referans ikisinin de çözümü: hem kopyalama yok, hem değiştirme yok.

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

// KOTU: string kopyalaniyor (yavas)
void yazdir1(string metin) {
    cout << metin << endl;
}

// KOTU: degistirilebilir (tehlikeli)
void yazdir2(string& metin) {
    cout << metin << endl;
}

// IDEAL: kopya yok + degistirilemez
void yazdir3(const string& metin) {
    cout << metin << endl;
}

int main() {
    string mesaj = "Merhaba Dunya!";
    yazdir3(mesaj);

    return 0;
}

💡 İpucu: Genel kural: fonksiyona büyük nesneler geçirirken const referans kullan. Küçük tipler (int, double, char) için değerle geçirmek yeterli — kopyalama maliyeti zaten düşük.

const Referans ve Geçici Değerler

const referansın özel bir özelliği var — geçici değerlere (temporary/rvalue) bağlanabilir:

const int& ref = 42;       // OK — const referans gecici degere baglanabilir
// int& ref = 42;          // HATA — normal referans gecici degere baglanamaz

const string& s = "merhaba";  // OK
// string& s = "merhaba";     // HATA

Bu özellik, fonksiyon çağrılarında çok işe yarar:

void yazdir(const string& s) {
    cout << s << endl;
}

yazdir("dogrudan string literal");  // OK — const ref gecici degere baglanir

Referans Döndüren Fonksiyonlar

Fonksiyonlar referans döndürebilir. Bu, fonksiyonun sonucunu doğrudan değiştirmenizi sağlar.

#include <iostream>
using namespace std;

int& enBuyukBul(int& a, int& b) {
    return (a > b) ? a : b;
}

int main() {
    int x = 10, y = 20;

    cout << "En buyuk: " << enBuyukBul(x, y) << endl;  // 20

    enBuyukBul(x, y) = 99;  // y'yi degistir!
    cout << "y: " << y << endl;  // 99

    return 0;
}

Fonksiyon referans döndürdüğü için, sonucuna atama yapabiliyoruz. Bu pattern, operator overloading'de çok sık kullanılır (örneğin [] operatörü).

⚠️ Dikkat: Yerel değişkene referans döndürme! Bu dangling reference oluşturur — birazdan göreceğiz.

Pointer vs Referans: Farklar Tablosu

Bellekte Ne Olur?

int x = 42;
int* ptr = &x;   // Bellekte ayri bir degisken (8 byte adres tutar)
int& ref = x;    // Bellekte ek yer kaplamayabilir (derleyici optimize eder)

Pointer bellekte ayrı bir alan kaplar — orada adres saklanır. Referans ise çoğu zaman derleyici tarafından optimize edilir ve ayrı bir yer kaplamaz. Ama pratikte derleyici, referansı da arka planda pointer olarak implement edebilir.

Referans Ne Zaman, Pointer Ne Zaman?

Referans Kullan:

• Fonksiyon parametresi olarak büyük nesneler geçirirken (const T&)

• Fonksiyon parametresiyle orijinal değişkeni değiştirmek istediğinde (T&)

• Operatör overloading'de

• Nesne her zaman var olacaksa (null durumu yoksa)

• Basit ve temiz syntax istiyorsan

Pointer Kullan:

• Değer opsiyonel olabilirse (nullptr olabilir)

• Pointer'ı başka bir nesneye yönlendirmen gerekiyorsa

• Dinamik bellek yönetimi yapıyorsan (new/delete)

• C API'leriyle çalışıyorsan

• Veri yapıları (linked list, tree) oluşturuyorsan

• Pointer aritmetiği gerekiyorsa

💡 İpucu: Modern C++ felsefesi: "Referans kullanabiliyorsan referans kullan. Pointer'a ihtiyacın varsa smart pointer kullan. Raw pointer en son çare olsun."

// Tercih sirasi:
void fonk(const string& s);     // 1. const referans (en yaygin)
void fonk(string& s);           // 2. referans (degistireceksen)
void fonk(unique_ptr<string> s); // 3. smart pointer (sahiplik aktarimi)
void fonk(string* s);           // 4. raw pointer (nadiren)

Dangling Reference Tehlikesi

Dangling reference (sarkan referans), artık geçerli olmayan bir bellek alanına bağlı referanstır. Bu, en tehlikeli bug türlerinden biridir çünkü program bazen çalışır, bazen çöker — belirsiz davranış (undefined behavior).

Yerel Değişkene Referans Döndürme

#include <iostream>
using namespace std;

// TEHLIKELI — bunu yapma!
int& tehlikeliFonksiyon() {
    int yerel = 42;
    return yerel;  // yerel degisken yok olacak!
}

int main() {
    int& ref = tehlikeliFonksiyon();
    // ref artik gecersiz bir yeri gosteriyor
    cout << ref << endl;  // Undefined behavior!

    return 0;
}

yerel değişkeni fonksiyon bittiğinde bellekten silinir. Ama ref hâlâ o eski adrese bağlı. Bu adresteki veri artık güvenilir değil — o alan başka bir şey tarafından kullanılmış olabilir.

⚠️ Dikkat: Modern derleyiciler (GCC, Clang) bu hatayı genellikle yakalar ve uyarı verir. Ama tüm durumları yakalaması garanti değildir. Kuralı bilmek senin sorumluluğun.

Geçerli Referans Döndürme Örnekleri

// OK — parametre referansi donduruyor (cagiranin sahip oldugu deger)
int& guvenli1(int& x) {
    return x;
}

// OK — static degisken donduruyor (program boyunca yasıyor)
int& guvenli2() {
    static int deger = 0;
    deger++;
    return deger;
}

// OK — sinif uyesi donduruyor (nesne yasadigi surece gecerli)
class Kutu {
    int boyut;
public:
    int& boyutAl() { return boyut; }
};

Kural basit: döndürdüğün referansın bağlı olduğu değişken, referans kullanılırken hâlâ hayatta olmalı.

Referans ve auto

C++11'deki auto anahtar kelimesi referanslarla dikkatli kullanılmalı:

#include <iostream>
using namespace std;

int main() {
    int x = 42;
    int& ref = x;

    auto a = ref;     // a'nin tipi int (kopya!)
    auto& b = ref;    // b'nin tipi int& (referans)

    a = 100;
    cout << "x: " << x << endl;  // 42 — a kopya, x degismedi

    b = 200;
    cout << "x: " << x << endl;  // 200 — b referans, x degisti

    return 0;
}

auto referansı otomatik düşürmez — auto& yazman gerekir. Aksi halde kopya alırsın.

Fonksiyon Overloading ve Referans

Referans parametreler, fonksiyon overloading'de de kullanılır:

#include <iostream>
using namespace std;

void isle(int& x) {
    cout << "lvalue referans: " << x << endl;
}

void isle(const int& x) {
    cout << "const lvalue referans: " << x << endl;
}

void isle(int&& x) {
    cout << "rvalue referans: " << x << endl;
}

int main() {
    int a = 10;
    const int b = 20;

    isle(a);     // lvalue referans
    isle(b);     // const lvalue referans
    isle(30);    // rvalue referans

    return 0;
}

int&& — bu bir rvalue referans. C++11 ile gelen move semantics'in temelidir. Şimdilik sadece varlığını bil, ileride detaylı göreceğiz.

Yaygın Hatalar

1. Referansı Başlatmadan Tanımlamak

int& ref;  // HATA — derleyici reddeder

2. Geçici Değere Normal Referans Bağlamak

int& ref = 42;          // HATA
const int& ref = 42;    // OK

3. Referansın Yeniden Bağlanacağını Sanmak

int a = 10, b = 20;
int& ref = a;
ref = b;        // ref hala a'ya bagli! a'ya 20 atadi
cout << a;      // 20

4. Yerel Değişkene Referans Döndürmek

int& tehlikeli() {
    int x = 5;
    return x;  // Dangling reference!
}

Özet

• Referans (&), bir değişkenin takma adıdır — aynı bellek hücresini paylaşır, ayrı yer kaplamaz.

• Referans null olamaz, başlatılmalıdır ve yeniden bağlanamaz — bu onu pointer'dan daha güvenli yapar.

• `const` referans hem kopyalamayı önler hem değiştirmeyi engeller — fonksiyon parametrelerinde ideal seçimdir.

• Pointer kullan eğer nullptr olasılığı varsa, yeniden yönlendirme gerekiyorsa veya dinamik bellek yönetimi yapıyorsan.

• Dangling reference, yok olmuş bir değişkene bağlı kalan referanstır — yerel değişkene referans döndürme, asla.

• Modern C++ felsefesi: önce const T&, sonra T&, en son raw pointer. Mümkünse referansı tercih et.