1. STL
STL (Standard Template Library, შაბლონების სტანდარტული ბიბლიოთეკა) წარმოადგენს ალგორითმების, კონტეინერების, მათი შიგთავსისადმი წვდომის საშუალებების და სხვადასხვა დამხმარე ფუნქციების განზოგადებულ კრებულს. ეს ბიბლიოთეკა C++ ენის უმნიშვნელოვანესი ნაწილია, თუმცა თავიდან ის კერძო ფირმების (ჯერ HP, ხოლო შემდეგ SGI – Silicon Graphics, Inc.) მიერ შემუშავებული მოდული იყო.
ბიბლიოთეკა შეიცავს დიდი რაოდენობით ცნობილ ალგორითმებს და მონაცემთა სტრუქტურებს.

2. STL–ის საფუძველს წარმოადგენს ხუთი ძირითადი კომპონენტი:
1.კონტეინერი (container) - ობიექტთა სიმრავლის შენახვა მეხსიერებაში.
2.იტერატორი (iterator) - წვდომის საშუალებათა უზრუნველყოფა კონტეინერის შიგთავსისადმი.
3.ალგორითმი (algorithm) - გამომთვლელი პროცედურის განსაზღვრა.
4.ადაპტერი (adaptor) - კომპონენტების ადაპტაცია სხვადასხვა ინტერფეისის უზრუნველყოფისათვის.
5.ფუნქციონალური ობიექტი (functor) - ფუნქციის მოთავსება ობიექტში სხვა კომპონენტების მიერ მის გამოსაყენებლად.
ყოველივე ამასთან ერთად STL–ს გააჩნია კიდევ ერთი ძალიან საჭირო კლასი — string. ეს კლასი საშუალებას იძლევა სიმბოლურ მონაცემებთან ვიმუშაოთ ოპერატორების, და არა მხოლოდ ფუნქციების საშუალებით.

3. კონტეინერები წარმოადგენენ ობიექტებს, რომლებიც თავის შიგნით სხვა ობიექტებს ინახავენ. ისინი იყოფიან 4 კატეგორიად: მიმდევრობითი, ასოციაციური, კონტეინერი–ადაპტერი და ფსევდოკონტეინერი.
კონტეინერი
აღწერა
ბიბლიოთ.
მიმდევრობითი კონტეინერები
ვექტორი
დინამიური მასივი ელემენტებისადმი თავისუფალი წვდომით და ელემენტის წაშლა/ჩამატებისას ზომის ავტომატური შეცვლით
<vector>
სია
წრფივი სია, რომლის ელემენტები შეიძლება ინახებოდეს მეხსიერების სხვადასხვა ნაწილებში, განსხვავებით ვექტორისაგან, რომლის ელემენტებიც მეხსიერებაში უწყვეტ არედ არიან შენახული.
<list>
დეკი
ორმხრივი რიგი. კონტეინერი წააგავს ვექტორს, მაგრამ აქვს საშუალება სწრაფად წაშალოს და ჩაამატოს ელემენტები ორივე ბოლოდან.
<deque>
ასოციაციური კონტეინერები
სიმრავლე
სიმრავლე, რომელშიც ყოველი ელემენტი მხოლოდ ერთ ეგზემპლარად ინახება.
<set>
მულტისიმრა ვლე
იგივეა რაც სიმრავლე, ოღონდ განმეორებით ელემენტებსაც ინახავს.

4. map
ინახავს წყვილს “გასაღები–მნიშვნელობა", რომელშიც ყოველ გასაღებს შეესაბამება მხოლოდ ერთი მნიშვნელობა.
<map>
multimap
იგივეა, რაც map, ოღონდ ყოველ გასაღებს შეიძლება რამდენიმე მნიშნელობა შეესაბამებოდეს.
კონტეინერი–ადაპტერი
სტეკი
სტეკი — კონტეინერი, რომელშიც დამატება და წაშლა ხდება ერთი ბოლოდან.
<stack>
რიგი
რიგი — კონტეინერი, რომლის ერთი ბოლოდან ხდება დამატება, ხოლო მეორედან – წაშლა.
<queue>
პრიორიტეტე ბიანი რიგი priority_queue
პრიორიტეტებიანი რიგი, რომელიც ისე ორგანიზებული, რომ უდიდესი ელემენტი ყოველთვის პირველ ადგილზე დგას.
ფსევდოკონტეინერები
bitset
გამოიყენება ბიტმასკების შესანახად.
<bitset>
basic_string
კონტეინერი სტრიქონების დასამუშავებლად და შესანახად. ელემენტებს ინახავს თანმიმდევრობით ერთ ბლოკში.
<string>
valarray
ციფრული მასივის შესანახი შაბლონი, რომელიც ზრდის გამოთვლით მწარმოებლურობას. წააგავს ვექტორს, თუმცა არ გააჩნია სტანდარტული ოპერაციების უმეტესობა.
<valarray>
Фцвфвфцв

