อาร์เรย์เป็นรูปแบบการจัดเก็บข้อมูลที่มีโครงสร้างรูปแบบหนึ่งที่ใช้กันมากที่สุดในโปรแกรมคอมพิวเตอร์ การประมวลผลสามารถทำได้โดยใช้อัลกอริธึมต่างๆ ที่ใช้ในเมธอดและฟังก์ชันของคลาส ดังนั้นจึงมักจะต้องส่งผ่านอาร์เรย์ไปยังฟังก์ชัน ภาษา C และ C ++ ให้อิสระอย่างมากในการเลือกวิธีการดำเนินการนี้
มันจำเป็น
คอมไพเลอร์ของภาษา C และ C ++
คำแนะนำ
ขั้นตอนที่ 1
ส่งอาร์เรย์ขนาดคงที่ไปยังฟังก์ชัน เปลี่ยนต้นแบบของฟังก์ชันให้มีอาร์กิวเมนต์ประเภทที่เหมาะสม ตัวอย่างเช่น การประกาศฟังก์ชันที่ใช้อาร์เรย์ของค่าตัวเลขจำนวนเต็มขององค์ประกอบสามองค์ประกอบเป็นพารามิเตอร์อาจมีลักษณะดังนี้:
โมฆะ ArrayFunction (int aNumbers [3]);
ฟังก์ชันดังกล่าวถูกเรียกโดยการส่งผ่านอาร์เรย์โดยตรงไปยังอาร์กิวเมนต์:
เป็นโมฆะ SomeFunction ()
{
int aNumbers = {1, 2, 3};
ArrayFunction (ตัวเลข);
}
ข้อมูลที่ถ่ายโอนจะถูกคัดลอกไปยังสแต็ก การปรับเปลี่ยนอาร์เรย์ในฟังก์ชันที่เรียกจะไม่เปลี่ยนแหล่งที่มา
ขั้นตอนที่ 2
ส่งผ่านอาร์เรย์ความยาวผันแปรไปยังฟังก์ชัน ในการดำเนินการนี้ อย่าเพิ่งระบุขนาดของอาร์กิวเมนต์ที่เกี่ยวข้อง:
โมฆะ ArrayFunction (int aNumbers );
อาร์เรย์หลายมิติสามารถส่งผ่านในลักษณะเดียวกันได้ (เฉพาะ "มิติ" แรกเท่านั้นที่สามารถเป็นตัวแปรได้):
โมฆะ ArrayFunction (int aNumbers [3] [2]);
ฟังก์ชันเหล่านี้ถูกเรียกในลักษณะเดียวกับในขั้นตอนแรก
เพื่อให้สามารถประมวลผลอาร์เรย์ของความยาวตัวแปรในฟังก์ชันได้อย่างถูกต้อง คุณต้องส่งผ่านจำนวนองค์ประกอบอย่างชัดเจนผ่านพารามิเตอร์เพิ่มเติม หรือใช้แบบแผนที่กำหนดข้อ จำกัด เกี่ยวกับค่าขององค์ประกอบเอง (ค่าที่แน่นอน ต้องเป็นเครื่องหมายสิ้นสุดอาร์เรย์)
ขั้นตอนที่ 3
ส่งผ่านอาร์เรย์ด้วยตัวชี้ อาร์กิวเมนต์ของฟังก์ชันจะต้องเป็นตัวชี้ไปยังค่าที่มีประเภทที่สอดคล้องกับองค์ประกอบของอาร์เรย์ ตัวอย่างเช่น:
โมฆะ ArrayFunction (int * pNumbers);
การเข้าถึงข้อมูลในฟังก์ชันสามารถทำได้ทั้งในสัญกรณ์สำหรับการทำงานกับองค์ประกอบอาร์เรย์ และการใช้เลขคณิตที่อยู่:
โมฆะ ArrayFunction (int * pNumbers)
{
pNumbers [0] = 10; // เข้าถึงองค์ประกอบ 0
* (pNumbers + 1) = 20; // เข้าถึงรายการ 1
}
ระวัง! เนื่องจากฟังก์ชันไม่ได้ส่งผ่านไม่ใช่สำเนาของข้อมูล แต่เป็นตัวชี้ไปยังฟังก์ชันนั้น อาร์เรย์ดั้งเดิมจะถูกแก้ไข
ข้อดีของวิธีนี้คือความเร็ว ความประหยัดของทรัพยากรการคำนวณ และความยืดหยุ่นบางอย่าง ดังนั้น คุณสามารถเรียกใช้ฟังก์ชันเป้าหมายโดยส่งตัวชี้ไปยังองค์ประกอบตามอำเภอใจของอาร์เรย์:
เป็นโมฆะ SomeFunction ()
{
int aNumbers = {1, 2, 3};
ArrayFunction (ตัวเลข); // ทั้งอาร์เรย์
ArrayFunction (& ตัวเลข [1]); // เริ่มจากองค์ประกอบที่สอง
}
วิธีการนี้มักจะเกี่ยวข้องกับการส่งจำนวนขององค์ประกอบที่มีอยู่ในพารามิเตอร์เพิ่มเติมหรือการใช้ตัวสิ้นสุดอาร์เรย์
ขั้นตอนที่ 4
ส่งข้อมูลไปยังฟังก์ชันที่มีพารามิเตอร์ที่เป็นอ็อบเจ็กต์หรือการอ้างอิงไปยังอ็อบเจ็กต์ของคลาสที่ใช้ฟังก์ชันอาร์เรย์ คลาสหรือเทมเพลตคลาสดังกล่าวมักพบในไลบรารีและเฟรมเวิร์กยอดนิยม (QVector ใน Qt, CArray ใน MFC, std:: vector ใน STL เป็นต้น)
คลาสเหล่านี้มักใช้กลยุทธ์การแชร์ข้อมูลโดยปริยายพร้อมการนับการอ้างอิง ดำเนินการคัดลอกแบบลึกเฉพาะเมื่อมีการแก้ไขข้อมูลเท่านั้น (คัดลอกเมื่อเขียน) วิธีนี้ช่วยให้คุณลดการใช้ทรัพยากรการคำนวณได้แม้ในกรณีที่ส่งผ่านอ็อบเจ็กต์อาร์เรย์ตามค่าผ่านอาร์กิวเมนต์ของฟังก์ชันและเมธอด:
โมฆะ ArrayFunction (QVector oArray)
{
int nItemCount = oArray.count ();
int nItem = oArray [0];
}
เป็นโมฆะ SomeFunction ()
{
QVector oArray (10);
สำหรับ (int i = 0; i