C++ ভেক্টরের 30টি উদাহরণ

C++ এ, ভেক্টর হল এক মাত্রিক ডেটা স্ট্রাকচার যা প্রয়োজনের উপর ভিত্তি করে গতিশীলভাবে বৃদ্ধি পায়। এই ডেটা স্ট্রাকচারে ডেটা সংগঠন (সন্নিবেশ/পরিবর্তন/মোছা) দক্ষতার সাথে করা যেতে পারে। এর অ্যাপ্লিকেশনগুলির মধ্যে নিম্নলিখিতগুলি অন্তর্ভুক্ত রয়েছে:

বৈজ্ঞানিক এবং প্রকৌশল প্রয়োগে গাণিতিক ভেক্টরের প্রতিনিধিত্ব করা
এই ডেটা স্ট্রাকচার ইত্যাদি ব্যবহার করে সারি, স্ট্যাক প্রয়োগ করা যেতে পারে।

এই ডেটা স্ট্রাকচারের সাথে সম্পর্কিত বেশিরভাগ সাধারণ CRUD ক্রিয়াকলাপ এবং ফাংশনগুলি সিনট্যাক্স এবং কোড স্নিপেটগুলির সাথে পরিস্থিতি অনুসারে বিশদভাবে আলোচনা করা হয়েছে।

বিষয়বস্তুর বিষয়:

একটি ভেক্টরে একটি উপাদান সন্নিবেশ করান
একটি ভেক্টরে একাধিক উপাদান সন্নিবেশ করান
একটি ভেক্টর থেকে উপাদান অ্যাক্সেস
একটি ভেক্টরে উপাদান আপডেট করুন
একটি ভেক্টর থেকে একটি নির্দিষ্ট উপাদান সরান
একটি ভেক্টর থেকে সমস্ত উপাদান সরান
ভেক্টর ইউনিয়ন
ভেক্টরের ছেদ
ভেক্টর খালি কি না তা পরীক্ষা করুন
Const_Iterator ব্যবহার করে একটি ভেক্টর অতিক্রম করুন
Reverse_Iterator ব্যবহার করে একটি ভেক্টর অতিক্রম করুন
উপাদানগুলিকে ভেক্টরে পুশ করুন
ভেক্টর থেকে উপাদানগুলি পপ করুন
ভেক্টর অদলবদল করুন
ভেক্টর থেকে প্রথম উপাদানটি আনুন
ভেক্টর থেকে শেষ উপাদানটি আনুন
একটি ভেক্টরে নতুন মান বরাদ্দ করুন
Emplace() ব্যবহার করে ভেক্টর প্রসারিত করুন
Emplace_Back() ব্যবহার করে ভেক্টর প্রসারিত করুন
একটি ভেক্টরের সর্বোচ্চ উপাদান
একটি ভেক্টরের সর্বনিম্ন উপাদান
একটি ভেক্টরে উপাদানের সমষ্টি
দুটি ভেক্টরের উপাদান-ভিত্তিক গুণ
দুই ভেক্টরের ডট প্রোডাক্ট
একটি সেটকে ভেক্টরে রূপান্তর করুন
ডুপ্লিকেট উপাদানগুলি সরান
একটি ভেক্টরকে একটি সেটে রূপান্তর করুন
খালি স্ট্রিংগুলি সরান
একটি টেক্সট ফাইলে একটি ভেক্টর লিখুন
একটি টেক্সট ফাইল থেকে একটি ভেক্টর তৈরি করুন

একটি ভেক্টরে একটি উপাদান সন্নিবেশ করান

দ্য std::vector::insert() C++ STL-এ ফাংশনটি নির্দিষ্ট অবস্থানে উপাদান সন্নিবেশ করতে ব্যবহৃত হয়।

বাক্য গঠন:

ভেক্টর সন্নিবেশ ( অবস্থান, উপাদান ) ;

আসুন এই ফাংশনটি ব্যবহার করি এবং একটি প্যারামিটার হিসাবে প্রথম অবস্থানটি পাস করি যা সেই অবস্থানটি নির্দিষ্ট করে যেখানে উপাদানটি সন্নিবেশ করতে হবে এবং উপাদানটিকে দ্বিতীয় পরামিতি হিসাবে সরবরাহ করি।

begin() ফাংশনটি এখানে ব্যবহার করা যেতে পারে একটি পুনরাবৃত্তিকারী ফেরত দিতে যা ইনপুট ভেক্টরের প্রথম উপাদানের দিকে নির্দেশ করে। এই ফাংশনে অবস্থান যোগ করে, উপাদানটি সেই অবস্থানে ঢোকানো হয়।

আসুন টাইপ স্ট্রিং-এর 'student_names' ভেক্টর তৈরি করি এবং insert() ফাংশন ব্যবহার করে প্রথম এবং দ্বিতীয় অবস্থানে দুটি স্ট্রিং সন্নিবেশ করি।

#include

ব্যবহার নামস্থান std ;

প্রধান ( )

{

// ভেক্টরের সূচনা করা হচ্ছে - student_names

ভেক্টর < স্ট্রিং > ছাত্রদের_নাম ;

cout << 'বিদ্যমান ভেক্টর: \n ' ;

জন্য ( স্বয়ংক্রিয় i : ছাত্রদের_নাম ) cout << i << endl ;

// প্রথম অবস্থানে 'শ্রাবণ কুমার' ঢোকান

ছাত্রদের_নাম সন্নিবেশ ( ছাত্রদের_নাম শুরু ( ) + 0 , 'শ্রাবণ কুমার' ) ;

// দ্বিতীয় অবস্থানে 'শ্রাবণ কুমার' সন্নিবেশ করান

ছাত্রদের_নাম সন্নিবেশ ( ছাত্রদের_নাম শুরু ( ) + 1 , 'ললিতা' ) ;

cout << 'চূড়ান্ত ভেক্টর: \n ' ;

জন্য ( স্বয়ংক্রিয় j : ছাত্রদের_নাম ) cout << j << endl ;

}

আউটপুট:

পূর্বে, 'ছাত্র_নাম' ভেক্টর খালি ছিল। সন্নিবেশের পরে, ভেক্টর দুটি উপাদান ধারণ করে।

একটি ভেক্টরে একাধিক উপাদান সন্নিবেশ করান

আমরা একই ফাংশন ব্যবহার করি যা std::vector::insert() এই দৃশ্যে। কিন্তু একটি ভেক্টরে একাধিক উপাদান সন্নিবেশ করার জন্য আমাদের একই ফাংশনে অতিরিক্ত/ভিন্ন প্যারামিটার পাস করতে হবে।

দৃশ্যকল্প 1: একটি একক উপাদান একাধিক বার সন্নিবেশ করান

এই দৃশ্যে, আমরা একই উপাদান একাধিকবার যোগ করি।

বাক্য গঠন:

ভেক্টর সন্নিবেশ ( অবস্থান, আকার, উপাদান ) ;

এটি করার জন্য, আমাদের insert() ফাংশনে দ্বিতীয় প্যারামিটার হিসাবে আকারটি পাস করতে হবে। এই ফাংশনে পাস করা মোট প্যারামিটার তিনটি।

এখানে:

অবস্থানের পরামিতি সন্নিবেশ করাতে উপাদান অবস্থান নির্দিষ্ট করে। আকার 1-এর বেশি হলে, স্টার্ট পজিশন ইনডেক্স হবে পজিশন।
আকারের প্যারামিটারটি নির্দিষ্ট করে যে কতবার একটি উপাদান ঢোকানো হবে।
উপাদান পরামিতি একটি ভেক্টর মধ্যে ঢোকানো উপাদান লাগে.

দুটি স্ট্রিং সহ 'ছাত্র_নাম' ভেক্টর বিবেচনা করুন। দ্বিতীয় অবস্থানে পাঁচবার 'লাবণ্য' স্ট্রিংগুলি সন্নিবেশ করুন।

#include

ব্যবহার নামস্থান std ;

প্রধান ( )

{

// ভেক্টরের সূচনা করা হচ্ছে - student_names

ভেক্টর < স্ট্রিং > ছাত্রদের_নাম { 'শ্রাবণ কুমার' , 'ললিতা' } ;

cout << 'বিদ্যমান ভেক্টর: \n ' ;

জন্য ( স্বয়ংক্রিয় i : ছাত্রদের_নাম ) cout << i << endl ;

// দ্বিতীয় অবস্থানে 5 বার 'লাবণ্য' ঢোকান

ছাত্রদের_নাম সন্নিবেশ ( ছাত্রদের_নাম শুরু ( ) + 1 , 5 , 'লাবণ্য' ) ;

cout << ' \n চূড়ান্ত ভেক্টর: \n ' ;

জন্য ( স্বয়ংক্রিয় j : ছাত্রদের_নাম ) cout << j << endl ;

}

আউটপুট:

বিদ্যমান ভেক্টরে, 'শ্রাবণ কুমার' প্রথম অবস্থানে এবং 'ললিতা' দ্বিতীয় অবস্থানে রয়েছে। 'লাবণ্য' পাঁচবার (দ্বিতীয় অবস্থান থেকে ষষ্ঠ অবস্থানে) ঢোকানোর পরে, 'ললিতা' সপ্তম অবস্থানে (শেষ) চলে গেছে।

দৃশ্য 2: একাধিক উপাদান সন্নিবেশ করান

এই দৃশ্যে, আমরা অন্য ভেক্টর থেকে এক সময়ে বিভিন্ন উপাদান যোগ করি। আমরা এখানে একই ফাংশন ব্যবহার করি কিন্তু সিনট্যাক্স এবং প্যারামিটার পরিবর্তন হবে।

বাক্য গঠন:

ভেক্টর সন্নিবেশ ( অবস্থান, প্রথম_পুনরাবৃত্ত, দ্বিতীয়_পুনরাবৃত্ত ) ;

এখানে:

অবস্থানের পরামিতি সন্নিবেশ করাতে উপাদান অবস্থান নির্দিষ্ট করে।
'first_iterator' সেই প্রারম্ভিক অবস্থানটি নির্দিষ্ট করে যেখান থেকে উপাদানগুলি সন্নিবেশ করা হবে (মূলত, begin() ফাংশন ব্যবহার করে, একটি পুনরাবৃত্তিকারী ফেরত দেওয়া হয় যা কন্টেইনারে উপস্থিত প্রথম উপাদানটিকে নির্দেশ করে)।
'second_iterator' শেষের অবস্থানটি নির্দিষ্ট করে যতক্ষণ না উপাদানগুলি সন্নিবেশ করা হবে (মূলত, end() ফাংশন ব্যবহার করে, একটি পুনরাবৃত্তিকারী ফেরত দেওয়া হয় যা কন্টেইনারে উপস্থিত শেষ বিন্দুর পাশে থাকে)।

পূর্ণসংখ্যার প্রকারের দুটি ভেক্টর, 'মার্কস1' এবং 'মার্কস2' তৈরি করুন। 'marks2' ভেক্টরে উপস্থিত সমস্ত উপাদানগুলিকে 'marks1' ভেক্টরের প্রথম অবস্থানে প্রবেশ করান।

