C++'da Dönüş Referansı

C Da Donus Referansi



C++, bir değeri veya adresi işaretçiler yerine referansına göre döndürme olanağı sağlar. İşaretçiler yerine referansların kullanılması, bir C++ programının okunmasını ve yönetilmesini kolaylaştırabilir. C++'da referanslar ve işaretçiler birbiriyle yakından ilişkilidir. Temel fark, referansların yalnızca alternatif bir ad (başka bir değişken için 'takma ad') olmasına rağmen, işaretçilerin değer ekleme gibi işlemlerde kullanılabilmesidir. Referans, orijinal değerin alternatif adı veya kopyasıdır ve '&' sembolüyle gösterilir.

Örnek 1:

“iostream” başlık dosyasını içe aktarıyoruz ve ardından “std” ad alanını kullanıyoruz. Başlık dosyaları, birçok fonksiyon tanımlandığı için C++ kodlarına aktarılır. Daha sonra fonksiyonun adı olan “returnTheValue”nun yanına “&” sembolünü yerleştirerek bir dönüş referans fonksiyonu oluşturuyoruz.







Burada “değer” referansı artık eklenmiştir. Bunun altına değeri ve “&value” referanslı adresi yazdırıyoruz. Daha sonra dönüş referansını yerleştirip “değeri” yerleştiriyoruz. Şimdi burada “main()” çağrılıyor ve “n1”i “44” değeriyle başlatıyoruz. Bunun altında “int& n2”, “returnTheValue(n1)” ile başlatılır. Şimdi “n1”in değerini ve adresini yazdırıyoruz. Daha sonra “cout”u kullanarak “n2”nin değerini ve “n2”nin adresini yazdırıyoruz.



Kod 1:



#include
ad alanı std'sini kullanma;
int & returnTheValue ( int & değer )
{
cout << 'Değer =' << değer << sonunda
<< 'Değerin adresi'
<< & değer << sonunda;
geri dönmek değer;
}
int ana ( )
{
sen n1 = 44 ;
int & n2 = returnTheValue ( n1 ) ;
cout << 'n1 =' << n1 << sonunda
<< 'n1'in adresi:'
<< & n1 << sonunda;
cout << 'n2 =' << n2 << sonunda
<< 'n2'nin adresi:'
<< & n2 << sonunda;
geri dönmek 0 ;
}


Çıktı:





Burada bir referansın, aşağıda gösterildiği gibi yalnızca başka bir değişkenin alternatif adı olduğunu not edebiliriz. Değerin adresi olan “n1” ve “n2” hiçbir zaman değişmez.



Örnek 2:

“iostream” başlık dosyasını içe aktardıktan sonra “std” ad alanını kullanıyoruz. Daha sonra, bir dönüş referansı işlevi oluşturmak için “MyReturnValueFunc” işlev adını ve “&” sembolünü kullanırız. “v1” değişkenine referans buraya yerleştirilir. Bunun altına “&v1” referansı ile değeri ve adresi yazdırıyoruz. Daha sonra bu konuma “return” ve “v1” kullanarak “return reference”ı ekliyoruz. Burada “main()” çağrılır ve “num_1” “19” değeri ile başlatılır. “int& num_2”nin başlatılması “MyReturnValueFunc(num_1)” ile yapılır.

Şu anda “num_1” değerini ve adresini yazdırıyoruz ve “cout” kullanarak “num_2” değerini ve adresini yazdırıyoruz. Artık “MyReturnValueFunc”un buraya döndürdüğü adresi kullanarak “num_1”in değerini değiştiriyoruz. Bu işlev, aynı zamanda 'num_1'in alternatif adı olan 'v1'in alternatif adını döndürür. Böylece değerini değiştirip “91” olarak ayarlıyoruz. Burada takma ad görevi gören “MyReturnValueFunc(num_1)” öğesine “91” atadık. Daha sonra tekrar değeri ve “num_1” adresini yazdırıyoruz.

Kod 2:

#include
ad alanı std'sini kullanma;
int & Dönüş Değerim İşlevi ( int & v1 )
{
cout << 'v1'in değeri = ' << v1 << sonunda
<< 'v1 değişkeninin adresi:'
<< & v1 << sonunda;
geri dönmek v1;
}
int ana ( )
{
int sayı_1 = 19 ;
int & num_2 = DönüşDeğerimİşlevim ( sayı_1 ) ;
cout << 'Sayı_1'in değeri = ' << sayı_1 << sonunda
<< ' Num_1'in adresi: '
<< & sayı_1 << sonunda;
cout << 'Sayı_2'nin değeri = ' << sayı_2 << sonunda
<< ' Num_2'nin adresi: '
<< & sayı_2 << sonunda;
Dönüş Değerim İşlevi ( sayı_1 ) = 91 ;
cout << 'Şimdi num_1'in değeri = ' << sayı_1 << sonunda
<< 'Numara_1'in adresi: '
<< & sayı_1 << sonunda;
geri dönmek 0 ;
}


Çıktı:

Aşağıda da gösterildiği gibi “v1”, “num_1” ve “num_2” değerlerinin adresi sabit kaldığından referansın yalnızca başka bir değişkenin alternatif adı olduğunu görebiliriz:

Örnek 3:

“iostream” başlık dosyası içe aktarılır ve “std” ad alanı kullanılır. Başlık dosyalarında çok sayıda fonksiyon belirtildiği için bunları C++ kodlarına aktarıyoruz. Burada referansı döndüren “int& my_ref”i yerleştirdiğimiz “ReturnRefFun()” fonksiyonunu oluşturuyoruz. “int& ReturnRefFun” burada referans işlevi olarak bildirildi. Bundan sonra “my_ref” değişkeninin değerini arttırıyoruz. Bunun altına “my_ref”in referansını döndüren “return”u koyuyoruz.

