في C++، Vector عبارة عن بنية بيانات أحادية البعد والتي تزيد نفسها ديناميكيًا بناءً على المتطلبات. يمكن تنظيم البيانات (الإدراج/التعديل/الحذف) بكفاءة في بنية البيانات هذه. وتشمل تطبيقاتها ما يلي:
- تمثيل المتجهات الرياضية في التطبيقات العلمية والهندسية
- يمكن تنفيذ قوائم الانتظار والمكدسات باستخدام بنية البيانات هذه، وما إلى ذلك.
تتم مناقشة معظم عمليات ووظائف CRUD الشائعة المتعلقة ببنية البيانات هذه حسب السيناريوهات بالتفصيل مع بناء الجملة ومقتطفات التعليمات البرمجية.
موضوع المحتويات:
- إدراج عنصر في ناقل
- إدراج عناصر متعددة في المتجهات
- الوصول إلى العناصر من المتجهات
- تحديث العنصر في المتجهات
- إزالة عنصر محدد من المتجه
- إزالة جميع العناصر من المتجه
- اتحاد المتجهات
- تقاطع المتجهات
- تحقق مما إذا كان المتجه فارغًا أم لا
- اجتياز متجه باستخدام Const_Iterator
- اجتياز متجه باستخدام Reverse_Iterator
- ادفع العناصر إلى المتجه
- قم بإخراج العناصر من المتجه
- مبادلة المتجهات
- جلب العنصر الأول من المتجه
- جلب العنصر الأخير من المتجه
- تعيين قيم جديدة للمتجه
- توسيع المتجه باستخدام Emplace()
- تمديد المتجه باستخدام Emplace_Back()
- الحد الأقصى لعنصر المتجه
- الحد الأدنى لعنصر المتجه
- مجموع العناصر في المتجهات
- الضرب الحكيم لمتجهين
- المنتج النقطي لمتجهين
- تحويل مجموعة إلى ناقل
- إزالة العناصر المكررة
- تحويل المتجهات إلى مجموعة
- إزالة السلاسل الفارغة
- كتابة ناقل إلى ملف نصي
- إنشاء ناقل من ملف نصي
إدراج عنصر في ناقل
ال الأمراض المنقولة جنسيا::vector::insert() يتم استخدام الوظيفة في C++ STL لإدراج العناصر في الموضع المحدد.
بناء الجملة:
المتجه. إدراج ( موضع، عنصر ) ;دعونا نستخدم هذه الوظيفة ونمرر الموضع الأول كمعلمة تحدد الموضع الذي يجب إدراج العنصر فيه ونوفر العنصر كمعلمة ثانية.
يمكن استخدام الدالة begin() هنا لإرجاع مُكرِّر يشير إلى العنصر الأول في متجه الإدخال. وبإضافة الموضع إلى هذه الوظيفة، يتم إدراج العنصر في ذلك الموضع.
لنقم بإنشاء متجه 'student_names' لسلسلة من النوع وإدراج سلسلتين في الموضعين الأول والثاني، واحدة تلو الأخرى، باستخدام وظيفة الإدراج ().
#تتضمناستخدام مساحة الاسم الأمراض المنقولة جنسيا ;
رئيسي ( )
{
// تهيئة المتجه - Student_names
المتجه < خيط > Student_names ;
cout << 'المتجه الموجود: \ن ' ;
ل ( آلي أنا : Student_names ) cout << أنا << endl ;
// أدخل 'سرافان كومار' في الموضع الأول
Student_names. إدراج ( Student_names. يبدأ ( ) + 0 , 'شرافان كومار' ) ;
// أدخل 'سرافان كومار' في الموضع الثاني
Student_names. إدراج ( Student_names. يبدأ ( ) + 1 , 'لاليثا' ) ;
cout << 'المتجه النهائي: \ن ' ;
ل ( آلي ي : Student_names ) cout << ي << endl ;
}
انتاج:
في السابق، كان المتجه 'student_names' فارغًا. بعد الإدراج، يحمل المتجه عنصرين.
إدراج عناصر متعددة في المتجهات
نحن نستخدم نفس الوظيفة وهي std::vector::insert() في هذا السيناريو. لكننا نحتاج إلى تمرير المعلمات الإضافية/المختلفة إلى نفس الوظيفة لإدراج عناصر متعددة في المتجه.
السيناريو 1: إدراج عنصر واحد عدة مرات
في هذا السيناريو، نضيف نفس العنصر عدة مرات.
بناء الجملة:
المتجه. إدراج ( الموضع، الحجم، العنصر ) ;للقيام بذلك، نحن بحاجة إلى تمرير الحجم كمعلمة ثانية إلى وظيفة الإدراج (). إجمالي المعلمات التي تم تمريرها إلى هذه الوظيفة هو ثلاثة.
هنا:
- تحدد معلمة الموضع موضع العنصر الذي سيتم إدراجه. إذا كان الحجم أكبر من 1، فسيكون مؤشر موضع البداية هو الموضع.
- تحدد معلمة الحجم عدد مرات إدراج العنصر.
- تأخذ معلمة العنصر العنصر المراد إدراجه في المتجه.
خذ بعين الاعتبار المتجه 'student_names' الذي يحتوي على سلسلتين. أدخل سلاسل 'Lavanya' خمس مرات في الموضع الثاني.
#تتضمناستخدام مساحة الاسم الأمراض المنقولة جنسيا ;
رئيسي ( )
{
// تهيئة المتجه - Student_names
المتجه < خيط > Student_names { 'شرافان كومار' , 'لاليثا' } ;
cout << 'المتجه الموجود: \ن ' ;
ل ( آلي أنا : Student_names ) cout << أنا << endl ;
// أدخل 'Lavanya' في الموضع الثاني 5 مرات
Student_names. إدراج ( Student_names. يبدأ ( ) + 1 , 5 , 'لافانيا' ) ;
cout << ' \ن المتجه النهائي: \ن ' ;
ل ( آلي ي : Student_names ) cout << ي << endl ;
}
انتاج:
في المتجه الحالي، 'Sravan Kumar' في المركز الأول و'Lalitha' في المركز الثاني. وبعد إدخال «لافانيا» خمس مرات (من المركز الثاني إلى المركز السادس)، انتقل «لاليثا» إلى المركز السابع (الأخير).
السيناريو 2: إدراج عناصر متعددة
في هذا السيناريو، نقوم بإضافة العناصر المختلفة في كل مرة من متجه آخر. نستخدم أيضًا نفس الوظيفة هنا ولكن سيتغير بناء الجملة والمعلمات.
بناء الجملة:
المتجه. إدراج ( الموضع، first_iterator، Second_iterator ) ;للقيام بذلك، نحن بحاجة إلى تمرير الحجم كمعلمة ثانية إلى وظيفة الإدراج (). إجمالي المعلمات التي تم تمريرها إلى هذه الوظيفة هو ثلاثة.
هنا:
- تحدد معلمة الموضع موضع العنصر الذي سيتم إدراجه.
- يحدد 'first_iterator' موضع البداية الذي سيتم إدراج العناصر منه (بشكل أساسي، باستخدام وظيفة begin()، يتم إرجاع مكرر يشير إلى العنصر الأول الموجود في الحاوية).
- يحدد 'secret_iterator' موضع النهاية الذي سيتم إدراج العناصر فيه (بشكل أساسي، باستخدام وظيفة end()، يتم إرجاع مكرر يشير إلى النقطة المجاورة للنقطة الأخيرة الموجودة في الحاوية).
قم بإنشاء متجهين، 'marks1' و'marks2'، من النوع الصحيح. أدخل جميع العناصر الموجودة في المتجه 'marks2' في الموضع الأول للمتجه 'marks1'.
#تتضمناستخدام مساحة الاسم الأمراض المنقولة جنسيا ;
رئيسي ( )
{
// تهيئة المتجه - Marks1
المتجه < كثافة العمليات > علامات1 { 100 , 89 , 90 , 78 , 98 } ;
cout << 'المتجه الأول: \ن ' ;
ل ( آلي أنا : علامات1 ) cout << أنا << endl ;
// تهيئة المتجه - Marks2
المتجه < كثافة العمليات > علامات2 { 56 , أربعة خمسة , 65 } ;
cout << 'المتجه الثاني: \ن ' ;
ل ( آلي ي : علامات2 ) cout << ي << endl ;
علامات1. إدراج ( يبدأ ( علامات1 ) ، يبدأ ( علامات2 ) ، نهاية ( علامات2 ) ) ;
// المتجه النهائي
cout << 'المتجه الأول والنهائي: \ن ' ;
ل ( آلي س : علامات1 )
cout << س << ' ' ;
}
انتاج:
المتجه الأول (marks1) يحمل خمسة عناصر والمتجه الثاني (marks2) يحمل ثلاثة عناصر. مررنا معلمات البداية (علامات 1) والبدء (علامات 2) والنهاية (علامات 2) إلى وظيفة 'إدراج' بحيث يتم تكرار جميع العناصر الموجودة في المتجه الثاني وإدراجها في المتجه الأول في البداية. إذن، المتجه الأول يحتوي على ثمانية عناصر.
الوصول إلى العناصر من المتجهات
1. استخدام عامل التشغيل []
في بعض السيناريوهات، قد يكون لديك مطلب لإرجاع العناصر المحددة فقط من المتجه. ليست هناك حاجة لإعادة كافة العناصر. لذلك، لإرجاع العناصر المحددة فقط بناءً على الفهرس، يتم استخدام عامل الفهرس والدوال at().
بناء الجملة:
المتجه [ Index_position ]في لغة C++، تبدأ الفهرسة من 0 لأي بنية بيانات. إذا كان العنصر غير موجود، فإنه يعود فارغًا (لا يظهر أي خطأ أو تحذير).
خذ بعين الاعتبار ناقل 'المنتجات' الذي يحتوي على خمسة عناصر. يمكنك الوصول إلى كافة العناصر واحدًا تلو الآخر باستخدام موضع الفهرس.
#تتضمناستخدام مساحة الاسم الأمراض المنقولة جنسيا ;
رئيسي ( )
{
// إنشاء ناقل - منتجات ذات 5 سلاسل
المتجه < خيط > منتجات { 'صابون' , 'شامبو' , 'زيت' , 'الفاكهة' , 'خضروات' } ;
// الوصول إلى العناصر من المنتجات
cout << 'العنصر الأول:' << منتجات [ 0 ] << endl ;
cout << 'العنصر الثاني:' << منتجات [ 1 ] << endl ;
cout << 'العنصر الثالث:' << منتجات [ 2 ] << endl ;
cout << 'العنصر الرابع:' << منتجات [ 3 ] << endl ;
cout << 'العنصر الخامس:' << منتجات [ 4 ] << endl ;
// حاول الوصول إلى العنصر التاسع
cout << 'العنصر التاسع:' << منتجات [ 8 ] << endl ;
}
انتاج:
لا يوجد عنصر موجود في الفهرس 8. لذا، يتم إرجاع فارغ.
2. استخدام الدالة At()
At() هي دالة عضو تشبه حالة الاستخدام السابقة ولكنها تُرجع استثناء 'std::out_of_range' عندما يتم توفير الفهرس خارج النطاق لها.
بناء الجملة:
المتجه. في ( Index_position )نحن بحاجة إلى تمرير موضع الفهرس إلى هذه الوظيفة.
خذ بعين الاعتبار ناقل 'المنتجات' الذي يحتوي على خمسة عناصر. قم بالوصول إلى جميع العناصر واحدًا تلو الآخر باستخدام موضع الفهرس وحاول الوصول إلى العنصر الموجود في الموضع التاسع.
#تتضمناستخدام مساحة الاسم الأمراض المنقولة جنسيا ;
رئيسي ( )
{
// إنشاء ناقل - منتجات ذات 5 سلاسل
المتجه < خيط > منتجات { 'صابون' , 'شامبو' , 'زيت' , 'الفاكهة' , 'خضروات' } ;
// الوصول إلى العناصر من المنتجات
cout << 'العنصر الأول:' << منتجات. في ( 0 ) << endl ;
cout << 'العنصر الثاني:' << منتجات. في ( 1 ) << endl ;
cout << 'العنصر الثالث:' << منتجات. في ( 2 ) << endl ;
cout << 'العنصر الرابع:' << منتجات. في ( 3 ) << endl ;
cout << 'العنصر الخامس:' << منتجات. في ( 4 ) << endl ;
// الوصول إلى العناصر غير الموجودة في المتجه
cout << 'العنصر التاسع:' << منتجات. في ( 8 ) << endl ;
}
انتاج:
حدث خطأ أثناء الوصول إلى العنصر التاسع:
إنهاء يسمى بعد رمي مثيل 'الأمراض المنقولة جنسيا::out_of_range'ماذا ( ) : المتجه :: _M_range_check : __ن ( الذي 8 ) >= هذا - > مقاس ( ) ( الذي 5 )
تحديث عنصر في ناقل
1. استخدام عامل التشغيل []
باستخدام موضع الفهرس، يمكننا تحديث العنصر في المتجه. يأخذ عامل التشغيل [] موضع فهرس العنصر الذي يجب تحديثه. سيتم تعيين العنصر الجديد لهذا العامل.
بناء الجملة:
المتجه [ Index_position ] = عنصرخذ بعين الاعتبار متجه 'student_marks' الذي يحتوي على خمس قيم. قم بتحديث العناصر الموجودة في الفهرسين 1 و3.
#تشمل#تشمل <ناقل>
استخدام مساحة الاسم الأمراض المنقولة جنسيا ;
رئيسي ( )
{
// إنشاء ناقل - Student_marks
المتجه < كثافة العمليات > Student_marks { 98 , 78 , 90 , 67 , 89 } ;
cout << 'العلامات الموجودة:' << endl ;
ل ( كثافة العمليات itr : Student_marks )
cout << itr << endl ;
// تحديث العنصر في الفهرس 3 بـ 100
Student_marks [ 3 ] = 100 ;
// تحديث العنصر في الفهرس 1 بـ 60
Student_marks [ 1 ] = 60 ;
cout << 'العلامات النهائية:' << endl ;
ل ( كثافة العمليات itr : Student_marks )
cout << itr << endl ;
}
انتاج:
يمكننا أن نرى أن المتجه النهائي يحمل عناصر التحديث عند الفهرسين 1 و3.
2. استخدام الدالة At()
كما هو الحال مع عامل الفهرس، فإن at() هي في الأساس وظيفة عضو تقوم بتحديث القيمة بناءً على الفهرس الموجود في المكرر. إذا كان الفهرس المحدد داخل هذه الوظيفة غير موجود، فسيتم طرح الاستثناء 'std::out_of_range'.
المتجه. في ( Index_position ) = عنصرخذ بعين الاعتبار ناقل 'المنتجات' الذي يحتوي على خمسة عناصر. تحديث جميع العناصر الموجودة في المتجه بعناصر أخرى.
#تتضمناستخدام مساحة الاسم الأمراض المنقولة جنسيا ;
رئيسي ( )
{
// إنشاء ناقل - منتجات ذات 5 سلاسل
المتجه < خيط > منتجات { 'صابون' , 'شامبو' , 'زيت' , 'الفاكهة' , 'خضروات' } ;
cout << 'المنتجات الحالية: ' << endl ;
ل ( سلسلة itr : منتجات )
cout << itr << endl ;
// تحديث كافة السلاسل
منتجات. في ( 0 ) = 'كيك' ;
منتجات. في ( 1 ) = 'شوكولاتة' ;
منتجات. في ( 2 ) = 'الفاكهة' ;
منتجات. في ( 3 ) = 'بصل' ;
منتجات. في ( 4 ) = 'المشروبات الغازية' ;
cout << ' \ن المنتجات النهائية: ' << endl ;
ل ( سلسلة itr : منتجات )
cout << itr << endl ;
}
انتاج:
إزالة عنصر محدد من المتجه
في لغة C++، الأمراض المنقولة جنسيا::ناقل::محو () تُستخدم الوظيفة لإزالة عنصر/نطاق محدد من العناصر من المتجه. تتم إزالة العناصر بناءً على مواضع التكرار.
بناء الجملة:
المتجه. محو ( موقف التكرار )دعونا نرى بناء الجملة لإزالة العنصر المحدد من المتجه. يمكننا استخدام الدالتين begin() أو end() للحصول على موضع العنصر الموجود في المتجه المراد إزالته.
خذ بعين الاعتبار ناقل 'المنتجات' الذي يحتوي على خمسة عناصر.
- قم بإزالة العنصر الثالث عن طريق تحديد مكرر begin(). يشير Begin() إلى العنصر الأول في المتجه. وإذا أضفنا اثنين إلى هذه الدالة، فهذا يشير إلى العنصر الثالث.
- قم بإزالة العنصر الأخير عن طريق تحديد مكرر end(). يشير End() إلى العنصر الأخير في المتجه.
استخدام مساحة الاسم الأمراض المنقولة جنسيا ;
رئيسي ( )
{
// إنشاء ناقل - منتجات ذات 5 سلاسل
المتجه < خيط > منتجات { 'صابون' , 'شامبو' , 'زيت' , 'الفاكهة' , 'خضروات' } ;
cout << 'المنتجات الحالية: ' << endl ;
ل ( سلسلة itr : منتجات )
cout << itr << endl ;
// إزالة العنصر الثالث
منتجات. محو ( منتجات. يبدأ ( ) + 2 ) ;
cout << ' \ن بعد إزالة العنصر الثالث: \ن ' ;
ل ( سلسلة itr : منتجات )
cout << itr << endl ;
// إزالة العنصر الأخير
منتجات. محو ( منتجات. نهاية ( ) ) ;
cout << ' \ن بعد إزالة العنصر الأخير: \ن ' ;
ل ( سلسلة itr : منتجات )
cout << itr << endl ;
}
انتاج:
الآن، لا يوجد سوى ثلاثة عناصر (“الصابون”، “الشامبو”، “الفواكه”) الموجودة في ناقل “المنتجات”.
إزالة جميع العناصر من المتجه
السيناريو 1: إزالة نطاق من العناصر من المتجه
دعونا نستخدم الدالة std::vector::erase() لإزالة عناصر متعددة في النطاق.
بناء الجملة:
المتجه. محو ( المكرر أولاً، المكرر أخيرًا )يتم استخدام التكرارين (begin () يشير إلى العنصر الأول ويشير end () إلى وظائف العنصر الأخير) لتحديد النطاق.
خذ بعين الاعتبار متجه 'المنتجات' الذي يحتوي على خمسة عناصر وقم بإزالة جميع العناصر من الموضع الثاني. لتحقيق ذلك، المكرر الأول هو البدء (المنتجات)+1 الذي يشير إلى العنصر الثاني والمكرر الثاني هو النهاية (المنتجات).
#تتضمناستخدام مساحة الاسم الأمراض المنقولة جنسيا ;
رئيسي ( )
{
// إنشاء ناقل - منتجات ذات 5 سلاسل
المتجه < خيط > منتجات { 'صابون' , 'شامبو' , 'زيت' , 'الفاكهة' , 'خضروات' } ;
cout << 'المنتجات الحالية: ' << endl ;
ل ( سلسلة itr : منتجات )
cout << itr << endl ;
// قم بإزالة جميع العناصر من الموضع الثاني
منتجات. محو ( يبدأ ( منتجات ) + 1 ،نهاية ( منتجات ) ) ;
cout << ' \ن المنتجات النهائية: \ن ' ;
ل ( سلسلة itr : منتجات )
cout << itr << endl ;
}
انتاج:
الآن، يوجد عنصر واحد فقط ('الصابون') موجود في ناقل 'المنتجات'.
السيناريو 2: إزالة كافة العناصر من المتجه
دعونا نستخدم الأمراض المنقولة جنسيا::vector::clear() وظيفة لإزالة جميع العناصر من المتجه.
بناء الجملة:
المتجه. واضح ( )لم يتم تمرير أية معلمات إلى هذه الوظيفة.
خذ بعين الاعتبار نفس المتجه الذي تم استخدامه في السيناريو الأول وقم بإزالة كافة العناصر باستخدام الدالة Clear().
#تتضمناستخدام مساحة الاسم الأمراض المنقولة جنسيا ;
رئيسي ( )
{
// إنشاء ناقل - منتجات ذات 5 سلاسل
المتجه < خيط > منتجات { 'صابون' , 'شامبو' , 'زيت' , 'الفاكهة' , 'خضروات' } ;
cout << 'المنتجات الحالية: ' << endl ;
ل ( سلسلة itr : منتجات )
cout << itr << endl ;
// إزالة جميع العناصر من المنتجات
منتجات. واضح ( ) ;
cout << ' \ن المنتجات النهائية: \ن ' ;
ل ( سلسلة itr : منتجات )
cout << itr << endl ;
}
انتاج:
يمكننا أن نرى أنه لا توجد عناصر في ناقل 'المنتجات'.
اتحاد المتجهات
من الممكن تنفيذ عملية UNION على المتجهات باستخدام الدالة std::set_union(). يقوم Union بإرجاع العناصر الفريدة من المتجهات عن طريق تجاهل العناصر المكررة. نحن بحاجة إلى تمرير كل من التكرارات إلى هذه الوظيفة. بالإضافة إلى ذلك، يجب تمرير مكرر الإخراج الذي يخزن النتيجة التي يتم إرجاعها بواسطة كلا المكررين.
بناء الجملة:
set_union ( InputIterator1 first1، InputIterator1 last1، InputIterator2 first2، InputIterator2 last2، OutputIterator res ) ;هنا:
- يشير 'first1' إلى العنصر الأول للمكرر الأول (المتجه).
- يشير 'last1' إلى العنصر الأخير في المكرر الأول (المتجه).
- يشير 'first2' إلى العنصر الأول من المكرر الثاني (المتجه).
- يشير 'last2' إلى العنصر الأخير في المكرر الثاني (المتجه).
قم بإنشاء متجهين - 'subjects1' و'subjects2' - من النوع الصحيح.
- قم بفرز المتجهين باستخدام الدالةsort() عن طريق تمرير التكرارات.
- إنشاء متجه الإخراج (المكرر).
- ابحث عن اتحاد هذين المتجهين باستخدام الدالة std::set_union() . استخدم begin() باعتباره المكرر الأول و end() باعتباره المكرر الأخير.
- قم بتكرار متجه الإخراج لعرض العناصر التي يتم إرجاعها بواسطة الوظيفة.
#تشمل
#تشمل <ناقل>
استخدام مساحة الاسم الأمراض المنقولة جنسيا ;
رئيسي ( )
{
// إنشاء متجه - علامات 1
المتجه < كثافة العمليات > علامات1 = { 100 , 90 , 80 , 70 , 60 } ;
// إنشاء متجه - Marks2
المتجه < كثافة العمليات > علامات2 = { 80 , 90 , 60 , 70 , 100 } ;
// قم بفرز كلا المتجهين
نوع ( علامات1. يبدأ ( ) ، علامات1. نهاية ( ) ) ;
نوع ( علامات2. يبدأ ( ) ، علامات 2. نهاية ( ) ) ;
المتجه < كثافة العمليات > inputVector ( علامات1. مقاس ( ) + علامات2. مقاس ( ) ) ;
المتجه < كثافة العمليات > :: مكرر يكون ;
أنا = set_union ( علامات1. يبدأ ( ) ، علامات1. نهاية ( ) ,
علامات2. يبدأ ( ) ، علامات2. نهاية ( ) ,
inputVector. يبدأ ( ) ) ;
cout << ' \ن علامات 1 علامات U 2: \ن ' ;
ل ( س = inputVector. يبدأ ( ) ; س ! = أنا ; ++ س )
cout << * س << ' ' << ' \ن ' ;
}
انتاج:
لا يوجد سوى خمسة عناصر فريدة في كلا المتجهين (الموضوعات 1 والموضوعات 2).
تقاطع المتجهات
يمكن العثور على تقاطع متجهين باستخدام الدالة std::set_intersection() . يُرجع التقاطع العناصر الموجودة في كلا المتجهين.
بناء الجملة:
set_intersection ( InputIterator1 first1، InputIterator1 last1، InputIterator2 first2، InputIterator2 last2، OutputIterator res ) ;يمكن تمرير المعلمات التي تم تمريرها إلى الدالة set_union() إلى الدالة set_intersection() هذه أيضًا.
قم بإنشاء متجهين - 'subjects1' و'subjects2' - من النوع الصحيح.
- قم بفرز المتجهين باستخدام الدالةsort() عن طريق تمرير التكرارات.
- إنشاء متجه الإخراج (المكرر).
- ابحث عن تقاطع هذين المتجهين باستخدام الدالة std::set_intersection() . استخدم begin() باعتباره المكرر الأول و end() باعتباره المكرر الأخير.
- قم بتكرار متجه الإخراج لعرض العناصر التي يتم إرجاعها بواسطة الوظيفة.
#تشمل
#تشمل <ناقل>
استخدام مساحة الاسم الأمراض المنقولة جنسيا ;
رئيسي ( )
{
// إنشاء متجه - علامات 1
المتجه < كثافة العمليات > علامات1 = { 100 , 10 , 80 , 40 , 60 } ;
// إنشاء متجه - Marks2
المتجه < كثافة العمليات > علامات2 = { خمسون , 90 , 60 , 10 , 100 } ;
// قم بفرز كلا المتجهين
نوع ( علامات1. يبدأ ( ) ، علامات1. نهاية ( ) ) ;
نوع ( علامات2. يبدأ ( ) ، علامات 2. نهاية ( ) ) ;
المتجه < كثافة العمليات > inputVector ( علامات1. مقاس ( ) + علامات2. مقاس ( ) ) ;
المتجه < كثافة العمليات > :: مكرر يكون ;
أنا = set_intersection ( علامات1. يبدأ ( ) ، علامات1. نهاية ( ) ,
علامات2. يبدأ ( ) ، علامات2. نهاية ( ) ,
inputVector. يبدأ ( ) ) ;
cout << ' \ن علامات1 ∩ علامات2: \ن ' ;
ل ( س = inputVector. يبدأ ( ) ; س ! = أنا ; ++ س )
cout << * س << ' ' << ' \ن ' ;
}
انتاج:
لا يوجد سوى ثلاثة عناصر موجودة في كلا المتجهين (الموضوعات 1 والموضوعات 2).
تحقق مما إذا كان المتجه فارغًا أم لا
قبل العمل على المتجهات، من المهم التحقق مما إذا كان المتجه فارغًا أم لا. من الممارسات الجيدة أيضًا في مشاريع البرمجيات التحقق مما إذا كان المتجه فارغًا أم لا قبل القيام بعمليات مثل عمليات CRUD وما إلى ذلك.
1. استخدام Std::vector::empty()
ترجع هذه الدالة 1 إذا كان المتجه فارغًا (لا يحتوي على أي عنصر). خلاف ذلك، يتم إرجاع 0. لا يتم تمرير أي معلمة إلى هذه الوظيفة.
2. استخدام الأمراض المنقولة جنسيا::ناقل::حجم()
تقوم الدالة std::vector::size() بإرجاع العدد الصحيح الذي يمثل العدد الإجمالي للعناصر الموجودة في المتجه.
قم بإنشاء متجهين - 'college1' و'college2'. يحتوي 'College1' على خمسة عناصر و'college2' فارغ. قم بتطبيق كلتا الوظيفتين على كلا المتجهين وتحقق من الإخراج.
#تشمل <الخوارزمية>#تشمل
#تشمل <ناقل>
استخدام مساحة الاسم الأمراض المنقولة جنسيا ;
رئيسي ( )
{
// إنشاء ناقل - College1
المتجه < خيط > كلية 1 = { 'الكلية أ' , 'الكلية-ب' , 'الكلية-ج' , 'الكلية-د' , 'الكلية-E' } ;
// إنشاء ناقل - College2
المتجه < خيط > كلية2 ;
// فارغ()
cout << كلية 1. فارغ ( ) << endl ;
cout << كلية2. فارغ ( ) << endl ;
// مقاس()
cout << كلية 1. مقاس ( ) << endl ;
cout << كلية2. مقاس ( ) << endl ;
}
انتاج:
ترجع الدالة الفارغة () 0 لـ 'college1' و1 لـ 'college2'. ترجع الدالة size() خمسة لـ 'college1' و0 لـ 'college2'.
اجتياز المتجه باستخدام Const_Iterator
عندما تعمل على حاويات C++ مثل المجموعات والمتجهات وما إلى ذلك، فمن الممكن التكرار على جميع العناصر الموجودة في الحاوية دون تعديلها. ال const_iterator هو أحد التكرارات التي تحقق هذا السيناريو. إن cbegin () (يشير إلى العنصر الأول في المتجه) و cend () (يشير إلى العنصر الأخير في المتجه) هما الوظيفتان اللتان توفرهما كل حاوية والتي يتم استخدامها لإرجاع المكرر الثابت إلى بداية ونهاية الحاوية. أثناء تكرار المتجه، يمكننا الاستفادة من هاتين الوظيفتين.
- لنقم بإنشاء متجه يسمى 'الأقسام' بخمسة سلاسل.
- قم بتعريف const_iterator – ctr من النوع
. - قم بالتكرار على الأقسام باستخدام المكرر السابق باستخدام حلقة 'for' وعرضها.
#تشمل <ناقل>
استخدام مساحة الاسم الأمراض المنقولة جنسيا ;
رئيسي ( )
{
// إنشاء ناقلات - الأقسام
المتجه < خيط > الإدارات = { 'مبيعات' , 'خدمة' ,
'الموارد البشرية' , 'هو - هي' , 'آحرون' } ;
المتجه < خيط > :: const_iterator نسبة النقر إلى الظهور ;
// كرر على الأقسام باستخدام const_iterator - ctr.
ل ( نسبة النقر إلى الظهور = الإدارات. com.cbegin ( ) ; نسبة النقر إلى الظهور ! = الإدارات. قليلة ( ) ; نسبة النقر إلى الظهور ++ ) {
cout << * نسبة النقر إلى الظهور << endl ;
}
}
انتاج:
اجتياز متجه باستخدام Reverse_Iterator
ال reverse_iterator هو أيضًا مكرر يشبه const_iterator ولكنه يُرجع العناصر في الاتجاه المعاكس. إن rbegin () (يشير إلى العنصر الأخير في المتجه) و rend () (يشير إلى العنصر الأول في المتجه) هما الوظيفتان اللتان توفرهما كل حاوية والتي يتم استخدامها لإرجاع المكرر الثابت إلى نهاية وبداية الحاوية.
- لنقم بإنشاء متجه يسمى 'الأقسام' بخمسة سلاسل.
- قم بتعريف المكرر العكسي – rtr من النوع
. - قم بالتكرار على الأقسام باستخدام المكرر السابق باستخدام حلقة 'for' وعرضها.
#تشمل <ناقل>
استخدام مساحة الاسم الأمراض المنقولة جنسيا ;
رئيسي ( )
{
// إنشاء ناقلات - الأقسام
المتجه < خيط > الإدارات = { 'مبيعات' , 'خدمة' ,
'الموارد البشرية' , 'هو - هي' , 'آحرون' } ;
المتجه < خيط > :: reverse_iterator rtr ;
// كرر على الأقسام باستخدام Reverse_iterator - RTR.
ل ( rtr = الإدارات. rbegin ( ) ; rtr ! = الإدارات. يصنع ( ) ; rtr ++ ) {
cout << * rtr << endl ;
}
}
انتاج:
ادفع العناصر إلى المتجه
يعد دفع العناصر أو إلحاقها بالمتجه بمثابة إدراج أحادي الاتجاه يمكن إجراؤه باستخدام المتجه::push_back() وظيفة.
بناء الجملة:
المتجه. إدفع إلى الخلف ( عنصر )يتطلب الأمر دفع عنصر إلى المتجه كمعلمة.
لنقم بإنشاء متجه فارغ يسمى 'الأقسام' بخمس سلاسل ثم ندفع سلسلتين واحدة تلو الأخرى باستخدام الدالة Push_back().
#تشمل#تشمل <ناقل>
استخدام مساحة الاسم الأمراض المنقولة جنسيا ;
رئيسي ( )
{
// تهيئة المتجه - الأقسام
المتجه < خيط > الإدارات ;
cout << 'الأقسام الفعلية:' << endl ;
ل ( آلي itr = الإدارات. يبدأ ( ) ; itr ! = الإدارات. نهاية ( ) ; ++ itr )
cout << * itr << endl ;
// ادفع 'المبيعات'
الإدارات. إدفع إلى الخلف ( 'مبيعات' ) ;
// ادفعه'
الإدارات. إدفع إلى الخلف ( 'هو - هي' ) ;
cout << ' \ن الأقسام النهائية:' << endl ;
ل ( آلي itr = الإدارات. يبدأ ( ) ; itr ! = الإدارات. نهاية ( ) ; ++ itr )
cout << * itr << endl ;
}
انتاج:
أولاً، نقوم بدفع 'المبيعات'. بعد ذلك، يتم دفع 'IT' إلى المتجه. الآن، يحمل متجه 'الأقسام' عنصرين.
قم بإخراج العناصر من المتجه
إذا كنت تريد حذف العنصر الأخير الموجود في المتجه، فاستخدم المتجه::pop_back() الوظيفة هي أفضل نهج. يقوم بحذف العنصر الأخير الموجود في المتجه.
بناء الجملة:
المتجه. عودة البوب ( )ليست هناك حاجة إلى معلمة لهذه الوظيفة. يُظهر السلوك غير المحدد إذا حاولنا حذف العنصر الأخير من متجه فارغ.
لنقم بإنشاء متجه فارغ باسم 'الأقسام' بخمس سلاسل وحذف العنصر الأخير باستخدام الوظيفة السابقة. عرض المتجه في كلتا الحالتين.
#تشمل#تشمل <ناقل>
استخدام مساحة الاسم الأمراض المنقولة جنسيا ;
رئيسي ( )
{
// تهيئة المتجه - الأقسام
المتجه < خيط > الإدارات = { 'مبيعات' , 'هو - هي' , 'خدمة' , 'تسويق' , 'الموارد البشرية' } ;
cout << 'الأقسام الفعلية:' << endl ;
ل ( آلي itr = الإدارات. يبدأ ( ) ; itr ! = الإدارات. نهاية ( ) ; ++ itr )
cout << * itr << endl ;
// احذف العنصر الأخير
الإدارات. عودة البوب ( ) ;
cout << ' \ن الأقسام النهائية:' << endl ;
ل ( آلي itr = الإدارات. يبدأ ( ) ; itr ! = الإدارات. نهاية ( ) ; ++ itr )
cout << * itr << endl ;
}
انتاج:
'الموارد البشرية' هو العنصر الأخير الموجود في ناقل 'الأقسام'. لذا، تتم إزالته من المتجه ويكون المتجه النهائي يحمل 'المبيعات' و'تكنولوجيا المعلومات' و'الخدمة' و'التسويق'.
مبادلة المتجهات
ال ناقل::مبادلة() يتم استخدام الوظيفة في C++ STL لمبادلة جميع العناصر الموجودة في ناقلين.
بناء الجملة:
first_vector. تبديل ( Second_vector )لا يأخذ في الاعتبار حجم المتجهات ولكن يجب أن تكون المتجهات من نفس النوع (يتم ظهور الخطأ إذا كانت أنواع المتجهات مختلفة).
لنقم بإنشاء متجهين - 'الفواكه' و'الخضروات' - من نوع السلسلة بأحجام مختلفة. قم بتبديل كل واحد منهم وعرض المتجهات في كلتا الحالتين.
#تشمل#تشمل <ناقل>
استخدام مساحة الاسم الأمراض المنقولة جنسيا ;
رئيسي ( )
{
// تهيئة المتجه - الفواكه
المتجه < خيط > الفاكهة = { 'تفاحة' , 'مانجو' } ;
cout << 'الفواكه الحقيقية:' << endl ;
ل ( آلي itr = الفاكهة. يبدأ ( ) ; itr ! = الفاكهة. نهاية ( ) ; ++ itr )
cout << * itr << endl ;
// تهيئة المتجه - الخضروات
المتجه < خيط > خضروات = { 'البطاطس' , 'طماطم' , 'برينجال' } ;
cout << ' \ن الخضار الحقيقية:' << endl ;
ل ( آلي itr = خضروات. يبدأ ( ) ; itr ! = خضروات. نهاية ( ) ; ++ itr )
cout << * itr << endl ;
// قم بتبديل العناصر في كلا المتجهين
الفاكهة. تبديل ( خضروات ) ;
cout << ' \ن الفواكه بعد التبديل:' << endl ;
ل ( آلي itr = الفاكهة. يبدأ ( ) ; itr ! = الفاكهة. نهاية ( ) ; ++ itr )
cout << * itr << endl ;
cout << ' \ن الخضار بعد التبديل:' << endl ;
ل ( آلي itr = خضروات. يبدأ ( ) ; itr ! = خضروات. نهاية ( ) ; ++ itr )
cout << * itr << endl ;
}
انتاج:
في السابق، كان متجه 'الفواكه' يحمل عنصرين ومتجه 'الخضروات' يحمل ثلاثة عناصر. بعد التبديل، يحمل متجه 'الفواكه' ثلاثة عناصر ومتجه 'الخضروات' يحمل عنصرين.
جلب العنصر الأول من المتجه
في بعض الحالات، يكون المتطلب هو إرجاع العنصر الأول فقط من المتجه. تقوم الدالة Vector::front() في C++ STL بجلب العنصر الأول فقط من المتجه.
بناء الجملة:
المتجه. أمام ( )لن تأخذ هذه الوظيفة أي معلمة. إذا كان المتجه فارغًا، فسيتم طرح خطأ.
لنقم بإنشاء متجهين - 'الفواكه' و'الخضروات' - من نوع السلسلة ونحاول جلب العنصر الأول بشكل منفصل عن المتجهين.
#تشمل#تشمل <ناقل>
استخدام مساحة الاسم الأمراض المنقولة جنسيا ;
رئيسي ( )
{
// إنشاء ناقل - فواكه تحتوي على عنصرين
المتجه < خيط > الفاكهة = { 'تفاحة' , 'مانجو' } ;
// إرجاع العنصر الأول
cout << الفاكهة. أمام ( ) << endl ;
// تهيئة المتجه - الخضروات
المتجه < خيط > خضروات ;
// حاول إرجاع العنصر الأول
cout << خضروات. أمام ( ) ;
}
انتاج:
'التفاحة' هي العنصر الأول الموجود في ناقل 'الفواكه'. لذلك، يتم إعادته. ولكن يحدث خطأ عندما نحاول جلب العنصر الأول من متجه 'الخضروات' لأنه فارغ.
جلب العنصر الأخير من المتجه
تقوم الدالة Vector::end() في C++ STL بجلب العنصر الأخير فقط من المتجه.
بناء الجملة:
المتجه. خلف ( )لن تأخذ هذه الوظيفة أي معلمة. إذا كان المتجه فارغًا، فسيتم طرح خطأ.
لنقم بإنشاء متجهين - 'الفواكه' و'الخضروات' - من نوع السلسلة ونحاول جلب العنصر الأخير بشكل منفصل عن المتجهين.
#تشمل#تشمل <ناقل>
استخدام مساحة الاسم الأمراض المنقولة جنسيا ;
رئيسي ( )
{
// إنشاء ناقل - فواكه تحتوي على عنصرين
المتجه < خيط > الفاكهة = { 'تفاحة' , 'مانجو' } ;
// جلب العنصر الأخير
cout << الفاكهة. خلف ( ) << endl ;
// تهيئة المتجه - الخضروات
المتجه < خيط > خضروات ;
// حاول جلب العنصر الأخير
cout << خضروات. خلف ( ) ;
}
انتاج:
'المانجو' هو العنصر الأخير الموجود في ناقل 'الفواكه'. لذلك، يتم إعادته. ولكن يحدث خطأ عندما نحاول جلب العنصر الأخير من متجه 'الخضروات' لأنه فارغ.
تعيين قيم جديدة للمتجه
في بعض السيناريوهات، إذا كنت تريد تحديث كافة القيم بالقيمة الجديدة أو إنشاء متجه بنفس القيم، فإن استخدام الدالة Vector::sign() هو أفضل أسلوب. باستخدام هذه الدالة يمكننا:
- قم بإنشاء المتجه بجميع العناصر المتشابهة
- تعديل المتجه الموجود بنفس العنصر
بناء الجملة:
المتجه. تعيين ( الحجم والقيمة )هناك حاجة إلى معلمتين لهذه الوظيفة.
هنا:
- يحدد الحجم عدد العناصر التي سيتم تعيينها.
- تحدد القيمة العنصر الذي سيتم تعيينه.
لنقم بإنشاء متجه باسم 'marks1' بخمس قيم ونقوم بتحديث هذا المتجه بأربعة عناصر بحيث تكون جميع العناصر في المتجه المحدث تساوي 20.
#تشمل <الخوارزمية>#تشمل
#تشمل <ناقل>
استخدام مساحة الاسم الأمراض المنقولة جنسيا ;
رئيسي ( )
{
// إنشاء متجه - علامات 1
المتجه < كثافة العمليات > علامات1 = { 100 , 90 , 80 , 70 , 60 } ;
cout << 'المتجه الفعلي:' << endl ;
ل ( كثافة العمليات أنا = 0 ; أنا < علامات1. مقاس ( ) ; أنا ++ )
cout << علامات1 [ أنا ] << endl ;
علامات1. تعيين ( 4 , عشرين ) ;
cout << ' \ن المتجه المحدث:' << endl ;
ل ( كثافة العمليات أنا = 0 ; أنا < علامات1. مقاس ( ) ; أنا ++ )
cout << علامات1 [ أنا ] << endl ;
}
انتاج:
في السابق، كان المتجه يحمل خمسة عناصر مختلفة. الآن، يحتوي على أربعة عناصر فقط، وكلها تساوي 20.
توسيع المتجه باستخدام Emplace()
نحن نعلم بالفعل أنه يتم إدراج العناصر الجديدة ديناميكيًا في أي موضع في المتجه. من الممكن استخدام الدالة Vector::emplace(). دعونا نلقي نظرة سريعة على بناء الجملة والمعلمات المقبولة بواسطة هذه الوظيفة.
بناء الجملة:
المتجه. موقع ( موضع const_iterator، العنصر )يتم تمرير معلمتين إلزاميتين إلى هذه الوظيفة.
هنا:
- تأخذ المعلمة الأولى الموضع حتى نتمكن من إدراج العنصر في أي موضع. يمكننا الحصول على الموضع باستخدام وظيفة التكرار begin() أو end().
- المعلمة الثانية هي العنصر الذي سيتم إدراجه في المتجه.
خذ بعين الاعتبار ناقل 'المواد الكيميائية' الذي يحتوي على عنصرين.
- أدخل 'المنجنيز' في الموضع الأول - ابدأ (المواد الكيميائية)
- أدخل 'النحاس' في الموضع الأخير - النهاية (المواد الكيميائية)
- أدخل 'الكبريت' في الموضع الثالث - ابدأ (المواد الكيميائية) +2
#تشمل
#تشمل <ناقل>
استخدام مساحة الاسم الأمراض المنقولة جنسيا ;
رئيسي ( )
{
// إنشاء ناقلات - المواد الكيميائية
المتجه < خيط > مواد كيميائية = { 'الأكسجين' , 'ثاني أكسيد الكربون' } ;
cout << 'المواد الكيميائية الفعلية:' << endl ;
ل ( كثافة العمليات أنا = 0 ; أنا < مواد كيميائية. مقاس ( ) ; أنا ++ )
cout << مواد كيميائية [ أنا ] << endl ;
// أدخل العنصر في الموضع الأول
مواد كيميائية. موقع ( يبدأ ( مواد كيميائية ) , 'المنجنيز' ) ;
// أدخل العنصر في الموضع الأخير
مواد كيميائية. موقع ( نهاية ( مواد كيميائية ) , 'نحاس' ) ;
// أدخل العنصر في الموضع الثالث
مواد كيميائية. موقع ( يبدأ ( مواد كيميائية ) + 2 , 'الكبريت' ) ;
cout << ' \ن المواد الكيميائية النهائية:' << endl ;
ل ( كثافة العمليات أنا = 0 ; أنا < مواد كيميائية. مقاس ( ) ; أنا ++ )
cout << مواد كيميائية [ أنا ] << endl ;
}
انتاج:
الآن، يحمل المتجه النهائي خمسة عناصر (موضحة في لقطة الشاشة التالية).
تمديد المتجه باستخدام Emplace_Back()
يمكن إلحاق عنصر (إضافة في نهاية المتجه) والذي يمكن القيام به باستخدام ملف المتجه::emplace_back() وظيفة.
بناء الجملة:
المتجه. emplace_back ( عنصر )من الضروري تمرير العنصر المراد إلحاقه بالمتجه كمعلمة.
دعونا نضيف عنصرين واحدًا تلو الآخر باستخدام وظيفة emplace_back().
#تشمل <الخوارزمية>#تشمل
#تشمل <ناقل>
استخدام مساحة الاسم الأمراض المنقولة جنسيا ;
رئيسي ( )
{
// إنشاء ناقلات - المواد الكيميائية
المتجه < خيط > مواد كيميائية = { 'الأكسجين' , 'ثاني أكسيد الكربون' } ;
cout << 'المواد الكيميائية الفعلية:' << endl ;
ل ( كثافة العمليات أنا = 0 ; أنا < مواد كيميائية. مقاس ( ) ; أنا ++ )
cout << مواد كيميائية [ أنا ] << endl ;
// أدخل المنغنيز في نهاية المتجه
مواد كيميائية. emplace_back ( 'المنجنيز' ) ;
// أدخل المنغنيز في نهاية المتجه
مواد كيميائية. emplace_back ( 'نحاس' ) ;
cout << ' \ن المواد الكيميائية النهائية:' << endl ;
ل ( كثافة العمليات أنا = 0 ; أنا < مواد كيميائية. مقاس ( ) ; أنا ++ )
cout << مواد كيميائية [ أنا ] << endl ;
}
انتاج:
الآن، المتجه النهائي يحمل أربعة عناصر بعد إضافة 'المنغنيز' و'النحاس'.
الحد الأقصى لعنصر المتجه
- إنشاء ناقل مع بعض العناصر.
- للعثور على الحد الأقصى للعنصر الموجود في المتجه، استخدم الدالة *max_element() التي تقبل مكررين كوسائط. تعمل هاتان المعلمتان كنطاق ويتم إرجاع الحد الأقصى للعنصر ضمن النطاق المقدم. موضع البداية هو البدء () والموضع الأخير هو النهاية ().
لنفكر في متجه يسمى 'item_costs' يحمل خمس قيم من النوع الصحيح ويعيد الحد الأقصى للعنصر.
#تشمل <ناقل>#تشمل
#تشمل <الخوارزمية>
استخدام مساحة الاسم الأمراض المنقولة جنسيا ;
رئيسي ( )
{
// إنشاء ناقل - item_costs
المتجه < كثافة العمليات > item_costs = { 8900 , 5677 , 200 , 1000 , 2300 } ;
cout << 'تكلفة العناصر: \ن ' ;
ل ( كثافة العمليات أنا = 0 ; أنا < item_costs. مقاس ( ) ; أنا ++ )
cout << item_costs [ أنا ] << endl ;
// قم بإرجاع الحد الأقصى للعنصر من المتجه أعلاه - item_costs
cout << ' \ن الحد الأقصى للتكلفة: ' << * max_element ( يبدأ ( item_costs ) ،نهاية ( item_costs ) ) ;
}
انتاج:
هنا، 8900 هو الحد الأقصى للعنصر بين جميع العناصر الموجودة في متجه 'تكاليف_العنصر'.
الحد الأدنى لعنصر المتجه
- إنشاء ناقل مع بعض العناصر.
- للعثور على الحد الأدنى من العناصر الموجودة في المتجه، استخدم الدالة *min_element() التي تقبل مكررين كوسائط. تعمل هاتان المعلمتان كنطاق ويتم إرجاع العنصر الأدنى (أقل من كافة العناصر الأخرى) ضمن النطاق المقدم. موضع البداية هو البدء () والموضع الأخير هو النهاية ().
استخدم نفس المتجه الذي تم إنشاؤه للعثور على الحد الأقصى للعنصر والعثور على الحد الأدنى للعنصر باستخدام الدالة *min_element().
#تشمل <ناقل>#تشمل
#تشمل <الخوارزمية>
استخدام مساحة الاسم الأمراض المنقولة جنسيا ;
رئيسي ( )
{
// إنشاء ناقل - item_costs
المتجه < كثافة العمليات > item_costs = { 8900 , 5677 , 200 , 1000 , 2300 } ;
cout << 'تكلفة العناصر: \ن ' ;
ل ( كثافة العمليات أنا = 0 ; أنا < item_costs. مقاس ( ) ; أنا ++ )
cout << item_costs [ أنا ] << endl ;
// قم بإرجاع الحد الأدنى من العناصر من المتجه أعلاه - item_costs
cout << ' \ن الحد الأدنى للتكلفة: ' << * min_element ( يبدأ ( item_costs ) ،نهاية ( item_costs ) ) ;
}
انتاج:
هنا، 200 هو الحد الأدنى للعنصر بين جميع العناصر الموجودة في ناقل 'تكاليف_العنصر'.
مجموع العناصر في المتجهات
لإرجاع مجموع جميع العناصر الموجودة في المتجه، فإن جمع() يتم استخدام الوظيفة في C++ STL. يقبل ثلاث معلمات. تأخذ المعلمة الأولى الفهرس الأول الذي يمثل عنصر البداية في النطاق (حدد مكرر begin()) وتأخذ المعلمة الثانية الفهرس الأخير الذي يمثل عنصر النهاية في النطاق (حدد مكرر end()) . وأخيرًا، نحتاج إلى تمرير القيمة الأولية للمجموع (في حالتنا، هي 0).
جمع ( الفهرس الأول، الفهرس الأخير، الفهرس الأولي ) ;قم بإنشاء متجه باسم 'item_costs' بخمسة عناصر من النوع الصحيح واحسب المجموع.
#تتضمناستخدام مساحة الاسم الأمراض المنقولة جنسيا ;
رئيسي ( )
{
// إنشاء ناقل - item_costs
المتجه < كثافة العمليات > item_costs = { 8900 , 5677 , 200 , 1000 , 2300 } ;
cout << 'تكلفة العناصر: \ن ' ;
ل ( كثافة العمليات أنا = 0 ; أنا < item_costs. مقاس ( ) ; أنا ++ )
cout << item_costs [ أنا ] << endl ;
// قم بإرجاع مجموع جميع العناصر في المتجه أعلاه - item_costs
cout << ' \ن التكلفة الإجمالية: ' << جمع ( يبدأ ( item_costs ) ،نهاية ( item_costs ) , 0 ) ;
}
انتاج:
مجموع 8900، 5677، 200، 1000، 2300 هو 18077.
الضرب الحكيم لمتجهين
- قم بإنشاء متجهين من النوع الرقمي ويجب أن يكون المتجهان بنفس الحجم (إجمالي عدد العناصر الموجودة في المتجه الأول = إجمالي عدد العناصر الموجودة في المتجه الثاني).
- أعلن عن ناقل جديد واستخدم لحلقة قم بإجراء عملية الضرب على عنصرين في كل تكرار، وقم بتخزين القيمة في المتجه الذي تم إنشاؤه باستخدام وظيفة Push_back(). ل ( كثافة العمليات itr = 0 ; أنا < first_vec. مقاس ( ) ; itr ++ )
- اعرض العناصر الموجودة في المتجه الناتج عن طريق تكراره.
{
result_vector. إدفع إلى الخلف ( first_vec [ itr ] * sec_thing [ itr ] ) ;
}
قم بإنشاء متجه باسم 'item_costs' بخمسة عناصر من النوع الصحيح واحسب المجموع.
#تتضمناستخدام مساحة الاسم الأمراض المنقولة جنسيا ;
رئيسي ( )
{
// قم بإنشاء متجهين - المنتجات 1 والمنتجات 2 مع 5 عناصر لكل منهما
المتجه < كثافة العمليات > المنتجات1 = { 10 , عشرين , 30 , 40 , خمسون } ;
المتجه < كثافة العمليات > المنتجات2 = { خمسون , 40 , 30 , 70 , 60 } ;
المتجه < كثافة العمليات > result_products ;
// إجراء الضرب الحكيم للعنصر
ل ( كثافة العمليات أنا = 0 ; أنا < المنتجات1. مقاس ( ) ; أنا ++ ) {
result_products. إدفع إلى الخلف ( المنتجات1 [ أنا ] * المنتجات2 [ أنا ] ) ;
}
// عرض المتجه الناتج
cout << 'ضرب المتجهات: \ن ' ;
ل ( كثافة العمليات الدقة : result_products )
cout << الدقة << endl ;
}
انتاج:
تكرار - 1 : 10 * خمسون => 500تكرار - 2 : عشرين * 40 => 800
تكرار - 3 : 30 * 30 => 900
تكرار - 4 : 40 * 70 => 2800
تكرار - 5 : خمسون * 60 => 3000
المنتج النقطي لمتجهين
في حالة ناقلات C++، يتم تعريف المنتج النقطي على أنه 'مجموع منتجات الإدخالات المقابلة لتسلسلي المتجهات'.
بناء الجملة:
منتج داخلي ( Vector1 أولًا، Vector1 أخيرًا، Vector2 أولًا، Primary_Val )استخدم الدالة Internal_product() لإرجاع المنتج النقطي. تأخذ هذه الوظيفة أربعة معلمات مطلوبة.
هنا:
- تشير المعلمة الأولى إلى مكرر يشير إلى بداية المتجه الأول (حدد باستخدام وظيفة begin()).
- تشير المعلمة الثانية إلى مكرر يشير إلى نهاية المتجه الأول (حدد باستخدام وظيفة end()).
- تشير المعلمة الثالثة إلى مكرر يشير إلى بداية المتجه الثاني (حدد باستخدام وظيفة begin()).
- يجب تمرير القيمة الأولية كمعلمة أخيرة وهي عبارة عن عدد صحيح لتراكم منتج النقطة.
استخدم نفس البرنامج الذي تم إنشاؤه لضرب متجهين واستخدم الدالة innsr_product() للعثور على المنتج النقطي للمتجهين.
#تتضمناستخدام مساحة الاسم الأمراض المنقولة جنسيا ;
رئيسي ( )
{
// قم بإنشاء متجهين - المنتجات 1 والمنتجات 2 مع 5 عناصر لكل منهما
المتجه < كثافة العمليات > المنتجات1 = { 10 , عشرين , 30 , 40 , خمسون } ;
المتجه < كثافة العمليات > المنتجات2 = { خمسون , 40 , 30 , 70 , 60 } ;
// عرض المتجه الناتج
cout << 'المنتج النقطي للمنتجات 1 والمنتجات 2:' ;
cout << منتج داخلي ( يبدأ ( المنتجات1 ) ،نهاية ( المنتجات1 ) ،يبدأ ( المنتجات2 ) , 0 ) ;
}
انتاج:
( 10 * خمسون ) + ( عشرين * 40 ) + ( 30 * 30 ) + ( 40 * 70 ) + ( خمسون * 60 )=> 500 + 800 + 900 + 2800 + 3000
=> 8000
تحويل مجموعة إلى ناقل
هناك العديد من الطرق لتحويل مجموعة إلى متجه عن طريق تمرير جميع العناصر المرفوعة في مجموعة إلى متجه. أفضل وأبسط طريقة هي استخدام الدالة std::copy().
بناء الجملة
الأمراض المنقولة جنسيا :: ينسخ ( مكرر المصدر أولاً، مكرر المصدر أخيرًا، مكرر الوجهة أولاً )استخدم ال الأمراض المنقولة جنسيا::نسخ () دالة تقوم بإدراج العناصر من مجموعة في المتجه. يستغرق ثلاث معلمات.
هنا:
- تشير المعلمة الأولى إلى المكرر المصدر الذي يشير إلى العنصر الأول في المكرر. هنا، set هو مكرر المصدر المحدد باستخدام الدالة begin().
- وبالمثل، تشير المعلمة الثانية إلى العنصر الأخير (وظيفة end()).
- تشير المعلمة الثالثة إلى مكرر الوجهة الذي يشير إلى العنصر الأول (المحدد باستخدام وظيفة begin()) في المكرر.
لنقم بإنشاء مجموعة مكونة من خمسة طلاب وننسخ جميع العناصر إلى متجه باستخدام الوظيفة السابقة.
#تتضمناستخدام مساحة الاسم الأمراض المنقولة جنسيا ;
رئيسي ( )
{
// قم بإنشاء مجموعة - الطلاب بخمسة عناصر
تعيين < خيط > طلاب = { 'سرافان' , 'بوبي' , 'مادهو' , 'ميجانا' , 'لافانيا' } ;
cout << 'تعيين: \ن ' ;
ل ( سلسلة ط : طلاب )
cout << أنا << endl ;
// إنشاء ناقل - حجم Student_vcof يساوي حجم المجموعة
المتجه < خيط > Student_vc ( طلاب. مقاس ( ) ) ;
// أدخل عناصر من المجموعة - الطلاب في المتجهات - Student_vc.
ينسخ ( طلاب. يبدأ ( ) ، طلاب. نهاية ( ) , Student_vc. يبدأ ( ) ) ;
cout << ' \ن المتجه: \ن ' ;
ل ( سلسلة ط : Student_vc )
cout << أنا << endl ;
}
انتاج:
الآن، يتم نسخ جميع العناصر الموجودة في مجموعة 'الطلاب' إلى المتجه 'students_vc'.
إزالة العناصر المكررة
- أولاً، نحتاج إلى فرز العناصر الموجودة في المتجه بحيث تكون جميع العناصر المكررة مجاورة لبعضها البعض باستخدام الأمر الأمراض المنقولة جنسيا::فرز () وظيفة. الأمراض المنقولة جنسيا :: نوع ( المتجه أولاً، المتجه أخيرًا ) ;
- استخدم الدالة std::unique() لتحديد العناصر المكررة. في الوقت نفسه، استخدم وظيفة المسح () لإزالة التكرارات التي يتم إرجاعها بواسطة وظيفة std::unique(). قد يتغير ترتيب العناصر في المتجه النهائي. المتجه. محو ( الأمراض المنقولة جنسيا :: فريد ( المتجه أولاً، المتجه أخيرًا ) ، ناقلات الماضي ) )
قم بإنشاء متجه 'الطلاب' باستخدام 10 عناصر وقم بإرجاع المتجه عن طريق إزالة التكرارات.
#تتضمناستخدام مساحة الاسم الأمراض المنقولة جنسيا ;
رئيسي ( )
{
// قم بإنشاء متجه - الطلاب بـ 10 عناصر
المتجه < خيط > طلاب = { 'سرافان' , 'بوبي' , 'مادهو' , 'ميجانا' , 'لافانيا' ,
'سرافان' , 'بوبي' , 'مادهو' , 'ميجانا' , 'لافانيا' } ;
cout << 'طلاب: \ن ' ;
ل ( سلسلة ط : طلاب )
cout << أنا << ' ' ;
// قم بفرز جميع العناصر الموجودة في متجه الطلاب.
نوع ( يبدأ ( طلاب ) ، نهاية ( طلاب ) ) ;
// استخدم الدالة الفريدة () لإزالة التكرارات باستخدام وظيفة المسح ().
طلاب. محو ( فريد ( يبدأ ( طلاب ) ، نهاية ( طلاب ) ) ، نهاية ( طلاب ) ) ;
cout << ' \ن \ن الطلاب الفريدون: \ن ' ;
ل ( آلي itr = com.cbegin ( طلاب ) ; itr ! = قليلة ( طلاب ) ; ++ itr ) {
cout << * itr << ' ' ;
}
}
انتاج:
الآن، جميع العناصر فريدة من نوعها في المتجه.
تحويل المتجهات إلى مجموعة
مجموعة لا تسمح بالعناصر المكررة. إذا كنت تكتب لإدراج متجه في مجموعة تحتوي على نسخ مكررة، فسيتم تجاهلها. نستخدم نفس الدالة std::copy() التي تم استخدامها في السيناريو السابق والتي حولت المجموعة إلى متجه.
في هذا السيناريو:
- تأخذ المعلمة الأولى المتجه كمكرر المصدر المحدد باستخدام وظيفة begin().
- تأخذ المعلمة الثانية المتجه كمكرر المصدر المحدد باستخدام وظيفة end().
- قم بتمرير الدالة std::inserter() التي تُستخدم للكتابة فوق/نسخ العناصر تلقائيًا في موضع محدد في المجموعة من خلال توفير المجموعة والمكرر الذي يشير إلى نهاية المجموعة كمعلمات.
لنقم بإنشاء متجه مكون من 10 أعداد صحيحة ونسخ العناصر إلى مجموعة.
#تتضمناستخدام مساحة الاسم الأمراض المنقولة جنسيا ;
رئيسي ( )
{
// إنشاء مجموعة - علامات بـ 10 قيم
المتجه < كثافة العمليات > علامات = { 12 , 3. 4 , 56 , 78 , 65 , 78 , 90 , 90 , 78 , 3. 4 } ;
cout << 'المتجه: \ن ' ;
ل ( كثافة العمليات أنا : علامات )
cout << أنا << ' ' ;
// إنشاء مجموعة - Mark_set بحجم يساوي حجم المتجه
تعيين < كثافة العمليات > Marks_set ;
// أدخل عناصر من المجموعة - الطلاب في المتجهات - Student_vc.
ينسخ ( يبدأ ( علامات ) ،نهاية ( علامات ) ، الواضع ( علامات_مجموعة، نهاية ( Marks_set ) ) ) ;
cout << ' \ن \ن تعيين: \ن ' ;
ل ( كثافة العمليات أنا : Marks_set )
cout << أنا << ' ' ;
}
انتاج:
يحتوي المتجه الموجود المسمى 'العلامات' على 10 قيم. وبعد نسخها إلى مجموعة 'marks_set'، فإنها تحتوي على ستة عناصر فقط لأن العناصر الأربعة الأخرى مكررة.
إزالة السلاسل الفارغة
لا يوجد استخدام للسلاسل الفارغة الموجودة في المتجه. من الممارسات الجيدة إزالة السلاسل الفارغة الموجودة في المتجه. دعونا نرى كيفية إزالة السلاسل الفارغة من ناقل C++:
- كرر المتجه باستخدام حلقة 'for'.
- في كل تكرار، تحقق مما إذا كان العنصر فارغًا ('') أو لا تستخدم عامل التشغيل '==' مع وظيفة العضو at().
- باستخدام الدالة std::erase()، قم بإزالة السلاسل الفارغة بعد التحقق من الشرط السابق.
- كرر الخطوتين 2 والخطوة 3 حتى نهاية المتجه.
لنقم بإنشاء ناقل 'الشركات' المكون من 10 سلاسل. منها خمسة فارغة ونقوم بإزالتها بتنفيذ الطريقة السابقة.
#تشمل#تشمل <ناقل>
استخدام مساحة الاسم الأمراض المنقولة جنسيا ;
رئيسي ( ) {
المتجه < خيط > شركات { 'الشركة-أ' , '' , 'الشركة-ب' ,
'' , 'الشركة-ج' , '' , 'الشركة-د' , '' , '' , '' } ;
// التكرار على الشركات
// وإزالة العناصر الفارغة باستخدام المسح ()
ل ( كثافة العمليات itr = 1 ; itr < شركات. مقاس ( ) ; ++ itr ) {
لو ( شركات. في ( itr ) == '' ) {
شركات. محو ( شركات. يبدأ ( ) + itr ) ;
-- itr ;
}
}
// عرض المتجه
ل ( آلي & أنا : شركات ) {
cout << أنا << endl ;
}
}
انتاج:
الآن، يحمل المتجه 'الشركات' السلاسل غير الفارغة.
كتابة ناقل إلى ملف نصي
دعونا نناقش كيفية كتابة جميع العناصر الموجودة في المتجه إلى ملف باستخدام فهارس المتجهات باستخدام com.fstream .
- ادفع بعض العناصر إليه باستخدام وظيفة Push_back بعد تهيئة المتجه.
- استخدم الدالة open() من مكتبة 'fstream' مع وضع الوضع خارجًا.
- قم باجتياز كل عنصر موجود في المتجه باستخدام المؤشرات في حلقة 'for' واكتب كل عنصر في الملف المقدم.
- وأخيرا، أغلق الملف.
دعونا ننفذ النهج السابق عن طريق تشغيل كود C++.
#تشمل <ناقل>#تشمل <سلسلة>
#تشمل
#تشمل
استخدام مساحة الاسم الأمراض المنقولة جنسيا ;
رئيسي ( )
{
// إنشاء ناقل - v_data
// وادفع عنصرين فيه.
المتجه < خيط > v_data ;
v_data. إدفع إلى الخلف ( 'مرحباً' ) ;
v_data. إدفع إلى الخلف ( 'إلى LinuxHint' ) ;
تيار و ;
// افتح الملف
F. يفتح ( 'كتابة_ملف.txt' ,ios_base :: خارج ) ;
// كرر كل عنصر من عناصر المتجه واكتب في الملف واحدًا تلو الآخر.
ل ( كثافة العمليات أنا = 0 ; أنا < v_data. مقاس ( ) ; أنا ++ )
{
F << v_data [ أنا ] << endl ;
}
// أغلق الملف
F. يغلق ( ) ;
}
انتاج:
يحتوي المتجه 'v_data' على عنصرين ويتم إنشاء ملف في المسار الذي يتم فيه تنفيذ البرنامج بالعناصر الموجودة في المتجه.
إنشاء ناقل من ملف نصي
لقد تعلمنا كيفية كتابة العناصر الموجودة في المتجه إلى ملف نصي. لنقم هنا بإنشاء متجه من المحتوى الموجود في الملف النصي.
- يخترع ' 'إذا ستريم' المتغير الذي يستخدم لقراءة المعلومات من الملف النصي الذي نقوم بإنشاء المتجه من الملف فيه.
- قم بإنشاء متجه فارغ لتخزين محتوى الملف واستخدم متغير سلسلة فارغ كعلامة للتحقق من نهاية الملف.
- اقرأ السطر التالي من الملف حتى يصل إلى النهاية (باستخدام حلقة 'أثناء' بشكل أساسي). استخدم الدالة Push_back() لقراءة السطر التالي ودفعه إلى المتجه.
- اعرض الخط الموجود في السطر بشكل منفصل لرؤية العناصر الموجودة في المتجه على وحدة التحكم.
دعونا ننفذ النهج السابق عن طريق تشغيل كود C++. لنفكر في ملف 'data.txt' بالمحتوى التالي. هنا اسم المتجه هو 'v_data'.
استخدام مساحة الاسم الأمراض المنقولة جنسيا ;
رئيسي ( )
{
// افتح الملف النصي - data
ملف ifstream ( 'بيانات.txt' ) ;
// إنشاء متجه - v_data من النوع - سلسلة
المتجه < خيط > v_data ;
كان ثونغ ;
// اقرأ السطر التالي من ملف data.txt
// حتى يصل إلى النهاية.
بينما ( ملف >> كان ) {
// اقرأ السطر التالي وادفع إلى v_data
v_data. إدفع إلى الخلف ( كان ) ;
}
// عرض السطر الموجود في السطر بشكل منفصل.
ينسخ ( v_data. يبدأ ( ) , v_data. نهاية ( ) , ostream_iterator < خيط > ( cout , ' \ن ' ) ) ;
}
انتاج:
يمكننا أن نرى أن 'v_data' يحتوي على خمسة عناصر جاءت من الملف.
خاتمة
في هذه المقالة الطويلة، استكشفنا جميع الأمثلة المحتملة المستخدمة في تطبيقات الوقت الفعلي المتعلقة بالمتجهات في لغة برمجة C++. يتم شرح كل مثال من خلال بناء الجملة والمعلمات والمثال مع الإخراج. تتم إضافة التعليقات في كل رمز للحصول على فهم واضح للكود.