Bagaimana saya bisa mendapatkan alamat objek dengan andal ketika operator & kelebihan beban?

Pertimbangkan program berikut:

struct ghost
{
    // ghosts like to pretend that they don't exist
    ghost* operator&() const volatile { return 0; }
};

int main()
{
    ghost clyde;
    ghost* clydes_address = &clyde; // darn; that's not clyde's address :'( 
}

Bagaimana cara saya mendapatkan clydealamat?

Saya mencari solusi yang akan bekerja sama baiknya untuk semua jenis objek. Solusi C ++ 03 akan lebih baik, tetapi saya juga tertarik pada solusi C ++ 11. Jika memungkinkan, mari kita hindari perilaku spesifik implementasi.

Saya mengetahui std::addressoftemplat fungsi C ++ 11 , tetapi saya tidak tertarik menggunakannya di sini: Saya ingin memahami bagaimana implementor Perpustakaan Standar dapat mengimplementasikan templat fungsi ini.

Pembaruan: di C ++ 11, orang dapat menggunakan std::addressofsebagai ganti boost::addressof.

Pertama-tama mari kita salin kode dari Boost, minus pekerjaan kompiler di sekitar bit:

template<class T>
struct addr_impl_ref
{
  T & v_;

  inline addr_impl_ref( T & v ): v_( v ) {}
  inline operator T& () const { return v_; }

private:
  addr_impl_ref & operator=(const addr_impl_ref &);
};

template<class T>
struct addressof_impl
{
  static inline T * f( T & v, long ) {
    return reinterpret_cast<T*>(
        &const_cast<char&>(reinterpret_cast<const volatile char &>(v)));
  }

  static inline T * f( T * v, int ) { return v; }
};

template<class T>
T * addressof( T & v ) {
  return addressof_impl<T>::f( addr_impl_ref<T>( v ), 0 );
}

Apa yang terjadi jika kita meneruskan referensi ke fungsi ?

Catatan: addressoftidak dapat digunakan dengan pointer berfungsi

Dalam C ++ jika void func();dideklarasikan, maka funcadalah referensi ke fungsi tanpa argumen dan tidak mengembalikan hasil. Referensi ke fungsi ini dapat secara sepele dikonversi menjadi pointer ke fungsi - dari @Konstantin: Menurut 13.3.3.2 keduanya T &dan T *tidak dapat dibedakan untuk fungsi. Yang pertama adalah konversi Identity dan yang kedua adalah konversi Function-to-Pointer yang keduanya memiliki peringkat "Pencocokan Tepat" (13.3.3.1.1 tabel 9).

The referensi ke fungsi melewati addr_impl_ref, ada ambiguitas dalam resolusi yang berlebihan untuk pilihan f, yang diselesaikan berkat argumen boneka 0, yang merupakan intpertama dan bisa dipromosikan ke long(Konversi Integral).

Jadi kita cukup mengembalikan pointer.

Apa yang terjadi jika kami melewati jenis dengan operator konversi?

Jika operator konversi menghasilkan a T*maka kami memiliki ambiguitas: untuk f(T&,long)Promosi Integral diperlukan untuk argumen kedua sedangkan untuk f(T*,int)operator konversi dipanggil pada yang pertama (terima kasih kepada @litb)

Saat itulah addr_impl_refmasuk. Standar C ++ mengamanatkan bahwa urutan konversi dapat berisi paling banyak satu konversi yang ditentukan pengguna. Dengan memasukkan jenis addr_impl_refdan memaksa penggunaan urutan konversi, kami "menonaktifkan" semua operator konversi yang disertakan.

Dengan demikian f(T&,long)kelebihan dipilih (dan Promosi Integral dilakukan).

Apa yang terjadi untuk jenis lainnya?

Dengan demikian f(T&,long)kelebihan dipilih, karena jenisnya tidak sesuai dengan T*parameter.

Catatan: dari keterangan dalam file tentang kompatibilitas Borland, array tidak membusuk ke pointer, tetapi diteruskan dengan referensi.

Apa yang terjadi pada kelebihan ini?

Kami ingin menghindari penerapan operator&ke jenis, karena mungkin telah kelebihan beban.

Standar menjamin yang reinterpret_castdapat digunakan untuk pekerjaan ini (lihat jawaban @Matteo Italia: 5.2.10 / 10).

