Karşılaştırma Tablosu:
| Karşılaştırma için temel | Call_By_Value | Referansa Göre Ara |
|---|---|---|
| Temel | Değişkenin bir kopyası iletildi. | Bir değişkenin kendisi iletilir. |
| Efekt | Bir değişkenin kopyasındaki değişiklik, işlev dışındaki değişkenlerin orijinal değerini değiştirmez. | Değişkendeki değişim, fonksiyonun dışındaki değişkenin değerini de etkiler. |
| Arama parametreleri | function_name (değişken_adı1, değişken_adı2, ...); | function_name (& değişken_adı1, & değişken_adı2, ...); // nesne durumunda object.func_name (nesne); |
| Parametreleri alma | type function_name (değişken_adı1 yazın, değişken_adı2, yazın.) {. . } | type function_name (tür * değişken_adı1, tür * değişken_adı2, ....) {. . } // nesne durumunda type function_name (class_type nesnesi_adı) {. . } |
| Varsayılan arama | ilkel tür "değere göre arama" kullanılarak geçirilir. | nesneler "referans ile çağrı" kullanılarak örtük olarak geçirilir. |
Çağrıya Değer Tanımı
Bir işlev / yönteme ilkel bir veri türü (tam sayı, karakter ve dize) iletirseniz, işlev koduna yalnızca “değer” iletilir. İşlev, bir argümanın değerini işlev kodunun 'resmi parametresine' kopyalar. Bir fonksiyon kodunda formal parametrede herhangi bir değişiklik varsa, bu fonksiyonu çağırmak için kullanılan argümanın orijinal değerini değiştirmez.
Basit bir deyişle, eğer bir fonksiyon / yöntem 'değere göre çağır' yaklaşımı ile çağrılıyorsa; daha sonra değişkenin bir kopyası işlev koduna iletilir. Bir fonksiyon kodu değişkenin kopyasındaki değerde herhangi bir değişiklik yaparsa, değişkenin orijinal değerini değiştirmez.
Bunu kısaca anlamak için bir örnek görelim.
// Java sınıfındaki örnek kontrol {void change (int i, int j) {i = i * i; j = j / 2; system.out.println ("fonksiyon içindeki parametrenin değeri"); system.out.println ("a" argümanının değerini kabul eden "i" nin değeri "+ i); system.out.println ("b" argümanının değerini kabul eden "j" nin değeri "+ j); }} sınıf call_by _value {genel statik boşluk ana (string args []) {int a = 12, b = 20; çek C = yeni çek (); system.out.println ("+ a +" "+ b işlev çağrısından önce" a "ve" b "değerleri); C.change (a, b); // değerine göre arayın. system.out.println ("+ a +" "+ b işlev çağrısından sonra" a "ve" b "değerleri); }} // işlev çağrısından önce 'a' ve 'b' çıkış değeri '20' i 'işlev değerinin içindeki' 20 'parametresinin değeri, ' a 'değişkeninin değerini kabul eden' a '144 değerinin' j 'değerini kabul eder. 'b' argümanı İşlev çağrısından sonra 'a' ve 'b' nin 10 değeri 12 20 Referansa Göre Aramanın Tanımı
Reference by Call metodu bir argümanın referansını / adresini fonksiyon koduna iletir. Bir argümanın adresi işlev koduna geçirildiğinde, bu adresi kabul eden biçimsel parametre 'işaretçi' değişkeni olur. Şimdi, fonksiyon kodu bir argümanın adresini edindiğinde, bir argüman değerindeki değişiklik aynı zamanda bir argümanın orijinal değerini de değiştirir.
C ++ ve Java'da nesneyi işleve / yönteme geçirmek çok yaygındır ve nesne her zaman kendi başvurusuyla iletilir. İşlev / yöntem içindeki nesnede yapılan değişiklikler, bu işlevi / yöntemi çağırmak için kullanılan nesneyi etkiler.
Aşağıdaki parça, 'referans ile ara' için doğru yolu gösterir.
// C ++ sınıfındaki örnek takas {void takas (int * x, int * y) {int temp; temp = * x; X = * y; * Y, temp =; }} int main {int a = 10, b = 20; cout << "a, b" << a << "işlev çağrısından önce değeri Şimdi bir 'nesneyi' argüman olarak ileterek, 'referansla çağrı' yaklaşımıyla örtüşen bir argüman olarak ileterek 'referansla ara'yı tartışalım.
sınıf kontrolü {int a, b; check (int x, int b) {// bu inşaatçı tarafından başlatılan nesne a = x; b = y; } boşluk değişimi (kontrol ob) {ob.a = a * 2; ob.b = b / 2; }} sınıf main_class {genel statik boşluk main (string args []) {kontrol C = yeni kontrol (20, 40); // nesne başlatma. system.out.println ("+" ob.a + "" + ob.b işlevinden önce "ob.a" ve "ob.b" değerleri); C.exchange (C); // referans olarak arayın. system.out.println ("+" ob.a + "" + ob.b işlevinden önce "ob.a" ve "ob.b" değerleri); }} // fonksiyon çağrısından önce 40 'ob.a' ve 'ob.b' çıkış değeri 20 40 fonksiyon çağrısından sonra 'ob.a' ve 'ob.b' değeri 40 20 Değere Göre Arama ve Referansa Göre Arama Arasındaki Temel Farklılıklar
- Argümanı 'değer by call' yaklaşımı kullanarak geçmek, sadece bu değişkenin kopyasını iletir, bu nedenle bu değişkenin kopyasındaki değerde yapılan değişiklikler o değişkenin orijinal değerini etkilemez. 'Referansa göre ara' yaklaşımında değişkenin kendisi bir argüman olarak iletilir, bu nedenle değişiklikler, orijinal değişkenin değerini değiştirir.
- İletilen argümanlar ilkel veri türleri ise, bunlar basitçe 'değere göre çağır' dır, ancak argümanların veya nesnelerin referansları / adresleri iletilirse, bir fonksiyon 'referansla ara' yöntemiyle çağrılır.
- 'Değere göre arama' seçeneğinde, iletilen argümanlar yalnızca değişkenlerin adıdır, oysa 'referansa göre çağrı' yaklaşımında iletilen değişkenler, '&' işareti boyunca değişken ismi veya sadece kendi adına geçen bir nesnedir.
- Argümanın parametrelerini 'call by value' yaklaşımında almak, veri tipiyle birlikte değişken isimdir. 'Referansa göre ara' yaklaşımında alıcı parametre her zaman veri tipiyle birlikte bir işaretçi değişkenidir ve nesne durumunda, sınıf tipiyle birlikte bir nesne adıdır.
Sonuç:
C ++ ve Java, geçenlere bağlı olarak her iki yaklaşımı da kullanır. Değişken değerinin sadece değerini 'yaklaşımla' yaklaşımını ve değişkenin orijinal değerindeki değişikliği görmek istiyorsanız 'referansa göre ara' yaklaşımını kullanın.