#include

ব্যবহার নামস্থান std ;

প্রধান ( )

{

// ভেক্টর শুরু করা হচ্ছে - মার্কস1

ভেক্টর < int > মার্কস1 { 100 , ৮৯ , 90 , 78 , 98 } ;

cout << 'প্রথম ভেক্টর: \n ' ;

জন্য ( স্বয়ংক্রিয় i : মার্কস1 ) cout << i << endl ;

// ভেক্টরের সূচনা - মার্কস2

ভেক্টর < int > চিহ্ন2 { 56 , চার পাঁচ , 65 } ;

cout << 'দ্বিতীয় ভেক্টর: \n ' ;

জন্য ( স্বয়ংক্রিয় j : চিহ্ন2 ) cout << j << endl ;

মার্কস1 সন্নিবেশ ( শুরু ( মার্কস1 ) , শুরু ( চিহ্ন2 ) , শেষ ( চিহ্ন2 ) ) ;

// চূড়ান্ত ভেক্টর

cout << 'প্রথম-ফাইনাল ভেক্টর: \n ' ;

জন্য ( স্বয়ংক্রিয় এক্স : মার্কস1 )

cout << এক্স << '' ;

}

আউটপুট:

প্রথম ভেক্টর (marks1) পাঁচটি উপাদান ধারণ করে এবং দ্বিতীয় ভেক্টর (marks2) তিনটি উপাদান ধারণ করে। আমরা 'ইনসার্ট' ফাংশনে begin (marks1), begin(marks2), end(marks2) প্যারামিটারগুলিকে পাস করেছি যাতে দ্বিতীয় ভেক্টরে উপস্থিত সমস্ত উপাদানগুলি পুনরাবৃত্তি করা হয় এবং শুরুতে প্রথম ভেক্টরে প্রবেশ করানো হয়। সুতরাং, প্রথম ভেক্টর আটটি উপাদান ধারণ করে।

একটি ভেক্টর থেকে উপাদান অ্যাক্সেস

1. [] অপারেটর ব্যবহার করা

কিছু পরিস্থিতিতে, আপনার ভেক্টর থেকে শুধুমাত্র নির্দিষ্ট উপাদানগুলি ফেরত দেওয়ার প্রয়োজন হতে পারে। সমস্ত উপাদান ফেরত প্রয়োজন হয় না. সুতরাং, সূচকের উপর ভিত্তি করে শুধুমাত্র নির্দিষ্ট উপাদানগুলি ফেরত দিতে, সূচক অপারেটর এবং at() ফাংশনগুলি ব্যবহার করা হয়।

বাক্য গঠন:

ভেক্টর [ index_position ]

C++ এ, যেকোনো ডেটা স্ট্রাকচারের জন্য ০ থেকে ইন্ডেক্সিং শুরু হয়। যদি উপাদানটি বিদ্যমান না থাকে তবে এটি খালি ফেরত দেয় (কোন ত্রুটি বা একটি সতর্কতা উত্থাপিত হয় না)।

পাঁচটি আইটেম সহ 'পণ্য' ভেক্টর বিবেচনা করুন। সূচক অবস্থান ব্যবহার করে এক এক করে সমস্ত উপাদান অ্যাক্সেস করুন।

#include

ব্যবহার নামস্থান std ;

প্রধান ( )

{

// ভেক্টর তৈরি করুন - 5টি স্ট্রিং সহ পণ্য

ভেক্টর < স্ট্রিং > পণ্য { 'সাবান' , 'শ্যাম্পু' , 'তেল' , 'ফল' , 'সবজি' } ;

// পণ্য থেকে উপাদান অ্যাক্সেস

cout << 'প্রথম উপাদান:' << পণ্য [ 0 ] << endl ;

cout << 'দ্বিতীয় উপাদান:' << পণ্য [ 1 ] << endl ;

cout << 'তৃতীয় উপাদান:' << পণ্য [ 2 ] << endl ;

cout << 'চতুর্থ উপাদান:' << পণ্য [ 3 ] << endl ;

cout << 'পঞ্চম উপাদান:' << পণ্য [ 4 ] << endl ;

// 9ম উপাদান অ্যাক্সেস করার চেষ্টা করুন

cout << 'নবম উপাদান:' << পণ্য [ 8 ] << endl ;

}

আউটপুট:

সূচক 8 এ কোন উপাদান নেই। তাই, খালি ফেরত দেওয়া হয়।

2. At() ফাংশন ব্যবহার করা

At() হল একটি সদস্য ফাংশন যা পূর্ববর্তী ব্যবহারের ক্ষেত্রে অনুরূপ কিন্তু এটি 'std::out_of_range' ব্যতিক্রম প্রদান করে যখন রেঞ্জের বাইরে সূচী প্রদান করা হয়।

বাক্য গঠন:

ভেক্টর এ ( index_position )

আমাদের এই ফাংশনে সূচক অবস্থান পাস করতে হবে।

পাঁচটি আইটেম সহ 'পণ্য' ভেক্টর বিবেচনা করুন। ইনডেক্স পজিশন ব্যবহার করে একে একে সমস্ত উপাদান অ্যাক্সেস করুন এবং 9ম অবস্থানে উপস্থিত উপাদানটি অ্যাক্সেস করার চেষ্টা করুন।

#include

ব্যবহার নামস্থান std ;

প্রধান ( )

{

// ভেক্টর তৈরি করুন - 5টি স্ট্রিং সহ পণ্য

ভেক্টর < স্ট্রিং > পণ্য { 'সাবান' , 'শ্যাম্পু' , 'তেল' , 'ফল' , 'সবজি' } ;

// পণ্য থেকে উপাদান অ্যাক্সেস

cout << 'প্রথম উপাদান:' << পণ্য এ ( 0 ) << endl ;

cout << 'দ্বিতীয় উপাদান:' << পণ্য এ ( 1 ) << endl ;

cout << 'তৃতীয় উপাদান:' << পণ্য এ ( 2 ) << endl ;

cout << 'চতুর্থ উপাদান:' << পণ্য এ ( 3 ) << endl ;

cout << 'পঞ্চম উপাদান:' << পণ্য এ ( 4 ) << endl ;

// ভেক্টরে না থাকা উপাদানগুলি অ্যাক্সেস করা

cout << 'নবম উপাদান:' << পণ্য এ ( 8 ) << endl ;

}

আউটপুট:

9ম উপাদান অ্যাক্সেস করার জন্য একটি ত্রুটি ঘটে:

একটি দৃষ্টান্ত নিক্ষেপ করার পর বলা বন্ধ 'std::out_of_range'

কি ( ) : ভেক্টর :: _এম_রেঞ্জ_চেক : __n ( যা হলো 8 ) >= এই - > আকার ( ) ( যা হলো 5 )

একটি ভেক্টরে একটি উপাদান আপডেট করুন

1. [] অপারেটর ব্যবহার করা

ইনডেক্স পজিশন ব্যবহার করে আমরা ভেক্টরের উপাদান আপডেট করতে পারি। [] অপারেটর আপডেট করা উপাদানটির সূচক অবস্থান নেয়। নতুন উপাদান এই অপারেটর বরাদ্দ করা হবে.

বাক্য গঠন:

ভেক্টর [ index_position ] = উপাদান

পাঁচটি মান সহ 'ছাত্র_মার্কস' ভেক্টর বিবেচনা করুন। সূচক 1 এবং 3 এ উপস্থিত উপাদানগুলি আপডেট করুন।

# অন্তর্ভুক্ত করুন

# অন্তর্ভুক্ত <ভেক্টর>

ব্যবহার নামস্থান std ;

প্রধান ( )

{

// ভেক্টর তৈরি করুন - ছাত্র_মার্কস

ভেক্টর < int > ছাত্র_মার্কস { 98 , 78 , 90 , 67 , ৮৯ } ;

cout << 'বিদ্যমান চিহ্ন:' << endl ;

জন্য ( int itr : ছাত্র_মার্কস )

cout << itr << endl ;

// 100 সহ index-3 এ উপাদান আপডেট করুন

ছাত্র_মার্কস [ 3 ] = 100 ;

// সূচী-১ এ 60 সহ উপাদান আপডেট করুন

ছাত্র_মার্কস [ 1 ] = 60 ;

cout << 'চূড়ান্ত মার্কস:' << endl ;

জন্য ( int itr : ছাত্র_মার্কস )

cout << itr << endl ;

}

আউটপুট:

আমরা দেখতে পাচ্ছি যে চূড়ান্ত ভেক্টরটি সূচক 1 এবং 3 এ আপডেট উপাদানগুলি ধারণ করে।

2. At() ফাংশন ব্যবহার করা

ইনডেক্স অপারেটরের অনুরূপ, at() মূলত একটি সদস্য ফাংশন যা একটি পুনরাবৃত্তিকারীর সূচকের উপর ভিত্তি করে মান আপডেট করে। যদি এই ফাংশনের ভিতরে নির্দিষ্ট করা সূচীটি বিদ্যমান না থাকে তবে 'std::out_of_range' ব্যতিক্রমটি নিক্ষেপ করা হয়।

ভেক্টর এ ( index_position ) = উপাদান

পাঁচটি আইটেম সহ 'পণ্য' ভেক্টর বিবেচনা করুন। অন্যান্য উপাদানের সাথে ভেক্টরে উপস্থিত সমস্ত উপাদান আপডেট করুন।

#include

ব্যবহার নামস্থান std ;

প্রধান ( )

{

// ভেক্টর তৈরি করুন - 5টি স্ট্রিং সহ পণ্য

ভেক্টর < স্ট্রিং > পণ্য { 'সাবান' , 'শ্যাম্পু' , 'তেল' , 'ফল' , 'সবজি' } ;

cout << 'বিদ্যমান পণ্য: ' << endl ;

জন্য ( স্ট্রিং itr : পণ্য )

cout << itr << endl ;

//সব স্ট্রিং আপডেট করা হচ্ছে

পণ্য এ ( 0 ) = 'কেক' ;

পণ্য এ ( 1 ) = 'চকলেট' ;

পণ্য এ ( 2 ) = 'ফল' ;

পণ্য এ ( 3 ) = 'পেঁয়াজ' ;

পণ্য এ ( 4 ) = 'কোমল পানীয়' ;

cout << ' \n চূড়ান্ত পণ্য: ' << endl ;

জন্য ( স্ট্রিং itr : পণ্য )

cout << itr << endl ;

}

আউটপুট:

একটি ভেক্টর থেকে একটি নির্দিষ্ট উপাদান সরান

C++ এ, std::vector::erase() ফাংশন একটি ভেক্টর থেকে উপাদানের একটি নির্দিষ্ট উপাদান/পরিসীমা অপসারণ করতে ব্যবহৃত হয়। উপাদানগুলি পুনরাবৃত্তিকারী অবস্থানের উপর ভিত্তি করে সরানো হয়।

বাক্য গঠন:

ভেক্টর মুছে ফেলা ( পুনরাবৃত্তিকারী অবস্থান )

