Melewati referensi ke petunjuk dalam C ++

Sejauh yang saya tahu, tidak ada alasan saya tidak diizinkan untuk memberikan referensi ke pointer di C ++. Namun, upaya saya untuk melakukannya gagal, dan saya tidak tahu mengapa.

Inilah yang saya lakukan:

void myfunc(string*& val)
{
    // Do stuff to the string pointer
}

// sometime later 
{
    // ...
    string s;
    myfunc(&s);
    // ...
}

Dan saya mendapatkan kesalahan ini:

tidak dapat mengonversi parameter 1 dari 'std :: string *' ke 'std :: string * &'

Fungsi Anda mengharapkan referensi ke penunjuk string aktual dalam lingkup panggilan, bukan penunjuk string anonim. Jadi:

string s;
string* _s = &s;
myfunc(_s);

harus mengkompilasi dengan baik.

Namun, ini hanya berguna jika Anda ingin memodifikasi pointer yang Anda berikan ke fungsi. Jika Anda bermaksud untuk memodifikasi string itu sendiri, Anda harus menggunakan referensi ke string seperti yang disarankan Sake. Dengan mengingat hal itu harus lebih jelas mengapa kompiler mengeluh tentang kode asli Anda. Dalam kode Anda, pointer dibuat 'on the fly', mengubah pointer itu tidak akan memiliki konsekuensi dan itu bukan yang dimaksudkan. Ide referensi (vs pointer) adalah referensi selalu menunjuk ke objek yang sebenarnya.

Masalahnya adalah bahwa Anda mencoba untuk mengikat sementara ke referensi, yang tidak diizinkan C ++ kecuali referensi tersebut const.

Jadi, Anda dapat melakukan salah satu dari yang berikut ini:

void myfunc(string*& val)
{
    // Do stuff to the string pointer
}


void myfunc2(string* const& val)
{
    // Do stuff to the string pointer
}

int main()
// sometime later 
{
    // ...
    string s;
    string* ps = &s;

    myfunc( ps);   // OK because ps is not a temporary
    myfunc2( &s);  // OK because the parameter is a const&
    // ...

    return 0;
}

Ubah ke:

  std::string s;
  std::string* pS = &s;
  myfunc(pS);

EDIT:

Ini disebut ref-to-pointerdan Anda tidak dapat memberikan alamat sementara sebagai referensi untuk fungsi. (kecuali jika itu const reference).

Meskipun, saya telah menunjukkan std::string* pS = &s;(pointer ke variabel lokal), penggunaannya yang khas adalah: ketika Anda ingin callee untuk mengubah pointer itu sendiri, bukan objek yang ditunjuknya. Misalnya, fungsi yang mengalokasikan memori dan menetapkan alamat blok memori yang dialokasikan untuk argumennya harus mengambil referensi ke pointer, atau pointer ke pointer:

void myfunc(string*& val)
{
//val is valid even after function call
   val = new std::string("Test");

}

&s menghasilkan penunjuk sementara ke string dan Anda tidak dapat membuat referensi ke objek sementara.

Mencoba:

void myfunc(string& val)
{
    // Do stuff to the string pointer
}

// sometime later 
{
    // ...
    string s;
    myfunc(s);
    // ...
}

atau

void myfunc(string* val)
{
    // Do stuff to the string pointer
}

// sometime later 
{
    // ...
    string s;
    myfunc(&s);
    // ...
}

EDIT: Saya mencoba beberapa, dan menemukan sesuatu yang sedikit lebih halus dari yang saya kira. Inilah yang sekarang saya pikirkan adalah jawaban yang akurat.

&sbukan lvalue sehingga Anda tidak dapat membuat referensi untuk itu kecuali jika jenis rujukannya adalah const. Jadi misalnya, Anda tidak dapat melakukannya

string * &r = &s;

tapi kamu bisa melakukannya

string * const &r = &s;

Jika Anda meletakkan deklarasi serupa di header fungsi, itu akan berfungsi.

void myfunc(string * const &a) { ... }

Ada masalah lain, yaitu, sementara. Aturannya adalah Anda hanya bisa mendapatkan referensi sementara jika itu const. Jadi dalam hal ini orang mungkin berpendapat bahwa & s bersifat sementara, dan karenanya harus dinyatakan constdalam prototipe fungsi. Dari sudut pandang praktis, tidak ada bedanya dalam kasus ini. (Ini baik nilai atau sementara. Either way, aturan yang sama berlaku.) Namun, secara tegas, saya pikir itu bukan sementara tapi nilai. Saya bertanya-tanya apakah ada cara untuk membedakan keduanya. (Mungkin hanya didefinisikan bahwa semua temporari adalah nilai, dan semua bukan-nilai adalah temporal. Saya bukan ahli dalam standar.)

Yang sedang berkata, masalah Anda mungkin pada tingkat yang lebih tinggi. Mengapa Anda ingin referensi ke alamat s? Jika Anda ingin referensi ke pointer s, Anda perlu mendefinisikan pointer seperti di

string *p = &s;
myfunc(p);

Jika Anda ingin referensi satau penunjuk s, lakukan hal langsung.

Saya baru saja menggunakan referensi ke pointer untuk membuat semua pointer di pohon biner yang dihapus kecuali root safe. Untuk membuat pointer aman, kita hanya perlu mengaturnya ke 0. Saya tidak bisa membuat fungsi yang menghapus pohon (hanya menyimpan root) untuk menerima ref ke pointer karena saya menggunakan root (pointer ini) sebagai yang pertama masukan untuk melintasi kiri dan kanan.

void BinTree::safe_tree(BinTree * &vertex ) {
    if ( vertex!=0 ) {  // base case
        safe_tree(vertex->left);    // left subtree.
            safe_tree(vertex->right);   //  right subtree.
          // delete vertex;  // using this delete causes an error, since they were deleted on the fly using inorder_LVR. If inorder_LVR does not perform delete to the nodes, then, use delete vertex;
        vertex=0;  // making a safe pointer
    }
} // end in

Intinya, referensi ke pointer tidak valid ketika parameter formal adalah pointer (ini).

Selamat datang di C ++ 11 dan nilai referensi:

#include <cassert>
#include <string>

using std::string;

void myfunc(string*&& val)
{
    assert(&val);
    assert(val);
    assert(val->c_str());
    // Do stuff to the string pointer
}

// sometime later 
int main () {
    // ...
    string s;
    myfunc(&s);
    // ...
}

Sekarang Anda memiliki akses ke nilai pointer (disebut oleh val), yang merupakan alamat string.

Anda dapat memodifikasi pointer, dan tidak ada yang peduli. Itu adalah salah satu aspek dari apa nilai di tempat pertama.

Hati-hati: Nilai pointer hanya valid hingga myfunc()kembali. Akhirnya, ini hanya sementara.

Saya tahu bahwa itu mungkin untuk melewati referensi pointer, saya melakukannya minggu lalu, tetapi saya tidak ingat apa sintaksinya, karena kode Anda terlihat benar di otak saya saat ini. Namun opsi lain adalah menggunakan pointer dari pointer:

Myfunc(String** s)

myfunc ("string * & val") ini sendiri tidak masuk akal. "string * & val" menyiratkan "string val", * dan & membatalkan satu sama lain. Akhirnya kita tidak bisa memasukkan variabel string ke suatu fungsi ("string val"). Hanya tipe data dasar yang dapat diteruskan ke suatu fungsi, untuk tipe data lainnya harus lulus sebagai penunjuk atau referensi. Anda dapat memiliki string & val atau string * val ke suatu fungsi.