Apakah ada manfaat lewat pointer dari melewati referensi di C ++?

Apa manfaat lewat pointer dari melewati referensi di C ++?

Akhir-akhir ini, saya telah melihat sejumlah contoh yang memilih lewat argumen fungsi oleh pointer daripada lewat referensi. Apakah ada manfaatnya melakukan ini?

Contoh:

func(SPRITE *x);

dengan panggilan

func(&mySprite);

vs.

func(SPRITE &x);

dengan panggilan

func(mySprite);

Pointer dapat menerima parameter NULL, parameter referensi tidak bisa. Jika ada kemungkinan Anda ingin meneruskan "tidak ada objek", maka gunakan pointer daripada referensi.

Selain itu, lewat penunjuk memungkinkan Anda melihat secara eksplisit di situs panggilan apakah objek dilewatkan oleh nilai atau dengan referensi:

// Is mySprite passed by value or by reference?  You can't tell 
// without looking at the definition of func()
func(mySprite);

// func2 passes "by pointer" - no need to look up function definition
func2(&mySprite);

Melewati dengan pointer

• Penelepon harus mengambil alamat -> tidak transparan
• Nilai 0 dapat diberikan dengan rata-rata nothing. Ini dapat digunakan untuk memberikan argumen opsional.

Lewati dengan referensi

• Penelepon hanya melewati objek -> transparan. Harus digunakan untuk overloading operator, karena overloading untuk tipe pointer tidak dimungkinkan (pointer adalah tipe builtin). Jadi Anda tidak bisa string s = &str1 + &str2;menggunakan pointer.
• Tidak ada 0 nilai yang mungkin -> Fungsi yang dipanggil tidak perlu memeriksa mereka
• Referensi ke const juga menerima temporaries void f(const T& t); ... f(T(a, b, c));:, pointer tidak dapat digunakan seperti itu karena Anda tidak dapat mengambil alamat sementara.
• Last but not least, referensi lebih mudah digunakan -> lebih sedikit kesempatan untuk bug.

Saya suka alasannya dengan artikel dari "cplusplus.com:"

1. Lewati nilai ketika fungsi tidak ingin memodifikasi parameter dan nilainya mudah untuk disalin (ints, doubles, char, bool, dll ... tipe sederhana. Std :: string, std :: vector, dan semua STL lainnya wadah BUKAN jenis sederhana.)

2. Lewati oleh pointer const ketika nilainya mahal untuk disalin DAN fungsi tersebut tidak ingin mengubah nilai yang menunjuk ke AND NULL adalah nilai yang valid dan diharapkan yang ditangani oleh fungsi tersebut.

3. Lewati oleh pointer non-const ketika nilainya mahal untuk menyalin DAN fungsi ingin mengubah nilai menunjuk ke DAN NULL adalah nilai, valid yang diharapkan bahwa fungsi menangani.

4. Lewati referensi const ketika nilainya mahal untuk disalin DAN fungsi tidak ingin mengubah nilai yang dirujuk DAN NULL tidak akan menjadi nilai yang valid jika pointer digunakan sebagai gantinya.

5. Lewati referensi non-cont ketika nilainya mahal untuk menyalin DAN fungsi ingin mengubah nilai yang dirujuk ke AND NULL tidak akan menjadi nilai yang valid jika pointer digunakan sebagai gantinya.

6. Saat menulis fungsi templat, tidak ada jawaban yang jelas karena ada beberapa pertukaran yang perlu dipertimbangkan yang berada di luar cakupan diskusi ini, tetapi cukuplah untuk mengatakan bahwa sebagian besar fungsi templat mengambil parameternya berdasarkan nilai atau referensi (konst) , namun karena sintaks iterator mirip dengan pointer (asterisk to "dereference"), setiap fungsi templat yang mengharapkan iterator sebagai argumen juga akan secara default menerima pointer juga (dan tidak memeriksa NULL karena konsep iterator NULL memiliki sintaks yang berbeda ).

http://www.cplusplus.com/articles/z6vU7k9E/