একটি ভেক্টর থেকে নির্দিষ্ট উপাদান অপসারণের জন্য সিনট্যাক্স দেখুন। আমরা শুরু () বা শেষ() ফাংশন ব্যবহার করে ভেক্টরে যে উপাদানটি অপসারণ করতে হবে তার অবস্থান পেতে পারি।

পাঁচটি আইটেম সহ 'পণ্য' ভেক্টর বিবেচনা করুন।

Begin() iterator উল্লেখ করে তৃতীয় উপাদানটি সরান। Begin() ভেক্টরের প্রথম উপাদানটিকে নির্দেশ করে। যদি আমরা এই ফাংশনে দুটি যোগ করি, এটি তৃতীয় উপাদানের দিকে নির্দেশ করে।
end() পুনরাবৃত্তিকারী নির্দিষ্ট করে শেষ উপাদানটি সরান। End() ভেক্টরের শেষ উপাদানটিকে নির্দেশ করে।

#include

ব্যবহার নামস্থান std ;

প্রধান ( )

{

// ভেক্টর তৈরি করুন - 5টি স্ট্রিং সহ পণ্য

ভেক্টর < স্ট্রিং > পণ্য { 'সাবান' , 'শ্যাম্পু' , 'তেল' , 'ফল' , 'সবজি' } ;

cout << 'বিদ্যমান পণ্য: ' << endl ;

জন্য ( স্ট্রিং itr : পণ্য )

cout << itr << endl ;

// 3য় উপাদান সরান

পণ্য মুছে ফেলা ( পণ্য শুরু ( ) + 2 ) ;

cout << ' \n 3য় উপাদান অপসারণের পরে: \n ' ;

জন্য ( স্ট্রিং itr : পণ্য )

cout << itr << endl ;

// শেষ উপাদান সরান

পণ্য মুছে ফেলা ( পণ্য শেষ ( ) ) ;

cout << ' \n শেষ উপাদান অপসারণের পরে: \n ' ;

জন্য ( স্ট্রিং itr : পণ্য )

cout << itr << endl ;

}

আউটপুট:

এখন, শুধুমাত্র তিনটি উপাদান ('সাবান', 'শ্যাম্পু', 'ফল') 'পণ্য' ভেক্টরে বিদ্যমান।

একটি ভেক্টর থেকে সমস্ত উপাদান সরান

দৃশ্য 1: একটি ভেক্টর থেকে উপাদানের একটি পরিসর সরান

চলুন std::vector::erase() ফাংশনটি একটি পরিসরের একাধিক উপাদান অপসারণ করতে ব্যবহার করি।

বাক্য গঠন:

ভেক্টর মুছে ফেলা ( পুনরাবৃত্তিকারী প্রথম, পুনরাবৃত্তিকারী শেষ )

দুটি পুনরাবৃত্তিকারী (begin() প্রথম এলিমেন্টের পয়েন্ট এবং শেষ () শেষ এলিমেন্ট ফাংশন পয়েন্ট করে) রেঞ্জ নির্দিষ্ট করতে ব্যবহৃত হয়।

পাঁচটি আইটেম সহ 'পণ্য' ভেক্টর বিবেচনা করুন এবং দ্বিতীয় অবস্থান থেকে সমস্ত উপাদান সরান। এটি অর্জন করতে, প্রথম পুনরাবৃত্তিকারীটি হল শুরু (পণ্য)+1 যা দ্বিতীয় উপাদানকে নির্দেশ করে এবং দ্বিতীয় পুনরাবৃত্তিকারীটি শেষ (পণ্য)।

#include

ব্যবহার নামস্থান std ;

প্রধান ( )

{

// ভেক্টর তৈরি করুন - 5টি স্ট্রিং সহ পণ্য

ভেক্টর < স্ট্রিং > পণ্য { 'সাবান' , 'শ্যাম্পু' , 'তেল' , 'ফল' , 'সবজি' } ;

cout << 'বিদ্যমান পণ্য: ' << endl ;

জন্য ( স্ট্রিং itr : পণ্য )

cout << itr << endl ;

// দ্বিতীয় অবস্থান থেকে সমস্ত উপাদান সরান

পণ্য মুছে ফেলা ( শুরু ( পণ্য ) + 1 ,শেষ ( পণ্য ) ) ;

cout << ' \n চূড়ান্ত পণ্য: \n ' ;

জন্য ( স্ট্রিং itr : পণ্য )

cout << itr << endl ;

}

আউটপুট:

এখন, শুধুমাত্র একটি উপাদান ('সাবান') যা 'পণ্য' ভেক্টরে উপস্থিত রয়েছে।

দৃশ্য 2: ভেক্টর থেকে সমস্ত উপাদান সরান

চলুন ব্যবহার করা যাক std::vector::clear() ভেক্টর থেকে সমস্ত উপাদান অপসারণের ফাংশন।

বাক্য গঠন:

ভেক্টর পরিষ্কার ( )

এই ফাংশনে কোন পরামিতি পাস করা হয় না।

একই ভেক্টর বিবেচনা করুন যা প্রথম দৃশ্যে ব্যবহার করা হয়েছিল এবং clear() ফাংশন ব্যবহার করে সমস্ত উপাদান সরিয়ে ফেলুন।

#include

ব্যবহার নামস্থান std ;

প্রধান ( )

{

// ভেক্টর তৈরি করুন - 5টি স্ট্রিং সহ পণ্য

ভেক্টর < স্ট্রিং > পণ্য { 'সাবান' , 'শ্যাম্পু' , 'তেল' , 'ফল' , 'সবজি' } ;

cout << 'বিদ্যমান পণ্য: ' << endl ;

জন্য ( স্ট্রিং itr : পণ্য )

cout << itr << endl ;

// পণ্য থেকে সমস্ত উপাদান সরান

পণ্য পরিষ্কার ( ) ;

cout << ' \n চূড়ান্ত পণ্য: \n ' ;

জন্য ( স্ট্রিং itr : পণ্য )

cout << itr << endl ;

}

আউটপুট:

আমরা দেখতে পাচ্ছি যে 'পণ্য' ভেক্টরে কোন উপাদান নেই।

ভেক্টর ইউনিয়ন

std::set_union() ফাংশন ব্যবহার করে ভেক্টরগুলিতে UNION অপারেশন করা সম্ভব। ইউনিয়ন ডুপ্লিকেট উপাদান উপেক্ষা করে ভেক্টর থেকে অনন্য উপাদান ফেরত দেয়। আমাদের এই ফাংশনে উভয় পুনরাবৃত্তিকারী পাস করতে হবে। এর সাথে, একটি আউটপুট পুনরাবৃত্তিকারীকে পাস করতে হবে যা উভয় পুনরাবৃত্তিকারী দ্বারা ফিরে আসা ফলাফল সংরক্ষণ করে।

বাক্য গঠন:

সেট_ইউনিয়ন ( InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, OutputIterator রেস ) ;

এখানে:

'first1' প্রথম পুনরাবৃত্তিকারীর (ভেক্টর) প্রথম উপাদানটিকে নির্দেশ করে।
'last1' প্রথম পুনরাবৃত্তিকারীর (ভেক্টর) শেষ উপাদানটিকে নির্দেশ করে।
'প্রথম2' দ্বিতীয় পুনরাবৃত্তিকারীর (ভেক্টর) প্রথম উপাদানটিকে নির্দেশ করে।
'last2' দ্বিতীয় পুনরাবৃত্তিকারীর (ভেক্টর) শেষ উপাদানটিকে নির্দেশ করে।

দুটি ভেক্টর তৈরি করুন - 'বিষয় 1' এবং 'বিষয় 2' - টাইপ পূর্ণসংখ্যার।

সর্ট() ফাংশন ব্যবহার করে ইটারেটর পাস করে দুটি ভেক্টর সাজান।
একটি আউটপুট ভেক্টর (ইটারেটর) তৈরি করুন।
std::set_union() ফাংশন ব্যবহার করে এই দুটি ভেক্টরের মিলন খুঁজুন। প্রথম পুনরাবৃত্তিকারী হিসাবে begin() এবং শেষ পুনরাবৃত্তিকারী হিসাবে end() ব্যবহার করুন।
ফাংশন দ্বারা ফিরে আসা উপাদানগুলি প্রদর্শন করতে আউটপুট ভেক্টর পুনরাবৃত্তি করুন।

# অন্তর্ভুক্ত <অ্যালগরিদম>

# অন্তর্ভুক্ত করুন

# অন্তর্ভুক্ত <ভেক্টর>

ব্যবহার নামস্থান std ;

প্রধান ( )

{

// ভেক্টর তৈরি করুন - মার্কস1

ভেক্টর < int > মার্কস1 = { 100 , 90 , 80 , 70 , 60 } ;

// ভেক্টর তৈরি করুন - মার্কস2

ভেক্টর < int > চিহ্ন2 = { 80 , 90 , 60 , 70 , 100 } ;

// উভয় ভেক্টর সাজান

সাজান ( মার্কস1 শুরু ( ) , মার্কস1। শেষ ( ) ) ;

সাজান ( চিহ্ন2। শুরু ( ) , চিহ্ন2। শেষ ( ) ) ;

ভেক্টর < int > আউটপুটভেক্টর ( মার্কস1 আকার ( ) + চিহ্ন2। আকার ( ) ) ;

ভেক্টর < int > :: পুনরাবৃত্তিকারী i, s ;

i = সেট_ইউনিয়ন ( মার্কস1 শুরু ( ) , মার্কস1। শেষ ( ) ,

চিহ্ন2। শুরু ( ) , চিহ্ন 2। শেষ ( ) ,

আউটপুটভেক্টর। শুরু ( ) ) ;

cout << ' \n মার্কস1 ইউ মার্কস2: \n ' ;

জন্য ( s = আউটপুটভেক্টর। শুরু ( ) ; s ! = i ; ++ s )

cout << * s << '' << ' \n ' ;

}

আউটপুট:

উভয় ভেক্টরে মাত্র পাঁচটি অনন্য উপাদান রয়েছে (বিষয় 1 এবং বিষয় 2)।

ভেক্টরের ছেদ

std::set_intersection() ফাংশন ব্যবহার করে দুটি ভেক্টরের ছেদ খুঁজে পাওয়া সম্ভব। ছেদ উভয় ভেক্টরে উপস্থিত উপাদানগুলি প্রদান করে।

বাক্য গঠন:

সেট_ছেদ ( InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, OutputIterator রেস ) ;

সেট_ইউনিয়ন() ফাংশনে পাস করা প্যারামিটারগুলি এই set_intersection() ফাংশনেও পাস করা যেতে পারে।

দুটি ভেক্টর তৈরি করুন - 'বিষয় 1' এবং 'বিষয় 2' - টাইপ পূর্ণসংখ্যার।