5. ყოველი კონტეინერული კლასი განსაზღვრავს ფუნქციათა კრებულს, რომელიც შეიძლება მასზე გამოვიყენოთ. მაგალითად, კლასი list შეიცავს ფუნქციებს ელემენტთა ჩასმის, წაშლის და შერწყმის საშუალებებით, ხოლო კლასი stack შეიცავს ფუნქციებს ელემენტთა ჩატვირთვის და ამოტვირთვის საშუალებებით.
ალგორითმები
ალგორითმები გამოიყენება კონტეინერების მიერ. მათ შეუძლიათ კონტეინერის შიგთავსის ინიციალიზაცია, სორტირება და გარდაქმნა.
იტერატორი
იტერატორი — ობიექტი, რომელიც მიმთითებელს წააგავს. ის საშუალებას იძლევა ვიმოძრაოთ კონტეინერის შიგთავსში. ყოველი კონტეინერი საკუთარი სახის იტერატორთან მუშაობს. C++ ენის სტანდარტი განსაზღვრავს 5 კატეგორიის იტერატორს, რომლებიც ქვემოთ ცხრილშია აღწერილი:

6. იტერატორები მოქმედებენ როგორც მიმთითებლები.
იტერატორი
აღწერა
თავისუფალი წვდომა
ინახავს და იღებს მნიშვნელობებს. უზრუნველყოფს თავისუფალ წვდომას ელემენტებთან. იყენებს მიმთითებლის არითმეტიკას და მასივის ინდექსაციის სინტაქსს.
პირდაპირი (ცალმხრივი)
ინახავს და იღებს მნიშვნელობებს. გადაადგილდება მხოლოდ წინ.
ორმხრივი
ინახავს და იღებს მნიშვნელობებს. გადაადგილდება მხოლოდ წინ და უკან
შეტანის
იღებს, მაგრამ არ ინახავს ელემენტებს. გადაადგილდება მხოლოდ წინ.
გამოტანის
ინახავს, მაგრამ არ იღებს მნიშვნელობებს. გადაადგილდება მხოლოდ წინ.
როგორც წესი, ფართო შესაძლებლობების იტერატორები შეიძლება უფრო სუსტი იტერატორების ნაცვლად გამოვიყენოთ. მაგალითად, შეტანის ოპერატორის ნაცვლად შეიძლება პირდაპირი იტერატორი გამოვიყენოთ.
იტერატორები მოქმედებენ როგორც მიმთითებლები.

7. გამანაწილებლები
ყოველ იტერატორს გააჩნია თავისი გამანაწილებელი (allocator), რომელიც სპეციალურად მისთვისაა შერჩეული. გამანაწილებლები ახორციელებენ მეხსიერების გამოყოფას კონტეინერებისათვის. ისინი წარმოადგენენ კლას allocator–ის ობიექტებს.
პრედიკატები
ზოგიერტი ალგორითმი და კონტეინერი იყენებს ფუნქციათა სპეციალურ ტიპს, რომელსაც პრედიკატს უწოდებენ. არსებობს პრედიკატთა ორი სახესხვაობა: ბინარული და უნარული. ეს ფუნქციები აბრუნებენ true ან false, თუმცა პირობები, რომელთაგანაც დამოკიდებულია ეს მნიშვნელობები, შეიძლება დამოუკიდებლად დაიწეროს. პრედიკატების არგუმენტებად გამოიყენება კონტეინერში შენახული ობიექტები. პრედიკატების კერძო შემთხვევას წარმოადგენს კომპარატორი. ის გამოიყენება ორი ელემენტის შესადარებლად და აბრუნებს true–ს, თუ პირველი არგუმენტი ნაკლებია მეორეზე.

8. კლას vector–ის შაბლონური სპეციფიკაცია:
ვექტორები
ყველაზე უნივერსალური კონტეინერია კლასია vector, რომელიც წარმოადგენს დინამიურ მასივს და მისი ზომები საჭიროების მიხედვით იცვლება. მიუხედავად ზომების ცვალებადობისა, ელემენტების წვდომისათვისათვის გამოიყენება ინდექსაციის ჩვეულებრივი მეთოდი.
კლას vector–ის შაბლონური სპეციფიკაცია:
template <class Type, class Allocator=allocator<Type> > class vector
Type განსაზღვრავს კონტეინერში შესანახ მონაცემთა ტიპს, ხოლო კლასი Allocator განსაზღვრავს მეხსიერების განაწილების მექანიზმს. გაჩუმების პრინციპით გამოიყენება სტანდარტული გამანაწილებელი. Vector–ი შეიცავს შემდეგ კონსტრუქტორებს:
explicit vector(const Allocator &a = Allocator());
explicit vector(size_type num, const T &val = T(), const Allocator &a = Allocator());
vector(const vector<Type, Allocator &ob);
template <class InIter> vector(InIter start, InIter end, const Allocator &a = Allocator());
შენიშვნა:
explicit კრძალავს არაცხად გარდაქმნებს.