Apa yang saya ambil dari ini adalah bahwa perbedaan utama antara memilih untuk menggunakan pointer atau parameter referensi adalah jika NULL adalah nilai yang dapat diterima. Itu dia.

Apakah nilainya input, output, dapat dimodifikasi dll. Harus dalam dokumentasi / komentar tentang fungsi, setelah semua.

Allen Holub "Cukup Rope untuk Menembak Diri Anda di Kaki" daftar 2 aturan berikut:

120. Reference arguments should always be `const`
121. Never use references as outputs, use pointers

Dia mencantumkan beberapa alasan mengapa referensi ditambahkan ke C ++:

• mereka perlu mendefinisikan konstruktor salinan
• mereka diperlukan untuk kelebihan operator
• const referensi memungkinkan Anda memiliki semantik nilai per nilai sambil menghindari salinan

Poin utamanya adalah bahwa referensi tidak boleh digunakan sebagai parameter 'output' karena di situs panggilan tidak ada indikasi apakah parameter tersebut merupakan referensi atau parameter nilai. Jadi aturannya adalah hanya menggunakan constreferensi sebagai argumen.

Secara pribadi, saya pikir ini adalah aturan praktis yang baik karena membuatnya lebih jelas ketika suatu parameter adalah parameter keluaran atau tidak. Namun, sementara saya pribadi setuju dengan ini secara umum, saya membiarkan diri saya terpengaruh oleh pendapat orang lain di tim saya jika mereka memperdebatkan parameter output sebagai referensi (beberapa pengembang sangat menyukainya).

Klarifikasi ke posting sebelumnya:

Referensi BUKAN jaminan mendapatkan pointer non-null. (Meskipun kita sering memperlakukan mereka seperti itu.)

Walaupun kode tersebut sangat buruk, seperti saat membawa Anda keluar di balik kode buruk woodshed , yang berikut ini akan dikompilasi & dijalankan: (Setidaknya di bawah kompiler saya.)

bool test( int & a)
{
  return (&a) == (int *) NULL;
}

int
main()
{
  int * i = (int *)NULL;
  cout << ( test(*i) ) << endl;
};

Masalah sebenarnya yang saya miliki dengan referensi ada pada programmer lain, untuk selanjutnya disebut IDIOTS , yang mengalokasikan dalam konstruktor, membatalkan alokasi dalam destruktor, dan gagal memasok copy constructor atau operator = ().

Tiba-tiba ada perbedaan antara foo (BAR bar) dan foo (BAR & bar) . (Operasi salin bitwise otomatis dipanggil. Deallokasi di destructor dipanggil dua kali.)

Untungnya kompiler modern akan mengambil alokasi ganda ini dari pointer yang sama. 15 tahun yang lalu, mereka tidak melakukannya. (Di bawah gcc / g ++, gunakan setenv MALLOC_CHECK_ 0 untuk meninjau kembali cara lama.) Menghasilkan, di bawah DEC UNIX, dalam memori yang sama dialokasikan ke dua objek yang berbeda. Banyak kesenangan debugging di sana ...

Lebih praktis:

• Referensi menyembunyikan bahwa Anda mengubah data yang disimpan di tempat lain.
• Sangat mudah untuk membingungkan Referensi dengan objek yang disalin.
• Pointer membuatnya jelas!

Sebagian besar jawaban di sini gagal mengatasi ambiguitas yang melekat dalam memiliki pointer mentah dalam tanda tangan fungsi, dalam hal mengekspresikan niat. Masalahnya adalah sebagai berikut:

• Penelepon tidak tahu apakah penunjuk menunjuk ke objek tunggal, atau ke awal "array" objek.

• Penelepon tidak tahu apakah pointer "memiliki" memori yang ditunjuknya. Yaitu apakah fungsi tersebut harus membebaskan memori atau tidak. ( foo(new int)- Apakah ini kebocoran memori?).

• Penelepon tidak tahu apakah nullptrbisa dengan aman masuk ke dalam fungsi.

Semua masalah ini diselesaikan dengan referensi:

• Referensi selalu merujuk ke satu objek.

• Referensi tidak pernah memiliki ingatan yang mereka rujuk, mereka hanyalah pandangan ke ingatan.

