ใช้พอยน์เตอร์เพื่อส่งคืน Static Array
เมื่อเราใช้อาร์เรย์ปกติมีโอกาสที่จะมีผลลัพธ์ที่ผิดปกติบางอย่าง เพื่อหลีกเลี่ยงปัญหานี้ เราใช้อาร์เรย์แบบคงที่ในโค้ด C++ ของเรา ให้เราเข้าใจตัวอย่างที่เราใช้ ในฟังก์ชันนี้ เราได้ประกาศอาร์เรย์ที่มี 5 ค่าประเภทการส่งคืนดังที่กล่าวไว้ที่นี่
ฟังก์ชัน Int * ()
เนื่องจากค่าจะเป็นประเภทจำนวนเต็ม ดังนั้นจึงมีการแท็กเป็น int ในตัวอย่างด้านล่าง ตามที่เราได้แนะนำฟังก์ชันเป็นตัวชี้ ฟังก์ชันจะเป็นประเภทตัวชี้ หลังจากป้อนค่าแล้ว อาร์เรย์จะกลับสู่โปรแกรมหลัก
ในโปรแกรมหลัก เราได้ทำการเรียกฟังก์ชัน ในการยอมรับค่าที่ส่งคืนจากฟังก์ชัน เราจะใช้ตัวแปรจำนวนเต็ม เมื่ออาร์เรย์ถูกส่งกลับ เราสามารถเข้าถึงค่าของอาร์เรย์ได้อย่างง่ายดาย ค่าจะถูกพิมพ์ด้วยตนเอง
Int*ตัวชี้=การทำงาน();จุดประสงค์ของตัวชี้คือเพื่อค้นหารายการที่มีอยู่ในดัชนีหนึ่งในอาร์เรย์ กล่าวอีกนัยหนึ่งจะแสดงที่อยู่ของค่าในอาร์เรย์ จากนั้น เราใช้ฟังก์ชันต้นแบบที่จะส่งคืนตัวชี้
หากต้องการดูผลลัพธ์ของอาร์เรย์ที่ส่งคืนผ่านฟังก์ชัน เราจำเป็นต้องเข้าถึงเทอร์มินัล Ubuntu ในกรณีของ Linux นี่เป็นเพราะเอาต์พุตสามารถเข้าถึงได้ผ่านเทอร์มินัล Linux ใน Linux เราจำเป็นต้องมีคอมไพเลอร์เพื่อเรียกใช้โค้ด C++ ที่เขียนในโปรแกรมแก้ไขข้อความใดๆ การรวบรวมนี้ทำผ่าน G++ -o ใช้เพื่อเก็บเอาต์พุตในไฟล์ ที่นี่เราต้องการไฟล์เอาต์พุตและไฟล์ซอร์สโค้ด หลังจากคอมไพล์แล้ว เราจะรันโค้ด:
$g++ -หรือfile1 file1.c$./ไฟล์1
จากผลลัพธ์ เราจะเห็นอาร์เรย์ซึ่งเริ่มต้นในฟังก์ชัน แสดงในฟังก์ชันหลักโดยใช้อาร์เรย์แบบคงที่ กำหนดค่าเริ่มต้นด้วยตนเองและผ่านพอยน์เตอร์
ส่งคืนอาร์เรย์ที่จัดสรรแบบไดนามิกโดยใช้ตัวชี้
อาร์เรย์สามารถส่งคืนได้โดยใช้การจัดสรรแบบไดนามิก อาร์เรย์สามารถจัดสรรแบบไดนามิกได้โดยใช้คำใหม่ พวกเขาจะอยู่ที่นั่นจนกว่าเราจะลบออกด้วยตัวเอง สแตติกอาร์เรย์มีขนาดคงที่ ซึ่งหมายความว่าคุณต้องระบุขนาดระหว่างการเริ่มต้น เมื่อสร้างอาร์เรย์แล้วจะเป็นการยากที่จะเพิ่มขนาดในขณะใช้งานหรือต่อจากนี้ แต่ในกรณีของไดนามิกอาเรย์ เราสามารถเพิ่มรายการเพิ่มเติมได้ทุกเมื่อที่ต้องการ เพราะมันขยายออกเมื่อเราป้อนค่าเข้าไป ดังนั้นเราจึงไม่จำเป็นต้องระบุหรือระบุขนาดใดๆ
ย้ายไปยังตัวอย่างที่เราใช้ที่นี่ เราใช้ไดนามิกอาร์เรย์กับพอยน์เตอร์เหมือนในตัวอย่างก่อนหน้านี้ ซึ่งเราใช้พอยน์เตอร์กับสแตติกอาร์เรย์
Int*การทำงาน()หลังจากการประกาศฟังก์ชัน อาร์เรย์จะถูกประกาศแบบไดนามิก:
Int*อาร์เรย์= ใหม่ int [100];คำว่า ใหม่ ถูกใช้อย่างต่อเนื่องเพื่อสร้างไดนามิกอาร์เรย์ เราจะดำเนินการกับอาร์เรย์โดยป้อนค่าลงในอาร์เรย์ หลังจากนั้นอาร์เรย์จะกลับสู่โปรแกรมหลัก:
ตอนนี้พิจารณาหน้าที่หลัก เราได้ทำการเรียกใช้ฟังก์ชันแล้ว เมื่ออาร์เรย์ถูกส่งกลับ เราจึงเพิ่มตัวแปรประเภทจำนวนเต็มของตัวชี้เพื่อยอมรับค่า
Int*ตัวชี้=การทำงาน();ค่าที่เก็บไว้ในอาร์เรย์จะถูกพิมพ์ด้วยตนเอง ผลลัพธ์ที่ได้มาจากวิธีการคอมไพล์และการดำเนินการ
อาร์เรย์ส่งคืนโดยใช้โครงสร้าง
โครงสร้างคือคอนเทนเนอร์เช่นอาร์เรย์ แต่อาร์เรย์มีค่าของประเภทข้อมูลเดียวกันในแต่ละครั้ง และในกรณีของโครงสร้าง มีค่าประเภทข้อมูลมากกว่าหนึ่งค่า เราได้นำโครงสร้างชื่อตัวอย่าง ในที่นี้การประกาศอาร์เรย์จะอยู่ภายในโครงสร้างแทนที่จะเป็นฟังก์ชัน ชนิดส่งคืนคือชื่อของโครงสร้าง ตัวแปรโครงสร้างจะกลับสู่โปรแกรมหลัก โครงสร้างใช้คำว่า struct สำหรับการประกาศ
ตัวอย่างโครงสร้าง{
Int arr[100];
};
หลังจากการประกาศโครงสร้าง เราได้ใช้ฟังก์ชันที่สร้างอ็อบเจ็กต์ของโครงสร้าง วัตถุนี้จะใช้ในการเข้าถึงโครงสร้าง ฟังก์ชันนี้จะคืนค่าอ็อบเจ็กต์ของโครงสร้างกลับเป็นฟังก์ชันหลัก เพื่อให้เราสามารถพิมพ์อาร์เรย์ผ่านอ็อบเจ็กต์นี้ได้ ตัวแปรจะได้รับค่าในตัวแปร ค่านี้เป็นจำนวนเต็มที่เราจะป้อนค่าในอาร์เรย์ ในตัวอย่างนี้ เราได้เลือก 6 เป็นตัวเลข ดังนั้นตัวเลขจะถูกป้อนถึง 6 ในอาร์เรย์
โครงสร้างตัวอย่าง func(intNS) 
ตอนนี้ ย้ายไปยังโปรแกรมหลัก เราได้สร้างวัตถุเพื่อเข้าถึงอาร์เรย์ผ่านสิ่งนี้:
ตัวอย่างโครงสร้าง x; 
หลังจากการเริ่มต้นวัตถุ ค่าจะถูกเพิ่มให้กับตัวแปรที่เราต้องการให้ป้อนตัวเลขในอาร์เรย์ ในการเรียกใช้ฟังก์ชัน เราจะส่งค่าในพารามิเตอร์:
NS=การทำงาน(NS);เราจะมีการแสดงผลโดยใช้ for loop ค่าจะแสดงผ่านวัตถุที่ประกาศเมื่อเริ่มต้นโปรแกรมหลัก:
ผลลัพธ์ระบุว่ามีการแสดงค่า 6 ค่าในผลลัพธ์เมื่อเราป้อนตัวเลข 6 ตัวในโปรแกรม
กลับอาร์เรย์โดยใช้ Std
C ++ ใช้วิธีการมากมายในการส่งคืนอาร์เรย์จากฟังก์ชัน หนึ่งในนั้นคือผ่าน std::array เป็นแบบอย่างของโครงสร้าง คุณลักษณะนี้ยังมีฟังก์ชันเพิ่มเติมอีกสองฟังก์ชันคือขนาด () และว่างเปล่า () ส่งคืนชื่ออาร์เรย์ที่ระบุว่าอาร์เรย์ทั้งหมดถูกส่งกลับไปยังโปรแกรมหลัก ที่นี่เราจะเพิ่มอาร์เรย์ไฟล์ส่วนหัว นอกจากไลบรารี่แล้ว ยังมีฟังก์ชันทั้งหมดของอาร์เรย์อีกด้วย
#รวม 
เนื่องจากเราสามารถคืนค่าอาร์เรย์ทั้งหมดด้วยชื่อ ดังนั้นในการประกาศฟังก์ชัน เราจะใช้อาร์เรย์เป็นประเภทการส่งคืน ข้อมูลถูกป้อนในอาร์เรย์ หลังจากนั้นอาร์เรย์จะกลับสู่โปรแกรมหลัก ย้ายไปยังฟังก์ชันหลัก ตัวแปรอาร์เรย์จะยอมรับอาร์เรย์เมื่อเรียกใช้ฟังก์ชัน
arr=การทำงาน();อีกครั้ง for loop จะใช้สำหรับแสดงค่าอาร์เรย์ เราสังเกตผลลัพธ์จากภาพที่แสดงด้านล่าง เนื่องจากเราใช้ขนาด 10 ขนาด จะมีการป้อนตัวเลข 0 ตัว ดังนั้นสิ่งเหล่านี้จะแสดง:
ส่งคืนอาร์เรย์ผ่านคอนเทนเนอร์เวกเตอร์
วิธีการนี้เป็นอาร์เรย์ที่จัดสรรแบบไดนามิก ในกรณีนี้ไม่จำเป็นต้องระบุขนาดอาร์เรย์ เราไม่ต้องการพารามิเตอร์ขนาดใด ๆ ที่นี่ จากตัวอย่างนี้ เราจำเป็นต้องเพิ่มส่วนหัวของเวกเตอร์ในไลบรารีที่มีฟังก์ชันต่างๆ ของเวกเตอร์
ย้ายไปยังฟังก์ชัน โดยที่ประเภทการส่งคืนยังเป็นเวกเตอร์ int และยังมีตัวชี้เวกเตอร์เป็นอาร์กิวเมนต์ในพารามิเตอร์ อาร์เรย์ที่มีชื่อ temp ถูกนำมาใช้ที่นี่:
เวกเตอร์<int>MultiplyArrayByTwo(constเวกเตอร์<int> *arr)ฟังก์ชันนี้จะคูณองค์ประกอบของอาร์เรย์ด้วยสองโดยใช้ฟังก์ชัน tmp.push_back () จากนั้นส่งคืน tmp ตัวแปรประเภทอัตโนมัติจะยอมรับค่าของอาร์เรย์จากฟังก์ชัน อาร์เรย์มีรายการอยู่ในนั้น
ผลลัพธ์แสดงการทำงานของคอนเทนเนอร์เวกเตอร์
บทสรุป
ในบทความดังกล่าว เราได้อธิบายวิธีการที่ใช้บ่อยที่สุดห้าวิธีเพื่ออธิบายฟังก์ชันการทำงานของการคืนค่าอาร์เรย์จากฟังก์ชัน