เวกเตอร์ถูกส่งผ่านไปยังฟังก์ชันตามค่าหรือโดยการอ้างอิงใน C ++

ฉันกำลังเขียนโค้ดใน C ++ ถ้าฉันมีฟังก์ชันบางอย่างvoid foo(vector<int> test)และฉันเรียกมันในโปรแกรมของฉันเวกเตอร์จะถูกส่งต่อด้วยค่าหรือการอ้างอิงหรือไม่? ฉันไม่แน่ใจเพราะฉันรู้ว่าเวกเตอร์และอาร์เรย์มีความคล้ายคลึงกันและฟังก์ชันที่ต้องการvoid bar(int test[])จะผ่านการทดสอบโดยการอ้างอิง (ตัวชี้?) แทนที่จะเป็นค่า ฉันเดาว่าฉันจะต้องส่งเวกเตอร์ด้วยตัวชี้ / การอ้างอิงอย่างชัดเจนหากฉันต้องการหลีกเลี่ยงการส่งผ่านค่า แต่ฉันไม่แน่ใจ

ถ้าให้เดาก็คงบอกได้ว่าคุณมาจากพื้นหลัง Java นี่คือ C ++ และสิ่งต่างๆจะถูกส่งผ่านด้วยค่าเว้นแต่คุณจะระบุเป็นอย่างอื่นโดยใช้&-operator (โปรดทราบว่าตัวดำเนินการนี้ยังใช้เป็นตัวดำเนินการ 'address-of' แต่ในบริบทที่แตกต่างกัน) ทั้งหมดนี้ได้รับการบันทึกไว้เป็นอย่างดี แต่ฉันจะทบทวนซ้ำ:

void foo(vector<int> bar); // by value
void foo(vector<int> &bar); // by reference (non-const, so modifiable inside foo)
void foo(vector<int> const &bar); // by const-reference

คุณยังสามารถเลือกที่จะส่งตัวชี้ไปยังเวกเตอร์ ( void foo(vector<int> *bar)) แต่ถ้าคุณไม่ทราบว่าคุณกำลังทำอะไรอยู่และคุณรู้สึกว่านี่เป็นวิธีที่จะไปจริงๆอย่าทำ

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

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

void foo1(int *arr) { cout << sizeof(arr) << '\n'; }
void foo2(int arr[]) { cout << sizeof(arr) << '\n'; }
void foo3(int arr[10]) { cout << sizeof(arr) << '\n'; }
void foo4(int (&arr)[10]) { cout << sizeof(arr) << '\n'; }

int main()
{
    int arr[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
    foo1(arr);
    foo2(arr);
    foo3(arr);
    foo4(arr);
}

A vectorมีหน้าที่เหมือนกับอาร์เรย์ แต่สำหรับภาษาvectorเป็นประเภทและintยังเป็นประเภท สำหรับอาร์กิวเมนต์ของฟังก์ชันอาร์เรย์ประเภทใด ๆ (รวมถึงvector[]) จะถือว่าเป็นตัวชี้ A vector<int>ไม่เหมือนกับint[](ไปยังคอมไพเลอร์) vector<int>ไม่ใช่อาร์เรย์ไม่ใช่การอ้างอิงและไม่ใช่ตัวชี้ - จะถูกส่งผ่านด้วยค่าดังนั้นจึงเรียกตัวสร้างสำเนา

ดังนั้นคุณต้องใช้vector<int>&(โดยเฉพาะอย่างยิ่งกับconstถ้าฟังก์ชันไม่ได้แก้ไข) เพื่อส่งผ่านเป็นข้อมูลอ้างอิง

void foo(vector<int> test)

เวกเตอร์จะถูกส่งผ่านด้วยค่าในสิ่งนี้

คุณมีหลายวิธีในการส่งเวกเตอร์ขึ้นอยู่กับบริบท: -

1) ผ่านการอ้างอิง: - สิ่งนี้จะช่วยให้ฟังก์ชัน foo เปลี่ยนเนื้อหาของเวกเตอร์ มีประสิทธิภาพมากกว่าการส่งผ่านค่าเนื่องจากหลีกเลี่ยงการคัดลอกเวกเตอร์

2) ผ่านการอ้างอิง const: - มีประสิทธิภาพและเชื่อถือได้เมื่อคุณไม่ต้องการให้ฟังก์ชันเปลี่ยนเนื้อหาของเวกเตอร์

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