Lulus dengan referensi dalam C

Jika C tidak mendukung melewati variabel dengan referensi, mengapa ini bekerja?

#include <stdio.h>

void f(int *j) {
  (*j)++;
}

int main() {
  int i = 20;
  int *p = &i;
  f(p);
  printf("i = %d\n", i);

  return 0;
}

Keluaran:

$ gcc -std=c99 test.c
$ a.exe
i = 21 

Karena Anda melewatkan nilai pointer ke metode dan kemudian mendereferensi untuk mendapatkan integer yang ditunjuk.

Itu bukan pass-by-reference, yaitu pass-by-value seperti yang dinyatakan orang lain.

Bahasa C adalah pass-by-value tanpa kecuali. Melewati pointer sebagai parameter tidak berarti lulus dengan referensi.

Aturannya adalah sebagai berikut:

Suatu fungsi tidak dapat mengubah nilai parameter aktual.

Mari kita coba melihat perbedaan antara parameter skalar dan pointer dari suatu fungsi.

Variabel skalar

Program singkat ini menunjukkan nilai per nilai menggunakan variabel skalar. paramdisebut parameter formal dan variablepada pemanggilan fungsi disebut parameter aktual. Catatan kenaikan paramfungsi tidak berubah variable.

#include <stdio.h>

void function(int param) {
    printf("I've received value %d\n", param);
    param++;
}

int main(void) {
    int variable = 111;

    function(variable);
    printf("variable %d\m", variable);
    return 0;
}

Hasilnya adalah

I've received value 111
variable=111

Ilusi pass-by-reference

Kami mengubah sedikit kode. paramadalah pointer sekarang.

#include <stdio.h>

void function2(int *param) {
    printf("I've received value %d\n", *param);
    (*param)++;
}

int main(void) {
    int variable = 111;

    function2(&variable);
    printf("variable %d\n", variable);
    return 0;
}

Hasilnya adalah

I've received value 111
variable=112

Itu membuat Anda percaya bahwa parameter dilewatkan oleh referensi. Bukan itu. Itu diteruskan oleh nilai, nilai param menjadi alamat. Nilai tipe int bertambah, dan itulah efek samping yang membuat kita berpikir bahwa itu adalah panggilan fungsi pass-by-reference.

Pointer - melewati nilai

Bagaimana kita bisa menunjukkan / membuktikan fakta itu? Yah, mungkin kita bisa mencoba contoh pertama variabel Scalar, tetapi alih-alih skalar kita menggunakan alamat (pointer). Mari kita lihat apakah itu bisa membantu.

#include <stdio.h>

void function2(int *param) {
    printf("param's address %d\n", param);
    param = NULL;
}

int main(void) {
    int variable = 111;
    int *ptr = &variable;

    function2(ptr);
    printf("ptr's address %d\n", ptr);
    return 0;
}

Hasilnya adalah bahwa kedua alamat tersebut sama (jangan khawatir tentang nilai pastinya).

Contoh hasil:

param's address -1846583468
ptr's address -1846583468

Menurut pendapat saya ini membuktikan dengan jelas bahwa pointer dilewatkan oleh nilai. Kalau tidak ptrakan NULLsetelah pemanggilan fungsi.

Dalam C, Pass-by-reference disimulasikan dengan mengirimkan alamat variabel (pointer) dan mendereferensi alamat tersebut dalam fungsi untuk membaca atau menulis variabel aktual. Ini akan disebut sebagai "pass-by-reference gaya C".

Sumber: www-cs-students.stanford.edu

Karena tidak ada pass-by-reference dalam kode di atas. Menggunakan pointer (seperti void func(int* p)) adalah pass-by-address. Ini adalah referensi per detik dalam C ++ (tidak akan berfungsi dalam C):

void func(int& ref) {ref = 4;}

...
int a;
func(a);
// a is 4 now

Contoh Anda berfungsi karena Anda meneruskan alamat variabel Anda ke fungsi yang memanipulasi nilainya dengan operator dereference .

Sementara C tidak mendukung tipe data referensi , Anda masih bisa mensimulasikan melewati-oleh-referensi dengan secara eksplisit melewati nilai pointer, seperti dalam contoh Anda.