সর্ট() ফাংশন ব্যবহার করে ইটারেটর পাস করে দুটি ভেক্টর সাজান।
একটি আউটপুট ভেক্টর (ইটারেটর) তৈরি করুন।
std::set_intersection() ফাংশন ব্যবহার করে এই দুটি ভেক্টরের ছেদ খুঁজে বের করুন। প্রথম পুনরাবৃত্তিকারী হিসাবে begin() এবং শেষ পুনরাবৃত্তিকারী হিসাবে end() ব্যবহার করুন।
ফাংশন দ্বারা ফিরে আসা উপাদানগুলি প্রদর্শন করতে আউটপুট ভেক্টর পুনরাবৃত্তি করুন।

# অন্তর্ভুক্ত <অ্যালগরিদম>

# অন্তর্ভুক্ত করুন

# অন্তর্ভুক্ত <ভেক্টর>

ব্যবহার নামস্থান std ;

প্রধান ( )

{

// ভেক্টর তৈরি করুন - মার্কস1

ভেক্টর < int > মার্কস1 = { 100 , 10 , 80 , 40 , 60 } ;

// ভেক্টর তৈরি করুন - মার্কস2

ভেক্টর < int > চিহ্ন2 = { পঞ্চাশ , 90 , 60 , 10 , 100 } ;

// উভয় ভেক্টর সাজান

সাজান ( মার্কস1 শুরু ( ) , মার্কস1। শেষ ( ) ) ;

সাজান ( চিহ্ন2। শুরু ( ) , চিহ্ন2। শেষ ( ) ) ;

ভেক্টর < int > আউটপুটভেক্টর ( মার্কস1 আকার ( ) + চিহ্ন2। আকার ( ) ) ;

ভেক্টর < int > :: পুনরাবৃত্তিকারী i, s ;

i = সেট_ছেদ ( মার্কস1 শুরু ( ) , মার্কস1। শেষ ( ) ,

চিহ্ন2। শুরু ( ) , চিহ্ন 2। শেষ ( ) ,

আউটপুটভেক্টর। শুরু ( ) ) ;

cout << ' \n চিহ্ন 1 ∩ চিহ্ন 2: \n ' ;

জন্য ( s = আউটপুটভেক্টর। শুরু ( ) ; s ! = i ; ++ s )

cout << * s << '' << ' \n ' ;

}

আউটপুট:

উভয় ভেক্টরে মাত্র তিনটি উপাদান উপস্থিত রয়েছে (বিষয় 1 এবং বিষয় 2)।

ভেক্টর খালি কি না তা পরীক্ষা করুন

ভেক্টরগুলিতে কাজ করার আগে, ভেক্টরটি খালি আছে কিনা তা পরীক্ষা করা গুরুত্বপূর্ণ। সফ্টওয়্যার প্রজেক্টে CRUD অপারেশন ইত্যাদির মতো অপারেশন করার আগে ভেক্টরটি খালি আছে কি না তা পরীক্ষা করাও একটি ভাল অভ্যাস।

1. Std::vector::empty() ব্যবহার করে

ভেক্টর খালি থাকলে এই ফাংশনটি 1 প্রদান করে (কোন উপাদান ধারণ করে না)। অন্যথায়, 0 ফেরত দেওয়া হয়। এই ফাংশনে কোন প্যারামিটার পাস করা হয় না।

2. ব্যবহার করে Std::vector::size()

std::vector::size() ফাংশনটি পূর্ণসংখ্যা প্রদান করে যা ভেক্টরে উপস্থিত মোট উপাদানের সংখ্যাকে প্রতিনিধিত্ব করে।

দুটি ভেক্টর তৈরি করুন - 'college1' এবং 'college2'। 'College1' পাঁচটি উপাদান ধারণ করে এবং 'college2' খালি। উভয় ভেক্টরে উভয় ফাংশন প্রয়োগ করুন এবং আউটপুট পরীক্ষা করুন।

# অন্তর্ভুক্ত <অ্যালগরিদম>

# অন্তর্ভুক্ত করুন

# অন্তর্ভুক্ত <ভেক্টর>

ব্যবহার নামস্থান std ;

প্রধান ( )

{

// ভেক্টর তৈরি করুন - কলেজ1

ভেক্টর < স্ট্রিং > কলেজ1 = { 'কলেজ-এ' , 'কলেজ-বি' , 'কলেজ-সি' , 'কলেজ-ডি' , 'কলেজ-ই' } ;

// ভেক্টর তৈরি করুন - কলেজ2

ভেক্টর < স্ট্রিং > কলেজ2 ;

// খালি()

cout << কলেজ1. খালি ( ) << endl ;

cout << কলেজ2। খালি ( ) << endl ;

// আকার()

cout << কলেজ1. আকার ( ) << endl ;

cout << কলেজ2। আকার ( ) << endl ;

}

আউটপুট:

খালি() ফাংশন 'college1' এর জন্য 0 এবং 'college2' এর জন্য 1 প্রদান করে। সাইজ() ফাংশন 'college1' এর জন্য পাঁচটি এবং 'college2' এর জন্য 0 প্রদান করে।

Const_Iterator ব্যবহার করে একটি ভেক্টর অতিক্রম করুন

আপনি যখন সেট, ভেক্টর ইত্যাদির মতো C++ পাত্রে কাজ করছেন, তখন কনটেইনারে উপস্থিত সমস্ত উপাদানগুলিকে পরিবর্তন না করেই পুনরাবৃত্তি করা সম্ভব। দ্য const_iterator এই দৃশ্যকল্প অর্জন যে পুনরাবৃত্তিকারী এক. cbegin() (ভেক্টরের প্রথম উপাদানের দিকে নির্দেশ করে) এবং cend() (ভেক্টরের শেষ উপাদানের দিকে নির্দেশ করে) হল প্রতিটি কন্টেইনার দ্বারা প্রদত্ত দুটি ফাংশন যা ধ্রুবক পুনরাবৃত্তিকারীকে শুরু এবং শেষে ফিরিয়ে আনতে ব্যবহৃত হয় ধারক ভেক্টর পুনরাবৃত্তি করার সময়, আমরা এই দুটি ফাংশন ব্যবহার করতে পারি।

আসুন পাঁচটি স্ট্রিং সহ 'বিভাগ' নামে একটি ভেক্টর তৈরি করি।
একটি const_iterator ঘোষণা করুন – প্রকারের ctr।
“for” লুপ ব্যবহার করে পূর্ববর্তী পুনরাবৃত্ত ব্যবহার করে বিভাগগুলিতে পুনরাবৃত্তি করুন এবং এটি প্রদর্শন করুন।

# অন্তর্ভুক্ত করুন

# অন্তর্ভুক্ত <ভেক্টর>

ব্যবহার নামস্থান std ;

প্রধান ( )

{

// ভেক্টর তৈরি করুন - বিভাগগুলি

ভেক্টর < স্ট্রিং > বিভাগ = { 'বিক্রয়' , 'পরিষেবা' ,

'HR' , 'IT' , 'অন্যান্য' } ;

ভেক্টর < স্ট্রিং > :: const_iterator ctr ;

// const_iterator - ctr ব্যবহার করে বিভাগগুলিতে পুনরাবৃত্তি করুন।

জন্য ( ctr = বিভাগ শুরু ( ) ; ctr ! = বিভাগ কিছু ( ) ; ctr ++ ) {

cout << * ctr << endl ;

}

}

আউটপুট:

Reverse_Iterator ব্যবহার করে একটি ভেক্টর অতিক্রম করুন

দ্য reverse_iterator এটি একটি পুনরাবৃত্তিকারী যা const_iterator এর অনুরূপ তবে এটি উপাদানগুলিকে বিপরীতে ফিরিয়ে দেয়। rbegin() (ভেক্টরের শেষ উপাদানের দিকে নির্দেশ করে) এবং rend() (ভেক্টরের প্রথম উপাদানের দিকে নির্দেশ করে) হল প্রতিটি ধারক দ্বারা প্রদত্ত দুটি ফাংশন যা ধ্রুবক পুনরাবৃত্তিকারীকে শেষ এবং শুরুতে ফিরিয়ে দিতে ব্যবহৃত হয় ধারক

আসুন পাঁচটি স্ট্রিং সহ 'বিভাগ' নামে একটি ভেক্টর তৈরি করি।
একটি reverse_iterator ঘোষণা করুন – টাইপের rtr।
“for” লুপ ব্যবহার করে পূর্ববর্তী পুনরাবৃত্ত ব্যবহার করে বিভাগগুলিতে পুনরাবৃত্তি করুন এবং এটি প্রদর্শন করুন।

# অন্তর্ভুক্ত করুন

# অন্তর্ভুক্ত <ভেক্টর>

ব্যবহার নামস্থান std ;

প্রধান ( )

{

// ভেক্টর তৈরি করুন - বিভাগগুলি

ভেক্টর < স্ট্রিং > বিভাগ = { 'বিক্রয়' , 'পরিষেবা' ,

'HR' , 'IT' , 'অন্যান্য' } ;

ভেক্টর < স্ট্রিং > :: reverse_iterator rtr ;

// reverse_iterator - rtr ব্যবহার করে বিভাগগুলিতে পুনরাবৃত্তি করুন।

জন্য ( rtr = বিভাগ আরম্ভ ( ) ; rtr ! = বিভাগ তোলে ( ) ; rtr ++ ) {

cout << * rtr << endl ;

}

}

আউটপুট:

উপাদানগুলিকে ভেক্টরে পুশ করুন

উপাদানগুলিকে ভেক্টরে পুশ করা বা যুক্ত করা একটি একমুখী সন্নিবেশ যা ব্যবহার করে করা যেতে পারে ভেক্টর ::পুশ_ব্যাক() ফাংশন

বাক্য গঠন:

ভেক্টর ফেরত পাঠাও ( উপাদান )

প্যারামিটার হিসাবে ভেক্টরে ধাক্কা দিতে একটি উপাদান লাগে।

আসুন পাঁচটি স্ট্রিং সহ “বিভাগ” নামে একটি খালি ভেক্টর তৈরি করি এবং push_back() ফাংশন ব্যবহার করে একের পর এক দুটি স্ট্রিং পুশ করি।

# অন্তর্ভুক্ত করুন

# অন্তর্ভুক্ত <ভেক্টর>

ব্যবহার নামস্থান std ;

প্রধান ( )

{

// ভেক্টর শুরু করুন - বিভাগগুলি

ভেক্টর < স্ট্রিং > বিভাগ ;

cout << 'প্রকৃত বিভাগ:' << endl ;

জন্য ( স্বয়ংক্রিয় itr = বিভাগ শুরু ( ) ; itr ! = বিভাগ শেষ ( ) ; ++ itr )

cout << * itr << endl ;

// পুশ 'বিক্রয়'

বিভাগ ফেরত পাঠাও ( 'বিক্রয়' ) ;

// এটা ধাক্কা দাও'

বিভাগ ফেরত পাঠাও ( 'IT' ) ;

cout << ' \n চূড়ান্ত বিভাগ:' << endl ;

জন্য ( স্বয়ংক্রিয় itr = বিভাগ শুরু ( ) ; itr ! = বিভাগ শেষ ( ) ; ++ itr )

cout << * itr << endl ;

}

আউটপুট:

