การส่งผ่านอาร์เรย์ไปยังฟังก์ชัน C++

Passing An Array Function C



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

ไวยากรณ์

[กลับพิมพ์] [ชื่อของการทำงาน] (ข้อมูลพิมพ์ชื่ออาร์เรย์[อาร์เรย์ขนาด])

{

การทำงานร่างกาย

}

ตัวอย่างที่ 1

พิจารณาตัวอย่างที่เราต้องพิมพ์เครื่องหมายของนักเรียนในโปรแกรม C++ งานพิมพ์นี้จะถูกถ่ายในฟังก์ชันแยกต่างหากแทนที่จะเป็นในโปรแกรมหลัก ในทางตรงกันข้าม เราจะรับอินพุตในโปรแกรมหลักและจะถ่ายโอนค่าเหล่านี้ไปยังฟังก์ชันเป็นพารามิเตอร์ พิจารณาฟังก์ชัน ในพารามิเตอร์มีตัวแปรประเภทข้อมูลอาร์เรย์ที่จะยอมรับค่าของอาร์เรย์ มีการประกาศอาร์เรย์แบบเต็มที่นี่ เครื่องหมายจะแสดงโดยใช้ for loop ในอาร์เรย์ เราจำเป็นต้องมีการวนซ้ำเพื่อสั่งพิมพ์









ย้ายไปยังฟังก์ชันหลัก เราประกาศอาร์เรย์ที่มีขนาดและค่าในนั้น เนื่องจากเราต้องเรียกใช้ฟังก์ชัน วิธีการคือเราเขียนชื่อฟังก์ชันด้วยชื่อของอาร์เรย์ในพารามิเตอร์เป็นอาร์กิวเมนต์ เราไม่ได้กำหนดขนาดของอาร์เรย์



แสดง(เครื่องหมาย);

อาร์กิวเมนต์ในพารามิเตอร์แสดงถึงที่อยู่หน่วยความจำของอาร์เรย์ ในพารามิเตอร์ของส่วนหัวของฟังก์ชัน int m[7] จะถูกแปลงเป็น int *m ซึ่งรวมถึงที่อยู่เดียวกันกับอาร์เรย์เดิม เมื่อเราใช้ m[5] ในเนื้อความของฟังก์ชัน เราจะจัดการกับอาร์เรย์ดั้งเดิม





การแสดงเป็นโมฆะ(int m[7] )

ในระบบปฏิบัติการ Linux การรับเอาต์พุตผ่านเทอร์มินัลต้องมีข้อกำหนดเบื้องต้นบางประการในการติดตั้ง มันต้องใช้คอมไพเลอร์เพื่อคอมไพล์แล้วรันโค้ดในเทอร์มินัลพรอมต์คำสั่ง G++ ใช้ใน C++ สำหรับการรวบรวม



$g++ -หรือcode3 code3.c

$./รหัส3

โดยที่ –o ใช้เพื่อเก็บเอาต์พุตจากไฟล์ต้นทางไปยังไฟล์เอาต์พุต

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

ตัวอย่าง 2

อีกตัวอย่างหนึ่งเกี่ยวกับอาร์เรย์ที่ส่งผ่านพารามิเตอร์คือการส่งอาร์เรย์หลายมิติไปยังฟังก์ชัน ใช้อาร์เรย์สองมิติ (2d) ที่นี่ ในฟังก์ชันหลัก เราจำเป็นต้องเริ่มต้นอาร์เรย์

Int array[แถว][คอลัมน์]

การเริ่มต้นอาร์เรย์ 2d รวมถึงแถวและคอลัมน์ และต้องรักษาลำดับไว้ตลอดทั้งโปรแกรม อาร์เรย์ 2d เริ่มต้นด้วยตัวเลขสองตัวในวงเล็บ ตามที่เราได้อธิบายไว้ 2 คอลัมน์ในการเริ่มต้น

แสดง(หนึ่ง);

เราจะใช้ชื่ออาร์เรย์ในพารามิเตอร์เป็นอาร์กิวเมนต์เท่านั้น

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

