ฉันจะรับที่อยู่ของวัตถุได้อย่างน่าเชื่อถือเมื่อโอเปอเรเตอร์ & มากเกินไปได้อย่างไร

พิจารณาโปรแกรมต่อไปนี้:

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 :'( 
}

ฉันจะได้รับclydeที่อยู่ของได้อย่างไร

ฉันกำลังมองหาทางออกที่จะทำงานได้ดีกับวัตถุทุกประเภท โซลูชัน C ++ 03 ก็ดี แต่ฉันก็สนใจ C ++ 11 เช่นกัน ถ้าเป็นไปได้ลองหลีกเลี่ยงพฤติกรรมการใช้งานเฉพาะ

ฉันทราบถึงstd::addressofเทมเพลตฟังก์ชันของ C ++ 11 แต่ไม่สนใจที่จะใช้ที่นี่: ฉันต้องการทำความเข้าใจว่าผู้ใช้ไลบรารีมาตรฐานอาจใช้เทมเพลตฟังก์ชันนี้ได้อย่างไร

ปรับปรุง:ใน C ++ 11 หนึ่งอาจจะใช้แทนstd::addressofboost::addressof

ให้เราคัดลอกรหัสจาก Boost ก่อนลบคอมไพเลอร์ทำงานกับบิต:

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 );
}

จะเกิดอะไรขึ้นถ้าเราผ่านการอ้างอิงถึงฟังก์ชั่น ?

หมายเหตุ: addressofไม่สามารถใช้กับตัวชี้ไปยังฟังก์ชั่น

ใน C ++ หากvoid func();มีการประกาศไว้funcจะมีการอ้างอิงไปยังฟังก์ชันที่ไม่มีการโต้แย้งและไม่มีผลลัพธ์ การอ้างอิงถึงฟังก์ชั่นนี้สามารถแปลงเป็นตัวชี้ไปยังฟังก์ชั่นได้เล็กน้อยจาก - @Konstantinตาม: 13.3.3.2 ทั้งคู่T &และT *แยกไม่ออกสำหรับฟังก์ชัน ฟังก์ชั่นที่หนึ่งคือการแปลงข้อมูลประจำตัวและที่สองคือการแปลงฟังก์ชันเป็นตัวชี้ทั้งสองมีอันดับ "การจับคู่แบบตรงทั้งหมด" (13.3.3.1.1 ตารางที่ 9)

การอ้างอิงฟังก์ชันผ่านaddr_impl_refมีความคลุมเครือในการแก้ปัญหาโอเวอร์โหลดสำหรับตัวเลือกfซึ่งแก้ไขได้ด้วยอาร์กิวเมนต์ดัมมี่0ซึ่งเป็นintครั้งแรกและสามารถเลื่อนเป็นlong(การแปลงอินทิกรัล)

ดังนั้นเราเพียงแค่ส่งกลับตัวชี้

จะเกิดอะไรขึ้นถ้าเราส่งประเภทด้วยตัวดำเนินการแปลง

หากผู้ประกอบการแปลงให้ผลตอบแทนT*แล้วเรามีความกำกวม: สำหรับf(T&,long)การส่งเสริมการขายเป็นสิ่งจำเป็นสำหรับการโต้แย้งที่สองในขณะที่สำหรับf(T*,int)ผู้ประกอบการแปลงจะถูกเรียกในครั้งแรก(ขอบคุณ @litb)

นั่นคือเมื่อaddr_impl_refเริ่มใช้งานมาตรฐาน C ++ กำหนดว่าลำดับการแปลงอาจมีการแปลงที่ผู้ใช้กำหนดสูงสุดหนึ่งรายการ ด้วยการห่อประเภทaddr_impl_refและบังคับให้ใช้ลำดับการแปลงแล้วเราจะ "ปิด" ผู้ให้บริการการแปลงที่มาพร้อมกับประเภทนั้น

ดังนั้นจึงf(T&,long)มีการเลือกเกินพิกัด (และดำเนินการโปรโมตอินทิกรัล)

จะเกิดอะไรขึ้นกับคนอื่น ๆ ?

ดังนั้นการf(T&,long)เลือกเกินพิกัดเนื่องจากมีประเภทไม่ตรงกับT*พารามิเตอร์

หมายเหตุ: จากข้อสังเกตในไฟล์ที่เกี่ยวกับความเข้ากันได้ของ Borland อาร์เรย์จะไม่สลายตัวไปยังพอยน์เตอร์ แต่ถูกส่งผ่านโดยการอ้างอิง

เกิดอะไรขึ้นกับการโอเวอร์โหลดนี้

เราต้องการหลีกเลี่ยงการใช้operator&กับประเภทเนื่องจากอาจมีการใช้งานมากเกินไป

การรับรองมาตรฐานที่reinterpret_castอาจใช้กับงานนี้ (ดูคำตอบของ @Matteo Italia: 5.2.10 / 10)

Boost เพิ่มสิ่งที่น่าสนใจด้วยconstและตัวระบุvolatileเพื่อหลีกเลี่ยงคำเตือนของคอมไพเลอร์ (และใช้ a const_castเพื่อลบออกอย่างเหมาะสม)

• ส่งT&ไปที่char const volatile&
• เปลื้องผ้าconstและvolatile
• ใช้&โอเปอเรเตอร์เพื่อจดที่อยู่
• โยนกลับไปที่ T*