প্রথমত, আমরা 'বিক্রয়' ধাক্কা দেই। এর পরে, 'IT' ভেক্টরে ঠেলে দেওয়া হয়। এখন, 'বিভাগ' ভেক্টর দুটি উপাদান ধারণ করে।

ভেক্টর থেকে উপাদানগুলি পপ করুন

আপনি যদি ভেক্টরে উপস্থিত শেষ আইটেমটি মুছতে চান, ব্যবহার করে ভেক্টর ::pop_back() ফাংশন হল সর্বোত্তম পন্থা। এটি ভেক্টরে উপস্থিত শেষ উপাদানটিকে মুছে ফেলে।

বাক্য গঠন:

ভেক্টর ফিরে পপ ( )

এই ফাংশনের জন্য কোন প্যারামিটারের প্রয়োজন নেই। এটি অনির্ধারিত আচরণ দেখায় যদি আমরা একটি খালি ভেক্টর থেকে শেষ উপাদানটি মুছে ফেলার চেষ্টা করি।

আসুন পাঁচটি স্ট্রিং সহ 'বিভাগ' নামে একটি খালি ভেক্টর তৈরি করি এবং আগের ফাংশনটি ব্যবহার করে শেষ উপাদানটি মুছে ফেলি। উভয় ক্ষেত্রে ভেক্টর প্রদর্শন করুন।

# অন্তর্ভুক্ত করুন

# অন্তর্ভুক্ত <ভেক্টর>

ব্যবহার নামস্থান std ;

প্রধান ( )

{

// ভেক্টর শুরু করুন - বিভাগগুলি

ভেক্টর < স্ট্রিং > বিভাগ = { 'বিক্রয়' , 'IT' , 'পরিষেবা' , 'বিপণন' , 'HR' } ;

cout << 'প্রকৃত বিভাগ:' << endl ;

জন্য ( স্বয়ংক্রিয় itr = বিভাগ শুরু ( ) ; itr ! = বিভাগ শেষ ( ) ; ++ itr )

cout << * itr << endl ;

// শেষ উপাদান মুছুন

বিভাগ ফিরে পপ ( ) ;

cout << ' \n চূড়ান্ত বিভাগ:' << endl ;

জন্য ( স্বয়ংক্রিয় itr = বিভাগ শুরু ( ) ; itr ! = বিভাগ শেষ ( ) ; ++ itr )

cout << * itr << endl ;

}

আউটপুট:

'এইচআর' হল শেষ উপাদান যা 'বিভাগ' ভেক্টরে উপস্থিত। সুতরাং, এটি ভেক্টর থেকে সরানো হয় এবং চূড়ান্ত ভেক্টর 'বিক্রয়', 'আইটি', 'পরিষেবা' এবং 'বিপণন' ধারণ করে।

ভেক্টর অদলবদল করুন

দ্য ভেক্টর::swap() C++ STL-এর ফাংশন দুটি ভেক্টরে উপস্থিত সমস্ত উপাদান অদলবদল করতে ব্যবহৃত হয়।

বাক্য গঠন:

প্রথম_ভেক্টর অদলবদল ( দ্বিতীয়_ভেক্টর )

এটি ভেক্টরের আকার বিবেচনা করে না তবে ভেক্টরগুলি একই ধরণের হওয়া উচিত (ভেক্টরের ধরন ভিন্ন হলে ত্রুটি নিক্ষেপ করা হয়)।

আসুন দুটি ভেক্টর তৈরি করি - 'ফল' এবং 'সবজি' - বিভিন্ন আকারের স্ট্রিং টাইপের। তাদের প্রতিটি অদলবদল করুন এবং উভয় ক্ষেত্রেই ভেক্টর প্রদর্শন করুন।

# অন্তর্ভুক্ত করুন

# অন্তর্ভুক্ত <ভেক্টর>

ব্যবহার নামস্থান std ;

প্রধান ( )

{

// ভেক্টর শুরু করুন - ফল

ভেক্টর < স্ট্রিং > ফল = { 'আপেল' , 'আম' } ;

cout << 'প্রকৃত ফল:' << endl ;

জন্য ( স্বয়ংক্রিয় itr = ফল শুরু ( ) ; itr ! = ফল শেষ ( ) ; ++ itr )

cout << * itr << endl ;

// ভেক্টর শুরু করুন - সবজি

ভেক্টর < স্ট্রিং > সবজি = { 'আলু' , 'টমেটো' , 'বেগুন' } ;

cout << ' \n আসল সবজি:' << endl ;

জন্য ( স্বয়ংক্রিয় itr = সবজি শুরু ( ) ; itr ! = সবজি শেষ ( ) ; ++ itr )

cout << * itr << endl ;

// উভয় ভেক্টরে উপাদান অদলবদল করুন

ফল অদলবদল ( সবজি ) ;

cout << ' \n অদলবদল করার পর ফল:' << endl ;

জন্য ( স্বয়ংক্রিয় itr = ফল শুরু ( ) ; itr ! = ফল শেষ ( ) ; ++ itr )

cout << * itr << endl ;

cout << ' \n অদলবদল করার পর সবজি:' << endl ;

জন্য ( স্বয়ংক্রিয় itr = সবজি শুরু ( ) ; itr ! = সবজি শেষ ( ) ; ++ itr )

cout << * itr << endl ;

}

আউটপুট:

পূর্বে, 'ফল' ভেক্টর দুটি উপাদান ধারণ করে এবং 'সবজি' ভেক্টর তিনটি উপাদান ধারণ করে। অদলবদল করার পরে, 'ফল' ভেক্টর তিনটি উপাদান ধারণ করে এবং 'সবজি' ভেক্টর দুটি উপাদান ধারণ করে।

ভেক্টর থেকে প্রথম উপাদানটি আনুন

কিছু ক্ষেত্রে, ভেক্টর থেকে শুধুমাত্র প্রথম উপাদানটি ফেরত দিতে হবে। C++ STL-এ ভেক্টর::front() ফাংশন ভেক্টর থেকে শুধুমাত্র প্রথম উপাদান নিয়ে আসে।

বাক্য গঠন:

ভেক্টর সামনে ( )

এই ফাংশন কোনো পরামিতি গ্রহণ করবে না। ভেক্টর খালি থাকলে, একটি ত্রুটি নিক্ষেপ করা হয়।

আসুন দুটি ভেক্টর তৈরি করি - 'ফল' এবং 'সবজি' - স্ট্রিং ধরণের এবং দুটি ভেক্টর থেকে আলাদাভাবে প্রথম উপাদানটি আনার চেষ্টা করি।

# অন্তর্ভুক্ত করুন

# অন্তর্ভুক্ত <ভেক্টর>

ব্যবহার নামস্থান std ;

প্রধান ( )

{

// ভেক্টর তৈরি করুন - 2টি উপাদান সহ ফল

ভেক্টর < স্ট্রিং > ফল = { 'আপেল' , 'আম' } ;

// প্রথম উপাদান ফেরত দিন

cout << ফল সামনে ( ) << endl ;

// ভেক্টর শুরু করুন - সবজি

ভেক্টর < স্ট্রিং > সবজি ;

// প্রথম উপাদানটি ফেরত দেওয়ার চেষ্টা করুন

cout << সবজি সামনে ( ) ;

}

আউটপুট:

'আপেল' হল প্রথম উপাদান যা 'ফল' ভেক্টরে উপস্থিত। সুতরাং, এটি ফেরত দেওয়া হয়। কিন্তু একটি ত্রুটি নিক্ষিপ্ত হয় যখন আমরা 'সবজি' ভেক্টর থেকে প্রথম উপাদানটি আনার চেষ্টা করি যেহেতু এটি খালি।

ভেক্টর থেকে শেষ উপাদানটি আনুন

C++ STL-এ ভেক্টর::end() ফাংশন ভেক্টর থেকে শুধুমাত্র শেষ উপাদান নিয়ে আসে।

বাক্য গঠন:

ভেক্টর পেছনে ( )

আসুন দুটি ভেক্টর তৈরি করি - 'ফল' এবং 'সবজি' - স্ট্রিং ধরণের এবং দুটি ভেক্টর থেকে আলাদাভাবে শেষ উপাদানটি আনার চেষ্টা করি।

# অন্তর্ভুক্ত করুন

# অন্তর্ভুক্ত <ভেক্টর>

ব্যবহার নামস্থান std ;

প্রধান ( )

{

// ভেক্টর তৈরি করুন - 2টি উপাদান সহ ফল

ভেক্টর < স্ট্রিং > ফল = { 'আপেল' , 'আম' } ;

// শেষ উপাদান আনুন

cout << ফল পেছনে ( ) << endl ;

// ভেক্টর শুরু করুন - সবজি

ভেক্টর < স্ট্রিং > সবজি ;

// শেষ উপাদান আনার চেষ্টা করুন

cout << সবজি পেছনে ( ) ;

}

আউটপুট:

'আম' হল শেষ উপাদান যা 'ফল' ভেক্টরে উপস্থিত। সুতরাং, এটি ফেরত দেওয়া হয়। কিন্তু একটি ত্রুটি নিক্ষিপ্ত হয় যখন আমরা 'সবজি' ভেক্টর থেকে শেষ উপাদানটি আনার চেষ্টা করি যেহেতু এটি খালি।

একটি ভেক্টরে নতুন মান বরাদ্দ করুন

কিছু পরিস্থিতিতে, আপনি যদি নতুন মান সহ সমস্ত মান আপডেট করতে চান বা একই মান সহ একটি ভেক্টর তৈরি করতে চান, ভেক্টর::assign() ফাংশনটি ব্যবহার করে সর্বোত্তম পদ্ধতি। এই ফাংশনটি ব্যবহার করে, আমরা করতে পারি:

সমস্ত অনুরূপ উপাদান দিয়ে ভেক্টর তৈরি করুন
একই উপাদান দিয়ে বিদ্যমান ভেক্টর পরিবর্তন করুন

বাক্য গঠন:

ভেক্টর বরাদ্দ করা ( আকার, মান )

এই ফাংশনের জন্য দুটি পরামিতি প্রয়োজন।

এখানে:

মাপ বরাদ্দ করা উপাদান সংখ্যা নির্দিষ্ট করে.
মান নির্ধারণ করা উপাদান নির্দিষ্ট করে.

আসুন পাঁচটি মান সহ 'মার্কস1' নামে একটি ভেক্টর তৈরি করি এবং এই ভেক্টরটিকে চারটি উপাদান সহ আপডেট করি যাতে আপডেট করা ভেক্টরের সমস্ত উপাদান 20 এর সমান হয়।

# অন্তর্ভুক্ত <অ্যালগরিদম>

# অন্তর্ভুক্ত করুন

# অন্তর্ভুক্ত <ভেক্টর>

ব্যবহার নামস্থান std ;

প্রধান ( )