• Referensi tidak boleh nol.

Ini menjadikan referensi kandidat yang jauh lebih baik untuk penggunaan umum. Namun, referensi tidak sempurna - ada beberapa masalah besar yang perlu dipertimbangkan.

• Tidak ada tipuan eksplisit. Ini bukan masalah dengan pointer mentah, karena kita harus menggunakan &operator untuk menunjukkan bahwa kita memang melewati pointer. Sebagai contoh, int a = 5; foo(a);Tidak jelas sama sekali di sini bahwa a sedang disahkan oleh referensi dan dapat dimodifikasi.
• Nullability. Kelemahan pointer ini juga bisa menjadi kekuatan, ketika kita benar - benar ingin referensi kita menjadi nol. Melihat sebagai std::optional<T&>tidak valid (untuk alasan yang baik), petunjuk memberi kami nullability yang Anda inginkan.

Jadi sepertinya ketika kita menginginkan referensi yang dapat dibatalkan dengan tipuan eksplisit, kita harus meraih T*hak? Salah!

Abstraksi

Dalam keputus-asaan kita untuk nullability, kita dapat meraih T*, dan mengabaikan semua kekurangan dan ambiguitas semantik yang disebutkan sebelumnya. Sebagai gantinya, kita harus meraih apa yang paling baik dilakukan C ++: abstraksi. Jika kita hanya menulis kelas yang membungkus sebuah pointer, kita memperoleh ekspresif, serta nullability dan tipuan eksplisit.

template <typename T>
struct optional_ref {
  optional_ref() : ptr(nullptr) {}
  optional_ref(T* t) : ptr(t) {}
  optional_ref(std::nullptr_t) : ptr(nullptr) {}

  T& get() const {
    return *ptr;
  }

  explicit operator bool() const {
    return bool(ptr);
  }

private:
  T* ptr;
};

Ini adalah antarmuka paling sederhana yang bisa saya buat, tapi itu berfungsi dengan efektif. Ini memungkinkan untuk menginisialisasi referensi, memeriksa apakah suatu nilai ada dan mengakses nilai tersebut. Kita bisa menggunakannya seperti ini:

void foo(optional_ref<int> x) {
  if (x) {
    auto y = x.get();
    // use y here
  }
}

int x = 5;
foo(&x); // explicit indirection here
foo(nullptr); // nullability

Kami telah mencapai tujuan kami! Sekarang mari kita lihat manfaatnya, dibandingkan dengan pointer mentah.

• Antarmuka menunjukkan dengan jelas bahwa referensi hanya merujuk pada satu objek.
• Jelas itu tidak memiliki memori yang dimaksud, karena tidak memiliki destruktor yang ditentukan pengguna dan tidak ada metode untuk menghapus memori.
• Pemanggil tahu nullptrdapat diteruskan, karena fungsi penulis secara eksplisit memintaoptional_ref

Kita bisa membuat antarmuka lebih kompleks dari sini, seperti menambahkan operator kesetaraan, monadik get_ordan mapantarmuka, metode yang mendapatkan nilai atau melempar pengecualian, constexprdukungan. Itu bisa dilakukan oleh Anda.

Sebagai kesimpulan, alih-alih menggunakan pointer mentah, alasan tentang apa yang sebenarnya dimaksud pointer dalam kode Anda, dan baik memanfaatkan abstraksi perpustakaan standar atau menulis milik Anda. Ini akan meningkatkan kode Anda secara signifikan.

Tidak juga. Secara internal, melewati dengan referensi dilakukan dengan dasarnya melewati alamat objek yang direferensikan. Jadi, sebenarnya tidak ada keuntungan efisiensi yang bisa didapat dengan melewatkan sebuah pointer.

Melewati dengan referensi memang memiliki satu manfaat. Anda dijamin memiliki instance dari objek / tipe apa pun yang sedang dilewati. Jika Anda meneruskan sebuah pointer, maka Anda berisiko mengambil pointer NULL. Dengan menggunakan pass-by-reference, Anda mendorong pemeriksaan NULL implisit satu tingkat ke pemanggil fungsi Anda.