9. ვექტორების გამოცხადების მაგალითები:
პირველი კონსტრუქტორი ჰქმნის ცარიელ ვექტორს. მეორე ვექტორი შედგება num ელემენტისაგან, რომელთა მნიშვნელობა არის val. მესამე კონსტრუქტორი ჰქმნის ვექტორს, რომელიც შეიცავს ვექტორ ob–ს ელემენტებს. მეოთხე ვექტორი შედგება ელემენტებისაგან, რომლებიც მოთავსებულნი არიან დიაპაზონში start და end.
ვექტორების გამოცხადების მაგალითები:
vector <int> iv; //იქმნება int ტიპის ცარიელი ვექტორი
vector <char> cv(5); //იქმნება 5–ელემენტიანი char ტიპის ვექტორი
vector <char> cv2(5, 'x'); //იქმნება 5–ელემენტიანი char ტიპის ვექტორი, //რომლის ელემენტთა მნიშვნელობებია х
vector <int> iv2(iv); //იქმნება int ტიპის ვექტორი, რომელიც //ინიციალიზდება სხვა ვექტორით.
Vector კლასში განსაზღვრულია შედარების შემდეგი ოპერატორები:
==, <, <=, !=, >, >=
ელემენტთა წვდომისათვის მასივის მსგავსად განსაზღვრულია [ ].

10. vector კლასში განსაზღვრულია წევრი ფუნქციების დიდი რაოდენობა
vector კლასში განსაზღვრულია წევრი ფუნქციების დიდი რაოდენობა. ზუსტი აღწერა შეგიძლიათ მიიღოთ შესაბამისი ვერსიის ცნობარში. თუმცა არის ფუნქციები, რომლებიც STL–ის ყველა ვერსიაშია.
წევრი ფუნქცია
აღწერა
reference back( );
const_reference back( ) const;
აბრუნებს მიმთითებელს ვექტორის ბოლო ელემენტზე.
const_iterator begin() const;
iterator begin();
აბრუნებს იტერატორს, რომელიც დგას ვექტორის პირველ ელემენტზე.
void clear();
შლის ყველა ელემენტს ვექტორიდან.
bool empty() const;
აბრუნებს true, თუ ვექტორი ცარიელია და false – თუ არა.
iterator end( );
const_iterator end( ) const;
აბრუნებს იტერატორს, რომელიც დგას ვექტორის ბოლო ელემენტზე.
iterator erase(iterator i );
შლის ელემენტს, რომელზეც მიუთითებს i იტერატორი. აბრუნებს იტერატორს, რომელიც მიუთითებს წაშლილის მომდევნო ელემენტზე.
iterator erase(iterator start, iterator end);
შლის ყველა ელემენტს დიაპაზონიდან, რომელიც მიეთითება start და end იტერატორებით. აბრუნებს იტერატორს, რომელიც მიუთითებს ბოლო წაშლილის მომდევნო ელემენტზე.
reference front( );
const_reference front( ) const;
აბრუნებს მიმთითებელს ვექტორის პირველ ელემენტზე.
iterator insert( iterator i, const Type& val );
ჩასვამს val ელემენტს იმ ელემენტის წინ, რომელზეც მიუთითებს იტერატორი i. აბრუნებს val ელემენტის იტერატორს.
void insert( iterator i, size_type num, const Type& val);
ჩასვამს val ელემენტის num ცალ ასლს იმ ელემენტის წინ, რომელზეც მიუთითებს იტერატორი i.