Tipe data referensi C ++ kurang kuat tetapi dianggap lebih aman daripada tipe pointer yang diwarisi dari C. Ini akan menjadi contoh Anda, disesuaikan untuk menggunakan referensi C ++ :

void f(int &j) {
  j++;
}

int main() {
  int i = 20;
  f(i);
  printf("i = %d\n", i);

  return 0;
}

Anda melewati sebuah pointer (alamat lokasi) berdasarkan nilai .

Itu seperti mengatakan "inilah tempat dengan data yang saya ingin Anda perbarui."

p adalah variabel pointer. Nilainya adalah alamat i. Saat Anda memanggil f, Anda meneruskan nilai p, yang merupakan alamat i.

Tidak ada pass-by-reference di C, tetapi p "merujuk" ke i, dan Anda melewatkan p dengan nilai.

Dalam C semuanya pass-by-value. Penggunaan pointer memberi kita ilusi bahwa kita melewati referensi karena nilai variabel berubah. Namun, jika Anda mencetak alamat variabel pointer, Anda akan melihat bahwa itu tidak terpengaruh. Sebuah salinan dari nilai dari alamat dilewatkan-in ke fungsi. Di bawah ini adalah cuplikan yang menggambarkan hal itu.

void add_number(int *a) {
    *a = *a + 2;
}

int main(int argc, char *argv[]) {
   int a = 2;

   printf("before pass by reference, a == %i\n", a);
   add_number(&a);
   printf("after  pass by reference, a == %i\n", a);

   printf("before pass by reference, a == %p\n", &a);
   add_number(&a);
   printf("after  pass by reference, a == %p\n", &a);

}

before pass by reference, a == 2
after  pass by reference, a == 4
before pass by reference, a == 0x7fff5cf417ec
after  pass by reference, a == 0x7fff5cf417ec

Karena Anda melewatkan pointer (alamat memori) ke variabel p ke dalam fungsi f. Dengan kata lain Anda melewatkan pointer bukan referensi.

Jawaban singkat: Ya, C mengimplementasikan parameter passing dengan referensi menggunakan pointer.

Saat mengimplementasikan parameter passing, perancang bahasa pemrograman menggunakan tiga strategi yang berbeda (atau model semantik): mentransfer data ke subprogram, menerima data dari subprogram, atau melakukan keduanya. Model-model ini umumnya dikenal sebagai dalam mode, mode keluar, dan mode keluar, sesuai.

Beberapa model telah dirancang oleh perancang bahasa untuk menerapkan tiga strategi pengoperan parameter dasar ini:

Pass-by-Value (dalam mode semantik) Pass-by-Result (semantik mode out) Pass-by-Value-Result (semantik mode inout) Pass-by-Reference (semantik mode inout) Pass-by-Name (mode inout) semantik)

Pass-by-reference adalah teknik kedua untuk passing parameter mode keluar. Alih-alih menyalin data bolak-balik antara rutin utama dan subprogram, sistem runtime mengirim jalur akses langsung ke data untuk subprogram. Dalam strategi ini, subprogram memiliki akses langsung ke data yang secara efektif berbagi data dengan rutin utama. Keuntungan utama dengan teknik ini adalah sangat efisien dalam waktu dan ruang karena tidak perlu menduplikasi ruang dan tidak ada operasi penyalinan data.

Implementasi passing parameter dalam C: C mengimplementasikan semantik nilai demi nilai dan juga semantik (inout mode) dengan menggunakan pointer sebagai parameter. Pointer dikirim ke subprogram dan tidak ada data aktual yang disalin sama sekali. Namun, karena pointer adalah jalur akses ke data rutin utama, subprogram dapat mengubah data dalam rutinitas utama. C mengadopsi metode ini dari ALGOL68.

Implementasi passing parameter dalam C ++: C ++ juga mengimplementasikan semantik pass-by-reference (mode keluaran) menggunakan pointer dan juga menggunakan pointer jenis khusus, yang disebut tipe referensi. Pointer tipe referensi secara implisit direferensikan di dalam subprogram tetapi semantik mereka juga lulus-oleh-referensi.

Jadi konsep utama di sini adalah pass-by-reference mengimplementasikan jalur akses ke data alih-alih menyalin data ke dalam subprogram. Jalur akses data dapat berupa pointer dereferensi secara eksplisit atau pointer dereferensi otomatis (tipe referensi).

