มีประโยชน์ในการผ่านโดยตัวชี้ไปผ่านโดยอ้างอิงใน C ++?

ประโยชน์ของการผ่านโดยตัวชี้ผ่านการอ้างอิงใน C ++ คืออะไร

เมื่อเร็ว ๆ นี้ฉันได้เห็นตัวอย่างจำนวนมากที่เลือกการส่งผ่านอาร์กิวเมนต์ของพอยน์เตอร์แทนที่จะส่งผ่านการอ้างอิง มีประโยชน์ในการทำเช่นนี้?

ตัวอย่าง:

func(SPRITE *x);

ด้วยการโทร

func(&mySprite);

เมื่อเทียบกับ

func(SPRITE &x);

ด้วยการโทร

func(mySprite);

ตัวชี้สามารถรับพารามิเตอร์ NULL พารามิเตอร์อ้างอิงไม่สามารถ หากมีโอกาสที่คุณจะต้องการผ่าน "ไม่มีวัตถุ" ให้ใช้ตัวชี้แทนการอ้างอิง

นอกจากนี้การส่งต่อโดยตัวชี้ช่วยให้คุณสามารถดูไซต์การโทรอย่างชัดเจนว่าวัตถุนั้นถูกส่งผ่านตามค่าหรือโดยการอ้างอิง:

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

ผ่านตัวชี้

• ผู้โทรต้องใช้ที่อยู่ -> ไม่โปร่งใส
• 0 nothingค่าสามารถให้กับค่าเฉลี่ย สิ่งนี้สามารถใช้เพื่อระบุอาร์กิวเมนต์ที่เป็นทางเลือก

ผ่านการอ้างอิง

• ผู้โทรเพิ่งผ่านวัตถุ -> โปร่งใส จะต้องใช้สำหรับการบรรทุกเกินพิกัดเนื่องจากการบรรทุกเกินพิกัดสำหรับประเภทตัวชี้เป็นไปไม่ได้ (พอยน์เตอร์เป็นประเภทบิวด์อิน) ดังนั้นคุณไม่สามารถ string s = &str1 + &str2;ใช้พอยน์เตอร์ได้
• ไม่มีค่า 0 ที่เป็นไปได้ -> ฟังก์ชั่นที่เรียกว่าไม่จำเป็นต้องตรวจสอบ
• อ้างอิงถึง const ยังยอมรับ temporaries void f(const T& t); ... f(T(a, b, c));:, ตัวชี้ไม่สามารถใช้เช่นนั้นเนื่องจากคุณไม่สามารถใช้ที่อยู่ของชั่วคราว
• ท้ายสุด แต่ไม่ท้ายสุดการอ้างอิงง่ายต่อการใช้ -> โอกาสน้อยที่จะเกิดข้อบกพร่อง

ฉันชอบการให้เหตุผลโดยบทความจาก "cplusplus.com:"

1. ผ่านค่าเมื่อฟังก์ชั่นไม่ต้องการแก้ไขพารามิเตอร์และค่านั้นง่ายต่อการคัดลอก (ints, doubles, char, bool, etc ... ประเภทที่เรียบง่าย std :: string, std :: vector, และ STL อื่น ๆ ทั้งหมด ภาชนะบรรจุไม่ใช่ประเภทที่ง่าย)

2. ผ่านตัวชี้ const เมื่อค่าใช้จ่ายสูงในการคัดลอกและฟังก์ชันไม่ต้องการแก้ไขค่าที่ชี้ไปที่ AND NULL เป็นค่าที่ถูกต้องและคาดหวังว่าฟังก์ชันนั้นจะจัดการ

3. ส่งผ่านตัวชี้ที่ไม่ใช่ const เมื่อค่ามีราคาแพงในการคัดลอกและฟังก์ชันต้องการแก้ไขค่าที่ชี้ไปที่ AND NULL เป็นค่าที่ถูกต้องและคาดหวังว่าฟังก์ชันนั้นจะจัดการ

4. ผ่านการอ้างอิง const เมื่อค่าใช้จ่ายสูงในการคัดลอกและฟังก์ชันไม่ต้องการแก้ไขค่าที่อ้างถึง AND NULL จะไม่เป็นค่าที่ถูกต้องหากใช้ตัวชี้แทน