11. ვექტორზე ძირითადი ოპერაციების მაგალითი.
template<class InputIterator> void insert( iterator i, InputIterator start, InputIterator end );
ელემენტის წინ, რომელზეც მიუთითებს იტერატორი i, ახდენს იმ ელემენტთა მიმდევრობის ჩასმას, რომელიც მოცემულია start და end იტერატორებით
void pop_back();
წაშლის ვექტორის ბოლო ელემენტს.
void push_back(const T& val);
დაამატებს val ელემენტს ვექტორის ბოლოში.
size_type size() const;
აბრუნებს ელემენტთა მიმდინარე რაოდენობას ვექტორში.
ვექტორზე ძირითადი ოპერაციების მაგალითი.
#include <vector>
#include <iostream>
#include <conio.h>
#include <ctype.h>
using namespace std;
Int main() {
vector <char> v(10); //10–ელემენტიანი ვექტორის შექმნა
int i;
//ვექტორის ზომის გამოტანა ეკრანზე
cout << "Size of v = " << v.size() << '\n';
//მნიშვნელობების მინიჭება ვექტორის ელემენტებისადმი
for(i=0; i<10; i++)
v[i] = i + 'a';

12. პროგრამის შესრულების შედეგი: Size of v = 10 Current contents:
//ვექტორის ელემენტთა მნიშვნელობების გამოტანა ეკრანზე
cout << "Current contents:\n";
for(i=0; i<10; i++)
cout << v[i] << ' ';
cout << "\n\n";
cout << "Extended vector\n";
//ახალი ელემენტების დამატება ვექტორის ბოლოში,
//ვექტორის ზომა ავტომატურად იზრდება
v.push_back(i+10+'a');
//ვექტორის ზომის გამოტანა ეკრანზე
сout << "New size = " << v.size() << '\n';
for(i=0; i<v.size(); i++)
//ვექტორის ელემენტების შეცვლა
v[i]=toupper(v[i]);
cout << "Modified contents:\n";
_getch();
return 0; }
პროგრამის შესრულების შედეგი:
Size of v = 10
Current contents:
a b c d e f g h i j
Extended vector
New size = 20
a b c d e f g h i j k l m n o p q r s t
Modified contents:
A B C D E F G H I J K L M N O P Q R S T