Untuk info lebih lanjut, silakan merujuk ke buku Concepts of Programming Languages ​​oleh Robert Sebesta, 10th Ed., Bab 9.

Anda tidak melewatkan int dengan referensi, Anda melewati nilai pointer-to-an-int. Sintaks berbeda, artinya sama.

Dalam C, untuk lulus dengan referensi Anda menggunakan alamat-operator &yang harus digunakan terhadap variabel, tetapi dalam kasus Anda, karena Anda telah menggunakan variabel pointer p, Anda tidak perlu awalan dengan alamat-operator. Itu akan menjadi benar jika Anda digunakan &isebagai parameter: f(&i).

Anda juga dapat menambahkan ini, ke dereferensi pdan melihat bagaimana nilai itu cocok i:

printf("p=%d \n",*p);

pointer dan referensi adalah dua hal yang berbeda.

Beberapa hal yang belum saya lihat disebutkan.

Pointer adalah alamat sesuatu. Pointer dapat disimpan dan disalin seperti variabel lainnya. Dengan demikian memiliki ukuran.

Referensi harus dilihat sebagai ALIAS sesuatu. Itu tidak memiliki ukuran dan tidak dapat disimpan. Ini HARUS referensi sesuatu, yaitu. itu tidak bisa nol atau diubah. Yah, kadang-kadang kompiler perlu menyimpan referensi sebagai pointer, tetapi itu adalah detail implementasi.

Dengan referensi Anda tidak memiliki masalah dengan pointer, seperti penanganan kepemilikan, pemeriksaan nol, de-referensi penggunaan.

'Lulus dengan referensi' (dengan menggunakan petunjuk) telah ada di C dari awal. Menurut Anda mengapa tidak?

Saya pikir C sebenarnya mendukung pass by reference.

Sebagian besar bahasa membutuhkan gula sintaksis untuk lulus dengan referensi alih-alih nilai. (C ++ misalnya membutuhkan & dalam deklarasi parameter).

C juga membutuhkan gula sintaksis untuk ini. Itu * dalam deklarasi tipe parameter dan & pada argumen. Jadi * dan & adalah sintaks C untuk pass by reference.

Orang sekarang dapat berpendapat bahwa pass by reference sebenarnya hanya memerlukan sintaks pada deklarasi parameter, bukan pada sisi argumen.

Tapi sekarang datang C # yang melakukan dukungan dengan referensi yang lewat dan membutuhkan gula sintaksis pada kedua parameter dan argumen sisi.

Argumen bahwa C tidak memiliki by-ref menyebabkan elemen sintaksis untuk mengekspresikannya menunjukkan implementasi teknis yang mendasarinya bukanlah argumen sama sekali, karena ini berlaku lebih atau kurang untuk semua implementasi.

Satu-satunya argumen yang tersisa adalah bahwa melewati oleh ref dalam C bukan fitur monolitik tetapi menggabungkan dua fitur yang ada. (Ambil ref argumen oleh &, harapkan ref untuk mengetikkan dengan *.) C # misalnya memang membutuhkan dua elemen sintaksis, tetapi mereka tidak dapat digunakan tanpa satu sama lain.

Ini jelas argumen yang berbahaya, karena banyak fitur lain dalam bahasa yang terdiri dari fitur lain. (seperti dukungan string dalam C ++)

Apa yang Anda lakukan adalah nilai demi nilai, bukan referensi. Karena Anda mengirim nilai variabel 'p' ke fungsi 'f' (utama sebagai f (p);)

Program yang sama dalam C dengan pass by reference akan terlihat seperti, (!!! program ini memberikan 2 kesalahan karena pass by reference tidak didukung dalam C)

#include <stdio.h>

void f(int &j) {    //j is reference variable to i same as int &j = i
  j++;
}

int main() {
  int i = 20;
  f(i);
  printf("i = %d\n", i);

  return 0;
}

Keluaran:-

3:12: kesalahan: diharapkan ';', ',' atau ')' sebelum '&' token
             batal f (int & j);
                        ^
9: 3: peringatan: pernyataan implisit fungsi 'f'
               f (a);
               ^