ใน C++ นั้น Vector เป็นโครงสร้างข้อมูลหนึ่งมิติที่เพิ่มตัวเองแบบไดนามิกตามความต้องการ การจัดระเบียบข้อมูล (การแทรก/การแก้ไข/การลบ) สามารถทำได้อย่างมีประสิทธิภาพในโครงสร้างข้อมูลนี้ การใช้งานมีดังต่อไปนี้:
- เป็นตัวแทนของเวกเตอร์ทางคณิตศาสตร์ในการใช้งานทางวิทยาศาสตร์และวิศวกรรมศาสตร์
- คิว สแต็กสามารถนำไปใช้ได้โดยใช้โครงสร้างข้อมูลนี้ ฯลฯ
การดำเนินการและฟังก์ชัน CRUD ทั่วไปส่วนใหญ่ที่เกี่ยวข้องกับโครงสร้างข้อมูลนี้จะมีการพูดคุยกันตามสถานการณ์โดยละเอียดด้วยไวยากรณ์และส่วนย่อยของโค้ด
หัวข้อเนื้อหา:
- แทรกองค์ประกอบลงในเวกเตอร์
- แทรกหลายองค์ประกอบลงในเวกเตอร์
- เข้าถึงองค์ประกอบจากเวกเตอร์
- อัปเดตองค์ประกอบในเวกเตอร์
- ลบองค์ประกอบเฉพาะออกจากเวกเตอร์
- ลบองค์ประกอบทั้งหมดออกจากเวกเตอร์
- สหพันธ์เวกเตอร์
- จุดตัดของเวกเตอร์
- ตรวจสอบว่าเวกเตอร์ว่างเปล่าหรือไม่
- สำรวจเวกเตอร์โดยใช้ Const_Iterator
- สำรวจเวกเตอร์โดยใช้ Reverse_Iterator
- ผลักองค์ประกอบเข้าไปในเวกเตอร์
- แสดงองค์ประกอบจากเวกเตอร์
- สลับเวกเตอร์
- ดึงองค์ประกอบแรกจากเวกเตอร์
- ดึงองค์ประกอบสุดท้ายจากเวกเตอร์
- กำหนดค่าใหม่ให้กับเวกเตอร์
- ขยายเวกเตอร์โดยใช้ Emplace()
- ขยายเวกเตอร์โดยใช้ Emplace_Back()
- องค์ประกอบสูงสุดของเวกเตอร์
- องค์ประกอบขั้นต่ำของเวกเตอร์
- ผลรวมขององค์ประกอบในเวกเตอร์
- การคูณเวกเตอร์สองแบบตามองค์ประกอบ
- ดอทโปรดัคของเวกเตอร์สองตัว
- แปลงเซตให้เป็นเวกเตอร์
- ลบองค์ประกอบที่ซ้ำกัน
- แปลงเวกเตอร์ให้เป็นเซต
- ลบสตริงว่าง
- เขียนเวกเตอร์ลงในไฟล์ข้อความ
- สร้างเวกเตอร์จากไฟล์ข้อความ
แทรกองค์ประกอบลงในเวกเตอร์
ที่ มาตรฐาน::เวกเตอร์::แทรก() ฟังก์ชันใน C++ STL ใช้เพื่อแทรกองค์ประกอบในตำแหน่งที่ระบุ
ไวยากรณ์:
เวกเตอร์ แทรก ( ตำแหน่งองค์ประกอบ ) ;ลองใช้ฟังก์ชันนี้และส่งผ่านตำแหน่งแรกเป็นพารามิเตอร์ที่ระบุตำแหน่งที่ต้องแทรกองค์ประกอบและระบุองค์ประกอบเป็นพารามิเตอร์ตัวที่สอง
สามารถใช้ฟังก์ชัน beginning() ที่นี่เพื่อส่งคืนตัววนซ้ำที่ชี้ไปยังองค์ประกอบแรกของเวกเตอร์อินพุต เมื่อเพิ่มตำแหน่งลงในฟังก์ชันนี้ องค์ประกอบจะถูกแทรกในตำแหน่งนั้น
มาสร้างเวกเตอร์ “student_names” ของประเภทสตริงแล้วแทรกสองสตริงที่ตำแหน่งที่หนึ่งและสอง ทีละสตริง โดยใช้ฟังก์ชัน insert()
#รวมโดยใช้ เนมสเปซ มาตรฐาน ;
หลัก ( )
{
// การเริ่มต้นเวกเตอร์ - Student_names
เวกเตอร์ < เชือก > นักเรียน_ชื่อ ;
ศาล << 'เวกเตอร์ที่มีอยู่: \n ' ;
สำหรับ ( อัตโนมัติ ฉัน : : นักเรียน_ชื่อ ) ศาล << ฉัน << สิ้นสุด ;
// แทรก 'Sravan Kumar' ที่ตำแหน่งแรก
นักเรียน_ชื่อ แทรก ( นักเรียน_ชื่อ เริ่ม ( ) + 0 , “ชราวัน กุมาร์” ) ;
// แทรก 'Sravan Kumar' ที่ตำแหน่งที่สอง
นักเรียน_ชื่อ แทรก ( นักเรียน_ชื่อ เริ่ม ( ) + 1 , “ลลิตา” ) ;
ศาล << 'เวกเตอร์สุดท้าย: \n ' ;
สำหรับ ( อัตโนมัติ เจ : : นักเรียน_ชื่อ ) ศาล << เจ << สิ้นสุด ;
}
เอาท์พุท:
ก่อนหน้านี้ เวกเตอร์ “student_names” ว่างเปล่า หลังจากการแทรก เวกเตอร์จะเก็บองค์ประกอบสองรายการไว้
แทรกหลายองค์ประกอบลงในเวกเตอร์
เราใช้ฟังก์ชันเดียวกันซึ่งก็คือ std::vector::insert() ในสถานการณ์นี้ แต่เราจำเป็นต้องส่งพารามิเตอร์พิเศษ/ต่างกันไปยังฟังก์ชันเดียวกันเพื่อแทรกองค์ประกอบหลายรายการลงในเวกเตอร์
สถานการณ์ที่ 1: การแทรกองค์ประกอบเดียวหลายครั้ง
ในสถานการณ์สมมตินี้ เราเพิ่มองค์ประกอบเดียวกันหลายครั้ง
ไวยากรณ์:
เวกเตอร์ แทรก ( ตำแหน่ง ขนาด องค์ประกอบ ) ;เมื่อต้องการทำเช่นนี้ เราต้องส่งขนาดเป็นพารามิเตอร์ตัวที่สองไปยังฟังก์ชัน insert() พารามิเตอร์ทั้งหมดที่ส่งไปยังฟังก์ชันนี้คือสาม
ที่นี่:
- พารามิเตอร์ตำแหน่งระบุตำแหน่งองค์ประกอบที่จะแทรก หากขนาดมากกว่า 1 ดัชนีตำแหน่งเริ่มต้นจะเป็นตำแหน่ง
- พารามิเตอร์ขนาดระบุจำนวนครั้งที่องค์ประกอบจะถูกแทรก
- พารามิเตอร์องค์ประกอบนำองค์ประกอบที่จะแทรกลงในเวกเตอร์
พิจารณาเวกเตอร์ “student_names” ด้วยสองสตริง ใส่สาย “Lavanya” ห้าครั้งที่ตำแหน่งที่สอง
#รวมโดยใช้ เนมสเปซ มาตรฐาน ;
หลัก ( )
{
// การเริ่มต้นเวกเตอร์ - Student_names
เวกเตอร์ < เชือก > นักเรียน_ชื่อ { “ชราวัน กุมาร์” , “ลลิตา” } ;
ศาล << 'เวกเตอร์ที่มีอยู่: \n ' ;
สำหรับ ( อัตโนมัติ ฉัน : : นักเรียน_ชื่อ ) ศาล << ฉัน << สิ้นสุด ;
// ใส่ 'Lavanya' ที่ตำแหน่งที่สอง 5 ครั้ง
นักเรียน_ชื่อ แทรก ( นักเรียน_ชื่อ เริ่ม ( ) + 1 , 5 , “ลาวันยา” ) ;
ศาล << ' \n เวกเตอร์สุดท้าย: \n ' ;
สำหรับ ( อัตโนมัติ เจ : : นักเรียน_ชื่อ ) ศาล << เจ << สิ้นสุด ;
}
เอาท์พุท:
ในเวกเตอร์ที่มีอยู่ “สรวัน กุมาร” อยู่ในตำแหน่งแรก และ “ลลิธา” อยู่ในตำแหน่งที่สอง หลังจากใส่คำว่าลาวันยะไปแล้ว 5 ครั้ง (จากตำแหน่งที่ 2 ไปตำแหน่งที่ 6) แล้ว “ลลิธา” ก็ย้ายไปอยู่ในตำแหน่งที่ 7 (สุดท้าย)
สถานการณ์ที่ 2: การแทรกองค์ประกอบหลายรายการ
ในสถานการณ์นี้ เราจะเพิ่มองค์ประกอบต่างๆ จากเวกเตอร์อื่นในแต่ละครั้ง เรายังใช้ฟังก์ชันเดียวกันนี้ แต่ไวยากรณ์และพารามิเตอร์จะเปลี่ยนไป
ไวยากรณ์:
เวกเตอร์ แทรก ( ตำแหน่ง, first_iterator, Second_iterator ) ;เมื่อต้องการทำเช่นนี้ เราต้องส่งขนาดเป็นพารามิเตอร์ตัวที่สองไปยังฟังก์ชัน insert() พารามิเตอร์ทั้งหมดที่ส่งไปยังฟังก์ชันนี้คือสาม
ที่นี่:
- พารามิเตอร์ตำแหน่งระบุตำแหน่งองค์ประกอบที่จะแทรก
- “first_iterator” ระบุตำแหน่งเริ่มต้นที่จะแทรกองค์ประกอบ (โดยทั่วไปแล้ว เมื่อใช้ฟังก์ชัน beginning() ตัววนซ้ำจะถูกส่งกลับโดยชี้ไปยังองค์ประกอบแรกที่มีอยู่ในคอนเทนเนอร์)
- “second_iterator” ระบุตำแหน่งสิ้นสุดที่จะแทรกองค์ประกอบต่างๆ (โดยทั่วไปแล้ว เมื่อใช้ฟังก์ชัน end() ตัววนซ้ำจะถูกส่งกลับซึ่งจุดถัดจากจุดสุดท้ายที่มีอยู่ในคอนเทนเนอร์)
สร้างเวกเตอร์สองตัว “marks1” และ “marks2” ที่เป็นจำนวนเต็ม แทรกองค์ประกอบทั้งหมดที่มีอยู่ในเวกเตอร์ “marks2” ลงในตำแหน่งแรกของเวกเตอร์ “marks1”
#รวมโดยใช้ เนมสเปซ มาตรฐาน ;
หลัก ( )
{
// การเริ่มต้นเวกเตอร์ - marks1
เวกเตอร์ < ภายใน > เครื่องหมาย1 { 100 , 89 , 90 , 78 , 98 } ;
ศาล << “เวกเตอร์แรก: \n ' ;
สำหรับ ( อัตโนมัติ ฉัน : : เครื่องหมาย1 ) ศาล << ฉัน << สิ้นสุด ;
// การเริ่มต้นเวกเตอร์ - marks2
เวกเตอร์ < ภายใน > เครื่องหมาย2 { 56 , สี่ห้า , 65 } ;
ศาล << 'เวกเตอร์ที่สอง: \n ' ;
สำหรับ ( อัตโนมัติ เจ : : เครื่องหมาย2 ) ศาล << เจ << สิ้นสุด ;
เครื่องหมาย1. แทรก ( เริ่ม ( เครื่องหมาย1 ) , เริ่ม ( เครื่องหมาย2 ) , จบ ( เครื่องหมาย2 ) ) ;
// เวกเตอร์สุดท้าย
ศาล << 'เวกเตอร์แรก-สุดท้าย: \n ' ;
สำหรับ ( อัตโนมัติ x : : เครื่องหมาย1 )
ศาล << x << ' ' ;
}
เอาท์พุท:
เวกเตอร์ตัวแรก (marks1) มีห้าองค์ประกอบ และเวกเตอร์ที่สอง (marks2) มีสามองค์ประกอบ เราส่งพารามิเตอร์ start (marks1), beginning(marks2), end(marks2) ไปยังฟังก์ชัน 'insert' เพื่อให้องค์ประกอบทั้งหมดที่มีอยู่ในเวกเตอร์ที่สองถูกวนซ้ำและแทรกลงในเวกเตอร์แรกที่จุดเริ่มต้น ดังนั้นเวกเตอร์แรกมีองค์ประกอบแปดตัว
เข้าถึงองค์ประกอบจากเวกเตอร์
1. การใช้ตัวดำเนินการ []
ในบางสถานการณ์ คุณอาจจำเป็นต้องส่งคืนเฉพาะองค์ประกอบเฉพาะจากเวกเตอร์ ไม่จำเป็นต้องส่งคืนองค์ประกอบทั้งหมด ดังนั้น หากต้องการส่งคืนเฉพาะองค์ประกอบตามดัชนี ตัวดำเนินการดัชนีและฟังก์ชัน at() จะถูกนำมาใช้
ไวยากรณ์:
เวกเตอร์ [ ดัชนี_ตำแหน่ง ]ใน C++ การจัดทำดัชนีเริ่มต้นจาก 0 สำหรับโครงสร้างข้อมูลใดๆ หากไม่มีองค์ประกอบก็จะส่งคืนค่าว่าง (ไม่มีข้อผิดพลาดหรือคำเตือนเกิดขึ้น)
พิจารณาเวกเตอร์ 'ผลิตภัณฑ์' ที่มีห้ารายการ เข้าถึงองค์ประกอบทั้งหมดทีละรายการโดยใช้ตำแหน่งดัชนี
#รวมโดยใช้ เนมสเปซ มาตรฐาน ;
หลัก ( )
{
// สร้างเวกเตอร์ - ผลิตภัณฑ์ที่มี 5 สาย
เวกเตอร์ < เชือก > สินค้า { 'สบู่' , 'แชมพู' , 'น้ำมัน' , 'ผลไม้' , 'ผัก' } ;
// การเข้าถึงองค์ประกอบจากผลิตภัณฑ์
ศาล << 'องค์ประกอบแรก:' << สินค้า [ 0 ] << สิ้นสุด ;
ศาล << 'องค์ประกอบที่สอง:' << สินค้า [ 1 ] << สิ้นสุด ;
ศาล << 'องค์ประกอบที่สาม:' << สินค้า [ 2 ] << สิ้นสุด ;
ศาล << 'องค์ประกอบที่สี่:' << สินค้า [ 3 ] << สิ้นสุด ;
ศาล << 'องค์ประกอบที่ห้า:' << สินค้า [ 4 ] << สิ้นสุด ;
// พยายามเข้าถึงองค์ประกอบที่ 9
ศาล << 'องค์ประกอบที่เก้า:' << สินค้า [ 8 ] << สิ้นสุด ;
}
เอาท์พุท:
ไม่มีองค์ประกอบอยู่ที่ดัชนี 8 ดังนั้นจะส่งคืนค่าว่าง
2. การใช้ฟังก์ชัน At()
At() เป็นฟังก์ชันสมาชิกที่คล้ายกับกรณีการใช้งานก่อนหน้า แต่จะส่งคืนข้อยกเว้น 'std::out_of_range' เมื่อมีดัชนีอยู่นอกช่วง
ไวยากรณ์:
เวกเตอร์ ที่ ( ดัชนี_ตำแหน่ง )เราจำเป็นต้องส่งตำแหน่งดัชนีไปยังฟังก์ชันนี้
พิจารณาเวกเตอร์ 'ผลิตภัณฑ์' ที่มีห้ารายการ เข้าถึงองค์ประกอบทั้งหมดทีละรายการโดยใช้ตำแหน่งดัชนี และพยายามเข้าถึงองค์ประกอบที่มีอยู่ในตำแหน่งที่ 9
#รวมโดยใช้ เนมสเปซ มาตรฐาน ;
หลัก ( )
{
// สร้างเวกเตอร์ - ผลิตภัณฑ์ที่มี 5 สาย
เวกเตอร์ < เชือก > สินค้า { 'สบู่' , 'แชมพู' , 'น้ำมัน' , 'ผลไม้' , 'ผัก' } ;
// การเข้าถึงองค์ประกอบจากผลิตภัณฑ์
ศาล << 'องค์ประกอบแรก:' << สินค้า. ที่ ( 0 ) << สิ้นสุด ;
ศาล << 'องค์ประกอบที่สอง:' << สินค้า. ที่ ( 1 ) << สิ้นสุด ;
ศาล << 'องค์ประกอบที่สาม:' << สินค้า. ที่ ( 2 ) << สิ้นสุด ;
ศาล << 'องค์ประกอบที่สี่:' << สินค้า. ที่ ( 3 ) << สิ้นสุด ;
ศาล << 'องค์ประกอบที่ห้า:' << สินค้า. ที่ ( 4 ) << สิ้นสุด ;
//การเข้าถึงองค์ประกอบที่ไม่อยู่ในเวกเตอร์
ศาล << 'องค์ประกอบที่เก้า:' << สินค้า. ที่ ( 8 ) << สิ้นสุด ;
}
เอาท์พุท:
เกิดข้อผิดพลาดในการเข้าถึงองค์ประกอบที่ 9:
ยุติการเรียกหลังจากโยนอินสแตนซ์ของ 'มาตรฐาน::อยู่นอกช่วง'อะไร ( ) : : เวกเตอร์ :: _M_range_ตรวจสอบ : : __น ( ซึ่งเป็น 8 ) >= นี้ - - > ขนาด ( ) ( ซึ่งเป็น 5 )
อัปเดตองค์ประกอบในเวกเตอร์
1. การใช้ตัวดำเนินการ []
เมื่อใช้ตำแหน่งดัชนี เราสามารถอัปเดตองค์ประกอบในเวกเตอร์ได้ ตัวดำเนินการ [] รับตำแหน่งดัชนีขององค์ประกอบที่ต้องอัปเดต องค์ประกอบใหม่จะถูกกำหนดให้กับตัวดำเนินการนี้
ไวยากรณ์:
เวกเตอร์ [ ดัชนี_ตำแหน่ง ] = องค์ประกอบพิจารณาเวกเตอร์ “student_marks” ที่มีค่า 5 ค่า อัปเดตองค์ประกอบที่มีอยู่ในดัชนี 1 และ 3
#รวม#รวม <เวกเตอร์>
โดยใช้ เนมสเปซ มาตรฐาน ;
หลัก ( )
{
// สร้างเวกเตอร์ - Student_marks
เวกเตอร์ < ภายใน > นักเรียน_เครื่องหมาย { 98 , 78 , 90 , 67 , 89 } ;
ศาล << 'เครื่องหมายที่มีอยู่: ' << สิ้นสุด ;
สำหรับ ( ภายใน มัน : : นักเรียน_เครื่องหมาย )
ศาล << มัน << สิ้นสุด ;
// อัปเดตองค์ประกอบที่ดัชนี-3 ด้วย 100
นักเรียน_เครื่องหมาย [ 3 ] = 100 ;
// อัปเดตองค์ประกอบที่ดัชนี-1 ด้วย 60
นักเรียน_เครื่องหมาย [ 1 ] = 60 ;
ศาล << 'เครื่องหมายสุดท้าย:' << สิ้นสุด ;
สำหรับ ( ภายใน มัน : : นักเรียน_เครื่องหมาย )
ศาล << มัน << สิ้นสุด ;
}
เอาท์พุท:
เราจะเห็นว่าเวกเตอร์สุดท้ายเก็บองค์ประกอบอัปเดตไว้ที่ดัชนี 1 และ 3
2. การใช้ฟังก์ชัน At()
คล้ายกับตัวดำเนินการดัชนี โดยพื้นฐานแล้ว at() นั้นเป็นฟังก์ชันสมาชิกที่อัปเดตค่าตามดัชนีในตัววนซ้ำ หากไม่มีดัชนีที่ระบุภายในฟังก์ชันนี้ ข้อยกเว้น 'std::out_of_range' จะถูกส่งออกไป
เวกเตอร์ ที่ ( ดัชนี_ตำแหน่ง ) = องค์ประกอบพิจารณาเวกเตอร์ 'ผลิตภัณฑ์' ที่มีห้ารายการ อัปเดตองค์ประกอบทั้งหมดที่มีอยู่ในเวกเตอร์ด้วยองค์ประกอบอื่นๆ
#รวมโดยใช้ เนมสเปซ มาตรฐาน ;
หลัก ( )
{
// สร้างเวกเตอร์ - ผลิตภัณฑ์ที่มี 5 สาย
เวกเตอร์ < เชือก > สินค้า { 'สบู่' , 'แชมพู' , 'น้ำมัน' , 'ผลไม้' , 'ผัก' } ;
ศาล << 'ผลิตภัณฑ์ที่มีอยู่:' << สิ้นสุด ;
สำหรับ ( สตริงมัน : : สินค้า )
ศาล << มัน << สิ้นสุด ;
// อัปเดตสตริงทั้งหมด
สินค้า. ที่ ( 0 ) = 'เค้ก' ;
สินค้า. ที่ ( 1 ) = 'ช็อคโกแลต' ;
สินค้า. ที่ ( 2 ) = 'ผลไม้' ;
สินค้า. ที่ ( 3 ) = 'หัวหอม' ;
สินค้า. ที่ ( 4 ) = 'เครื่องดื่มน้ำอัดลม' ;
ศาล << ' \n ผลิตภัณฑ์ขั้นสุดท้าย: ' << สิ้นสุด ;
สำหรับ ( สตริงมัน : : สินค้า )
ศาล << มัน << สิ้นสุด ;
}
เอาท์พุท:
ลบองค์ประกอบเฉพาะออกจากเวกเตอร์
ใน C ++ มาตรฐาน::เวกเตอร์::ลบ() ฟังก์ชัน ใช้เพื่อลบองค์ประกอบ/ช่วงขององค์ประกอบเฉพาะออกจากเวกเตอร์ องค์ประกอบจะถูกลบออกตามตำแหน่งตัววนซ้ำ
ไวยากรณ์:
เวกเตอร์ ลบ ( ตำแหน่งตัววนซ้ำ )มาดูไวยากรณ์สำหรับการลบองค์ประกอบเฉพาะออกจากเวกเตอร์ เราสามารถใช้ฟังก์ชัน beginning() หรือ end() เพื่อรับตำแหน่งขององค์ประกอบที่มีอยู่ในเวกเตอร์ที่จะลบออก
พิจารณาเวกเตอร์ 'ผลิตภัณฑ์' ที่มีห้ารายการ
- ลบองค์ประกอบที่สามโดยระบุตัววนซ้ำ start() Begin() ชี้ไปที่องค์ประกอบแรกในเวกเตอร์ ถ้าเราบวกสองเข้าไปในฟังก์ชันนี้ มันจะชี้ไปที่องค์ประกอบที่สาม
- ลบองค์ประกอบสุดท้ายโดยการระบุตัววนซ้ำ end() End() ชี้ไปที่องค์ประกอบสุดท้ายในเวกเตอร์
โดยใช้ เนมสเปซ มาตรฐาน ;
หลัก ( )
{
// สร้างเวกเตอร์ - ผลิตภัณฑ์ที่มี 5 สาย
เวกเตอร์ < เชือก > สินค้า { 'สบู่' , 'แชมพู' , 'น้ำมัน' , 'ผลไม้' , 'ผัก' } ;
ศาล << 'ผลิตภัณฑ์ที่มีอยู่:' << สิ้นสุด ;
สำหรับ ( สตริงมัน : : สินค้า )
ศาล << มัน << สิ้นสุด ;
// ลบองค์ประกอบที่ 3
สินค้า. ลบ ( สินค้า. เริ่ม ( ) + 2 ) ;
ศาล << ' \n หลังจากลบองค์ประกอบที่ 3 แล้ว: \n ' ;
สำหรับ ( สตริงมัน : : สินค้า )
ศาล << มัน << สิ้นสุด ;
// ลบองค์ประกอบสุดท้าย
สินค้า. ลบ ( สินค้า. จบ ( ) ) ;
ศาล << ' \n หลังจากลบองค์ประกอบสุดท้ายแล้ว: \n ' ;
สำหรับ ( สตริงมัน : : สินค้า )
ศาล << มัน << สิ้นสุด ;
}
เอาท์พุท:
ขณะนี้ มีเพียงสามองค์ประกอบเท่านั้น ('สบู่', 'แชมพู', 'ผลไม้') ที่มีอยู่ในเวกเตอร์ 'ผลิตภัณฑ์'
ลบองค์ประกอบทั้งหมดออกจากเวกเตอร์
สถานการณ์ที่ 1: ลบช่วงขององค์ประกอบออกจากเวกเตอร์
ลองใช้ฟังก์ชัน std::vector::erase() เพื่อลบองค์ประกอบหลายรายการในช่วง
ไวยากรณ์:
เวกเตอร์ ลบ ( ตัววนซ้ำก่อน ตัววนซ้ำสุดท้าย )ตัววนซ้ำสองตัว (begin() ชี้ไปที่องค์ประกอบแรกและ end() ชี้ไปที่ฟังก์ชันองค์ประกอบสุดท้าย) ใช้เพื่อระบุช่วง
พิจารณาเวกเตอร์ 'ผลิตภัณฑ์' ที่มีห้ารายการและลบองค์ประกอบทั้งหมดออกจากตำแหน่งที่สอง เพื่อให้บรรลุเป้าหมายนี้ ตัววนซ้ำตัวแรกคือ beginning (ผลิตภัณฑ์)+1 ซึ่งชี้ไปยังองค์ประกอบที่สอง และตัววนซ้ำที่สองคือจุดสิ้นสุด (ผลิตภัณฑ์)
#รวมโดยใช้ เนมสเปซ มาตรฐาน ;
หลัก ( )
{
// สร้างเวกเตอร์ - ผลิตภัณฑ์ที่มี 5 สาย
เวกเตอร์ < เชือก > สินค้า { 'สบู่' , 'แชมพู' , 'น้ำมัน' , 'ผลไม้' , 'ผัก' } ;
ศาล << 'ผลิตภัณฑ์ที่มีอยู่:' << สิ้นสุด ;
สำหรับ ( สตริงมัน : : สินค้า )
ศาล << มัน << สิ้นสุด ;
// ลบองค์ประกอบทั้งหมดออกจากตำแหน่งที่สอง
สินค้า. ลบ ( เริ่ม ( สินค้า ) + 1 ,จบ ( สินค้า ) ) ;
ศาล << ' \n ผลิตภัณฑ์ขั้นสุดท้าย: \n ' ;
สำหรับ ( สตริงมัน : : สินค้า )
ศาล << มัน << สิ้นสุด ;
}
เอาท์พุท:
ขณะนี้ มีเพียงองค์ประกอบเดียวเท่านั้น ('สบู่') ที่มีอยู่ในเวกเตอร์ 'ผลิตภัณฑ์'
สถานการณ์ที่ 2: ลบองค์ประกอบทั้งหมดออกจากเวกเตอร์
ลองใช้ มาตรฐาน::เวกเตอร์::ชัดเจน() ฟังก์ชันเพื่อลบองค์ประกอบทั้งหมดออกจากเวกเตอร์
ไวยากรณ์:
เวกเตอร์ ชัดเจน ( )ไม่มีการส่งพารามิเตอร์ไปยังฟังก์ชันนี้
พิจารณาเวกเตอร์เดียวกันกับที่ใช้ในสถานการณ์แรก และลบองค์ประกอบทั้งหมดออกโดยใช้ฟังก์ชัน clear()
#รวมโดยใช้ เนมสเปซ มาตรฐาน ;
หลัก ( )
{
// สร้างเวกเตอร์ - ผลิตภัณฑ์ที่มี 5 สาย
เวกเตอร์ < เชือก > สินค้า { 'สบู่' , 'แชมพู' , 'น้ำมัน' , 'ผลไม้' , 'ผัก' } ;
ศาล << 'ผลิตภัณฑ์ที่มีอยู่:' << สิ้นสุด ;
สำหรับ ( สตริงมัน : : สินค้า )
ศาล << มัน << สิ้นสุด ;
// ลบองค์ประกอบทั้งหมดออกจากผลิตภัณฑ์
สินค้า. ชัดเจน ( ) ;
ศาล << ' \n ผลิตภัณฑ์ขั้นสุดท้าย: \n ' ;
สำหรับ ( สตริงมัน : : สินค้า )
ศาล << มัน << สิ้นสุด ;
}
เอาท์พุท:
เราจะเห็นได้ว่าไม่มีองค์ประกอบใดในเวกเตอร์ “ผลิตภัณฑ์”
สหพันธ์เวกเตอร์
เป็นไปได้ที่จะดำเนินการ UNION บนเวกเตอร์โดยใช้ฟังก์ชัน std::set_union() Union ส่งคืนองค์ประกอบที่ไม่ซ้ำจากเวกเตอร์โดยไม่สนใจองค์ประกอบที่ซ้ำกัน เราจำเป็นต้องส่งตัววนซ้ำทั้งสองไปยังฟังก์ชันนี้ นอกจากนี้ จะต้องส่งตัววนซ้ำเอาต์พุตซึ่งจะเก็บผลลัพธ์ที่ส่งคืนโดยตัววนซ้ำทั้งสอง
ไวยากรณ์:
set_union ( InputIterator1 first1, InputIterator1 สุดท้าย 1, InputIterator2 first2, InputIterator2 สุดท้าย 2, OutputIterator res ) ;ที่นี่:
- “first1” ชี้ไปที่องค์ประกอบแรกของตัววนซ้ำตัวแรก (เวกเตอร์)
- “last1” ชี้ไปที่องค์ประกอบสุดท้ายของตัววนซ้ำตัวแรก (เวกเตอร์)
- “first2” ชี้ไปที่องค์ประกอบแรกของตัววนซ้ำที่สอง (เวกเตอร์)
- “last2” ชี้ไปที่องค์ประกอบสุดท้ายของตัววนซ้ำที่สอง (เวกเตอร์)
สร้างเวกเตอร์สองตัว – “วิชา1” และ “วิชา2” – ประเภทจำนวนเต็ม
- จัดเรียงเวกเตอร์สองตัวโดยใช้ฟังก์ชัน sort() โดยส่งผ่านตัววนซ้ำ
- สร้างเวกเตอร์เอาต์พุต (ตัววนซ้ำ)
- ค้นหาการรวมกันของเวกเตอร์ทั้งสองนี้โดยใช้ฟังก์ชัน std::set_union() ใช้ start() เป็นตัววนซ้ำตัวแรก และ end() เป็นตัววนซ้ำสุดท้าย
- วนซ้ำเวกเตอร์เอาท์พุตเพื่อแสดงองค์ประกอบที่ฟังก์ชันส่งคืน
#รวม
#รวม <เวกเตอร์>
โดยใช้ เนมสเปซ มาตรฐาน ;
หลัก ( )
{
// สร้างเวกเตอร์ - marks1
เวกเตอร์ < ภายใน > เครื่องหมาย1 = { 100 , 90 , 80 , 70 , 60 } ;
// สร้างเวกเตอร์ - marks2
เวกเตอร์ < ภายใน > เครื่องหมาย2 = { 80 , 90 , 60 , 70 , 100 } ;
// เรียงลำดับเวกเตอร์ทั้งสอง
เรียงลำดับ ( เครื่องหมาย1. เริ่ม ( ) , เครื่องหมาย1. จบ ( ) ) ;
เรียงลำดับ ( เครื่องหมาย2. เริ่ม ( ) , มาร์ก2. จบ ( ) ) ;
เวกเตอร์ < ภายใน > เอาท์พุตเวกเตอร์ ( เครื่องหมาย1. ขนาด ( ) + เครื่องหมาย2. ขนาด ( ) ) ;
เวกเตอร์ < ภายใน > :: ตัววนซ้ำ เป็น ;
ฉัน = set_union ( เครื่องหมาย1. เริ่ม ( ) , เครื่องหมาย1. จบ ( ) ,
เครื่องหมาย2. เริ่ม ( ) ,เครื่องหมาย2. จบ ( ) ,
เอาท์พุตเวกเตอร์ เริ่ม ( ) ) ;
ศาล << ' \n marks1 U marks2: \n ' ;
สำหรับ ( ส = เอาท์พุตเวกเตอร์ เริ่ม ( ) ; ส ! = ฉัน ; ++ ส )
ศาล << * ส << ' ' << ' \n ' ;
}
เอาท์พุท:
มีองค์ประกอบที่ไม่ซ้ำกันเพียงห้ารายการในเวกเตอร์ทั้งสอง (วิชา1 และวิชา2)
จุดตัดของเวกเตอร์
การหาจุดตัดของเวกเตอร์สองตัวสามารถทำได้โดยใช้ฟังก์ชัน std::set_intersection() Intersection ส่งคืนองค์ประกอบที่มีอยู่ในเวกเตอร์ทั้งสอง
ไวยากรณ์:
set_intersection ( InputIterator1 first1, InputIterator1 สุดท้าย 1, InputIterator2 first2, InputIterator2 สุดท้าย 2, OutputIterator res ) ;พารามิเตอร์ที่ส่งผ่านไปยังฟังก์ชัน set_union() ก็สามารถส่งผ่านไปยังฟังก์ชัน set_intersection() ได้เช่นกัน
สร้างเวกเตอร์สองตัว – “วิชา1” และ “วิชา2” – ประเภทจำนวนเต็ม
- จัดเรียงเวกเตอร์สองตัวโดยใช้ฟังก์ชัน sort() โดยส่งผ่านตัววนซ้ำ
- สร้างเวกเตอร์เอาต์พุต (ตัววนซ้ำ)
- ค้นหาจุดตัดของเวกเตอร์ทั้งสองนี้โดยใช้ฟังก์ชัน std::set_intersection() ใช้ start() เป็นตัววนซ้ำตัวแรก และ end() เป็นตัววนซ้ำสุดท้าย
- วนซ้ำเวกเตอร์เอาท์พุตเพื่อแสดงองค์ประกอบที่ฟังก์ชันส่งคืน
#รวม
#รวม <เวกเตอร์>
โดยใช้ เนมสเปซ มาตรฐาน ;
หลัก ( )
{
// สร้างเวกเตอร์ - marks1
เวกเตอร์ < ภายใน > เครื่องหมาย1 = { 100 , 10 , 80 , 40 , 60 } ;
// สร้างเวกเตอร์ - marks2
เวกเตอร์ < ภายใน > เครื่องหมาย2 = { ห้าสิบ , 90 , 60 , 10 , 100 } ;
// เรียงลำดับเวกเตอร์ทั้งสอง
เรียงลำดับ ( เครื่องหมาย1. เริ่ม ( ) , เครื่องหมาย1. จบ ( ) ) ;
เรียงลำดับ ( เครื่องหมาย2. เริ่ม ( ) , มาร์ก2. จบ ( ) ) ;
เวกเตอร์ < ภายใน > เอาท์พุตเวกเตอร์ ( เครื่องหมาย1. ขนาด ( ) + เครื่องหมาย2. ขนาด ( ) ) ;
เวกเตอร์ < ภายใน > :: ตัววนซ้ำ เป็น ;
ฉัน = set_intersection ( เครื่องหมาย1. เริ่ม ( ) , เครื่องหมาย1. จบ ( ) ,
เครื่องหมาย2. เริ่ม ( ) ,เครื่องหมาย2. จบ ( ) ,
เอาท์พุตเวกเตอร์ เริ่ม ( ) ) ;
ศาล << ' \n เครื่องหมาย 1 ∩ เครื่องหมาย 2: \n ' ;
สำหรับ ( ส = เอาท์พุตเวกเตอร์ เริ่ม ( ) ; ส ! = ฉัน ; ++ ส )
ศาล << * ส << ' ' << ' \n ' ;
}
เอาท์พุท:
เวกเตอร์ทั้งสองมีองค์ประกอบเพียงสามองค์ประกอบเท่านั้น (วิชา1 และวิชา2)
ตรวจสอบว่าเวกเตอร์ว่างเปล่าหรือไม่
ก่อนที่จะทำงานกับเวกเตอร์ สิ่งสำคัญคือต้องตรวจสอบว่าเวกเตอร์ว่างเปล่าหรือไม่ แนวทางปฏิบัติที่ดีในโครงการซอฟต์แวร์คือการตรวจสอบว่าเวกเตอร์ว่างเปล่าหรือไม่ก่อนดำเนินการ เช่น การดำเนินการ CRUD เป็นต้น
1. การใช้ Std::vector::empty()
ฟังก์ชันนี้จะคืนค่า 1 ถ้าเวกเตอร์ว่างเปล่า (ไม่มีองค์ประกอบใดๆ) มิฉะนั้น จะส่งกลับ 0 ไม่มีการส่งพารามิเตอร์ไปยังฟังก์ชันนี้
2. การใช้ มาตรฐาน::เวกเตอร์::ขนาด()
ฟังก์ชัน std::vector::size() ส่งคืนจำนวนเต็มที่แสดงถึงจำนวนองค์ประกอบทั้งหมดที่มีอยู่ในเวกเตอร์
สร้างเวกเตอร์สองตัว – “college1” และ “college2” “College1” มีห้าองค์ประกอบ และ “college2” ว่างเปล่า ใช้ทั้งสองฟังก์ชันกับเวกเตอร์ทั้งสองและตรวจสอบผลลัพธ์
#รวม <อัลกอริทึม>#รวม
#รวม <เวกเตอร์>
โดยใช้ เนมสเปซ มาตรฐาน ;
หลัก ( )
{
// สร้างเวกเตอร์ - College1
เวกเตอร์ < เชือก > วิทยาลัย1 = { 'วิทยาลัย-A' , 'วิทยาลัย-B' , 'วิทยาลัย-C' , 'วิทยาลัย-D' , 'วิทยาลัย-E' } ;
// สร้างเวกเตอร์ - College2
เวกเตอร์ < เชือก > วิทยาลัย2 ;
// ว่างเปล่า()
ศาล << วิทยาลัย1. ว่างเปล่า ( ) << สิ้นสุด ;
ศาล << วิทยาลัย2. ว่างเปล่า ( ) << สิ้นสุด ;
// ขนาด()
ศาล << วิทยาลัย1. ขนาด ( ) << สิ้นสุด ;
ศาล << วิทยาลัย2. ขนาด ( ) << สิ้นสุด ;
}
เอาท์พุท:
ฟังก์ชัน Empty() คืนค่า 0 สำหรับ 'college1' และ 1 สำหรับ 'college2' ฟังก์ชัน size() คืนค่า 5 สำหรับ 'college1' และ 0 สำหรับ 'college2'
สำรวจเวกเตอร์โดยใช้ Const_Iterator
เมื่อคุณทำงานกับคอนเทนเนอร์ C++ เช่น เซต เวกเตอร์ ฯลฯ คุณสามารถวนซ้ำองค์ประกอบทั้งหมดที่มีอยู่ในคอนเทนเนอร์ได้โดยไม่ต้องแก้ไของค์ประกอบเหล่านั้น ที่ const_iterator เป็นหนึ่งในตัววนซ้ำที่บรรลุสถานการณ์นี้ cbegin() (ชี้ไปที่องค์ประกอบแรกในเวกเตอร์) และ cend() (ชี้ไปที่องค์ประกอบสุดท้ายในเวกเตอร์) เป็นสองฟังก์ชันที่ได้รับจากแต่ละคอนเทนเนอร์ซึ่งใช้ในการส่งคืนตัววนซ้ำคงที่ไปที่จุดเริ่มต้นและจุดสิ้นสุดของ ภาชนะ ในขณะที่วนซ้ำเวกเตอร์ เราสามารถใช้ฟังก์ชันทั้งสองนี้ได้
- มาสร้างเวกเตอร์ชื่อ 'แผนก' ด้วยสตริง 5 เส้นกันดีกว่า
- ประกาศ const_iterator – ctr ประเภท
- วนซ้ำแผนกโดยใช้ตัววนซ้ำก่อนหน้าโดยใช้ลูป 'for' แล้วแสดง
#รวม <เวกเตอร์>
โดยใช้ เนมสเปซ มาตรฐาน ;
หลัก ( )
{
// สร้างเวกเตอร์ - แผนก
เวกเตอร์ < เชือก > แผนกต่างๆ = { 'ฝ่ายขาย' , 'บริการ' ,
'ทรัพยากรบุคคล' , 'มัน' , 'คนอื่น' } ;
เวกเตอร์ < เชือก > :: const_iterator กะรัต ;
// วนซ้ำแผนกต่างๆ โดยใช้ const_iterator - ctr
สำหรับ ( กะรัต = แผนกต่างๆ ซีบีกิน ( ) ; กะรัต ! = แผนกต่างๆ จำนวนน้อย ( ) ; กะรัต ++ ) {
ศาล << * กะรัต << สิ้นสุด ;
}
}
เอาท์พุท:
สำรวจเวกเตอร์โดยใช้ Reverse_Iterator
ที่ Reverse_iterator ยังเป็นตัววนซ้ำที่คล้ายกับ const_iterator แต่จะส่งคืนองค์ประกอบในแบบย้อนกลับ rbegin() (ชี้ไปที่องค์ประกอบสุดท้ายในเวกเตอร์) และ rend() (ชี้ไปที่องค์ประกอบแรกในเวกเตอร์) เป็นสองฟังก์ชันที่ได้รับจากแต่ละคอนเทนเนอร์ซึ่งใช้ในการส่งคืนตัววนซ้ำคงที่ไปยังจุดสิ้นสุดและจุดเริ่มต้นของ ภาชนะ
- มาสร้างเวกเตอร์ชื่อ 'แผนก' ด้วยสตริง 5 เส้นกันดีกว่า
- ประกาศ Reverse_iterator – rtr ประเภท
- วนซ้ำแผนกโดยใช้ตัววนซ้ำก่อนหน้าโดยใช้ลูป 'for' แล้วแสดง
#รวม <เวกเตอร์>
โดยใช้ เนมสเปซ มาตรฐาน ;
หลัก ( )
{
// สร้างเวกเตอร์ - แผนก
เวกเตอร์ < เชือก > แผนกต่างๆ = { 'ฝ่ายขาย' , 'บริการ' ,
'ทรัพยากรบุคคล' , 'มัน' , 'คนอื่น' } ;
เวกเตอร์ < เชือก > :: Reverse_iterator rtr ;
// วนซ้ำแผนกต่างๆ โดยใช้ Reverse_iterator - rtr
สำหรับ ( rtr = แผนกต่างๆ rbegin ( ) ; rtr ! = แผนกต่างๆ ทำให้ ( ) ; rtr ++ ) {
ศาล << * rtr << สิ้นสุด ;
}
}
เอาท์พุท:
ผลักองค์ประกอบเข้าไปในเวกเตอร์
การผลักหรือต่อท้ายองค์ประกอบต่างๆ ลงในเวกเตอร์เป็นการแทรกแบบทางเดียวที่สามารถทำได้โดยใช้ เวกเตอร์::push_back() การทำงาน.
ไวยากรณ์:
เวกเตอร์ ผลักดัน_กลับ ( องค์ประกอบ )ต้องใช้องค์ประกอบที่จะผลักเข้าไปในเวกเตอร์เป็นพารามิเตอร์
เรามาสร้างเวกเตอร์เปล่าชื่อ “แผนก” ที่มี 5 สาย และกด 2 สายทีละสายโดยใช้ฟังก์ชัน push_back()
#รวม#รวม <เวกเตอร์>
โดยใช้ เนมสเปซ มาตรฐาน ;
หลัก ( )
{
// เริ่มต้นเวกเตอร์ - แผนก
เวกเตอร์ < เชือก > แผนกต่างๆ ;
ศาล << 'แผนกจริง:' << สิ้นสุด ;
สำหรับ ( อัตโนมัติ มัน = แผนกต่างๆ เริ่ม ( ) ; มัน ! = แผนกต่างๆ จบ ( ) ; ++ มัน )
ศาล << * มัน << สิ้นสุด ;
// กด 'ยอดขาย'
แผนกต่างๆ ผลักดัน_กลับ ( 'ฝ่ายขาย' ) ;
// กด 'ไอที'
แผนกต่างๆ ผลักดัน_กลับ ( 'มัน' ) ;
ศาล << ' \n แผนกสุดท้าย:' << สิ้นสุด ;
สำหรับ ( อัตโนมัติ มัน = แผนกต่างๆ เริ่ม ( ) ; มัน ! = แผนกต่างๆ จบ ( ) ; ++ มัน )
ศาล << * มัน << สิ้นสุด ;
}
เอาท์พุท:
ขั้นแรกเราผลักดัน 'การขาย' หลังจากนั้น “IT” จะถูกผลักเข้าไปในเวกเตอร์ ตอนนี้ เวกเตอร์ 'แผนก' มีองค์ประกอบสองอย่าง
แสดงองค์ประกอบจากเวกเตอร์
หากคุณต้องการลบรายการสุดท้ายที่มีอยู่ในเวกเตอร์ ให้ใช้ เวกเตอร์::pop_back() ฟังก์ชั่นเป็นแนวทางที่ดีที่สุด มันจะลบองค์ประกอบสุดท้ายที่มีอยู่ในเวกเตอร์
ไวยากรณ์:
เวกเตอร์ pop_back ( )ไม่จำเป็นต้องมีพารามิเตอร์สำหรับฟังก์ชันนี้ มันจะแสดงพฤติกรรมที่ไม่ได้กำหนดหากเราพยายามลบองค์ประกอบสุดท้ายออกจากเวกเตอร์ว่าง
เรามาสร้างเวกเตอร์เปล่าชื่อ 'แผนก' โดยมี 5 สายและลบองค์ประกอบสุดท้ายโดยใช้ฟังก์ชันก่อนหน้า แสดงเวกเตอร์ในทั้งสองกรณี
#รวม#รวม <เวกเตอร์>
โดยใช้ เนมสเปซ มาตรฐาน ;
หลัก ( )
{
// เริ่มต้นเวกเตอร์ - แผนก
เวกเตอร์ < เชือก > แผนกต่างๆ = { 'ฝ่ายขาย' , 'มัน' , 'บริการ' , 'การตลาด' , 'ทรัพยากรบุคคล' } ;
ศาล << 'แผนกจริง:' << สิ้นสุด ;
สำหรับ ( อัตโนมัติ มัน = แผนกต่างๆ เริ่ม ( ) ; มัน ! = แผนกต่างๆ จบ ( ) ; ++ มัน )
ศาล << * มัน << สิ้นสุด ;
// ลบองค์ประกอบสุดท้าย
แผนกต่างๆ pop_back ( ) ;
ศาล << ' \n แผนกสุดท้าย:' << สิ้นสุด ;
สำหรับ ( อัตโนมัติ มัน = แผนกต่างๆ เริ่ม ( ) ; มัน ! = แผนกต่างๆ จบ ( ) ; ++ มัน )
ศาล << * มัน << สิ้นสุด ;
}
เอาท์พุท:
“HR” เป็นองค์ประกอบสุดท้ายที่มีอยู่ในเวกเตอร์ “แผนก” ดังนั้น มันถูกลบออกจากเวกเตอร์ และเวกเตอร์สุดท้ายจะเก็บ 'การขาย', 'ไอที', 'บริการ' และ 'การตลาด'
สลับเวกเตอร์
ที่ เวกเตอร์::สลับ() ฟังก์ชันใน C++ STL ใช้เพื่อสลับองค์ประกอบทั้งหมดที่มีอยู่ในเวกเตอร์สองตัว
ไวยากรณ์:
first_vector. แลกเปลี่ยน ( วินาที_เวกเตอร์ )ไม่ได้พิจารณาขนาดของเวกเตอร์ แต่เวกเตอร์ควรเป็นประเภทเดียวกัน (เกิดข้อผิดพลาดหากประเภทเวกเตอร์แตกต่างกัน)
มาสร้างเวกเตอร์สองตัว ได้แก่ “ผลไม้” และ “ผัก” ซึ่งเป็นประเภทสตริงที่มีขนาดต่างกัน สลับแต่ละรายการและแสดงเวกเตอร์ในทั้งสองกรณี
#รวม#รวม <เวกเตอร์>
โดยใช้ เนมสเปซ มาตรฐาน ;
หลัก ( )
{
// เริ่มต้นเวกเตอร์ - ผลไม้
เวกเตอร์ < เชือก > ผลไม้ = { 'แอปเปิล' , 'มะม่วง' } ;
ศาล << 'ผลไม้จริง:' << สิ้นสุด ;
สำหรับ ( อัตโนมัติ มัน = ผลไม้ เริ่ม ( ) ; มัน ! = ผลไม้ จบ ( ) ; ++ มัน )
ศาล << * มัน << สิ้นสุด ;
// เริ่มต้นเวกเตอร์ - ผัก
เวกเตอร์ < เชือก > ผัก = { 'มันฝรั่ง' , 'มะเขือเทศ' , “บรินจาล” } ;
ศาล << ' \n ผักจริง:' << สิ้นสุด ;
สำหรับ ( อัตโนมัติ มัน = ผัก. เริ่ม ( ) ; มัน ! = ผัก. จบ ( ) ; ++ มัน )
ศาล << * มัน << สิ้นสุด ;
// สลับองค์ประกอบในเวกเตอร์ทั้งสอง
ผลไม้ แลกเปลี่ยน ( ผัก ) ;
ศาล << ' \n ผลไม้หลังแลก:' << สิ้นสุด ;
สำหรับ ( อัตโนมัติ มัน = ผลไม้ เริ่ม ( ) ; มัน ! = ผลไม้ จบ ( ) ; ++ มัน )
ศาล << * มัน << สิ้นสุด ;
ศาล << ' \n ผักหลังแลก:' << สิ้นสุด ;
สำหรับ ( อัตโนมัติ มัน = ผัก. เริ่ม ( ) ; มัน ! = ผัก. จบ ( ) ; ++ มัน )
ศาล << * มัน << สิ้นสุด ;
}
เอาท์พุท:
ก่อนหน้านี้ เวกเตอร์ 'ผลไม้' มีองค์ประกอบสององค์ประกอบ และเวกเตอร์ 'ผัก' มีสามองค์ประกอบ หลังจากสลับกันแล้ว เวกเตอร์ 'ผลไม้' จะเก็บองค์ประกอบไว้ 3 องค์ประกอบ และเวกเตอร์ 'ผัก' จะเก็บองค์ประกอบไว้ 2 องค์ประกอบ
ดึงองค์ประกอบแรกจากเวกเตอร์
ในบางกรณี ข้อกำหนดคือการส่งคืนเฉพาะองค์ประกอบแรกจากเวกเตอร์ ฟังก์ชัน vector::front() ใน C++ STL จะดึงข้อมูลเฉพาะองค์ประกอบแรกจากเวกเตอร์
ไวยากรณ์:
เวกเตอร์ ด้านหน้า ( )ฟังก์ชันนี้จะไม่ใช้พารามิเตอร์ใดๆ หากเวกเตอร์ว่างเปล่า จะเกิดข้อผิดพลาด
มาสร้างเวกเตอร์สองตัว – “ผลไม้” และ “ผัก” – ประเภทสตริงแล้วลองดึงองค์ประกอบแรกแยกจากเวกเตอร์ทั้งสอง
#รวม#รวม <เวกเตอร์>
โดยใช้ เนมสเปซ มาตรฐาน ;
หลัก ( )
{
// สร้างเวกเตอร์ - ผลไม้ที่มี 2 องค์ประกอบ
เวกเตอร์ < เชือก > ผลไม้ = { 'แอปเปิล' , 'มะม่วง' } ;
// ส่งคืนองค์ประกอบแรก
ศาล << ผลไม้ ด้านหน้า ( ) << สิ้นสุด ;
// เริ่มต้นเวกเตอร์ - ผัก
เวกเตอร์ < เชือก > ผัก ;
// พยายามคืนค่าองค์ประกอบแรก
ศาล << ผัก. ด้านหน้า ( ) ;
}
เอาท์พุท:
“Apple” เป็นองค์ประกอบแรกที่มีอยู่ในเวกเตอร์ “ผลไม้” มันเลยคืนมา. แต่เกิดข้อผิดพลาดเมื่อเราพยายามดึงองค์ประกอบแรกจากเวกเตอร์ 'ผัก' เนื่องจากว่างเปล่า
ดึงองค์ประกอบสุดท้ายจากเวกเตอร์
ฟังก์ชัน vector::end() ใน C++ STL จะดึงข้อมูลเฉพาะองค์ประกอบสุดท้ายจากเวกเตอร์
ไวยากรณ์:
เวกเตอร์ กลับ ( )ฟังก์ชันนี้จะไม่ใช้พารามิเตอร์ใดๆ หากเวกเตอร์ว่างเปล่า จะเกิดข้อผิดพลาด
มาสร้างเวกเตอร์สองตัว – “ผลไม้” และ “ผัก” – ประเภทสตริงแล้วลองดึงองค์ประกอบสุดท้ายแยกจากเวกเตอร์ทั้งสอง
#รวม#รวม <เวกเตอร์>
โดยใช้ เนมสเปซ มาตรฐาน ;
หลัก ( )
{
// สร้างเวกเตอร์ - ผลไม้ที่มี 2 องค์ประกอบ
เวกเตอร์ < เชือก > ผลไม้ = { 'แอปเปิล' , 'มะม่วง' } ;
// ดึงข้อมูลองค์ประกอบสุดท้าย
ศาล << ผลไม้ กลับ ( ) << สิ้นสุด ;
// เริ่มต้นเวกเตอร์ - ผัก
เวกเตอร์ < เชือก > ผัก ;
// พยายามดึงองค์ประกอบสุดท้าย
ศาล << ผัก. กลับ ( ) ;
}
เอาท์พุท:
“มะม่วง” เป็นองค์ประกอบสุดท้ายที่มีอยู่ในเวกเตอร์ “ผลไม้” มันเลยคืนมา. แต่เกิดข้อผิดพลาดเมื่อเราพยายามดึงองค์ประกอบสุดท้ายจากเวกเตอร์ 'ผัก' เนื่องจากว่างเปล่า
กำหนดค่าใหม่ให้กับเวกเตอร์
ในบางสถานการณ์ หากคุณต้องการอัปเดตค่าทั้งหมดด้วยค่าใหม่ หรือสร้างเวกเตอร์ที่มีค่าเดียวกัน การใช้ฟังก์ชัน vector::assign() ถือเป็นแนวทางที่ดีที่สุด เมื่อใช้ฟังก์ชันนี้ เราสามารถ:
- สร้างเวกเตอร์ด้วยองค์ประกอบที่คล้ายกันทั้งหมด
- แก้ไขเวกเตอร์ที่มีอยู่ด้วยองค์ประกอบเดียวกัน
ไวยากรณ์:
เวกเตอร์ กำหนด ( ขนาดมูลค่า )ฟังก์ชันนี้จำเป็นต้องมีพารามิเตอร์สองตัว
ที่นี่:
- ขนาดระบุจำนวนองค์ประกอบที่จะกำหนด
- ค่าระบุองค์ประกอบที่จะกำหนด
มาสร้างเวกเตอร์ชื่อ 'marks1' ด้วยค่า 5 ค่าและอัปเดตเวกเตอร์นี้ด้วยองค์ประกอบ 4 องค์ประกอบเพื่อให้องค์ประกอบทั้งหมดในเวกเตอร์ที่อัปเดตมีค่าเท่ากับ 20
#รวม <อัลกอริทึม>#รวม
#รวม <เวกเตอร์>
โดยใช้ เนมสเปซ มาตรฐาน ;
หลัก ( )
{
// สร้างเวกเตอร์ - marks1
เวกเตอร์ < ภายใน > เครื่องหมาย1 = { 100 , 90 , 80 , 70 , 60 } ;
ศาล << 'เวกเตอร์จริง:' << สิ้นสุด ;
สำหรับ ( ภายใน ฉัน = 0 ; ฉัน < เครื่องหมาย1. ขนาด ( ) ; ฉัน ++ )
ศาล << เครื่องหมาย1 [ ฉัน ] << สิ้นสุด ;
เครื่องหมาย1. กำหนด ( 4 , ยี่สิบ ) ;
ศาล << ' \n อัปเดตเวกเตอร์:' << สิ้นสุด ;
สำหรับ ( ภายใน ฉัน = 0 ; ฉัน < เครื่องหมาย1. ขนาด ( ) ; ฉัน ++ )
ศาล << เครื่องหมาย1 [ ฉัน ] << สิ้นสุด ;
}
เอาท์พุท:
ก่อนหน้านี้ เวกเตอร์มีองค์ประกอบที่แตกต่างกันห้าองค์ประกอบ ตอนนี้มีเพียงสี่องค์ประกอบและทั้งหมดมีค่าเท่ากับ 20
ขยายเวกเตอร์โดยใช้ Emplace()
เรารู้อยู่แล้วว่าองค์ประกอบใหม่จะถูกแทรกแบบไดนามิกที่ตำแหน่งใดๆ ในเวกเตอร์ สามารถใช้ฟังก์ชัน vector::emplace() ได้ มาดูไวยากรณ์และพารามิเตอร์ที่ฟังก์ชันนี้ยอมรับกันอย่างรวดเร็ว
ไวยากรณ์:
เวกเตอร์ ที่ตั้ง ( ตำแหน่ง const_iterator องค์ประกอบ )พารามิเตอร์บังคับสองตัวถูกส่งผ่านไปยังฟังก์ชันนี้
ที่นี่:
- พารามิเตอร์แรกเข้ารับตำแหน่งเพื่อให้เราสามารถแทรกองค์ประกอบในตำแหน่งใดก็ได้ เราสามารถรับตำแหน่งได้โดยใช้ฟังก์ชัน start() หรือ end() iterator
- พารามิเตอร์ตัวที่สองคือองค์ประกอบที่จะแทรกลงในเวกเตอร์
พิจารณาเวกเตอร์ “สารเคมี” ที่มีองค์ประกอบ 2 ตัว
- ใส่ “แมงกานีส” ที่ตำแหน่งแรก – เริ่ม(สารเคมี)
- ใส่ “ทองแดง” ที่ตำแหน่งสุดท้าย – ปลาย(สารเคมี)
- ใส่ 'ซัลเฟอร์' ที่ตำแหน่งที่สาม – start(chemicals)+2
#รวม
#รวม <เวกเตอร์>
โดยใช้ เนมสเปซ มาตรฐาน ;
หลัก ( )
{
// สร้างเวกเตอร์ - สารเคมี
เวกเตอร์ < เชือก > สารเคมี = { 'ออกซิเจน' , 'ซีโอ' } ;
ศาล << 'สารเคมีจริง:' << สิ้นสุด ;
สำหรับ ( ภายใน ฉัน = 0 ; ฉัน < สารเคมี ขนาด ( ) ; ฉัน ++ )
ศาล << สารเคมี [ ฉัน ] << สิ้นสุด ;
// แทรกองค์ประกอบที่ตำแหน่งแรก
สารเคมี ที่ตั้ง ( เริ่ม ( สารเคมี ) , 'แมงกานีส' ) ;
// แทรกองค์ประกอบที่ตำแหน่งสุดท้าย
สารเคมี ที่ตั้ง ( จบ ( สารเคมี ) , 'ทองแดง' ) ;
// แทรกองค์ประกอบที่ตำแหน่งที่สาม
สารเคมี ที่ตั้ง ( เริ่ม ( สารเคมี ) + 2 , 'กำมะถัน' ) ;
ศาล << ' \n สารเคมีขั้นสุดท้าย:' << สิ้นสุด ;
สำหรับ ( ภายใน ฉัน = 0 ; ฉัน < สารเคมี ขนาด ( ) ; ฉัน ++ )
ศาล << สารเคมี [ ฉัน ] << สิ้นสุด ;
}
เอาท์พุท:
ตอนนี้ เวกเตอร์สุดท้ายมีห้าองค์ประกอบ (ตามภาพหน้าจอต่อไปนี้)
ขยายเวกเตอร์โดยใช้ Emplace_Back()
องค์ประกอบสามารถต่อท้ายได้ (เพิ่มที่ส่วนท้ายของเวกเตอร์) ซึ่งสามารถทำได้โดยใช้ เวกเตอร์::emplace_back() การทำงาน.
ไวยากรณ์:
เวกเตอร์ emplace_back ( องค์ประกอบ )จำเป็นต้องส่งองค์ประกอบที่จะต่อท้ายเวกเตอร์เป็นพารามิเตอร์
มาเพิ่มสององค์ประกอบทีละรายการโดยใช้ฟังก์ชัน emplace_back()
#รวม <อัลกอริทึม>#รวม
#รวม <เวกเตอร์>
โดยใช้ เนมสเปซ มาตรฐาน ;
หลัก ( )
{
// สร้างเวกเตอร์ - สารเคมี
เวกเตอร์ < เชือก > สารเคมี = { 'ออกซิเจน' , 'ซีโอ' } ;
ศาล << 'สารเคมีจริง:' << สิ้นสุด ;
สำหรับ ( ภายใน ฉัน = 0 ; ฉัน < สารเคมี ขนาด ( ) ; ฉัน ++ )
ศาล << สารเคมี [ ฉัน ] << สิ้นสุด ;
// ใส่แมงกานีสที่ส่วนท้ายของเวกเตอร์
สารเคมี emplace_back ( 'แมงกานีส' ) ;
// ใส่แมงกานีสที่ส่วนท้ายของเวกเตอร์
สารเคมี emplace_back ( 'ทองแดง' ) ;
ศาล << ' \n สารเคมีขั้นสุดท้าย:' << สิ้นสุด ;
สำหรับ ( ภายใน ฉัน = 0 ; ฉัน < สารเคมี ขนาด ( ) ; ฉัน ++ )
ศาล << สารเคมี [ ฉัน ] << สิ้นสุด ;
}
เอาท์พุท:
ตอนนี้ เวกเตอร์สุดท้ายมีองค์ประกอบสี่องค์ประกอบหลังจากเพิ่ม 'แมงกานีส' และ 'ทองแดง'
องค์ประกอบสูงสุดของเวกเตอร์
- สร้างเวกเตอร์ด้วยองค์ประกอบบางอย่าง
- หากต้องการค้นหาองค์ประกอบสูงสุดที่มีอยู่ในเวกเตอร์ ให้ใช้ฟังก์ชัน *max_element() ซึ่งยอมรับตัววนซ้ำสองตัวเป็นอาร์กิวเมนต์ พารามิเตอร์ทั้งสองนี้ทำหน้าที่เป็นช่วงและองค์ประกอบสูงสุดจะถูกส่งกลับภายในช่วงที่ระบุ ตำแหน่งเริ่มต้นคือ start() และตำแหน่งสุดท้ายคือ end()
ลองพิจารณาเวกเตอร์ชื่อ 'item_costs' ที่มีค่าประเภทจำนวนเต็มห้าค่าและส่งกลับองค์ประกอบสูงสุด
#รวม <เวกเตอร์>#รวม
#รวม <อัลกอริทึม>
โดยใช้ เนมสเปซ มาตรฐาน ;
หลัก ( )
{
// สร้างเวกเตอร์ - item_costs
เวกเตอร์ < ภายใน > รายการ_ต้นทุน = { 8900 , 5677 , 200 , 1,000 , 2300 } ;
ศาล << “ต้นทุนสิ่งของ: \n ' ;
สำหรับ ( ภายใน ฉัน = 0 ; ฉัน < รายการ_ต้นทุน ขนาด ( ) ; ฉัน ++ )
ศาล << รายการ_ต้นทุน [ ฉัน ] << สิ้นสุด ;
// ส่งคืนองค์ประกอบสูงสุดจากเวกเตอร์ด้านบน - item_costs
ศาล << ' \n ต้นทุนสูงสุด: ' << * สูงสุด_องค์ประกอบ ( เริ่ม ( รายการ_ต้นทุน ) ,จบ ( รายการ_ต้นทุน ) ) ;
}
เอาท์พุท:
ในที่นี้ 8900 เป็นองค์ประกอบสูงสุดในบรรดาองค์ประกอบทั้งหมดที่มีอยู่ในเวกเตอร์ ”item_costs”
องค์ประกอบขั้นต่ำของเวกเตอร์
- สร้างเวกเตอร์ด้วยองค์ประกอบบางอย่าง
- หากต้องการค้นหาองค์ประกอบขั้นต่ำที่มีอยู่ในเวกเตอร์ ให้ใช้ฟังก์ชัน *min_element() ซึ่งยอมรับตัววนซ้ำสองตัวเป็นอาร์กิวเมนต์ พารามิเตอร์ทั้งสองนี้ทำหน้าที่เป็นช่วงและองค์ประกอบขั้นต่ำ (น้อยกว่าองค์ประกอบอื่นๆ ทั้งหมด) จะถูกส่งกลับภายในช่วงที่ระบุ ตำแหน่งเริ่มต้นคือ start() และตำแหน่งสุดท้ายคือ end()
ใช้เวกเตอร์เดียวกันกับที่สร้างขึ้นเพื่อค้นหาองค์ประกอบสูงสุดและค้นหาองค์ประกอบขั้นต่ำโดยใช้ฟังก์ชัน *min_element()
#รวม <เวกเตอร์>#รวม
#รวม <อัลกอริทึม>
โดยใช้ เนมสเปซ มาตรฐาน ;
หลัก ( )
{
// สร้างเวกเตอร์ - item_costs
เวกเตอร์ < ภายใน > รายการ_ต้นทุน = { 8900 , 5677 , 200 , 1,000 , 2300 } ;
ศาล << “ต้นทุนสิ่งของ: \n ' ;
สำหรับ ( ภายใน ฉัน = 0 ; ฉัน < รายการ_ต้นทุน ขนาด ( ) ; ฉัน ++ )
ศาล << รายการ_ต้นทุน [ ฉัน ] << สิ้นสุด ;
// คืนองค์ประกอบขั้นต่ำจากเวกเตอร์ด้านบน - item_costs
ศาล << ' \n ต้นทุนขั้นต่ำ: ' << * min_element ( เริ่ม ( รายการ_ต้นทุน ) ,จบ ( รายการ_ต้นทุน ) ) ;
}
เอาท์พุท:
ในที่นี้ 200 คือองค์ประกอบขั้นต่ำในบรรดาองค์ประกอบทั้งหมดที่มีอยู่ในเวกเตอร์ 'item_costs'
ผลรวมขององค์ประกอบในเวกเตอร์
หากต้องการคืนค่าผลรวมขององค์ประกอบทั้งหมดที่มีอยู่ในเวกเตอร์ สะสม() มีการใช้ฟังก์ชันใน C++ STL ยอมรับพารามิเตอร์สามตัว พารามิเตอร์ตัวแรกใช้ดัชนีแรกที่แสดงถึงองค์ประกอบเริ่มต้นในช่วง (ระบุตัววนซ้ำ start()) และพารามิเตอร์ตัวที่สองใช้ดัชนีสุดท้ายที่แสดงถึงองค์ประกอบสิ้นสุดในช่วง (ระบุตัววนซ้ำ end()) สุดท้าย เราต้องผ่านค่าเริ่มต้นของผลรวม (ในกรณีของเราคือ 0)
สะสม ( first_index, Last_index, Initial_val ) ;สร้างเวกเตอร์ชื่อ 'item_costs' โดยมีองค์ประกอบประเภทจำนวนเต็ม 5 รายการ แล้วคำนวณผลรวม
#รวมโดยใช้ เนมสเปซ มาตรฐาน ;
หลัก ( )
{
// สร้างเวกเตอร์ - item_costs
เวกเตอร์ < ภายใน > รายการ_ต้นทุน = { 8900 , 5677 , 200 , 1,000 , 2300 } ;
ศาล << “ต้นทุนสิ่งของ: \n ' ;
สำหรับ ( ภายใน ฉัน = 0 ; ฉัน < รายการ_ต้นทุน ขนาด ( ) ; ฉัน ++ )
ศาล << รายการ_ต้นทุน [ ฉัน ] << สิ้นสุด ;
// ส่งคืนผลรวมขององค์ประกอบทั้งหมดในเวกเตอร์ด้านบน - item_costs
ศาล << ' \n ค่าใช้จ่ายทั้งหมด: ' << สะสม ( เริ่ม ( รายการ_ต้นทุน ) ,จบ ( รายการ_ต้นทุน ) , 0 ) ;
}
เอาท์พุท:
ผลรวมของ 8900, 5677, 200, 1,000, 2300 คือ 18077
การคูณเวกเตอร์สองแบบตามองค์ประกอบ
- สร้างเวกเตอร์สองตัวที่มีประเภทตัวเลข และเวกเตอร์สองตัวจะต้องมีขนาดเท่ากัน (จำนวนองค์ประกอบทั้งหมดที่มีอยู่ในเวกเตอร์แรก = จำนวนองค์ประกอบทั้งหมดที่มีอยู่ในเวกเตอร์ที่สอง)
- ประกาศเวกเตอร์ใหม่และใช้ สำหรับวง ดำเนินการคูณสององค์ประกอบในการวนซ้ำแต่ละครั้ง และจัดเก็บค่าลงในเวกเตอร์ที่สร้างขึ้นโดยใช้ฟังก์ชัน push_back() สำหรับ ( ภายใน มัน = 0 ; ฉัน < first_vec ขนาด ( ) ; มัน ++ )
- แสดงองค์ประกอบที่มีอยู่ในเวกเตอร์ผลลัพธ์โดยการวนซ้ำ
{
result_vector ผลักดัน_กลับ ( first_vec [ มัน ] * วินาที_สิ่ง [ มัน ] ) ;
}
สร้างเวกเตอร์ชื่อ 'item_costs' โดยมีองค์ประกอบประเภทจำนวนเต็ม 5 รายการ แล้วคำนวณผลรวม
#รวมโดยใช้ เนมสเปซ มาตรฐาน ;
หลัก ( )
{
// สร้างเวกเตอร์สองตัว - products1 และ products2 โดยแต่ละองค์ประกอบมี 5 องค์ประกอบ
เวกเตอร์ < ภายใน > ผลิตภัณฑ์1 = { 10 , ยี่สิบ , 30 , 40 , ห้าสิบ } ;
เวกเตอร์ < ภายใน > ผลิตภัณฑ์2 = { ห้าสิบ , 40 , 30 , 70 , 60 } ;
เวกเตอร์ < ภายใน > result_products ;
// ทำการคูณองค์ประกอบอย่างชาญฉลาด
สำหรับ ( ภายใน ฉัน = 0 ; ฉัน < ผลิตภัณฑ์1. ขนาด ( ) ; ฉัน ++ ) {
result_products ผลักดัน_กลับ ( ผลิตภัณฑ์1 [ ฉัน ] * ผลิตภัณฑ์2 [ ฉัน ] ) ;
}
// แสดงเวกเตอร์ผลลัพธ์
ศาล << “การคูณเวกเตอร์: \n ' ;
สำหรับ ( ภายใน ความละเอียด : : result_products )
ศาล << ความละเอียด << สิ้นสุด ;
}
เอาท์พุท:
การวนซ้ำ - - 1 : : 10 * ห้าสิบ => 500การวนซ้ำ - - 2 : : ยี่สิบ * 40 => 800
การวนซ้ำ - - 3 : : 30 * 30 => 900
การวนซ้ำ - - 4 : : 40 * 70 => 2800
การวนซ้ำ - - 5 : : ห้าสิบ * 60 => 3000
ดอทโปรดัคของเวกเตอร์สองตัว
ในกรณีของเวกเตอร์ C++ ผลิตภัณฑ์ดอทถูกกำหนดให้เป็น 'ผลรวมของผลิตภัณฑ์ของรายการที่สอดคล้องกันของลำดับทั้งสองของเวกเตอร์'
ไวยากรณ์:
สินค้าภายใน ( Vector1 ก่อน, Vector1 สุดท้าย, Vector2 ก่อน, Initial_Val )ใช้ฟังก์ชัน inner_product() เพื่อส่งคืน dot product ฟังก์ชันนี้รับพารามิเตอร์ที่จำเป็นสี่ตัว
ที่นี่:
- พารามิเตอร์ตัวแรกอ้างอิงถึงตัววนซ้ำที่ชี้ไปยังจุดเริ่มต้นของเวกเตอร์ตัวแรก (ระบุโดยใช้ฟังก์ชัน start())
- พารามิเตอร์ที่สองอ้างอิงถึงตัววนซ้ำที่ชี้ไปที่จุดสิ้นสุดของเวกเตอร์แรก (ระบุโดยใช้ฟังก์ชัน end())
- พารามิเตอร์ตัวที่สามอ้างอิงถึงตัววนซ้ำที่ชี้ไปยังจุดเริ่มต้นของเวกเตอร์ตัวที่สอง (ระบุโดยใช้ฟังก์ชัน start())
- จะต้องส่งค่าเริ่มต้นเป็นพารามิเตอร์สุดท้ายซึ่งเป็นจำนวนเต็มสำหรับการสะสมของผลคูณดอท
ใช้โปรแกรมเดียวกันที่สร้างขึ้นสำหรับการคูณเวกเตอร์สองตัว และใช้ฟังก์ชัน innsr_product() เพื่อค้นหาผลคูณดอทของเวกเตอร์สองตัว
#รวมโดยใช้ เนมสเปซ มาตรฐาน ;
หลัก ( )
{
// สร้างเวกเตอร์สองตัว - products1 และ products2 โดยแต่ละองค์ประกอบมี 5 องค์ประกอบ
เวกเตอร์ < ภายใน > ผลิตภัณฑ์1 = { 10 , ยี่สิบ , 30 , 40 , ห้าสิบ } ;
เวกเตอร์ < ภายใน > ผลิตภัณฑ์2 = { ห้าสิบ , 40 , 30 , 70 , 60 } ;
// แสดงเวกเตอร์ผลลัพธ์
ศาล << 'Dot Product ของ products1 และ products2: ' ;
ศาล << สินค้าภายใน ( เริ่ม ( ผลิตภัณฑ์1 ) ,จบ ( ผลิตภัณฑ์1 ) ,เริ่ม ( ผลิตภัณฑ์2 ) , 0 ) ;
}
เอาท์พุท:
( 10 * ห้าสิบ ) + ( ยี่สิบ * 40 ) + ( 30 * 30 ) + ( 40 * 70 ) + ( ห้าสิบ * 60 )=> 500 + 800 + 900 + 2800 + 3000
=> 8000
แปลงเซตให้เป็นเวกเตอร์
มีหลายวิธีในการแปลงเซตให้เป็นเวกเตอร์โดยการส่งองค์ประกอบทั้งหมดที่ยกขึ้นมาในชุดให้เป็นเวกเตอร์ วิธีที่ดีที่สุดและง่ายที่สุดคือการใช้ฟังก์ชัน std::copy()
ไวยากรณ์
มาตรฐาน :: สำเนา ( sourceIterator ก่อน, sourceIterator สุดท้าย, DestinationIterator ก่อน )ใช้ มาตรฐาน::คัดลอก() ฟังก์ชันที่แทรกองค์ประกอบจากเซตลงในเวกเตอร์ ต้องใช้พารามิเตอร์สามตัว
ที่นี่:
- พารามิเตอร์แรกอ้างอิงถึงตัววนซ้ำแหล่งที่มาที่ชี้ไปยังองค์ประกอบแรกในตัววนซ้ำ ในที่นี้ set คือตัววนซ้ำแหล่งที่มาที่ระบุโดยใช้ฟังก์ชัน start()
- ในทำนองเดียวกัน พารามิเตอร์ตัวที่สองชี้ไปที่องค์ประกอบสุดท้าย (ฟังก์ชัน end())
- พารามิเตอร์ที่สามอ้างอิงถึงตัววนซ้ำปลายทางที่ชี้ไปยังองค์ประกอบแรก (ระบุโดยใช้ฟังก์ชัน start()) ในตัววนซ้ำ
มาสร้างชุดที่มีนักเรียน 5 คนและคัดลอกองค์ประกอบทั้งหมดลงในเวกเตอร์โดยใช้ฟังก์ชันก่อนหน้า
#รวมโดยใช้ เนมสเปซ มาตรฐาน ;
หลัก ( )
{
// สร้างชุด - นักเรียนที่มี 5 องค์ประกอบ
ชุด < เชือก > นักเรียน = { “สรวรรณ” , 'บ๊อบบี้' , “มาธุ” , “เมกาน่า” , “ลาวันยา” } ;
ศาล << 'ชุด: \n ' ;
สำหรับ ( สตริงฉัน : : นักเรียน )
ศาล << ฉัน << สิ้นสุด ;
// สร้างเวกเตอร์ - ขนาด Student_vof เท่ากับขนาดของชุด
เวกเตอร์ < เชือก > นักเรียน_vc ( นักเรียน. ขนาด ( ) ) ;
// แทรกองค์ประกอบจากชุด - นักเรียนลงในเวกเตอร์ - Student_vc
สำเนา ( นักเรียน. เริ่ม ( ) , นักเรียน. จบ ( ) , นักเรียน_vc. เริ่ม ( ) ) ;
ศาล << ' \n เวกเตอร์: \n ' ;
สำหรับ ( สตริงฉัน : : นักเรียน_vc )
ศาล << ฉัน << สิ้นสุด ;
}
เอาท์พุท:
ตอนนี้ องค์ประกอบทั้งหมดที่มีอยู่ในชุด “Students” จะถูกคัดลอกไปยังเวกเตอร์ “students_vc”
ลบองค์ประกอบที่ซ้ำกัน
- ขั้นแรก เราต้องจัดเรียงองค์ประกอบในเวกเตอร์ เพื่อให้องค์ประกอบที่ซ้ำกันทั้งหมดอยู่ติดกันโดยใช้ มาตรฐาน::เรียงลำดับ() การทำงาน. มาตรฐาน :: เรียงลำดับ ( เวกเตอร์มาก่อน เวกเตอร์สุดท้าย ) ;
- ใช้ฟังก์ชัน std::unique() เพื่อเลือกองค์ประกอบที่ซ้ำกัน ในเวลาเดียวกัน ให้ใช้ฟังก์ชันลบ () เพื่อลบรายการที่ซ้ำกันที่ส่งคืนโดยฟังก์ชัน std::unique() ลำดับขององค์ประกอบอาจเปลี่ยนแปลงในเวกเตอร์สุดท้าย เวกเตอร์ ลบ ( มาตรฐาน :: มีเอกลักษณ์ ( เวกเตอร์มาก่อน เวกเตอร์สุดท้าย ) , เวกเตอร์สุดท้าย ) )
สร้างเวกเตอร์ “นักเรียน” ด้วยองค์ประกอบ 10 องค์ประกอบและส่งคืนเวกเตอร์โดยลบรายการที่ซ้ำกันออก
#รวมโดยใช้ เนมสเปซ มาตรฐาน ;
หลัก ( )
{
// สร้างเวกเตอร์ - นักเรียนที่มี 10 องค์ประกอบ
เวกเตอร์ < เชือก > นักเรียน = { “สรวรรณ” , 'บ๊อบบี้' , “มาธุ” , “เมกาน่า” , “ลาวันยา” ,
“สรวรรณ” , 'บ๊อบบี้' , “มาธุ” , “เมกาน่า” , “ลาวันยา” } ;
ศาล << 'นักเรียน: \n ' ;
สำหรับ ( สตริงฉัน : : นักเรียน )
ศาล << ฉัน << ' ' ;
// จัดเรียงองค์ประกอบทั้งหมดในเวกเตอร์ของนักเรียน
เรียงลำดับ ( เริ่ม ( นักเรียน ) , จบ ( นักเรียน ) ) ;
// ใช้ฟังก์ชัน Unique() เพื่อลบรายการที่ซ้ำกันด้วยฟังก์ชัน Erase()
นักเรียน. ลบ ( มีเอกลักษณ์ ( เริ่ม ( นักเรียน ) , จบ ( นักเรียน ) ) , จบ ( นักเรียน ) ) ;
ศาล << ' \n \n นักเรียนที่ไม่ซ้ำ: \n ' ;
สำหรับ ( อัตโนมัติ มัน = ซีบีกิน ( นักเรียน ) ; มัน ! = จำนวนน้อย ( นักเรียน ) ; ++ มัน ) {
ศาล << * มัน << ' ' ;
}
}
เอาท์พุท:
ตอนนี้ องค์ประกอบทั้งหมดมีเอกลักษณ์เฉพาะในเวกเตอร์
แปลงเวกเตอร์ให้เป็นเซต
ชุดไม่อนุญาตให้มีองค์ประกอบที่ซ้ำกัน หากคุณกำลังพิมพ์เพื่อแทรกเวกเตอร์ลงในชุดที่ซ้ำกัน เวกเตอร์เหล่านั้นจะถูกละเว้น เราใช้ฟังก์ชัน std::copy() เดียวกันกับที่ใช้ในสถานการณ์ก่อนหน้านี้ซึ่งแปลงเซตเป็นเวกเตอร์
ในสถานการณ์สมมตินี้:
- พารามิเตอร์แรกใช้เวกเตอร์เป็นตัววนซ้ำแหล่งที่มาที่ระบุโดยใช้ฟังก์ชัน start()
- พารามิเตอร์ที่สองใช้เวกเตอร์เป็นตัววนซ้ำแหล่งที่มาที่ระบุโดยใช้ฟังก์ชัน end()
- ส่งผ่านฟังก์ชัน std::inserter() ซึ่งใช้ในการเขียนทับ/คัดลอกองค์ประกอบโดยอัตโนมัติที่ตำแหน่งเฉพาะในชุดโดยระบุชุดและตัววนซ้ำที่ชี้ไปที่จุดสิ้นสุดของชุดเป็นพารามิเตอร์
มาสร้างเวกเตอร์ที่มีจำนวนเต็ม 10 ตัวและคัดลอกองค์ประกอบต่างๆ ลงในเซตกัน
#รวมโดยใช้ เนมสเปซ มาตรฐาน ;
หลัก ( )
{
// สร้างชุด - ทำเครื่องหมายด้วยค่า 10 ค่า
เวกเตอร์ < ภายใน > เครื่องหมาย = { 12 , 3. 4 , 56 , 78 , 65 , 78 , 90 , 90 , 78 , 3. 4 } ;
ศาล << 'เวกเตอร์: \n ' ;
สำหรับ ( ภายใน ฉัน : : เครื่องหมาย )
ศาล << ฉัน << ' ' ;
// สร้างชุด - marks_set ที่มีขนาดเท่ากับขนาดของเวกเตอร์
ชุด < ภายใน > mark_set ;
// แทรกองค์ประกอบจากชุด - นักเรียนลงในเวกเตอร์ - Student_vc
สำเนา ( เริ่ม ( เครื่องหมาย ) ,จบ ( เครื่องหมาย ) , ตัวแทรก ( marks_set,สิ้นสุด ( mark_set ) ) ) ;
ศาล << ' \n \n ชุด: \n ' ;
สำหรับ ( ภายใน ฉัน : : mark_set )
ศาล << ฉัน << ' ' ;
}
เอาท์พุท:
เวกเตอร์ที่มีอยู่ชื่อ 'เครื่องหมาย' มี 10 ค่า หลังจากคัดลอกลงในชุด 'marks_set' แล้ว จะมีองค์ประกอบเพียง 6 รายการเท่านั้น เนื่องจากอีก 4 องค์ประกอบที่เหลือซ้ำกัน
ลบสตริงว่าง
ไม่มีการใช้สตริงว่างที่มีอยู่ในเวกเตอร์ แนวทางปฏิบัติที่ดีในการลบสตริงว่างที่มีอยู่ในเวกเตอร์ มาดูวิธีลบสตริงว่างออกจากเวกเตอร์ C++:
- วนซ้ำเวกเตอร์โดยใช้ลูป 'for'
- ในการวนซ้ำแต่ละครั้ง ให้ตรวจสอบว่าองค์ประกอบว่างเปล่า (“”) หรือไม่ใช้ตัวดำเนินการ “==” กับฟังก์ชันสมาชิก at()
- การใช้ฟังก์ชัน std::erase() ลบสตริงว่างหลังจากตรวจสอบเงื่อนไขก่อนหน้า
- ทำซ้ำขั้นตอนที่ 2 และขั้นตอนที่ 3 จนกระทั่งสิ้นสุดเวกเตอร์
มาสร้างเวกเตอร์ “บริษัท” ด้วย 10 สตริงกันดีกว่า ในจำนวนนั้นมีห้าอันที่ว่างและเราลบออกโดยการนำแนวทางก่อนหน้านี้ไปใช้
#รวม#รวม <เวกเตอร์>
โดยใช้ เนมสเปซ มาตรฐาน ;
หลัก ( ) {
เวกเตอร์ < เชือก > บริษัท { 'บริษัท-A' , '' , 'บริษัท-B' ,
'' , 'บริษัท-ค' , '' , 'บริษัท-D' , '' , '' , '' } ;
// ย้ำบริษัทต่างๆ
// และลบองค์ประกอบว่างโดยใช้ Erase()
สำหรับ ( ภายใน มัน = 1 ; มัน < บริษัท. ขนาด ( ) ; ++ มัน ) {
ถ้า ( บริษัท. ที่ ( มัน ) == '' ) {
บริษัท. ลบ ( บริษัท. เริ่ม ( ) + มัน ) ;
-- มัน ;
}
}
// แสดงเวกเตอร์
สำหรับ ( อัตโนมัติ & ฉัน : : บริษัท ) {
ศาล << ฉัน << สิ้นสุด ;
}
}
เอาท์พุท:
ตอนนี้ เวกเตอร์ 'บริษัท' เก็บสตริงที่ไม่ว่างเปล่า
เขียนเวกเตอร์ลงในไฟล์ข้อความ
เรามาพูดคุยถึงวิธีการเขียนองค์ประกอบทั้งหมดที่มีอยู่ในเวกเตอร์ไปยังไฟล์โดยใช้ดัชนีเวกเตอร์โดยใช้ สตรีม .
- ดันองค์ประกอบบางอย่างเข้าไปโดยใช้ฟังก์ชัน push_back หลังจากเริ่มต้นเวกเตอร์
- ใช้ฟังก์ชัน open() จากไลบรารี 'fstream' โดยมีโหมดเป็น out
- สำรวจแต่ละองค์ประกอบที่มีอยู่ในเวกเตอร์โดยใช้ดัชนีในลูป 'for' และเขียนแต่ละองค์ประกอบลงในไฟล์ที่ให้มา
- สุดท้ายให้ปิดไฟล์
ลองใช้แนวทางก่อนหน้าโดยการรันโค้ด C++
#รวม <เวกเตอร์>#รวม
#รวม
#รวม
โดยใช้ เนมสเปซ มาตรฐาน ;
หลัก ( )
{
// สร้างเวกเตอร์ - v_data
// และดันองค์ประกอบทั้งสองเข้าไป
เวกเตอร์ < เชือก > v_data ;
v_data ผลักดัน_กลับ ( 'ยินดีต้อนรับ' ) ;
v_data ผลักดัน_กลับ ( 'ถึง LinuxHint' ) ;
กระแสฉ ;
//เปิดไฟล์
ฉ. เปิด ( 'write_file.txt' ,ios_base :: ออก ) ;
// วนซ้ำแต่ละองค์ประกอบของเวกเตอร์และเขียนลงในไฟล์ทีละรายการ
สำหรับ ( ภายใน ฉัน = 0 ; ฉัน < v_data ขนาด ( ) ; ฉัน ++ )
{
ฉ << v_data [ ฉัน ] << สิ้นสุด ;
}
//ปิดไฟล์
ฉ. ปิด ( ) ;
}
เอาท์พุท:
เวกเตอร์ “v_data” มีสององค์ประกอบและไฟล์จะถูกสร้างขึ้นในเส้นทางที่โปรแกรมถูกเรียกใช้งานด้วยองค์ประกอบที่มีอยู่ในเวกเตอร์
สร้างเวกเตอร์จากไฟล์ข้อความ
เราเรียนรู้วิธีเขียนองค์ประกอบที่มีอยู่ในเวกเตอร์ลงในไฟล์ข้อความ เรามาสร้างเวกเตอร์จากเนื้อหาที่มีอยู่ในไฟล์ข้อความกันดีกว่า
- สร้าง “ ถ้าสตรีม” ตัวแปรที่ใช้อ่านข้อมูลจากไฟล์ข้อความที่เราสร้างเวกเตอร์จากไฟล์
- สร้างเวกเตอร์ว่างเพื่อจัดเก็บเนื้อหาไฟล์และใช้ตัวแปรสตริงว่างเป็นแฟล็กเพื่อตรวจสอบจุดสิ้นสุดของไฟล์
- อ่านบรรทัดถัดไปจากไฟล์จนกระทั่งถึงจุดสิ้นสุด (โดยทั่วไปจะใช้ลูป ' while') ใช้ฟังก์ชัน push_back() เพื่ออ่านบรรทัดถัดไปแล้วดันเข้าไปในเวกเตอร์
- แสดงเส้นที่มีอยู่ในบรรทัดแยกกันเพื่อดูองค์ประกอบที่มีอยู่ในเวกเตอร์บนคอนโซล
ลองใช้แนวทางก่อนหน้าโดยการรันโค้ด C++ ลองพิจารณาไฟล์ “data.txt” ที่มีเนื้อหาดังต่อไปนี้ ในที่นี้ชื่อของเวกเตอร์คือ “v_data”
โดยใช้ เนมสเปซ มาตรฐาน ;
หลัก ( )
{
// เปิดไฟล์ข้อความ - ข้อมูล
ไฟล์ ifstream ( 'data.txt' ) ;
// สร้างเวกเตอร์ - v_data ประเภท - สตริง
เวกเตอร์ < เชือก > v_data ;
ทองเป็น ;
// อ่านบรรทัดถัดไปจาก data.txt
//จนกว่าจะถึงจุดสิ้นสุด
ในขณะที่ ( ไฟล์ >> เคยเป็น ) {
// อ่านบรรทัดถัดไปแล้วกดเข้าไปใน v_data
v_data ผลักดัน_กลับ ( เคยเป็น ) ;
}
// แสดงบรรทัดที่อยู่ในบรรทัดแยกกัน
สำเนา ( v_data เริ่ม ( ) , v_data. จบ ( ) , ostream_iterator < เชือก > ( ศาล , ' \n ' ) ) ;
}
เอาท์พุท:
เราจะเห็นได้ว่า “v_data” มีองค์ประกอบห้าอย่างที่มาจากไฟล์
บทสรุป
ในบทความขนาดยาวนี้ เราได้สำรวจตัวอย่างที่เป็นไปได้ทั้งหมดที่ใช้ในแอปพลิเคชันแบบเรียลไทม์ที่เกี่ยวข้องกับเวกเตอร์ในภาษาการเขียนโปรแกรม C++ แต่ละตัวอย่างจะอธิบายด้วยไวยากรณ์ พารามิเตอร์ และตัวอย่างพร้อมเอาต์พุต มีการเพิ่มความคิดเห็นในแต่ละโค้ดเพื่อให้เข้าใจโค้ดได้ชัดเจน