การแสดงเป็นโมฆะ(int n[][2] )

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

เราสามารถดูผลลัพธ์ได้โดยใช้คอมไพเลอร์ตัวเดียวกัน คุณสามารถดูผลลัพธ์ที่แต่ละค่าแสดงแยกจากกันด้วยหมายเลขแถวและคอลัมน์

ตัวอย่างที่ 3

ตัวอย่างนี้แตกต่างจากตัวอย่างก่อนหน้านี้เล็กน้อย ในตัวอย่างนี้ เราพูดถึงขนาดอาร์เรย์ในพารามิเตอร์ของการเรียกใช้ฟังก์ชัน และในการประกาศฟังก์ชัน ตัวแปรยังถูกแนะนำให้ยอมรับขนาดของอาร์เรย์

เริ่มต้นจากโปรแกรมหลัก อาร์เรย์จะเริ่มต้นด้วยค่าต่างๆ

เฉลี่ย = getAverage(สมดุล,5);

ผลลัพธ์จะถูกเก็บไว้ในตัวแปร avg แทนที่จะส่งผ่านเฉพาะชื่ออาร์เรย์ ขนาดอาร์เรย์จะถูกเพิ่มไปยังพารามิเตอร์ด้วย

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

ตอนนี้เราจะเห็นผลลัพธ์ ค่านี้สามารถมองเห็นได้ผ่านภาพที่ได้มาจากฟังก์ชัน

ตัวอย่างที่ 4

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

printMax(arr1);

printMax(arr2);

โดยที่ printMax คือชื่อของฟังก์ชันและ arr คืออาร์เรย์ ผลลัพธ์จะไม่กลับมาจากฟังก์ชันและแสดงที่นั่น For loop จะคำนวณจำนวนสูงสุดในอาร์เรย์ทั้งสอง if-statement ถูกใช้ภายใน for loop ส่วนหัวของฟังก์ชันคือ:

เป็นโมฆะ printMax(int arr[5])

เนื่องจากอาร์เรย์ทั้งสองมีค่าต่างกัน ผลลัพธ์ทั้งสองจึงต่างกัน

ตัวอย่างที่ 5

ตัวอย่างนี้เป็นบทสรุปของอาร์เรย์ทุกประเภทที่ส่งผ่านพารามิเตอร์ สิ่งเหล่านี้อาจเป็นอาร์เรย์ขนาด ไม่มีขนาด หรือพอยน์เตอร์ เราจะพิจารณาพวกเขาทีละคน

ในโปรแกรมหลัก แต่ละฟังก์ชันจะถูกประกาศก่อน คุณสามารถชี้ให้เห็นความแตกต่างในการประกาศได้

Int sum1(int tmp[5]);

Int sum2(int tmp[]);

Int sum3(int*tmp);

อาร์เรย์ทั้งสามนี้แสดงให้เห็นว่าอาร์เรย์สามารถส่งผ่านได้โดยมีพารามิเตอร์เหล่านี้ในฟังก์ชัน

หลังจากฟังก์ชันเริ่มต้น เรามีโปรแกรมหลักที่ประกาศอาร์เรย์ ไม่เหมือนกับตัวอย่างก่อนหน้านี้ อาร์เรย์หนึ่งถูกเตรียมใช้งานแทนสอง แต่จะถูกส่งผ่านในสามวิธีที่แตกต่างกัน ตอนนี้เราจะเห็นการเรียกใช้ฟังก์ชันที่นี่

รวม = sum1(ฝ่ายขาย);

รวม = sum2(ฝ่ายขาย);

รวม = sume3(ฝ่ายขาย);

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

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

คุณจะเห็นได้ว่าคำตอบเหมือนกันสำหรับฟังก์ชันทั้งสามที่ใช้

บทสรุป

ในบทความนี้ ผู้ใช้จะได้ทราบเกี่ยวกับวิธีการส่งผ่านของอาร์เรย์ในพารามิเตอร์ อาร์เรย์สามารถจัดการได้ในหลายกรณีเมื่อพูดถึงการคืนค่าหรือส่งต่อในอาร์กิวเมนต์