Bundan sonra burada “main()” metodu çağrılır. Daha sonra “first_value” değişkenini “21” ile başlatıyoruz. Bunun altında “ReturnRefFun” fonksiyonuna “first_value” yerleştirip referansın kopyasını döndürüp “copied_value” değişkenine kaydediyoruz. Daha sonra “cout”u kullanarak hem “ilk_değer”i hem de “kopyalanan_değeri” yazdırıyoruz. Bunun altına “kopyalanan_değer++” koyarak “kopyalanan_değer” değişkenini arttırıyoruz. Daha sonra “kopyalanan_değer”i artırıp, “ilk_değer”i ise “cout” kullanarak yazdırıyoruz. Bundan sonra “int& ref_value” değişkenini “ReturnRefFun(first_value)” ile başlatarak referansı döndürüyoruz.

Bundan sonra kopyaladığımız “my_ref” değişkeninin değerini yazdırıyoruz. Daha sonra “first_value” değişkeninin değerini yazdırıyoruz. Bunun altına “ref_value++” koyarak “ref_value” değerini arttırıyoruz. Bunun altına “ref_value”nun artırılmış değerini ve “cout” yardımıyla “first_value” değişkenini yazdırıyoruz. “Ref_value” değiştirildiğinde “first_value” da değişecektir.

Kod 3:

#include
ad alanı std'sini kullanma;
int & DönüşRefEğlenceli ( int & benim_ref ) {
my_ref++;
geri dönmek my_ref;
}
int ana ( ) {
int ilk_değer = yirmi bir ;
int kopyalanan_değer =DönüşRefEğlenceli ( ilk_değer ) ;
cout << 'İlk değer: ' << ilk_değer << sonunda;
cout << 'Kopyalanan değer: ' << kopyalanan_değer << sonunda;
kopyalanan_değer++;
cout << 'Kopyalanan_değer artırıldı: ' << kopyalanan_değer << sonunda;
cout << 'İlk değer: ' << ilk_değer << sonunda;
int & ref_value =DönüşRefEğlenceli ( ilk_değer ) ;
cout << 'Referans kopyalanan değer: ' << ref_value << sonunda;
cout << 'İlk değer: ' << ilk_değer << sonunda;
ref_value++;
cout << 'Referans değeri artırıldı: ' << ref_value << sonunda;
cout << 'İlk değer: ' << ilk_değer << sonunda;
geri dönmek 0 ;
}


Çıktı:

İşte “dönüş referansı” tekniğini kullandığımız önceki kodun sonucu. Örnek, referans değişkeninin bir kopyasını döndürmek ile referans değişkeninin kendisini döndürmek arasındaki farkı gösterir.

Örnek 4:

Burada referans değişkenini döndüren referans işlevi olarak “int& rByRef” bildirilir. Bu “int& rByref()” fonksiyonuna “int& data”yı aktarıyoruz. Burada “data” değişkeninin adresini yazdırıyoruz ve ardından bunun altındaki dönüş referansını kullanıyoruz. Şimdi “main()” metodunu çağırdıktan sonra “x_var” değişkenini başlatıyoruz. Daha sonra “cout” içerisine “&x_var” koyarak “x_var”ın adresini buraya yazdırıyoruz.

Bunun altında “int& y_var” değişkenine “rByref(x_var)” atayarak referans değişkenini kullanıyoruz. Daha sonra o “&y_var” referans değişkeninin adresini de yazdırıyoruz. Bunun altında “x_var” değişkenini “z_var” değişkenine kopyalıyoruz ve kopyalanan bu değişkenin adresini de yazdırıyoruz yani “&z_var”. Bundan sonra “rByref()” fonksiyonunu çağırıp içerisine parametre olarak “x_var” değişkenini aktarıyoruz ve bu değişkene “93” atayacağız. Ayrıca “cout”un içine “&x_var”ı koyarak “x_var”ın adresini tekrar oluşturuyoruz.

Kod 4:

#include
ad alanı std'sini kullanma;
int & rByref ( int & veri )
{
cout << 'Veri adresi: ' << & veri << sonunda;
geri dönmek veri;
}
int ana ( )
{
int x_var = 42 ;
cout << 'x_var'ın adresi: ' << & x_var << sonunda;
int & y_var = rByref ( x_var ) ;
cout << 'y_var'ın adresi: ' << & y_var << sonunda;
int z_var = rByref ( x_var ) ;
cout << 'z_var'ın adresi: ' << & z_var << sonunda;
rByref ( x_var ) = 93 ;
cout << 'x_var'ın adresi: ' << & x_var << sonunda;
geri dönmek 0 ;
}


Çıktı:

Sonuç, klonlanmış değişkenin adresi olan 'z_var'ın, orijinal değişken olan 'x_var'ın referans verdiği tüm diğer konumlardan farklı olduğunu açıkça ortaya koymaktadır.

Çözüm

'Geri dönüş referansı' kavramı bu eğitimde ayrıntılı olarak incelenmiştir. “Dönüş referansının” C++ programlamadaki “işaretçiler”e benzer olduğunu öğrendik. Hangi fonksiyonun referans döndürdüğünü belirtmek için fonksiyonun dönüş tipinde “&” sembolünün kullanılması gerektiğini tartıştık. Bu derste bazı örnekleri ve sonuçlarını gösterdik ve bu kavramı anladık.