5. ผ่านการอ้างอิงแบบไม่ต่อเนื่องเมื่อค่ามีราคาแพงในการคัดลอกและฟังก์ชันต้องการแก้ไขค่าที่อ้างถึง AND NULL จะไม่เป็นค่าที่ถูกต้องหากใช้ตัวชี้แทน

6. เมื่อเขียนฟังก์ชั่นเทมเพลตไม่มีคำตอบที่ชัดเจนเนื่องจากมีข้อ จำกัด เล็กน้อยในการพิจารณาว่าอยู่นอกเหนือขอบเขตของการสนทนา แต่พอเพียงเพื่อบอกว่าฟังก์ชั่นเทมเพลตส่วนใหญ่ใช้พารามิเตอร์ตามค่าหรือการอ้างอิง (const) อย่างไรก็ตามเนื่องจากไวยากรณ์ตัววนซ้ำนั้นคล้ายกับพอยน์เตอร์ (เครื่องหมายดอกจันถึง "การปฏิเสธ") ฟังก์ชันเทมเพลตใด ๆ ที่คาดว่าตัววนซ้ำเป็นอาร์กิวเมนต์ก็จะรับพอยน์เตอร์ตามค่าเริ่มต้นด้วยเช่นกัน (และไม่ตรวจสอบ NULL เนื่องจากแนวคิด )

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

สิ่งที่ฉันนำมาจากสิ่งนี้คือความแตกต่างที่สำคัญระหว่างการเลือกใช้ตัวชี้หรือพารามิเตอร์อ้างอิงคือถ้า NULL เป็นค่าที่ยอมรับได้ แค่นั้นแหละ.

ไม่ว่าจะเป็นค่าอินพุตเอาต์พุตเอาต์พุตที่แก้ไขได้ ฯลฯ ควรอยู่ในเอกสาร / ข้อคิดเห็นเกี่ยวกับฟังก์ชันหลังจากทั้งหมด

อัลเลนโฮล์บ "พอเชือกเพื่อยิงตัวเองในเท้า" แสดงกฎ 2 ข้อต่อไปนี้:

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

เขาแสดงเหตุผลหลายประการที่เพิ่มการอ้างอิงไปยัง C ++:

• พวกเขาจำเป็นต้องกำหนดตัวสร้างสำเนา
• จำเป็นสำหรับโอเปอเรเตอร์โอเวอร์โหลด
• const การอ้างอิงช่วยให้คุณมีความหมายแบบ pass-by-value ขณะที่หลีกเลี่ยงการคัดลอก

ประเด็นหลักของเขาคือการอ้างอิงไม่ควรใช้เป็นพารามิเตอร์ 'เอาท์พุท' เพราะที่ไซต์การโทรไม่มีข้อบ่งชี้ว่าพารามิเตอร์นั้นเป็นการอ้างอิงหรือพารามิเตอร์ค่า ดังนั้นกฎของเขาคือใช้constการอ้างอิงเป็นข้อโต้แย้งเท่านั้น