{

// ভেক্টর তৈরি করুন - মার্কস1

ভেক্টর < int > মার্কস1 = { 100 , 90 , 80 , 70 , 60 } ;

cout << 'প্রকৃত ভেক্টর:' << endl ;

জন্য ( int i = 0 ; i < মার্কস1 আকার ( ) ; i ++ )

cout << মার্কস1 [ i ] << endl ;

মার্কস1 বরাদ্দ করা ( 4 , বিশ ) ;

cout << ' \n আপডেট করা ভেক্টর:' << endl ;

জন্য ( int i = 0 ; i < মার্কস1 আকার ( ) ; i ++ )

cout << মার্কস1 [ i ] << endl ;

}

আউটপুট:

পূর্বে, ভেক্টর পাঁচটি ভিন্ন উপাদান ধারণ করে। এখন, এটি মাত্র চারটি উপাদান ধারণ করে এবং সবগুলি 20 এর সমান।

Emplace() ব্যবহার করে ভেক্টর প্রসারিত করুন

আমরা ইতিমধ্যে জানি যে নতুন উপাদানগুলি একটি ভেক্টরের যেকোনো অবস্থানে গতিশীলভাবে সন্নিবেশিত হয়। এটি ভেক্টর::emplace() ফাংশন ব্যবহার করে সম্ভব। আসুন দ্রুত এই ফাংশন দ্বারা গৃহীত সিনট্যাক্স এবং পরামিতিগুলি দেখুন।

বাক্য গঠন:

ভেক্টর অবস্থান ( const_iterator অবস্থান, উপাদান )

দুটি বাধ্যতামূলক পরামিতি এই ফাংশন পাস করা হয়.

এখানে:

প্রথম প্যারামিটারটি অবস্থান নেয় যাতে আমরা যে কোনো অবস্থানে উপাদান সন্নিবেশ করতে পারি। আমরা begin() বা end() iterator ফাংশন ব্যবহার করে অবস্থান পেতে পারি।
দ্বিতীয় প্যারামিটারটি হল ভেক্টরের মধ্যে ঢোকানো উপাদান।

দুটি উপাদান সহ 'রাসায়নিক' ভেক্টর বিবেচনা করুন।

প্রথম অবস্থানে 'ম্যাঙ্গানিজ' ঢোকান - শুরু করুন (রাসায়নিক)
শেষ অবস্থানে 'কপার' ঢোকান - শেষ (রাসায়নিক)
তৃতীয় অবস্থানে 'সালফার' ঢোকান - শুরু (রাসায়নিক) +2

# অন্তর্ভুক্ত <অ্যালগরিদম>

# অন্তর্ভুক্ত করুন

# অন্তর্ভুক্ত <ভেক্টর>

ব্যবহার নামস্থান std ;

প্রধান ( )

{

// ভেক্টর তৈরি করুন - রাসায়নিক

ভেক্টর < স্ট্রিং > রাসায়নিক = { 'অক্সিজেন' , 'CO' } ;

cout << 'প্রকৃত রাসায়নিক:' << endl ;

জন্য ( int i = 0 ; i < রাসায়নিক আকার ( ) ; i ++ )

cout << রাসায়নিক [ i ] << endl ;

// প্রথম অবস্থানে উপাদান সন্নিবেশ করান

রাসায়নিক অবস্থান ( শুরু ( রাসায়নিক ) , 'ম্যাঙ্গানিজ' ) ;

// শেষ অবস্থানে উপাদান সন্নিবেশ করান

রাসায়নিক অবস্থান ( শেষ ( রাসায়নিক ) , 'তামা' ) ;

// তৃতীয় অবস্থানে উপাদান সন্নিবেশ করান

রাসায়নিক অবস্থান ( শুরু ( রাসায়নিক ) + 2 , 'সালফার' ) ;

cout << ' \n চূড়ান্ত রাসায়নিক:' << endl ;

জন্য ( int i = 0 ; i < রাসায়নিক আকার ( ) ; i ++ )

cout << রাসায়নিক [ i ] << endl ;

}

আউটপুট:

এখন, চূড়ান্ত ভেক্টর পাঁচটি উপাদান ধারণ করে (নিম্নলিখিত স্ক্রিনশটে দেওয়া)।

Emplace_Back() ব্যবহার করে ভেক্টর প্রসারিত করুন

একটি উপাদান যুক্ত করা যেতে পারে (ভেক্টরের শেষে যোগ করা) যা ব্যবহার করে করা যেতে পারে ভেক্টর ::emplace_back() ফাংশন

বাক্য গঠন:

ভেক্টর emplace_back ( উপাদান )

প্যারামিটার হিসাবে ভেক্টরের সাথে যুক্ত করা উপাদানটি পাস করা বাধ্যতামূলক।

emplace_back() ফাংশন ব্যবহার করে একের পর এক দুটি উপাদান যোগ করি।

# অন্তর্ভুক্ত <অ্যালগরিদম>

# অন্তর্ভুক্ত করুন

# অন্তর্ভুক্ত <ভেক্টর>

ব্যবহার নামস্থান std ;

প্রধান ( )

{

// ভেক্টর তৈরি করুন - রাসায়নিক

ভেক্টর < স্ট্রিং > রাসায়নিক = { 'অক্সিজেন' , 'CO' } ;

cout << 'প্রকৃত রাসায়নিক:' << endl ;

জন্য ( int i = 0 ; i < রাসায়নিক আকার ( ) ; i ++ )

cout << রাসায়নিক [ i ] << endl ;

// ভেক্টরের শেষে ম্যাঙ্গানিজ ঢোকান

রাসায়নিক emplace_back ( 'ম্যাঙ্গানিজ' ) ;

// ভেক্টরের শেষে ম্যাঙ্গানিজ ঢোকান

রাসায়নিক emplace_back ( 'তামা' ) ;

cout << ' \n চূড়ান্ত রাসায়নিক:' << endl ;

জন্য ( int i = 0 ; i < রাসায়নিক আকার ( ) ; i ++ )

cout << রাসায়নিক [ i ] << endl ;

}

আউটপুট:

এখন, 'ম্যাঙ্গানিজ' এবং 'কপার' যোগ করার পর চূড়ান্ত ভেক্টর চারটি উপাদান ধারণ করে।

একটি ভেক্টরের সর্বোচ্চ উপাদান

কিছু উপাদান দিয়ে একটি ভেক্টর তৈরি করুন।
ভেক্টরে উপস্থিত সর্বাধিক উপাদান খুঁজে পেতে, *max_element() ফাংশনটি ব্যবহার করুন যা দুটি পুনরাবৃত্তিকারীকে আর্গুমেন্ট হিসাবে গ্রহণ করে। এই দুটি পরামিতি পরিসীমা হিসাবে কাজ করে এবং প্রদত্ত সীমার মধ্যে সর্বাধিক উপাদান ফেরত দেওয়া হয়। প্রারম্ভিক অবস্থান হল begin() এবং শেষ অবস্থান হল end()।

* max_element ( প্রথম_সূচক, শেষ_সূচক )

আসুন 'item_costs' নামে একটি ভেক্টর বিবেচনা করি যা পাঁচটি পূর্ণসংখ্যার মান ধারণ করে এবং সর্বাধিক উপাদান প্রদান করে।

# অন্তর্ভুক্ত <ভেক্টর>

# অন্তর্ভুক্ত করুন

# অন্তর্ভুক্ত <অ্যালগরিদম>

ব্যবহার নামস্থান std ;

প্রধান ( )

{

// ভেক্টর তৈরি করুন - item_costs

ভেক্টর < int > আইটেম_খরচ = { 8900 , 5677 , 200 , 1000 , 2300 } ;

cout << 'আইটেমের খরচ: \n ' ;

জন্য ( int i = 0 ; i < আইটেম_খরচ। আকার ( ) ; i ++ )

cout << আইটেম_খরচ [ i ] << endl ;

// উপরের ভেক্টর থেকে সর্বাধিক উপাদান ফেরত দিন - item_costs

cout << ' \n সর্বোচ্চ খরচ: ' << * max_element ( শুরু ( আইটেম_খরচ ) ,শেষ ( আইটেম_খরচ ) ) ;

}

আউটপুট:

এখানে, 8900 হল 'item_costs' ভেক্টরে উপস্থিত সমস্ত উপাদানের মধ্যে সর্বাধিক উপাদান।

একটি ভেক্টরের সর্বনিম্ন উপাদান

কিছু উপাদান দিয়ে একটি ভেক্টর তৈরি করুন।
ভেক্টরে উপস্থিত ন্যূনতম উপাদানটি খুঁজে পেতে, *min_element() ফাংশনটি ব্যবহার করুন যা দুটি পুনরাবৃত্তিকারীকে আর্গুমেন্ট হিসাবে গ্রহণ করে। এই দুটি পরামিতি পরিসীমা হিসাবে কাজ করে এবং সর্বনিম্ন উপাদান (অন্যান্য সমস্ত উপাদানের চেয়ে কম) প্রদত্ত সীমার মধ্যে ফেরত দেওয়া হয়। প্রারম্ভিক অবস্থান হল begin() এবং শেষ অবস্থান হল end()।

* min_element ( প্রথম_সূচক, শেষ_সূচক )

সর্বাধিক উপাদান খুঁজে বের করতে এবং *min_element() ফাংশন ব্যবহার করে সর্বনিম্ন উপাদান খুঁজে পেতে তৈরি করা একই ভেক্টর ব্যবহার করুন।

# অন্তর্ভুক্ত <ভেক্টর>

# অন্তর্ভুক্ত করুন

# অন্তর্ভুক্ত <অ্যালগরিদম>

ব্যবহার নামস্থান std ;

প্রধান ( )

{

// ভেক্টর তৈরি করুন - item_costs

ভেক্টর < int > আইটেম_খরচ = { 8900 , 5677 , 200 , 1000 , 2300 } ;

cout << 'আইটেমের খরচ: \n ' ;

জন্য ( int i = 0 ; i < আইটেম_খরচ। আকার ( ) ; i ++ )

cout << আইটেম_খরচ [ i ] << endl ;

// উপরের ভেক্টর থেকে ন্যূনতম উপাদান ফেরত দিন - item_costs

cout << ' \n সর্বনিম্ন খরচ: ' << * min_element ( শুরু ( আইটেম_খরচ ) ,শেষ ( আইটেম_খরচ ) ) ;

}

আউটপুট:

এখানে, 200 হল 'item_costs' ভেক্টরে উপস্থিত সমস্ত উপাদানের মধ্যে সর্বনিম্ন উপাদান।

একটি ভেক্টরে উপাদানের সমষ্টি

ভেক্টরে উপস্থিত সমস্ত উপাদানের যোগফল ফেরাতে, জমা করা() C++ STL-এ ফাংশন ব্যবহার করা হয়। এটি তিনটি পরামিতি গ্রহণ করে। প্রথম প্যারামিটারটি প্রথম সূচকটি নেয় যা পরিসরের শুরুর উপাদানটিকে উপস্থাপন করে (begin() iterator নির্দিষ্ট করুন) এবং দ্বিতীয় প্যারামিটারটি শেষ সূচকটি নেয় যা পরিসরের শেষ উপাদানটিকে উপস্থাপন করে (শেষ() পুনরাবৃত্তিকারী নির্দিষ্ট করুন)। সবশেষে, আমাদের যোগফলের প্রাথমিক মান পাস করতে হবে (আমাদের ক্ষেত্রে, এটি 0)।

