====== Referanslar ======

C++'da referans, mevcut bir nesne için bir takma addır. Bir referans tanımlandıktan sonra, referans üzerindeki gerçekleştirilen herhangi bir işlem refere edilen nesneye uygulanır.

Başlangıçta çok saçma gelsede. Aslında referanslar C++'ın en önemli özelliklerinden biridir.

C++'da fonksiyonlarada referanslar oluşturulabilir. Ancak bu kullanım pek yaygın değildir.

C++'da iki çeşit referans vardır. Bunlar **r-value** ve **l-value** referanslarıdır.

===== L-Value Referansları =====

Bir lvalue referansı, mevcut bir lvalue için takma ad görevi görür.

Bir lvalue referansını bildirmek için; referansın tipine **&** işareti eklenir.

<code cpp>
int      // normal bir int tipi
int&     // int tipi nesneye bir lvalue referansı
double&  // double tipi nesneye bir lvalue referansı
</code>

==== L-Value Referans Değişkeni ====

Bir lvalue referans tipiyle yapılabilecek şeylerden biri de bir lvalue referans değişkeni oluşturmaktır.
Bir lvalue referans değişkeni, bir lvalue'ye referans olarak davranan bir değişkendir.((Buradaki değişken tabiri uygun bir kullanım değildir. Yazının devamında sebebini anlayabilirsiniz.))

<code cpp>
int x { 5 };                // x normal bir int değişkenidir
int& ref { x };             // ref artık x değişkeni için takma ad olarak kullanılabilen bir lvalue referans değişkenidir
std::cout << x << '\n';     // x değerini yani 5 yazdırır
std::cout << ref << '\n';   // ref  aracılığıyla x değerini yani 5 yazdırır
</code>

<WRAP round info>
Bir referans tanımlarken, & işaretini tipin yanına yerleştirin.((Derleyici açısından herhangi bir fark yoktur. ancak okunurluk açısından daha iyi olur.))
</WRAP>

Referanslar C++'da birer nesne değillerdir. Bir referansın var olması veya bellek alanı işgal etmesi gerekmez. Derleyici eğer mümkünse, bir referansın kullanıldığı yerlerde refere edilen nesne ile değiştirerek referansları optimize edecektir. Ancak, bu her zaman mümkün değildir ve bu gibi durumlarda referanslar bellek alanı gerektirebilir.

Bu sebepten ötürü referans değişleni isimlendirmesi biraz yanıltıcı olmaktadır. Çünkü referanslar birer nesne değillerdir.

Referanslar nesne olmadıkları için, bir nesnenin gerekli olduğu her yerde kullanılamazlar. Nesne olan bir referansa veya yeniden atanabilen bir referansa ihtiyaç duyduğunuz durumlarda, ''std::reference_wrapper'' kullanabilirsiniz.

-----

Sabitler gibi referanslarda bildirilirken başlatılmak zorundadır.

<code cpp>
    int& invalidRef;    // HATA: referanslar başlatılmalıdır
    int x { 5 };
    int& ref { x };     // int referansı int değişkenine bağlanır.
}
</code>

<WRAP round important>
Referanslar başlatıldıklarında refere ettikleri nesneye bağlanırlar. Buna referans bağlaması denir. Bir kere bağlandıktan sonra başka bir nesneyi refere edemezler. Yani bağlanmış bir referans başka bir nesneyi refere etmesi için yeniden atanamaz.
</WRAP>

Lvalue referansları sadece değiştirilebilir lvalue nesnelere bağlanabilir. ''const'' nesnelere bağlanamaz. Çünkü o zaman referans üzerinden o nesnelere müdahale edilebilir.

<WRAP round important>
Referanslar ve refere ettikleri nesnelerin ömürleri birbirlerinden bağımsızdır.
  * Referanslar, bağlı oldukları nesneden önce silinebilirler.
  * Refere edilen nesneler, referanslarından önce silinebilirler.

Bu ikinci durum. sızıntıya neden olabilir. Bir referansın refere ettiği nesne silinirse, referans üzerinden o nesneye erişilmeye çalışılırsa, <wrap em>tanımsız davranış oluşur</wrap>.
</WRAP>

==== Const L-Value Referansları ====

Lvalue referansları tanımlanırken ''const'' anahtar kelimesi kullanılırsa bu referanslar, bağlı oldukları nesne sabitmiş gibi davranırlar.

Referansın bağlanacağı nesnenin sabit olması zorunlu değildir. Arka plandaki nesne değiştirilebilir olsa dahi **const lvalue referansı** üzerinden değiştirilemez.


<code cpp>
    const int x { 5 };      // x değiştirilemeyen bir lvalue'dir.
    const int& ref_x { x }; // ref_x bir const değere yapılan bir lvalue referansıdır
    int y { 5 };            // x değiştirilebilir bir lvalue'dir.
    const int& ref_y { x }; // bir const referansı değiştirilebilir bir lvalue'ye bağlayabiliriz

    ref_y = 7;              // HATA: const referans aracılığıyla bir nesneyi değiştiremeyiz
</code>

<WRAP round info>
Refere edilen nesneyi değiştirmeniz gerekmediği durumlarda, ''const'' lvalue referansları kullanmak daha iyidir.
</WRAP>

Const lvalue referansları, rvalue'yede bağlanabilir.

<code cpp>
    const int& ref { 5 };     // 5 bir rvalue'dir.
    std::cout << ref << '\n'; // 5 yazdırır.
</code>

Böyle bir durumda geçici bir nesne oluşturulur ve rvalue ile başlatılır. Referansımız bu geçici nesneye bağlanır.

Normalde bildiğimiz gibi geçici nesneler bulundukları ifadenin sonunda silinirler. Ancak bu durumda referansımız sızıntıya sebep olması gerekir. C++ bunun önüne geçmek için bu duruma özel geçici nesnenin ömrünü uzatır.

<WRAP round tip>
Bir const lvalue referansı geçici bir nesneye bağlandığında, geçici nesnenin ömrü referansın ömrüne uyacak şekilde uzatılır.
</WRAP>

<wrap onlyprint>[[tr:cs:cpp:common:reference|UCH Viki]]'den alınmıştır.</wrap>
<wrap hide>
https://wiki.ulascemh.com/doku.php?id=tr:cs:cpp:common:reference
</wrap>