ตัวชี้กับการอ้างอิง

สิ่งที่จะเป็นการปฏิบัติที่ดีกว่าเมื่อให้ฟังก์ชันตัวแปรต้นฉบับเพื่อทำงานกับ:

unsigned long x = 4;

void func1(unsigned long& val) {
     val = 5;            
}
func1(x);

หรือ:

void func2(unsigned long* val) {
     *val = 5;
}
func2(&x);

IOW: มีเหตุผลอะไรไหมที่จะเลือกคนอื่น?

กฎง่ายๆของฉันคือ:

ใช้พอยน์เตอร์ถ้าคุณต้องการใช้ตัวชี้ทางคณิตศาสตร์กับพวกมัน (เช่นการเพิ่มที่อยู่พอยน์เตอร์เพื่อก้าวผ่านอาร์เรย์) หรือถ้าคุณต้องผ่านตัวชี้ NULL

ใช้การอ้างอิงเป็นอย่างอื่น

ฉันคิดว่าคุณจะได้รับประโยชน์จากการสร้างแนวทางการเขียนโค้ดฟังก์ชั่นต่อไปนี้:

1. ในขณะที่ตำแหน่งอื่น ๆ ทั้งหมดจะเสมอconst-correct

   • หมายเหตุ: ซึ่งหมายความว่าเฉพาะค่าที่เกิน (ดูรายการที่ 3) และค่าที่ส่งผ่านตามค่า (ดูรายการที่ 4) อาจไม่มีตัวconstระบุ

2. ส่งผ่านค่าโดยตัวชี้เท่านั้นถ้าค่า 0 / NULL เป็นอินพุตที่ถูกต้องในบริบทปัจจุบัน

   • เหตุผลที่ 1: ในฐานะผู้โทรคุณจะเห็นว่าสิ่งที่คุณส่งผ่านจะต้องอยู่ในสถานะใช้งาน

   • เหตุผลที่ 2: ตามที่เรียกว่าคุณรู้ว่าอะไรก็ตามที่เข้ามาอยู่ในสถานะที่ใช้งานได้ ดังนั้นจึงไม่จำเป็นต้องตรวจสอบค่า NULL หรือการจัดการข้อผิดพลาดสำหรับค่านั้น

   • เหตุผลที่ 3: เหตุผลที่ 1 และ 2 จะเป็นคอมไพเลอร์บังคับ ตรวจสอบข้อผิดพลาดในเวลารวบรวมถ้าคุณทำได้

3. หากฟังก์ชั่นอาร์กิวเมนต์เป็นค่าออกให้ส่งโดยอ้างอิง

   • เหตุผล: เราไม่ต้องการแยกรายการ 2 ...

4. เลือก "pass by value" over "pass by const Reference" เฉพาะในกรณีที่ค่าเป็น POD ( โครงสร้างข้อมูลเก่าธรรมดา ) หรือขนาดเล็กพอ (หน่วยความจำที่ชาญฉลาด) หรือวิธีอื่น ๆ ที่ราคาถูก (ตามเวลา) เพื่อคัดลอก

   • เหตุผล: หลีกเลี่ยงสำเนาที่ไม่จำเป็น
   • หมายเหตุ: ขนาดเล็กพอและถูกพอไม่ใช่ค่าที่แน่นอน

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