13. ვექტორის ელემენტებთან წვდომა იტერატორის საშუალებით
ამ მაგალითში ჩანს ვექტორის ერთ–ერთი უპირატესობა ჩვეულებრივ დინამიურ მასივებთან — ფუნქცია size(). მისი დახმარებით ნებისმიერ დროს შეიძლება ვექტორის ზომის განსაზღვრა.
ვექტორის ელემენტებთან წვდომა იტერატორის საშუალებით
როგორც იცით მასივის ელემენტებთან წვდომა ხორციელდება ინდექსით ან მიმთითებლით. STL–ში მასივის როლს თამაშობს ვექტორი, ხოლო მიმთითებლის როლს – იტერატორი. ვექტორის ელემენტებთან წვდომა ხორციელდება ინდექსით ან იტერატორით. #include <vector>
#include <iostream>
#include <conio.h>
#include <ctype.h>
using namespace std;
Int main() {
vector <char> v(10);
vector <char>::iterator p; //ვქმნით p იტერატორს
int i=0;
//იტერატორს დავაყენებთ ვექტორის დასაწყისში
p=v.begin();
while (p!=v.end()){
*p = i + 'a';
p++;
i++; }

14. cout << "Starting contents\n";
p=v.begin();
while (p!=v.end()){
cout << *p << ' ';
p++; }
cout << "\n\n";
*p=toupper(*p);
cout << "Modified contents\n";
_getch();
return 0;
ამ მაგალითში მნიშვნელოვანი მომენტია იტერატორის გამოყენება. რადგან ტიპი iterator გამოცხადებულია თითოეული კონტეინერული კლასის შიგნით, ამიტომ იტერატორის შექმნისას საჭიროა კონტეინერის სახელისა და სპეციფიკატორ iterator–ის მითითება. მოცემულ პროგრამაში ელემენტების წვდომა ხორციელდება იტერატორით. თავიდან p დაყენებულია v.begin()–ზე, რის შემდეგაც იმოძრავებს ვექტორში, ვიდრე v.end()–ს არ მიაღწევს.

15. ელემენტების ჩასმა და წაშლა ვექტორში.
ვექტორში ნებისმიერ ადგილას ელემენტის ჩასასმელად გამოიყენება ფუნქცია insert(), ხოლო ნებისმიერი ელემენტის წასაშლელად – ფუნქცია erase().
#include <vector>
#include <iostream>
#include <conio.h>
using namespace std;
int _tmain(int argc, _TCHAR* argv[]) {
vector <char> v(10);
vector <char> v2;
char str[]="<Vector>";
int i;
for(i=0; i<v.size(); i++)
v[i] = i + 'a';
for(i=0; str[i]; i++)
v2.push_back(str[i]);
cout << "Starting contents of v:\n";
for (i=0; i<v.size(); i++)
cout << v[i] << ' ';
cout << "\n\n";

16. პროგრამის შესრულების შედეგი: Starting contents of v:
vector <char>::iterator p = v.begin();
p+=2;
v.insert(p, 10, 'X');
cout << "Size of v = " << v.size() << '\n';
cout << "Contents after insert:\n";
for (i=0; i<v.size(); i++)
cout << v[i] << ' ';
cout << "\n\n";
p=v.begin();
v.erase(p, p+10);
cout << "Contents after erase:\n";
p=v.begin()+2;
v.insert(p, v2.begin(), v2.end());
_getch();
return 0; }
პროგრამის შესრულების შედეგი:
Starting contents of v:
a b c d e f g h i j
Size of v = 20
Contents after insert:
a b X X X X X X X X X X c d e f g h i j
Size of v = 10
Contents after erase:
Size of v = 18
a b < V e c t o r > c d e f g h i j

17. ვექტორი, რომელიც კლასის ობიექტებს შეიცავს
რადგან ვექტორი წარმოადგენს შაბლონურ კლასს, მის ელემენტებად შეგვიძლია გამოვიყენოთ არა მარტო სტანდარტული ტიპების (int, double და ა.შ.) ეგზემპლარები, არამედ მომხმარებლის მიერ შექმნილი კლასებიც.

18. ბმული სიები
კლასი list ჰქმნის ორმხრივ ბმულ სიას. ვექტორისაგან განსხვავებით, რომელიც უზრუნველყოფს თავისუფალ წვდომას თავის ელემენტებზე, სიის ელემენტებისადმი წვდომა მხოლოდ მიმდევრობითია. მოძრაობა შესაძლებელია სიის დასაწყისიდან ბოლოსაკენ და პირიქით.
list კლასის შაბლონურ სპეციფიკაციას აქვს სახე:
template <class Type, class Allocator = allocator<Type> > class list;
შაბლონური პარამეტრი Type იძლევა მონაცემთა ტიპს, რომელიც ინახება სიაში. მეხსიერების გამანაწილებელი მიეთითება კლასით Allocator.
list კლასს აქვს შემდეგი კონსტრუქტორები:
explicit list(const Allocator &a = Allocator());
explicit list(size_type num, const Type &val = Type(), const Allocator &a = Allocator());
list(const list<Type, Allocator &ob);
template <class InIter> list(InIter start, InIter end, const Allocator &a = Allocator());
პირველი კონსტრუქტორი ჰქმნის ცარიელ სიას, ხოლო მეორე – სიას, რომელიც შედგება num ცალი ელემენტისაგან, რომელთა მნიშვნელობა არის val. მესამე კონსტრუქტორი ჰქმნის სიას, რომელიც შეიცავს ob ობიექტის ელემენტებს. მეოთხე აფორმირებს სიას, რომელიც შედგება start და end. იტერატორების მიერ მოცემულ დიაპაზონში არსებული ელემენტებისაგან.
როგორც კონსტრუქტორებიდან ჩანს, მათ ისეთივე სახე აქვთ, როგორც ვექტორის კონსტრუქტორებს. ასეთი უნიფიკაცია STL–ის ერთ–ერთი თავისებურებაა, რომელიც პროგრამისტს საშუალებას აძლევს არ იფიქროს გარკვეული კონტეინერის კონსტრუქტორის თავისებურებებზე.

19. list კლასთან მუშაობის მაგალითი:
list კლასი შეიცავს ყველა ფუნქციას, რომელსაც შეიცავდა კლასი vector (გარდა [ ] ოპერატორისა – სია მას ვერ იყენებს). ქვემოთ მოყვანილია წევრ ფუნქციათა ცხრილი, რომელიც მხოლოდ სიებისთვისაა განკუთვნილი.
წევრი –ფუნქცია
აღწერა
void merge(list<T, Allocator &ob);
template <class Comp>
void merge(list<T, Allocator &ob, Comp cmpfn);
მოცემულ სიასთან აერთიანებს დალაგებულ სიას, რომელსაც შეიცავს ობიექტი ob. შედეგად მიიღება დალაგებული სია, ხოლო ob ობიექტში არსებული სია ხდება ცარიელი. მეორე ფუნქცია merge პარამეტრის სახით ღებულობს ფუნქციას, რომელიც სიის ელემენტებს ერთმანეთთან ადარებს.
void pop_front();
შლის სიის პირველ ელემენტს.
void push_front();
ამატებს ელემენტს სიის დასაწყისში
void remove (const T &val);
შლის სიიდან ყველა ელემენტს, რომლის მნიშვნელობაც ტოლია val–ის.
void reverse();
ცვლის სიის ელემენტთა თანმიმდევრობას საწინააღმდეგოთი.
void sort();
void sort(Comp cmpfn);
ალაგებს სიას. მეორე ვერსია ალაგებს სიას და ელემენტთა შედარებისათვის იყენებს cmpfn ფუნქციას.
void splice(iterator i, list <T, Allocator> &ob);
i იტერატორის მიერ მითითებულ პოზიციაში სვამს ob ობიექტის სიას. ოპერაციის შესრულების შემდეგ ob ხდება ცარიელი.
void splice(iterator i, list <T, Allocator> &ob, iterator el);
ელემენტი, რომელზეც მიუთითებს el იტერატორი, წაიშლება სიიდან ob და ჩაისმება გამომძახებელ სიაში i იტერატორით მითითებულ ადგილას
void splice(iterator i, list <T, Allocator> &ob, iterator start, iterator end);
ob სიის ელემენტები, რომლებიც განლაგებულია start და end იტერატორებით მითითებულ დიაპაზონში, წაიშლება ob სიიდან და ჩაისმება გამომძახებელ სიაში i იტერატორით მითითებულ ადგილას
list კლასთან მუშაობის მაგალითი:

20. პროგრამის შესრულების შედეგი Size of list = 10
#include <list>
#include <iostream>
#include <conio.h>
using namespace std;
int _tmain(int argc, _TCHAR* argv[]) {
list <int> lst; // ვქმნით ცარიელ სიას
int i;
for(i=0; i<10; i++)
lst.push_back(i);
cout << "Size of list = " << lst.size() << '\n';
cout << "Contents: ";
list <int>::iterator p = lst.begin();
while (p!=lst.end()){
cout << *p << ' ';
p++; }
cout << "\n\n";
//ვცვლით სიის ელემენტებს
p=lst.begin();
*p=*p + 100;
cout << "Modified contents: ";
_getch();
return 0;
პროგრამის შესრულების შედეგი
Size of list = 10
Contents:
Modified contents:

21. ეს პროგრამა ჰქმნის მთელი რიცხვების სიას
ეს პროგრამა ჰქმნის მთელი რიცხვების სიას. თავიდან ფორმირდება ცარიელი სია, შემდეგ push_back()–ის საშუალებით ჩაიწერება 10 მთელი რიცხვი. თითოეული მათგანი ჩაიწერება არსებული სიის ბოლოში. ამის შემდეგ ეკრანზე გამოდის სიის ზომა და მისი ელემენტები. შემდეგ ყოველი რიცხვი 100–ჯერ იზრდება და ხელახლა გამოდის ეკრანზე.
ხაზგასამელია იტერატორთან მუშაობა. ის მიმთითებელზე უფრო მოსახერხებელი და უნივერსალურია. მიმდინარე იტერატორზე ერთის მიმატებისას მივიღებთ მომდევნო ობიექტს კონტეინერიდან მიუხედავად კონტეინერის ელემენტთა ტიპისა.
ფუნქცია end()
ყველა მოყვანილ მაგალითში კონტეინერის “შემოსავლელად” გამოიყენება ციკლი პირობით, ხოლო პირობაში გამოიყენებოდა იტერატორის შედარება კონტეინერის ბოლოსთან. end() ფუნქცია აბრუნებს მიმთითებელს არა კონტეინერის ბოლო ელემენტზე, არამედ მის მომდევნო ელემენტზე, ამიტომ ბოლო ელემენტს შეესაბამება მნიშვნელობა end() - 1. თუ იტერატორის მნიშვნელობა ხდება end()–ის ტოლი, ეს ნიშნავს, რომ კონტეინერის ყველა ელემენტი გავლილია.

22. პროგრამის მუშაობის შედეგი: Size of list = 10
#include <list>
#include <iostream>
#include <conio.h>
using namespace std;
int _tmain(int argc, _TCHAR* argv[]) {
list <int> lst; // ვქმნით ცარიელ სიას
int i;
for(i=0; i<10; i++)
lst.push_back(i);
cout << "Size of list = " << lst.size() << '\n';
cout << "Contents: ";
list <int>::iterator p = lst.begin();
while (p!=lst.end()){
cout << *p << ' ';
p++; }
cout << "\n\n";
cout << "Reversed contents: ";
p=lst.end();
while (p!=lst.begin()){
p--; //იტერატორის შემცირება
_getch();
return 0;
პროგრამის მუშაობის შედეგი:
Size of list = 10
Contents:
Reversed contents:

23. push_front() და push_back() ფუნქციების შედარება
კოდის ანალიზისას ყურადღება მიაქციეთ იმ მომენტს, სადაც სიის ელემენტები შებრუნებული თანმიმდევრობით გამოგვაქვს. თავიდან იტერატორი p დადგება სიის ბოლოში end() ოპერატორის საშუალებით. მაგრამ რადგან ამ იტერატორი დგას ბოლო ელემენტის შემდეგ, ჯერ p უნდა შევამციროთ 1–ით და შემდეგ დავიწყოთ გამოტანა.
push_front() და push_back() ფუნქციების შედარება
სიის შექმნა შეიძლება მისთვის ელემენტების დამატებით ან თავში, ან ბოლოში. სიის თავში ელემენტების დასამატებლად გამოიყენება ფუნქცია push_front(). სიის ბოლოში ელემენტები ემატება ფუნქციით push_back().
#include <list>
#include <iostream>
#include <conio.h>
using namespace std;
int _tmain(int argc, _TCHAR* argv[]) {
list <int> lst1, lst2;
int i;
for(i=0; i<10; i++)
lst1.push_back(i);
lst2.push_front(i);

24. list<int>::iterator p;
cout << "Contents of lst1:\n";
p=lst1.begin();
while(p!=lst1.end()){
cout << *p << ' ';
p++; }
cout << "\n\n";
cout << "Contents of lst2:\n";
p=lst2.begin();
while(p!=lst2.end()){
_getch();
return 0;
რადგან lst2 სიის შექმნისას ელემენტები ემატება სიის თავში, მისი თანმიმდევრობა შებრუნებულია lst1 სიასთან შედარებით, რომელიც ფორმირდებოდა ელემენტების დამატებით სიის ბოლოში.
სიის სორტირება
სიის სორტირება ხდება ფუნქციით sort(), რომელიც გაჩუმების პრინციპით სიას ზრდადობით ალაგებს. მისი გამოძახება ასე ხდება:
lst.sort();
პროგრამის მუშაობის შედეგი:
Contents of lst1:
Contents of lst2:

25. ერთი სიის ჩასმა მეორეში
დასორტირებული სია შეიძლება ჩავსვათ მეორე სხვა სიაში. შედეგად მივიღებთ დალაგებულ სიას, რომელიც შედგება საწყისი სიების ელემენტებისაგან. ახალი სია ინახება გამომძახებელ ობიექტში, ხოლო მეორე სია ცარიელდება. ქვემოთ ნაჩვენებ მაგალითში პირველი სია შედგება ლუწი ციფრებისაგან, ხოლო მეორე – კენტი ციფრებისაგან. მათი გაერთიანებით ვღებულობთ:
#include <list>
#include <iostream>
#include <conio.h>
using namespace std;
int _tmain(int argc, _TCHAR* argv[]){
list <int> lst1, lst2;
int i;
for(i=0; i<10; i+=2)
lst1.push_back(i);
for(i=1; i<11; i+=2)
lst2.push_back(i);
list <int>::iterator p;
lst1.merge(lst2);
if(lst2.empty())
cout << "lst2 is empty\n";
cout << "Contents of lst1 after merge:\n";
p=lst1.begin();
while(p!=lst1.end()){
cout << *p << ' ';
p++; }
_getch();
return 0;
პროგრამის მუშაობის შედეგი:
lst2 is empty
Contents of lst1 after merge:

26. ასოციაციური კონტეინერები
კლასი map ჰქმნის ასოციაციურ კონტეინერს, რომელშიც ყოველ გასაღებს ერთადერთი მნიშვნელობა შეესაბამება. თავად გასაღები წარმოადგენს სიტყვას, რომლის საშუალებითაც შეიძლება მივიღოთ საჭირო მნიშვნელობა. თუ კონტეინერში რაიმე მნიშვნელობა ინახება, მისდამი წვდომა მხოლოდ გასაღების საშუალებით შეიძლება. ამრიგად, ასოციაციურ კონტეინერში ინახება წყვილები “გასაღები–მნიშვნელობა". ასეთი კონტეინერების უპირატესობა მნიშვნელობებისადმი სწრაფი წვდომაა. მაგალითად, ადამიანის გვარის მიხედვით (გასაღები) შეიძლება გავიგოთ მისი ტელეფონი (მნიშვნელობა).
map (ისევე როგორც set კლასი) ინახავს მხოლოდ უნიკალურ გასაღებებს. თუ აუცილებელია დუბლიკატების შენახვაც მაშინ უნდა გამოიყენოთ multimap ან multiset კლასები.
map კლასის შაბლონურ სპეციფიკაციას აქვს სახე:
template <class Key, class Type, class Comp = less<Key>, class Allocator = allocator< pair<const Key, Type> > class map

27. კლასს map აქვს შემდეგი კონსტრუქტორები
explicit map(const Comp &cmpfn=Comp(), const Allocator &a = Allocator());
map(const map<Key, Type, Comp, Allocator> &ob);
template <class InIter> map (InIter start, InIter end, const Comp &cmpfn = Comp(), const Allocator &a = Allocator());
პირველი კონსტრუქტორი ჰქმნის ცარიელ ასოციაციურ მასივს, ხოლო მეორე – კონტეინერს, რომელიც შეიცავს ob ობიექტის ელემენტებს. მესამე აფორმირებს მასივს, რომელიც შედგება start და end. იტერატორების მიერ მოცემულ დიაპაზონში არსებული ელემენტებისაგან. ფუნქცია cmpfn განსაზღვრავს ელემენტთა თანმიმდევრობას მასივში.
map კლასში განსაზღვრულია შედარების შემდეგი ოპერატორები:
==, <, <=, !=, >, >=

28. Daw წევრი ფუნქცია აღწერა iterator begin();
const_iterator begin() const;
აბრუნებს პირველ ელემენტზე მიმართულ იტერატორს
void clear();
შლის ასოციაციური მასივიდან ყველა ელემენტს
size_type count (
const key_type &k) const;
აბრუნებს k მნიშვნელობის მქონე ელემენტის დუბლიკატების მიმდინარე რაოდენობას.
bool empty() const;
აბრუნებს true, თუ კონტეინერი ცარიელია და false – წინააღმდეგ შემთხვევაში
iterator end();
const_iterator end() const;
აბრუნებს ბოლო ელემენტზე მიმართულ იტერატორს
iterator erase(iterator i);
შლის ელემენტს, რომელზეც მიმართულია იტერატორი i. აბრუნებს იტერატორს, რომელიც მიმართულია წაშლილის მომდევნო ელემენტზე.
iterator erase (iterator start, iterator end);
შლის ყველა ელემენტს დიაპაზონში, რომელიც მოთავსებულია start და end იტერატორებს შორის. აბრუნებს იტერატორს, რომელიც მიმართულია ბოლო წაშლილი ელემენტისს მომდევნო ელემენტზე.
size_type erase (const key_type &k);
შლის კონტეინერიდან ელემენტებს, რომელთა მნიშვნელობაა k.
iterator find(const key_type &k);
const_iterator find ( const key_type &k);
აბრუნებს იტერატორს, რომელიც მიმართულია მითითებულ გასაღებზე. თუ გასაღები არ მოიძებნა, დააბრუნებს მასივის ბოლოზე მიმართულ იტერატორს.
iterator insert(iterator i, const value_type &val);
სვამს val მნიშვნელობის მქონე ელემენტს i იტერატორის მქონე ელემენტის ნაცვლად ან მის შემდეგ. აბრუნებს იტერატორს, რომელიც მიმართულია ჩასმულელემენტზე.
template <class InIter>
void insert(InIter start, InIter end);
სვამს ელემენტებს დიაპაზონიდან, რომელიც მოთავსებულია start და end იტერატორებს შორის.
Daw

29. pair <iterator, bool>
insert(const value_type &val);
სვამს val მნიშვნელობის მქონე ელემენტს ასოციაციურ კონტეინერში. აბრუნებს იტერატორს, მიმარტულს ჩასმულ ელემენტზე. ელემენტის ჩასმა ხდება, თუ ის მანამდე არ იყო მასივში. წარმატებული ჩასმის შემთხვევაში ბრუნდება ობიექტი pair <iterator, true>, წინააღმდეგ შემთხვევაში — pair <iterator, false>
mapped_type& operator[ ] ( const key_type &i);
აბრუნებს მიმართვას ელემენტზე, რომელიც მოცემულია i იტერატორით. თუ ელემენტი მასივში არ იყო, ხდება მისი ჩასმა მასივში.
size_type size() const;
აბრუნებს კონტეინერში ელემენტების მიმდინარე რაოდენობას
წყვილი “გასაღება–მნიშვნელობა" ინახება ასოციაციურ მასივში pair ტიპის ობიექტის სახით. მისი შაბლონური სპეციფიკაციაა:
template <class Ktype, class Vtype> struct pair{
typedef Ktype first_type;
typedef Vtype second_type;
Ktype first;
Vtype second;
//კონსტრუქტორები
pair();
pair(const Ktype &k, const Vtype &v);
template <class A, class B>
pair (const <A, B> &ob); }
ველი first შეიცავს გასაღებს, ხოლო ველი second ინახავს ამ გასაღების შესაბამის მნიშვნელობას.
წყვილი შეიძლება შეიქმნას pair ტიპის კონსტრუქტორის გამოძახებით, ან ფუნქციით make_pair().