জমা করা ( first_index, last_index, initial_val ) ;

পাঁচটি পূর্ণসংখ্যার উপাদান সহ “item_costs” নামে একটি ভেক্টর তৈরি করুন এবং যোগফল গণনা করুন।

#include

ব্যবহার নামস্থান std ;

প্রধান ( )

{

// ভেক্টর তৈরি করুন - item_costs

ভেক্টর < int > আইটেম_খরচ = { 8900 , 5677 , 200 , 1000 , 2300 } ;

cout << 'আইটেমের খরচ: \n ' ;

জন্য ( int i = 0 ; i < আইটেম_খরচ। আকার ( ) ; i ++ )

cout << আইটেম_খরচ [ i ] << endl ;

// উপরের ভেক্টরের সমস্ত উপাদানের যোগফল ফিরিয়ে দিন - item_costs

cout << ' \n মোট খরচ: ' << জমা করা ( শুরু ( আইটেম_খরচ ) ,শেষ ( আইটেম_খরচ ) , 0 ) ;

}

আউটপুট:

8900, 5677, 200, 1000, 2300 এর যোগফল হল 18077।

দুটি ভেক্টরের উপাদান-ভিত্তিক গুণ

সংখ্যাসূচক টাইপ সহ দুটি ভেক্টর তৈরি করুন এবং দুটি ভেক্টর অবশ্যই একই আকারের হতে হবে (প্রথম ভেক্টরে উপস্থিত মোট উপাদানের সংখ্যা = দ্বিতীয় ভেক্টরে উপস্থিত উপাদানগুলির মোট সংখ্যা)।
একটি নতুন ভেক্টর ঘোষণা করুন এবং ব্যবহার করুন লুপের জন্য , প্রতিটি পুনরাবৃত্তির দুটি উপাদানের উপর গুণন ক্রিয়া সম্পাদন করুন এবং push_back() ফাংশন ব্যবহার করে তৈরি ভেক্টরে মান সংরক্ষণ করুন।

জন্য

(

int

;

আকার

(

)

;

)

{

ফেরত পাঠাও

(

[

]

[

]

)

;

}

এটি পুনরাবৃত্তি করে ফলাফল ভেক্টরে উপস্থিত উপাদানগুলি প্রদর্শন করুন।

#include

ব্যবহার নামস্থান std ;

প্রধান ( )

{

// দুটি ভেক্টর তৈরি করুন - প্রতিটি 5টি উপাদান সহ পণ্য1 এবং পণ্য2

ভেক্টর < int > পণ্য1 = { 10 , বিশ , 30 , 40 , পঞ্চাশ } ;

ভেক্টর < int > পণ্য2 = { পঞ্চাশ , 40 , 30 , 70 , 60 } ;

ভেক্টর < int > ফলাফল_পণ্য ;

// উপাদান অনুযায়ী গুণন সম্পাদন করুন

জন্য ( int i = 0 ; i < পণ্য1. আকার ( ) ; i ++ ) {

ফলাফল_পণ্য। ফেরত পাঠাও ( পণ্য1 [ i ] * পণ্য2 [ i ] ) ;

}

// ফলাফল ভেক্টর প্রদর্শন করুন

cout << 'ভেক্টর গুণন: \n ' ;

জন্য ( int res : ফলাফল_পণ্য )

cout << res << endl ;

}

আউটপুট:

পুনরাবৃত্তি - 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() ফাংশন ব্যবহার করুন। এই ফাংশনটি চারটি প্রয়োজনীয় পরামিতি নেয়।

এখানে:

প্রথম প্যারামিটারটি একটি পুনরাবৃত্তিকারীকে বোঝায় যা প্রথম ভেক্টরের শুরুতে নির্দেশ করে (begin() ফাংশন ব্যবহার করে নির্দিষ্ট করুন)।
দ্বিতীয় প্যারামিটারটি একটি পুনরাবৃত্তিকারীকে নির্দেশ করে যা প্রথম ভেক্টরের শেষের দিকে নির্দেশ করে (end() ফাংশন ব্যবহার করে নির্দিষ্ট করুন)।
তৃতীয় প্যারামিটারটি একটি পুনরাবৃত্তিকারীকে বোঝায় যা দ্বিতীয় ভেক্টরের শুরুতে নির্দেশ করে (begin() ফাংশন ব্যবহার করে নির্দিষ্ট করুন)।
প্রাথমিক মানটিকে শেষ প্যারামিটার হিসাবে পাস করতে হবে যা ডট পণ্যের সঞ্চয়ের জন্য একটি পূর্ণসংখ্যা।

দুটি ভেক্টরের গুণনের জন্য তৈরি করা একই প্রোগ্রামটি ব্যবহার করুন এবং দুটি ভেক্টরের ডট পণ্য খুঁজে পেতে innsr_product() ফাংশনটি ব্যবহার করুন।

#include

ব্যবহার নামস্থান std ;

প্রধান ( )