ในขณะที่มีความสามารถที่แตกต่างกัน (ไม่ว่าจะเป็น NULL หรือไม่ก็ตาม) ด้วยตัวชี้ความแตกต่างในทางปฏิบัติที่ใหญ่ที่สุดสำหรับพารามิเตอร์เอาต์พุตคือไวยากรณ์อย่างแท้จริง คู่มือสไตล์ C ++ ของ Google ( https://google.github.io/styleguide/cppguide.html#Reference_Arguments ) ยกตัวอย่างเช่น mandates เฉพาะตัวชี้สำหรับพารามิเตอร์เอาต์พุตและอนุญาตเฉพาะการอ้างอิงที่มีค่า การให้เหตุผลเป็นหนึ่งในความสามารถในการอ่าน: สิ่งที่มีไวยากรณ์ของค่าไม่ควรมีความหมายเชิงพอยน์เตอร์ ฉันไม่ได้แนะนำว่าสิ่งนี้ถูกหรือผิด แต่ฉันคิดว่าประเด็นในที่นี้คือมันเป็นเรื่องของสไตล์ไม่ใช่ความถูกต้อง

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

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

ทางออกที่ดีในกรณีส่วนใหญ่ (จากมุมมองด้านความปลอดภัย) คือการใช้เพิ่ม :: ตัวเลือก สิ่งนี้ช่วยให้คุณผ่านค่าที่เป็นทางเลือกโดยการอ้างอิงและยังเป็นค่าตอบแทน

// Sample method using optional as input parameter
void PrintOptional(const boost::optional<std::string>& optional_str)
{
    if (optional_str)
    {
       cout << *optional_str << std::endl;
    }
    else
    {
       cout << "(no string)" << std::endl;
    }
}

// Sample method using optional as return value
boost::optional<int> ReturnOptional(bool return_nothing)
{
    if (return_nothing)
    {
       return boost::optional<int>();
    }

    return boost::optional<int>(42);
}

ใช้การอ้างอิงเมื่อคุณสามารถใช้ตัวชี้เมื่อคุณต้อง จากคำถามที่พบบ่อย C ++: "ฉันควรใช้การอ้างอิงเมื่อใดและเมื่อใดควรใช้ตัวชี้?"

ตัวชี้

• ตัวชี้เป็นตัวแปรที่เก็บที่อยู่หน่วยความจำ
• การประกาศตัวชี้ประกอบด้วยชนิดฐาน, *, และชื่อตัวแปร
• ตัวชี้สามารถชี้ไปที่ตัวแปรจำนวนเท่าใดก็ได้ในอายุการใช้งาน

• ตัวชี้ที่ไม่ได้ชี้ไปยังตำแหน่งหน่วยความจำที่ถูกต้องในปัจจุบันจะได้รับค่า null (ซึ่งเป็นศูนย์)

  BaseType* ptrBaseType;
  BaseType objBaseType;
  ptrBaseType = &objBaseType;

• & เป็นตัวดำเนินการเอกที่จะส่งคืนที่อยู่หน่วยความจำของตัวถูกดำเนินการ

• ตัวดำเนินการ Dereferencing (*) ใช้เพื่อเข้าถึงค่าที่เก็บไว้ในตัวแปรที่ตัวชี้ชี้ไป

     int nVar = 7;
     int* ptrVar = &nVar;
     int nVar2 = *ptrVar;

การอ้างอิง

• การอ้างอิง (&) เปรียบเสมือนนามแฝงของตัวแปรที่มีอยู่

• การอ้างอิง (&) เป็นเหมือนตัวชี้ค่าคงที่ที่ถูกอ้างอิงโดยอัตโนมัติ

• โดยปกติจะใช้สำหรับรายการอาร์กิวเมนต์ของฟังก์ชันและค่าส่งคืนของฟังก์ชัน

• การอ้างอิงจะต้องเริ่มต้นเมื่อมันถูกสร้างขึ้น

• เมื่อมีการเริ่มต้นการอ้างอิงไปยังวัตถุมันไม่สามารถเปลี่ยนแปลงได้เพื่ออ้างอิงไปยังวัตถุอื่น

• คุณไม่สามารถมีการอ้างอิงเป็นโมฆะ

• การอ้างอิง const สามารถอ้างถึง const int มันทำกับตัวแปรชั่วคราวที่มีค่าของ const

  int i = 3;    //integer declaration
  int * pi = &i;    //pi points to the integer i
  int& ri = i;    //ri is refers to integer i – creation of reference and initialization

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

พิจารณาคำสำคัญของ C # คอมไพเลอร์ต้องการผู้เรียกใช้เมธอดเพื่อใช้คีย์เวิร์ด out กับ args ใด ๆ แม้ว่ามันจะรู้อยู่แล้วถ้ามันเป็น สิ่งนี้มีจุดประสงค์เพื่อเพิ่มความสามารถในการอ่าน แม้ว่าจะมี IDEs ที่ทันสมัยฉันมีแนวโน้มที่จะคิดว่านี่เป็นงานสำหรับเน้นไวยากรณ์ (หรือความหมาย)

ผ่านการอ้างอิง const เว้นแต่มีเหตุผลที่คุณต้องการเปลี่ยน / เก็บเนื้อหาที่คุณกำลังผ่าน

นี่จะเป็นวิธีที่มีประสิทธิภาพมากที่สุดในกรณีส่วนใหญ่

ตรวจสอบให้แน่ใจว่าคุณใช้ const ในแต่ละพารามิเตอร์ที่คุณไม่ต้องการเปลี่ยนแปลงเนื่องจากไม่เพียง แต่ปกป้องคุณจากการทำสิ่งที่โง่ในฟังก์ชั่นเท่านั้น แต่ยังช่วยให้ผู้ใช้รายอื่นทราบถึงสิ่งที่ฟังก์ชันทำ ซึ่งรวมถึงการสร้างตัวชี้ const เมื่อคุณต้องการเปลี่ยนสิ่งที่ชี้ไปที่ ...

ตัวชี้:

• สามารถมอบหมายnullptr(หรือNULL )
• ที่ไซต์การโทรคุณต้องใช้ &หากประเภทของคุณไม่ใช่ตัวชี้ทำให้คุณต้องแก้ไขวัตถุของคุณอย่างชัดเจน
• พอยน์เตอร์สามารถฟื้นตัวได้

อ้างอิง:

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

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

การอ้างอิงมีประโยชน์อย่างยิ่งสำหรับการระบุอาร์กิวเมนต์ของฟังก์ชัน

สำหรับข้อมูลเพิ่มเติมโปรดดู "A Tour of C ++" โดย "Bjarne Stroustrup" (2014) หน้า 11-12