ในที่นี้ขนาดของอาร์เรย์หรือความยาวของอาร์เรย์คือ 6 และขนาดอาร์เรย์ทั้งหมดที่จะกำหนดจะไม่แสดง ขนาดจริงได้มาจากการใช้การดำเนินการต่างๆ การดำเนินการเหล่านี้ใช้ในบทความนี้เพื่อรับขนาดของอาร์เรย์
ตัวอย่างที่ 1
ในภาพประกอบนี้ เราจะใช้แนวคิดของ begin() และ end() วิธีนี้ช่วยให้ทราบขนาดของอาร์เรย์ได้ง่าย เหล่านี้เป็นสองไลบรารีที่เป็นที่รู้จักสำหรับไลบรารีมาตรฐาน ฟังก์ชันทั้งสองนี้จะคืนค่าตัววนซ้ำที่แสดงจุดเบื้องต้นและจุดสิ้นสุดของอาร์เรย์ เริ่มจากส่วนหัว เราใช้ไลบรารีอาร์เรย์ ซึ่งจะรวมถึงฟังก์ชันทั้งหมดที่เกี่ยวข้องกับอาร์เรย์ ในฟังก์ชันหลัก เราได้เริ่มต้นอาร์เรย์ที่มีค่าจำนวนเต็ม
ค่าใช้จ่าย<<……….<<จบ(ถึง)-begib(ถึง)<<
ที่นี่เราไม่ได้กล่าวถึงขนาดอาร์เรย์ ในคำสั่ง display ต่อจาก cout เราใช้ฟังก์ชัน end() และ start() ความแตกต่างระหว่างสองฟังก์ชันนี้จะแสดงให้เราเห็นขนาดของอาร์เรย์ ในพารามิเตอร์ของฟังก์ชันเหล่านี้ เราได้ส่งผ่านอาร์เรย์ โดยการทำเช่นนี้จะกำหนดขนาดจริง ค่าผลลัพธ์จากฟังก์ชันเหล่านี้จะแสดงโดยตรง
ตอนนี้ย้ายไปยังเอาท์พุท เราควรรันโปรแกรมเหล่านี้ใน Linux ดังนั้นเราจึงจำเป็นต้องมีส่วนร่วมของเทอร์มินัล Ubuntu เนื่องจากเราใช้โค้ด C++ เราจึงต้องคอมไพล์โค้ดผ่านคอมไพเลอร์ นั่นคือคอมไพเลอร์ G++ หลังจากรวบรวมรหัสเราจะดำเนินการ คำสั่งด้านล่างแสดงวิธีการส่งออกที่เราใช้
$ g++ -o รหัส 2 รหัส 2ค$./รหัส2
ตอนนี้คุณสามารถดูผลลัพธ์ อีกตัวอย่างหนึ่งที่คล้ายกันในกรณีของ std คือฟังก์ชันระยะทาง ในระยะทางนี้คำนวณโดยใช้ฟังก์ชัน start() และ end() เสร็จสมบูรณ์โดยใช้ฟังก์ชันเหล่านี้กับ std
Int n=ชั่วโมง:: ระยะทาง(ชั่วโมง::เริ่ม(arr),ชั่วโมง::จบ(arr)); 
ผลลัพธ์จะได้รับในคำสั่ง cout หากต้องการดูบันทึก ให้ใช้คอมไพเลอร์อีกครั้งเพื่อรันโค้ด
ที่นี่คุณจะเห็นว่าได้ผลลัพธ์ที่ต้องการแล้ว
ตัวอย่างที่ 2
ตัวอย่างนี้เกี่ยวข้องกับการใช้ฟังก์ชัน sizeof() ในโค้ด C++ เนื่องจากค่านี้จะส่งกลับขนาดจริงของข้อมูลในรูปของไบต์ นอกจากนี้ยังเกี่ยวข้องกับการส่งคืนจำนวนไบต์ที่ใช้ในการจัดเก็บอาร์เรย์ กล่าวอีกนัยหนึ่ง ในตัวอย่างนี้ ขั้นตอนแรกคือการเริ่มต้นอาร์เรย์โดยไม่ระบุขนาดของอาร์เรย์ ไวยากรณ์ที่ใช้สำหรับฟังก์ชัน sizeof() คือ:
Int al= ขนาดของ(arr)/ขนาดของ(arr[0]);โดยที่ arr คืออาร์เรย์ arr[0] แสดงดัชนีขององค์ประกอบในอาร์เรย์
ดังนั้นคำสั่งนี้จึงบอกเป็นนัยว่าขนาดอาร์เรย์ถูกหารด้วยขนาดขององค์ประกอบทั้งหมดที่มีอยู่ ทีละรายการ ซึ่งจะช่วยในการคำนวณความยาว เราใช้ตัวแปรจำนวนเต็มเพื่อรับและเก็บค่าที่ส่งคืนจากฟังก์ชัน
เราจะได้ผลลัพธ์ที่นี่จากพรอมต์คำสั่งโดยใช้วิธีการคอมไพล์การดำเนินการเดียวกัน
ผลลัพธ์แสดงขนาดของอาร์เรย์ ซึ่งหมายถึงจำนวนองค์ประกอบที่มีอยู่ในอาร์เรย์ ซึ่งเท่ากับ 6
ตัวอย่างที่ 3
ตัวอย่างนี้รวมถึงการใช้ฟังก์ชัน size () ฟังก์ชันนี้อยู่ในไลบรารีมาตรฐาน STL ขั้นตอนแรกในโปรแกรมหลักคือการประกาศอาร์เรย์ ที่นี่ชื่อของอาร์เรย์ยังมีขนาดและค่าจำนวนเต็ม เมธอดนี้ยังส่งคืนผลลัพธ์โดยตรงในคำสั่งเอาต์พุต
ค่าใช้จ่าย<<….<<ร.ขนาด()<<โดยที่ 'arr' คืออาร์เรย์ เพื่อดึงผลลัพธ์หรือเข้าถึงฟังก์ชัน เราจำเป็นต้องมีชื่อของอาร์เรย์ที่มีฟังก์ชันขนาด
ในการแสดงผลลัพธ์ เราใช้คอมไพเลอร์ g++ เพื่อคอมไพล์และดำเนินการผลลัพธ์
จากผลลัพธ์ คุณจะเห็นว่าผลลัพธ์เป็นผลลัพธ์ที่เราต้องการให้แสดงขนาดจริงของอาร์เรย์
ตัวอย่างที่ 4
ขนาดของอาร์เรย์สามารถรับได้โดยใช้พอยน์เตอร์เนื่องจากพอยน์เตอร์เก็บที่อยู่/ตำแหน่งของค่าของตัวแปร ตอนนี้ให้พิจารณาตัวอย่างด้านล่าง
ขั้นตอนแรกคือการเริ่มต้นอาร์เรย์ตามปกติ จากนั้นตัวชี้จะทำงานสำหรับขนาดอาร์เรย์
Int len= *(&อาร์เรย์+ 1)– อาร์เรย์;นี่คือคำสั่งหลักที่ทำงานเป็นตัวชี้ * ใช้เพื่อค้นหาตำแหน่งขององค์ประกอบใด ๆ ในอาร์เรย์ในขณะที่ตัวดำเนินการ & ถูกใช้เพื่อรับค่าของตำแหน่งที่ได้รับผ่านตัวชี้ นี่คือวิธีที่เราได้รับขนาดอาร์เรย์จากพอยน์เตอร์ ผลลัพธ์จะแสดงผ่านเทอร์มินัล คำตอบก็เหมือนกัน เนื่องจากขนาดของอาร์เรย์ดังกล่าวระบุไว้เป็น 13
ตัวอย่างที่ 5
ในตัวอย่างนี้ เราได้ใช้แนวคิดของการหักอาร์กิวเมนต์เทมเพลต อาร์กิวเมนต์เทมเพลตเป็นพารามิเตอร์ชนิดพิเศษ มันถูกใช้เพื่อส่งผ่านอาร์กิวเมนต์ทุกประเภท เช่นเดียวกับฟังก์ชันปกติที่สามารถส่งผ่านเป็นอาร์กิวเมนต์ได้
เมื่ออาร์เรย์ถูกส่งผ่านเป็นพารามิเตอร์ อาร์เรย์นั้นจะถูกแปลงเป็นตัวชี้เพื่อแสดงที่อยู่ เพื่อให้ได้ความยาวของอาร์เรย์ที่เฉพาะเจาะจง เราใช้วิธีการหักอาร์กิวเมนต์เทมเพลตนี้ Std เป็นรูปแบบย่อของมาตรฐาน
เมื่อพิจารณาจากตัวอย่างที่ได้รับ เราได้แนะนำคลาสเทมเพลตที่ใช้เพื่อรับขนาดอาร์เรย์ เป็นคลาสในตัวเริ่มต้นที่มีฟังก์ชันทั้งหมดของอาร์กิวเมนต์เทมเพลต
Constexpr std: : size_tขนาด(constNS(&อาร์เรย์)[NS])ไม่มีข้อยกเว้น{กลับNS;
}
นี่คือเส้นคงเส้นคงวาในแนวคิดนี้ ผลลัพธ์จะได้รับโดยตรงในคำสั่งศาล
จากผลลัพธ์ คุณจะเห็นว่าเราได้ผลลัพธ์ที่ต้องการแล้ว นั่นคือขนาดอาร์เรย์
ตัวอย่างที่ 6
เราใช้ std:: vector เพื่อรับขนาดอาร์เรย์ในโปรแกรม นี่คือภาชนะประเภทหนึ่ง หน้าที่ของมันคือการจัดเก็บอาร์เรย์ไดนามิก มันทำงานด้วยวิธีการต่าง ๆ สำหรับการดำเนินการที่แตกต่างกัน เพื่อให้บรรลุตัวอย่างนี้ เราได้ใช้ไลบรารีเวกเตอร์ที่มีฟังก์ชันเวกเตอร์ทั้งหมดอยู่ในนั้น นอกจากนี้ยังประกาศคำสั่ง cin, cout, endl และ vector ที่จะใช้ในโปรแกรม อาร์เรย์จะเริ่มต้นขึ้นก่อนในโปรแกรม ผลลัพธ์จะแสดงในคำสั่ง cout ตามขนาดเวกเตอร์
ค่าใช้จ่าย<<ขนาดเวกเตอร์: <<int_arrayขนาด() <<endl; 
ตอนนี้เราจะเห็นผลลัพธ์จากเทอร์มินัล Ubuntu ขนาดของอาร์เรย์นั้นแม่นยำสำหรับองค์ประกอบที่มีอยู่ในนั้น
บทสรุป
ในบทช่วยสอนนี้ เราได้ใช้วิธีอื่นเพื่อให้ได้ความยาวหรือขนาดของอาร์เรย์ บางส่วนเป็นฟังก์ชันในตัว ในขณะที่บางฟังก์ชันใช้ด้วยตนเอง