{

// দুটি ভেক্টর তৈরি করুন - প্রতিটি 5টি উপাদান সহ পণ্য1 এবং পণ্য2

ভেক্টর < int > পণ্য1 = { 10 , বিশ , 30 , 40 , পঞ্চাশ } ;

ভেক্টর < int > পণ্য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() ফাংশন ব্যবহার করা।

বাক্য গঠন

std :: অনুলিপি ( sourceIterator প্রথমে, sourceIterator শেষ, destinationIterator প্রথমে )

ব্যবহার std::কপি() ফাংশন যা একটি সেট থেকে উপাদানগুলিকে ভেক্টরে সন্নিবেশিত করে। এটি তিনটি পরামিতি লাগে।

এখানে:

প্রথম প্যারামিটারটি উত্স পুনরাবৃত্তিকারীকে বোঝায় যা পুনরাবৃত্তিকারীর প্রথম উপাদানটিকে নির্দেশ করে। এখানে, সেট হল সোর্স ইটারেটর যা begin() ফাংশন ব্যবহার করে নির্দিষ্ট করা হয়।
একইভাবে, দ্বিতীয় প্যারামিটারটি শেষ উপাদান (end() ফাংশনকে নির্দেশ করে।
তৃতীয় প্যারামিটারটি গন্তব্য পুনরাবৃত্তিকারীকে নির্দেশ করে যেটি ইটারেটারে প্রথম উপাদান (begin() ফাংশন ব্যবহার করে নির্দিষ্ট করা হয়েছে) নির্দেশ করে।

চলুন পাঁচজন শিক্ষার্থীর সাথে একটি সেট তৈরি করি এবং পূর্ববর্তী ফাংশন ব্যবহার করে সমস্ত উপাদানকে একটি ভেক্টরে কপি করি।

#include

ব্যবহার নামস্থান std ;

প্রধান ( )

{

// একটি সেট তৈরি করুন - 5টি উপাদান সহ শিক্ষার্থীরা

সেট < স্ট্রিং > ছাত্রদের = { 'শ্রাবণ' , 'ববি' , 'মধু' , 'মেঘনা' , 'লাবণ্য' } ;

cout << 'সেট: \n ' ;

জন্য ( স্ট্রিং i : ছাত্রদের )

cout << i << endl ;

// ভেক্টর তৈরি করুন - student_vcof আকার সেটের আকারের সমান

ভেক্টর < স্ট্রিং > ছাত্র_ভিসি ( ছাত্রদের আকার ( ) ) ;

// একটি সেট থেকে উপাদান সন্নিবেশ করান - ছাত্ররা একটি ভেক্টর - ছাত্র_ভিসিতে।

অনুলিপি ( ছাত্রদের শুরু ( ) , ছাত্র. শেষ ( ) , student_vc. শুরু ( ) ) ;

cout << ' \n ভেক্টর: \n ' ;

জন্য ( স্ট্রিং i : ছাত্র_ভিসি )

cout << i << endl ;

}

আউটপুট:

এখন, 'ছাত্র' সেটে উপস্থিত সমস্ত উপাদানগুলি 'students_vc' ভেক্টরে অনুলিপি করা হয়েছে।

ডুপ্লিকেট উপাদানগুলি সরান

প্রথমে, আমাদের ভেক্টরের উপাদানগুলিকে সাজাতে হবে যাতে সমস্ত সদৃশ উপাদানগুলি একে অপরের সংলগ্ন হয় std::sort() ফাংশন

সাজান

(

)

;

std::unique() ফাংশন ব্যবহার করুন যাতে ডুপ্লিকেট উপাদান নির্বাচন করা হয়। একই সময়ে, std::unique() ফাংশন দ্বারা ফিরে আসা সদৃশগুলি সরাতে erase() ফাংশনটি ব্যবহার করুন। উপাদানগুলির ক্রম চূড়ান্ত ভেক্টরে পরিবর্তিত হতে পারে।

মুছে ফেলা

(

অনন্য

(

)

10টি উপাদান সহ 'ছাত্র' ভেক্টর তৈরি করুন এবং সদৃশগুলি সরিয়ে ভেক্টরটি ফেরত দিন।

#include

ব্যবহার নামস্থান std ;

প্রধান ( )

{

// একটি ভেক্টর তৈরি করুন - 10টি উপাদান সহ শিক্ষার্থীরা

ভেক্টর < স্ট্রিং > ছাত্রদের = { 'শ্রাবণ' , 'ববি' , 'মধু' , 'মেঘনা' , 'লাবণ্য' ,

'শ্রাবণ' , 'ববি' , 'মধু' , 'মেঘনা' , 'লাবণ্য' } ;

cout << 'ছাত্ররা: \n ' ;

জন্য ( স্ট্রিং i : ছাত্রদের )

cout << i << '' ;

// ছাত্র ভেক্টরের সমস্ত উপাদান সাজান।

সাজান ( শুরু ( ছাত্রদের ) , শেষ ( ছাত্রদের ) ) ;

// erase() ফাংশন দিয়ে ডুপ্লিকেট অপসারণ করতে অনন্য() ফাংশন ব্যবহার করুন

ছাত্রদের মুছে ফেলা ( অনন্য ( শুরু ( ছাত্রদের ) , শেষ ( ছাত্রদের ) ) , শেষ ( ছাত্রদের ) ) ;

cout << ' \n \n অনন্য ছাত্র: \n ' ;

জন্য ( স্বয়ংক্রিয় itr = শুরু ( ছাত্রদের ) ; itr ! = কিছু ( ছাত্রদের ) ; ++ itr ) {

cout << * itr << '' ;

}

}

আউটপুট:

এখন, সব উপাদানই ভেক্টরে অনন্য।

একটি ভেক্টরকে একটি সেটে রূপান্তর করুন

সেট ডুপ্লিকেট উপাদানের অনুমতি দেয় না. আপনি যদি সদৃশ সহ একটি সেটে একটি ভেক্টর সন্নিবেশ করতে টাইপ করেন তবে সেগুলি উপেক্ষা করা হবে৷ আমরা একই std::copy() ফাংশন ব্যবহার করি যা পূর্ববর্তী দৃশ্যে ব্যবহৃত হয়েছিল যা সেটটিকে ভেক্টরে রূপান্তরিত করেছিল।

এই পরিস্থিতিতে:

প্রথম প্যারামিটারটি ভেক্টরটিকে সোর্স ইটারেটর হিসাবে নেয় যা begin() ফাংশন ব্যবহার করে নির্দিষ্ট করা হয়।
দ্বিতীয় প্যারামিটারটি ভেক্টরটিকে সোর্স ইটারেটর হিসাবে নেয় যা end() ফাংশন ব্যবহার করে নির্দিষ্ট করা হয়।
std::inserter() ফাংশনটি পাস করুন যা সেটের একটি নির্দিষ্ট অবস্থানে স্বয়ংক্রিয়ভাবে উপাদানগুলিকে ওভাররাইট/কপি করতে সেট এবং ইটারেটর প্রদান করে যা সেটের শেষে প্যারামিটার হিসাবে নির্দেশ করে।

আসুন 10টি পূর্ণসংখ্যা সহ একটি ভেক্টর তৈরি করি এবং উপাদানগুলিকে একটি সেটে অনুলিপি করি।

#include

ব্যবহার নামস্থান std ;

প্রধান ( )

{

// একটি সেট তৈরি করুন - 10টি মান সহ চিহ্ন

ভেক্টর < int > চিহ্ন = { 12 , 3. 4 , 56 , 78 , 65 , 78 , 90 , 90 , 78 , 3. 4 } ;

cout << 'ভেক্টর: \n ' ;

জন্য ( int i : চিহ্ন )

cout << i << '' ;

// সেট তৈরি করুন - ভেক্টরের আকারের সমান আকারের marks_set

সেট < int > marks_set ;

// একটি সেট থেকে উপাদান সন্নিবেশ করান - ছাত্ররা একটি ভেক্টর - ছাত্র_ভিসিতে।

অনুলিপি ( শুরু ( চিহ্ন ) ,শেষ ( চিহ্ন ) , সন্নিবেশকারী ( marks_set, end ( marks_set ) ) ) ;

cout << ' \n \n সেট: \n ' ;

জন্য ( int i : marks_set )

cout << i << '' ;

}

আউটপুট:

'মার্কস' নামের বিদ্যমান ভেক্টরটির 10টি মান রয়েছে। এটিকে “marks_set” সেটে অনুলিপি করার পরে, এটি কেবল ছয়টি উপাদান ধারণ করে কারণ বাকি চারটি উপাদান নকল করা হয়েছে।

খালি স্ট্রিংগুলি সরান

একটি ভেক্টরে উপস্থিত খালি স্ট্রিংগুলির কোনও ব্যবহার নেই। ভেক্টরে থাকা খালি স্ট্রিংগুলি সরিয়ে ফেলা একটি ভাল অভ্যাস। আসুন দেখি কিভাবে C++ ভেক্টর থেকে খালি স্ট্রিংগুলি সরিয়ে ফেলা যায়:

'for' লুপ ব্যবহার করে ভেক্টর পুনরাবৃত্তি করুন।
প্রতিটি পুনরাবৃত্তিতে, উপাদানটি খালি (“”) কিনা বা at() সদস্য ফাংশন সহ “==” অপারেটর ব্যবহার করে না তা পরীক্ষা করুন।
std::erase() ফাংশন ব্যবহার করে, আগের কন্ডিশন চেক করার পর খালি স্ট্রিংগুলো সরিয়ে ফেলুন।
ভেক্টরের শেষ না হওয়া পর্যন্ত step2 এবং step3 পুনরাবৃত্তি করুন।

আসুন 10টি স্ট্রিং দিয়ে 'কম্পানি' ভেক্টর তৈরি করি। তাদের মধ্যে, পাঁচটি খালি এবং আমরা পূর্বের পদ্ধতি প্রয়োগ করে সেগুলি সরিয়ে ফেলি।

# অন্তর্ভুক্ত করুন

# অন্তর্ভুক্ত <ভেক্টর>

ব্যবহার নামস্থান std ;

প্রধান ( ) {

ভেক্টর < স্ট্রিং > কোম্পানি { 'কোম্পানি-এ' , '' , 'কোম্পানি-বি' ,

'' , 'কোম্পানি-সি' , '' , 'কোম্পানি-ডি' , '' , '' , '' } ;

// কোম্পানির উপর পুনরাবৃত্তি

// এবং erase() ব্যবহার করে খালি উপাদানগুলি সরান

জন্য ( int itr = 1 ; itr < কোম্পানি আকার ( ) ; ++ itr ) {

যদি ( কোম্পানি এ ( itr ) == '' ) {

কোম্পানি মুছে ফেলা ( কোম্পানি শুরু ( ) + itr ) ;

-- itr ;

}
}

// ভেক্টর প্রদর্শন করুন

জন্য ( স্বয়ংক্রিয় এবং i : কোম্পানি ) {

cout << i << endl ;

}

}

আউটপুট:

এখন, 'কোম্পানী' ভেক্টর অ-খালি স্ট্রিং ধারণ করে।

একটি টেক্সট ফাইলে একটি ভেক্টর লিখুন

আসুন আলোচনা করি কিভাবে ভেক্টর সূচক ব্যবহার করে একটি ফাইলে ভেক্টরে উপস্থিত সমস্ত উপাদান লিখতে হয়। fstream .

ভেক্টর শুরু করার পরে পুশ_ব্যাক ফাংশন ব্যবহার করে কিছু উপাদান এতে পুশ করুন।
'fstream' লাইব্রেরি থেকে open() ফাংশনটি ব্যবহার করুন মোডটি আউট হিসাবে।
একটি 'ফর' লুপে সূচক ব্যবহার করে ভেক্টরে উপস্থিত প্রতিটি উপাদান অতিক্রম করুন এবং প্রদত্ত ফাইলে প্রতিটি উপাদান লিখুন।
অবশেষে, ফাইলটি বন্ধ করুন।

একটি C++ কোড চালানোর মাধ্যমে পূর্ববর্তী পদ্ধতি বাস্তবায়ন করা যাক।

# অন্তর্ভুক্ত <ভেক্টর>

#include

# অন্তর্ভুক্ত করুন

# অন্তর্ভুক্ত করুন

ব্যবহার নামস্থান std ;

প্রধান ( )

{

// একটি ভেক্টর তৈরি করুন - v_data

// এবং এতে দুটি উপাদান পুশ করুন।

ভেক্টর < স্ট্রিং > v_data ;

v_data। ফেরত পাঠাও ( 'স্বাগত' ) ;

v_data। ফেরত পাঠাও ( 'লিনাক্স হিন্টে' ) ;

প্রবাহ চ ;

// ফাইলটি খুলুন

চ খোলা ( 'written_file.txt' ,ios_base :: আউট ) ;

// ভেক্টরের প্রতিটি উপাদান পুনরাবৃত্তি করুন এবং ফাইলটিতে একে একে লিখুন।

জন্য ( int i = 0 ; i < v_ডেটা। আকার ( ) ; i ++ )

{

চ << v_ডেটা [ i ] << endl ;

}

// ফাইল বন্ধ করুন

চ বন্ধ ( ) ;

}

আউটপুট:

'v_data' ভেক্টর দুটি উপাদান ধারণ করে এবং ভেক্টরে উপস্থিত উপাদানগুলির সাথে প্রোগ্রামটি চালানোর পথে একটি ফাইল তৈরি করা হয়।

একটি টেক্সট ফাইল থেকে একটি ভেক্টর তৈরি করুন

আমরা শিখেছি কীভাবে ভেক্টরে উপস্থিত উপাদানগুলিকে একটি টেক্সট ফাইলে লিখতে হয়। এখানে, টেক্সট ফাইলে উপস্থিত বিষয়বস্তু থেকে একটি ভেক্টর তৈরি করা যাক।

তৈরি একটি ' ifstream' ভেরিয়েবল যা টেক্সট ফাইল থেকে তথ্য পড়ার জন্য ব্যবহৃত হয় যেখানে আমরা ফাইল থেকে ভেক্টর তৈরি করি।
ফাইলের বিষয়বস্তু সঞ্চয় করার জন্য একটি খালি ভেক্টর তৈরি করুন এবং ফাইলের শেষ পরীক্ষা করার জন্য একটি ফ্ল্যাগ হিসাবে একটি খালি স্ট্রিং ভেরিয়েবল ব্যবহার করুন।
ফাইলটি শেষ না হওয়া পর্যন্ত পরবর্তী লাইনটি পড়ুন (মূলত 'যখন' লুপ ব্যবহার করে)। পরবর্তী লাইনটি পড়তে এবং ভেক্টরে পুশ করতে push_back() ফাংশনটি ব্যবহার করুন।
কনসোলের ভেক্টরে উপস্থিত উপাদানগুলি দেখতে লাইনে উপস্থিত লাইনটি আলাদাভাবে প্রদর্শন করুন।

চলুন C++ কোড চালানোর মাধ্যমে পূর্ববর্তী পদ্ধতি বাস্তবায়ন করা যাক। আসুন নিম্নলিখিত বিষয়বস্তু সহ 'data.txt' ফাইলটি বিবেচনা করি। এখানে, ভেক্টরের নাম 'v_data'।

#include

ব্যবহার নামস্থান std ;

প্রধান ( )

{

// টেক্সট ফাইল খুলুন - ডেটা
ifstream ফাইল ( 'data.txt' ) ;

// ভেক্টর তৈরি করুন - v_data of type - string

ভেক্টর < স্ট্রিং > v_ডেটা ;

ঠোঙা ছিল ;

// data.txt থেকে পরবর্তী লাইন পড়ুন
// এটি শেষ পর্যন্ত পৌঁছানো পর্যন্ত।

যখন ( ফাইল >> ছিল ) {

// পরের লাইনটি পড়ুন এবং v_data এ পুশ করুন

v_data। ফেরত পাঠাও ( ছিল ) ;

}

// লাইনে উপস্থিত লাইনটি আলাদাভাবে প্রদর্শন করুন।

অনুলিপি ( v_data। শুরু ( ) , v_data। শেষ ( ) , ostream_iterator < স্ট্রিং > ( cout , ' \n ' ) ) ;

}

আউটপুট:

আমরা দেখতে পাচ্ছি যে 'v_data' ফাইল থেকে আসা পাঁচটি উপাদান ধারণ করে।

উপসংহার

এই দীর্ঘ নিবন্ধে, আমরা সি++ প্রোগ্রামিং ভাষায় ভেক্টর সম্পর্কিত রিয়েল-টাইম অ্যাপ্লিকেশনগুলিতে ব্যবহৃত সম্ভাব্য সমস্ত উদাহরণগুলি অন্বেষণ করেছি। প্রতিটি উদাহরণ সিনট্যাক্স, প্যারামিটার এবং আউটপুট সহ উদাহরণ দিয়ে ব্যাখ্যা করা হয়েছে। কোডের স্পষ্ট বোঝার জন্য প্রতিটি কোডে মন্তব্য যোগ করা হয়।