Boost menambahkan beberapa fitur constdan volatilekualifikasi untuk menghindari peringatan penyusun (dan menggunakan a const_castuntuk menghapusnya dengan benar).

• Diputar T&kechar const volatile&
• Strip constdanvolatile
• Terapkan &operator untuk mengambil alamatnya
• Kembali ke a T*

The const/ volatilejuggling adalah sedikit ilmu hitam, tetapi tidak menyederhanakan pekerjaan (daripada memberikan 4 overload). Perhatikan bahwa sejak Tadalah wajar tanpa pengecualian, jika kita lulus ghost const&, maka T*adalah ghost const*, dengan demikian kualifikasi belum benar-benar hilang.

EDIT: pointer overload digunakan untuk fungsi pointer, saya sedikit mengubah penjelasan di atas. Saya masih tidak mengerti mengapa itu perlu .

Output ideone berikut merangkum ini, agak.

Gunakan std::addressof.

Anda dapat menganggapnya sebagai berikut di belakang layar:

1. Menafsirkan kembali objek sebagai referensi-ke-char
2. Ambil alamat itu (tidak akan menyebut kelebihan beban)
3. Letakkan pointer kembali ke pointer tipe Anda.

Implementasi yang ada (termasuk Boost.Addressof) melakukan hal itu, hanya menjaga constdan volatilekualifikasi tambahan.

Trik di belakang boost::addressofdan implementasi yang disediakan oleh @Luc Danton bergantung pada keajaiban reinterpret_cast; standar secara eksplisit menyatakan pada §5.2.10 ¶10 itu

Ekspresi nilai lebih dari tipe T1dapat dilemparkan ke tipe "referensi ke T2" jika ekspresi tipe "pointer ke T1" dapat secara eksplisit dikonversi ke tipe "pointer ke T2" menggunakan a reinterpret_cast. Artinya, pemeran referensi reinterpret_cast<T&>(x)memiliki efek yang sama dengan konversi *reinterpret_cast<T*>(&x)dengan built-in &dan *operator. Hasilnya adalah nilai yang merujuk ke objek yang sama dengan nilai sumber, tetapi dengan jenis yang berbeda.

Sekarang, ini memungkinkan kita untuk mengkonversi referensi objek arbitrer ke a char &(dengan kualifikasi cv jika referensi tersebut memenuhi syarat cv), karena setiap pointer dapat dikonversi menjadi (mungkin memenuhi syarat cv) char *. Sekarang kita memiliki char &, operator kelebihan pada objek tidak lagi relevan, dan kita dapat memperoleh alamat dengan &operator builtin .

Implementasi boost menambahkan beberapa langkah untuk bekerja dengan objek yang memenuhi syarat cv: yang pertama reinterpret_castdilakukan const volatile char &, jika char &gips polos tidak akan bekerja untuk constdan / atau volatilereferensi ( reinterpret_casttidak dapat menghapus const). Kemudian constdan volatiledihapus dengan const_cast, alamat diambil dengan &, dan final reinterpet_castuntuk tipe "benar" dilakukan.

The const_castdiperlukan untuk menghapus const/ volatileyang bisa telah ditambahkan ke non-const / referensi volatile, tapi tidak "bahaya" apa adalah const/ volatilereferensi di tempat pertama, karena final reinterpret_castakan kembali add-cv-kualifikasi apakah itu ada di tempat pertama ( reinterpret_casttidak bisa menghapus consttetapi bisa menambahkannya).

Adapun sisa kode dalam addressof.hpp, tampaknya sebagian besar adalah untuk penyelesaian masalah. The static inline T * f( T * v, int )tampaknya diperlukan hanya untuk compiler Borland, namun kehadirannya memperkenalkan kebutuhan addr_impl_ref, jika jenis pointer akan ditangkap oleh kelebihan kedua ini.

Sunting : berbagai kelebihan memiliki fungsi yang berbeda, lihat @Matthieu M. jawaban yang sangat baik .

Yah, saya tidak lagi yakin akan hal ini juga; Saya harus menyelidiki lebih lanjut kode itu, tapi sekarang saya sedang memasak makan malam :), saya akan melihatnya nanti.

Saya telah melihat implementasi dari addressofmelakukan ini:

char* start = &reinterpret_cast<char&>(clyde);
ghost* pointer_to_clyde = reinterpret_cast<ghost*>(start);

Jangan tanya saya bagaimana menyesuaikannya!

Lihatlah boost :: addressof dan implementasinya.