โดยส่วนตัวฉันคิดว่านี่เป็นกฎที่ดีเพราะมันชัดเจนมากขึ้นเมื่อพารามิเตอร์เป็นพารามิเตอร์เอาต์พุตหรือไม่ อย่างไรก็ตามในขณะที่ฉันเห็นด้วยกับเรื่องนี้โดยทั่วไปฉันอนุญาตให้ตัวเองถูกครอบงำด้วยความคิดเห็นของคนอื่น ๆ ในทีมของฉันหากพวกเขาเถียงพารามิเตอร์เอาท์พุทเป็นการอ้างอิง (นักพัฒนาบางคนชอบพวกเขาอย่างมาก

ชี้แจงถึงการโพสต์ก่อนหน้านี้:

การอ้างอิงไม่ใช่การรับประกันในการรับพอยน์เตอร์ที่ไม่ใช่นัล (แม้ว่าเรามักจะปฏิบัติต่อพวกเขาเช่นนี้)

ในขณะที่โค้ดไม่ดีอย่างน่ากลัวในการนำคุณออกไปด้านหลังโค้ดไม่ดีของ woodshed สิ่งต่อไปนี้จะรวบรวมและเรียกใช้: (อย่างน้อยภายใต้คอมไพเลอร์ของฉัน)

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

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

ปัญหาที่แท้จริงที่ฉันมีกับการอ้างอิงอยู่กับโปรแกรมเมอร์คนอื่น ๆ ต่อจากนี้เรียกว่าIDIOTSที่จัดสรรใน Constructor, จัดสรรคืนใน Destructor และไม่สามารถจัดหา Constructor หรือตัวดำเนินการ = () ได้

ทันใดนั้นมีโลกของความแตกต่างระหว่างfoo (บาร์ BAR)และfoo (BAR &บาร์) (การดำเนินการคัดลอก bitwise อัตโนมัติถูกเรียกใช้การยกเลิกการจัดสรรใน destructor จะถูกเรียกสองครั้ง)

นักแปลสมัยใหม่ที่โชคดีจะรับการจัดสรรคืนสองเท่าของตัวชี้เดียวกันนี้ 15 ปีที่แล้วพวกเขาไม่ได้ (ภายใต้ gcc / g ++ ให้ใช้setenv MALLOC_CHECK_ 0เพื่อทบทวนวิธีเก่า ๆ ) ผลลัพธ์ภายใต้ DEC UNIX ในหน่วยความจำเดียวกันที่จัดสรรให้กับวัตถุสองชนิดที่แตกต่างกัน มีการดีบักความสนุกสนานมากมายที่นั่น ...

เพิ่มเติมจริง:

• การอ้างอิงซ่อนว่าคุณกำลังเปลี่ยนแปลงข้อมูลที่เก็บไว้ที่อื่น
• ง่ายต่อการสับสนกับการอ้างอิงกับวัตถุที่คัดลอก
• พอยน์เตอร์ทำให้มันชัดเจน!

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

• ผู้เรียกไม่ทราบว่าตัวชี้ชี้ไปที่วัตถุเดียวหรือไปยังจุดเริ่มต้นของ "อาร์เรย์" ของวัตถุ

• ผู้เรียกไม่ทราบว่าตัวชี้ "เป็นเจ้าของ" หน่วยความจำที่ชี้ไป IE ไม่ว่าจะเป็นฟังก์ชั่นควรเพิ่มหน่วยความจำหรือไม่ ( foo(new int)- นี่เป็นหน่วยความจำรั่วหรือไม่)

• ผู้เรียกไม่ทราบว่าnullptrสามารถส่งผ่านไปยังฟังก์ชันได้อย่างปลอดภัยหรือไม่

ปัญหาทั้งหมดเหล่านี้ได้รับการแก้ไขโดยการอ้างอิง:

• การอ้างอิงอ้างถึงวัตถุเดียวเสมอ

• การอ้างอิงไม่เคยเป็นเจ้าของหน่วยความจำที่อ้างถึง แต่เป็นเพียงมุมมองในหน่วยความจำ

• ข้อมูลอ้างอิงต้องไม่เป็นค่าว่าง

สิ่งนี้ทำให้การอ้างอิงเป็นตัวเลือกที่ดีกว่าสำหรับการใช้งานทั่วไป อย่างไรก็ตามการอ้างอิงไม่สมบูรณ์ - มีปัญหาใหญ่สองสามข้อที่ต้องพิจารณา

• ไม่มีทางอ้อมอย่างชัดเจน นี่ไม่ใช่ปัญหากับตัวชี้แบบดิบเนื่องจากเราต้องใช้ตัว&ดำเนินการเพื่อแสดงว่าเรากำลังผ่านตัวชี้ ตัวอย่างเช่น,int a = 5; foo(a);มันไม่ชัดเจนเลยที่นี่ว่า a กำลังถูกส่งผ่านโดยการอ้างอิงและสามารถแก้ไขได้
• Nullability จุดอ่อนของพอยน์เตอร์นี้สามารถเป็นจุดแข็งได้เมื่อเราต้องการให้การอ้างอิงของเราเป็นโมฆะ เมื่อเห็นว่าstd::optional<T&>ไม่ถูกต้อง (สำหรับเหตุผลที่ดี) พอยน์เตอร์จะบอกเราว่าคุณต้องการความถูกต้อง

ดังนั้นดูเหมือนว่าเมื่อเราต้องการการอ้างอิงที่เป็นโมฆะพร้อมกับการบอกทางอย่างชัดแจ้งเราควรไปถึง T*ใช่ไหม? ไม่ถูกต้อง!

นามธรรม

ในความสิ้นหวังของเราสำหรับความไร้ผลเราอาจถึงT*และเพียงเพิกเฉยต่อข้อบกพร่องและความกำกวมเชิงความหมายที่ระบุไว้ก่อนหน้า แต่เราควรไปถึงสิ่งที่ C ++ ทำได้ดีที่สุด: สิ่งที่เป็นนามธรรม ถ้าเราเพียงแค่เขียนคลาสที่ล้อมรอบพอยน์เตอร์เราจะได้รับการแสดงออกเช่นเดียวกับความไร้ประสิทธิภาพและความไม่แน่นอนทางอ้อม

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

นี่เป็นอินเทอร์เฟซที่ง่ายที่สุดที่ฉันสามารถทำได้ แต่ทำงานได้อย่างมีประสิทธิภาพ จะช่วยให้การเริ่มต้นการอ้างอิงตรวจสอบว่ามีค่าอยู่และเข้าถึงค่า เราสามารถใช้มันได้เช่น:

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

เราบรรลุเป้าหมายของเราแล้ว! ตอนนี้ให้เราเห็นประโยชน์เมื่อเทียบกับตัวชี้ดิบ

• อินเทอร์เฟซแสดงอย่างชัดเจนว่าการอ้างอิงควรอ้างถึงวัตถุเดียวเท่านั้น
• เห็นได้ชัดว่ามันไม่ได้เป็นเจ้าของหน่วยความจำมันหมายถึงเนื่องจากมันไม่มี destructor ที่ผู้ใช้กำหนดและไม่มีวิธีการลบหน่วยความจำ
• ผู้โทรรู้nullptrสามารถส่งต่อได้เนื่องจากผู้เขียนฟังก์ชั่นร้องขออย่างชัดเจนoptional_ref

เราสามารถทำให้ส่วนต่อประสานที่ซับซ้อนมากขึ้นจากที่นี่เช่นการเพิ่มตัวดำเนินการความเท่าเทียมกัน monadic get_orและmapส่วนต่อประสานซึ่งเป็นวิธีการที่ได้รับคุณค่าหรือส่งข้อยกเว้นconstexprสนับสนุน ที่สามารถทำได้โดยคุณ

โดยสรุปแทนที่จะใช้พอยน์เตอร์แบบดิบให้เหตุผลเกี่ยวกับความหมายของพอยน์เตอร์ในรหัสของคุณและใช้ประโยชน์จากไลบรารี่มาตรฐานที่เป็นนามธรรมหรือเขียนของคุณเอง สิ่งนี้จะปรับปรุงรหัสของคุณอย่างมีนัยสำคัญ

ไม่ได้จริงๆ ภายในผ่านการอ้างอิงจะดำเนินการโดยผ่านที่อยู่ของวัตถุอ้างอิง ดังนั้นจึงไม่มีประสิทธิภาพใด ๆ เพิ่มขึ้นโดยการส่งตัวชี้

อย่างไรก็ตามการส่งต่อโดยอ้างอิงมีประโยชน์อย่างเดียว คุณรับประกันว่าจะมีอินสแตนซ์ของวัตถุ / ประเภทใด ๆ ที่กำลังถูกส่งผ่านหากคุณผ่านตัวชี้คุณจะเสี่ยงต่อการรับตัวชี้ NULL ด้วยการใช้การอ้างอิงแบบผ่านคุณกำลังผลักดันค่า NULL โดยนัยตรวจสอบหนึ่งระดับไปยังตัวเรียกฟังก์ชันของคุณ