C++ STL के इस Hindi Tutorial में हम Iterators के बारे में बात करेंगे और C++ STL Iterators को और उसके functions को कैसे use करते हैं ये सीखेंगे.
जैसा की हम जानते हैं STL containers (vector, set, map, etc.) के object की help से हम अपने elements (data) को store करते हैं.
अब इन containers में मौजूद elements को access (point) करने के लिए हमें जरुरत होती है Iterator object की.
Iterators की help से ही हम STL algorithms को STL containers से connect करते हैं जिससे की वो algorithms (operations) उस container पर apply हो सकें.
C++ STL में Iterator कैसे Use करते हैं?
Iterators लगभग pointers की तरह होते हैं जैसे pointers किसी variable के address को point करता है ठीक ऐसे ही iterators STL container में मौजूद elements के address को point करता है.
Pointers की ही तरह iterators भी container elements को traverse करने के लिए increment operator (++) और decrement operator (–) और container elements को access करने के लिए dereference operator (*) का use करते हैं.
सभी STL containers classes के अंदर कुछ ऐसे member functions होते हैं जिनकी हेल्प से हम उस container के साथ iterators को use कर पाते हैं.
ऐसे ही 2 सबसे common functions के बारे में मैंने नीचे बताया है जिन्हें हम iterator के साथ use करते हैं और क्योंकि ये functions container classes में होते हैं तो इन्हें use करने के लिए आपको container class के object की जरूरत होती है.
begin() function
जिस भी container class के object के जरिये आप इस member function को call करते हैं ये function उस container के first element के address को return करता है जिसे आप किसी iterator में store कर सकते हो.
end() function
जिस भी container class के object के जरिये आप इस member function को call करते हैं ये function उस container के last element के बाद वाले address को return करता है.
नीचे कुछ example programs बनाये हैं जिसमें हमने इन functions को use करके दिखाया है लेकिन उससे पहले ये समझते हैं की कैसे आप C++ में iterator declare करते हैं.
Iterator Declaration
Iterator declare करने के 2 तरीके हैं. पहला तरीका old और standard तरीका है लेकिन थोड़ा lengthy (लंबा) है और जो दूसरा तरीका नया और short है. आपको दोनों तरीको से iterator use करना आना चाहिए.
Iterator Standard Declaration:
//old way container_type <parameter_list>::iterator iterator_name; //old way examples vector<int>::iterator it1; vector<string>::iterator it2; list<int>::iterator it3; map<int, int>::iterator it4;
ऊपर example में हमने जो पहला iterator declare किया है वो ऐसे vector container के साथ काम करेगा जिसमें int type के elements store हो.
ऐसे ही दूसरा iterator ऐसे vector container के साथ काम करेगा जिसमें string type के elements store हो. इसी तरह तीसरा iterator list container के साथ और चौथा iterator map container के साथ काम (traverse) करेगा.
Example Program:
#include<iostream>
#include<iterator>
#include<vector>
using namespace std;
int main()
{
vector<int> v = {24,85,60,35,94};
vector<int>::iterator it;
for(it = v.begin(); it < v.end(); it++)
{
cout << *it <<" ";
}
return 0;
}
Output:
25 85 60 35 94
Explanation:
हमने सबसे पहले int type parameter के साथ एक vector को declare और initialize किया है. उसके बाद इस vector के elements को access (traverse) करने के लिए हमने एक iterator declare किया है.
इसके बाद loop के अन्दर हमने vector के member function begin() को call किया है जो की vector के first element के address को return करके iterator object (it) को assign कर देगा.
Loop के अन्दर iterator के साथ dereference operator (*) का use करके उस element को print (access) कराया है जो उस address पर मौजूद है जिसे iterator ने currently store किया हुआ है.
इसके बाद iterator के साथ हमने increment operator (++) का use किया है जिससे की iterator को vector के next element का address मिल जाए.
Program में दिया for loop इसी तरह से तब तक चलता रहेगा जब तक हमारा iterator vector के last element को access नही कर लेता.
Iterator using Auto Keyword:
जैसा की शायद आप जानते होंगे की C++ जब किसी variable को auto type specifier के साथ declare किया जाता है तो उसका data type उस value के according अपने आप set हो जाता है जिस तरह की value आप उस variable को assign करते हो.
इसी तरह auto keyword की help से आप ऊपर बताये गये standard iterator declaration syntax को बहुत ही short और easy कर सकते हो.
जैसे की कोई container अपने किसी element का address auto variable को assign करेगा तभी उसी वक्त वो auto variable अपने आप internally उस container type के iterator में change हो जाएगा.
Example Program:
#include<iostream>
#include<iterator>
#include<vector>
using namespace std;
int main()
{
vector<int> v = {24,85,60,35,94};
for(auto it = v.begin(); it < v.end(); it++)
{
cout << *it <<" ";
}
return 0;
}
Output:
25 85 60 35 94
Operations on Iterators in STL
C++ STL में ऐसे बहुत से functions हैं जिन्हें हम बिना किसी object के यानी direct call करते हैं और उनकी help से iterator की position change करते हैं.
advance(iterator it, int num)
आप इस function के first argument में जो iterator pass करते हो उस iterator की position ये function उतने elements आगे पहुँचा देगा जितने number आपने इस function के second argument में pass किये हैं.
Note: Iterator की position move करने के लिए ये function current position से counting करता है.
next(iterator it, int num)
ये function भी लगभग advance function की तरह ही काम करता है बस फर्क इतना है की ये pass iterator की position को change नही करता बल्कि एक new iterator return करता है जिसे हम किसी new iterator में store कर लेते हैं.
prev(iterator it, int num)
ये function लगभग next function जैसा है बस फर्क इतना है की ये function जो new iterator return करना है उसकी position decrement steps में change होती है.
इस function में next function की तरह first argument में pass किये गये iterator की position में कोई change नही आता है.
Arithmetic Operations
आप iterator के साथ increment operator (++), decrement operator (–) और arithmetic operations perform करके iterator की position move कर सकते हैं.
distance(iterator first, iterator second)
ये function एक number return करता है जो की argument में pass किये गये दोनों iterator का distance होता है.
Example Program:
#include<iostream>
#include<iterator>
#include<vector>
using namespace std;
int main()
{
vector<int> v = {30,25,40,10,85,60,35,90};
auto it = v.begin();
cout<<"First Element: "<<*it<<endl;
advance(it,2);
cout<<"After 2 Advance Steps: "<<*it<<endl;
auto it2 = next(it,4);
cout<<"New Iterator After 4 Increment Steps: "<<*it2<<endl;
auto it3 = prev(it2,5);
cout<<"New Iterator After 5 Decrement Steps: "<<*it3<<endl;
auto it4 = v.begin();
it4++;
cout<<"After 1 Increment: "<<*it4<<endl;
cout<<"After Addition Operation: "<<*(it4+3)<<endl;
return 0;
}
Output:
First Element: 30 After 2 Advance Steps: 40 New Iterator After 4 Increment Steps: 35 New Iterator After 5 Decrement Steps: 25 After 1 Increment: 25 After Addition Operation: 85