กระบวนการconst/ volatileการเล่นกลเป็นบิตของมนต์ดำ แต่มันทำให้งานง่ายขึ้น (แทนที่จะให้การโอเวอร์โหลดเกิน 4 ครั้ง) หมายเหตุว่าตั้งแต่Tเป็นอย่างไม่มีเงื่อนไขถ้าเราผ่านghost const&แล้วT*เป็นghost const*จึงบ่นยังไม่ได้รับมันหายไป

แก้ไข:ตัวชี้โอเวอร์โหลดใช้สำหรับตัวชี้ไปยังฟังก์ชั่นฉันแก้ไขคำอธิบายข้างต้นบ้าง ผมก็ยังไม่เข้าใจว่าทำไมมันเป็นสิ่งที่จำเป็นแม้ว่า

เอาท์พุท ideoneต่อไปนี้สรุปสิ่งนี้ขึ้นมาบ้าง

std::addressofใช้

คุณสามารถคิดได้ว่าเป็นการทำสิ่งต่อไปนี้เบื้องหลัง:

1. ตีความวัตถุอีกครั้งเป็นการอ้างอิงถึงตัวอักษร
2. ใช้ที่อยู่ของสิ่งนั้น (จะไม่เรียกโอเวอร์โหลด)
3. เหวี่ยงตัวชี้กลับไปที่ตัวชี้ประเภทของคุณ

การใช้งานที่มีอยู่ (รวมถึง Boost.Addressof) ทำอย่างนั้นเพียงแค่ดูแลconstและvolatileคุณสมบัติเพิ่มเติม

เคล็ดลับที่อยู่เบื้องหลังboost::addressofและการดำเนินการโดย @Luc Danton ขึ้นอยู่กับความมหัศจรรย์ของreinterpret_cast; มาตรฐานระบุไว้ที่§5.2.10¶10อย่างชัดเจน

การแสดงออก lvalue ประเภทT1สามารถโยนไปประเภท“การอ้างอิงถึงT2” ถ้าการแสดงออกของประเภท“ชี้T1” สามารถแปลงอย่างชัดเจนชนิด“ชี้T2” reinterpret_castใช้ นั่นคือการอ้างอิงการอ้างอิงreinterpret_cast<T&>(x)มีผลเช่นเดียวกับการแปลง*reinterpret_cast<T*>(&x)ด้วยบิวด์อิน&และ*โอเปอเรเตอร์ ผลลัพธ์คือ lvalue ที่อ้างถึงวัตถุเดียวกันกับ lvalue ต้นฉบับ แต่มีชนิดอื่น

ตอนนี้ช่วยให้เราสามารถแปลงการอ้างอิงวัตถุพลไปchar &(ที่มีวุฒิการศึกษาพันธุ์ถ้าอ้างอิงเป็นพันธุ์ที่มีคุณสมบัติ) เพราะตัวชี้ใด ๆ ที่สามารถแปลงเป็น char *(อาจจะเป็นพันธุ์ที่ผ่านการคัดเลือก) ตอนนี้เรามีchar &, ผู้ประกอบการที่บรรทุกเกินพิกัดบนวัตถุนั้นไม่มีความเกี่ยวข้องอีกต่อไปและเราสามารถรับที่อยู่กับ&ผู้ประกอบการในตัวได้

การใช้งานบูสต์เพิ่มสองสามขั้นตอนในการทำงานกับออบเจ็กต์ที่ผ่านการรับรอง cv: ขั้นตอนแรกreinterpret_castถูกดำเนินการเพื่อconst volatile char &มิฉะนั้นการchar &ส่งแบบธรรมดาจะไม่ทำงานconstและ / หรือvolatileการอ้างอิง ( reinterpret_castไม่สามารถลบได้const) จากนั้นconstและvolatileจะถูกลบด้วยconst_castที่อยู่จะถูกนำไปใช้&และจะเป็นประเภทสุดท้ายreinterpet_castที่ "ถูกต้อง"

const_castเป็นสิ่งจำเป็นในการลบconst/ volatileที่จะได้รับการเพิ่มไม่ใช่ const / อ้างอิงผันผวน แต่มันก็ไม่ได้ "อันตราย" สิ่งที่เป็นconst/ volatileการอ้างอิงในสถานที่แรกเพราะสุดท้ายreinterpret_castจะเป็นการเพิ่ม CV-คุณสมบัติถ้ามันเป็น มีในสถานที่แรก ( reinterpret_castไม่สามารถลบconstแต่สามารถเพิ่มได้)

ส่วนที่เหลือของรหัสในaddressof.hppดูเหมือนว่าส่วนใหญ่สำหรับการแก้ไขปัญหา static inline T * f( T * v, int )ดูเหมือนว่าจะมีความจำเป็นเฉพาะสำหรับคอมไพเลอร์บอร์แลนด์ แต่การปรากฏตัวของมันแนะนำความจำเป็นในการaddr_impl_refมิฉะนั้นประเภทตัวชี้จะถูกจับโดยเกินสองนี้

แก้ไขที่: overloads ต่างๆมีฟังก์ชั่นที่แตกต่างกันเห็น @Matthieu เอ็มคำตอบที่ดี

ฉันก็ไม่แน่ใจเหมือนกัน ฉันควรตรวจสอบรหัสนั้นเพิ่มเติม แต่ตอนนี้ฉันกำลังทำอาหารเย็น :) ฉันจะดูทีหลัง

ฉันเคยเห็นการใช้งานของการaddressofทำสิ่งนี้:

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

อย่าถามฉันว่าการทำอย่างนี้เป็นอย่างไร!

ลองดูที่boost :: addressofและการนำไปปฏิบัติ