Map hakkında
Map sınıfı, benzersiz anahtarların belirli değerlerle eşleşdiği bir ilişkisel konteynerdir. Map, içinde anahtar/değer ikililerinden oluşan bir liste yer alır. Anahtar bir ismi ifade eder ve bu isim karşılığında bir değer yer alır. Anahtar adını kullanarak kaydettiğimiz bir değeri, yine anahtar adını kullanarak okuyabiliriz.
Map içinde yer alan anahtar/değer ikililerindeki değeri, anahtar adını kullanarak okuyabilmemiz için, tüm anahtar ifadeleri benzersiz olmalıdır.
Bir map sınıfı için şablon bildiriminin genel yapısı aşağıda gösterilmektedir:
template <class Key, class T, class Comp = less<Key>, class Allocator = allocator<pair<const key, T>> class map
Key: Anahtarların veri türüdür.
T: Map’e kaydedilen veri türünü gösterir.
Comp: İki anahtar karşılaştıran fonksiyonu gösterir.
allocator: Tahsis ediciyi ifade eder.
Map konteynerleri aşağıdaki constructor fonksiyonlarını içerir:
1
2
3
4
5
explicit map(const Comp &cmpfn = Comp(), const Allocator &a = Allocator());
map(const map<Key, T, Comp, Allocator> &ob);
template <class InIter> map(InIter start, InIter end, const Comp &cmpfn = Comp(), const Allocator &a = Allocator());
İlk yapı boş bir map oluşturur. İkinci yapı, ob nesnesi ile aynı elemanlara sahip bir map oluşturur. Üçüncü yapı, start ve end tekrarlayıcıları ile gösterilen aralıktaki elemanları içeren bir map oluşturur. cmpfn ile gösterilen fonksiyon map sıralamasını belirler.
Örnek
1
2
3
4
5
explicit map(const Comp &cmpfn = Comp(), const Allocator &a = Allocator());
map(const map<Key, T, Comp, Allocator> &ob);
template <class InIter> map(InIter start, InIter end, const Comp &cmpfn = Comp(), const Allocator &a = Allocator());
Azami esneklik ve taşınabilirlik amacıyla, bir listeye depolanacak herhangi bir nesne, varsayılan bir constructor fonksiyonu tanımlamalıdır.
Aşağıdaki işlemciler map’lerle birlikte kullanılabilir:
==, <, <=, !=, >, >=
Map sınıfı içinde tanımlanan bazı üye fonksiyonlar aşağıdaki tabloda yer almaktadır:
| Üye fonksiyon | Açıklama |
|---|---|
| iterator begin();const_iterator begin() const; | Map’teki ilk elemanı gösteren bir tekrarlayıcı geri döndürür. |
| void clear(); | Map’teki tüm elemanları siler. |
| size_type count(const key_type &k) const; | Map’te k ile gösterilen anahtar değerinin sayısını geri döndürür (0 veya 1). |
| bool empty() const; | Eğer çağıran map boş ise doğru, aksi takdirde yanlış bir değer geri döndürür. |
| iterator end();const_iterator end() const; | Map’in sonunu gösteren bir tekrarlayıcı geri döndürür. |
| iterator erase(iterator i); | Map içinde, i ile gösterilen elemanı siler. |
| iterator erase(iterator start, iterator end); | Map içinde start ile end arasındaki elemanları siler. |
| size_type erase(const key_type &k); | Map içinde, k ile gösterilen değere sahip elemanları siler. |
| iterator find(const key_type &k);const_iterator find(const key_type &k) const; | Tanımlanan anahtara bir tekrarlayıcı geri döndürür.Anahtar bulunamazsa, map’in sonunu gösteren bir tekrarlayıcı geri döndürür. |
| iterator insert(iterator i, const value_type &val); | Map içinde, i ile gösterilen eleman yerine veya sonrasına val değerini ekler.Elemanı gösteren bir tekrarlayıcı geri döndürür. |
template <class InIter> void insert(InIter start, InIter end) | Map içinde, start ile range değerleri arasında kalan elemanları ekler. |
pair<iterator, bool> insert(const value_type &val); | Çağıran map’e val değerini ekler. Elemanı gösteren bir tekrarlayıcı geri döndürür. Eleman, sadece mevcut değilse eklenir.Eleman eklenirse, pair<iterator, true> değeri aksi takdirde pair<iterator, false> değeri geri döndürülür. |
mapped_type & operator[ ](const key_type &i); | Map içinde, i ile gösterilen elemanın referansını geri döndürür. Eleman mevcut değilse eklenir. |
| size_type size() const; | Map içindeki elemanı sayısını geri döndürür. |
Anahtar/değer ikilisi map içine, aşağıda şablon yapısı verilen, pair türünde kaydedilir:
Örnek
1
2
3
4
5
6
7
8
9
10
11
12
13
template <class Ktype, class Vtype> struct pair {
typedef Ktype first_type; // anahtar veri türü
typedef Vtype second_type; // değer veri türü
Ktype first; // anahtar içerir
Vtype second; // değer içerir
// constructor fonksiyonları
pair();
pair(const Ktype &k, const Vtype &v);
template<class A, class B> pair(const<A, B> &ob);
}
Bir ikili değer oluşturmak için pair constructor fonksiyonlarından birisini veya aşağıda genel yapısı verilen make_pair() fonksiyonunu kullanabiliriz.
1
2
3
4
5
template <class Ktype, class Vtype> pair<Ktype, Vtype> make_pair(const Ktype &k, const Vtype &v);
Fonksiyon, Ktype ve Vtype tarafından gösterilen veri türlerinden oluşan bir ikili nesne geri döndürür. Bu fonksiyonun avantajı, depolanan nesnelerin türlerinin, derleyici tarafından otomatik olarak belirlenmesidir.
Map oluşturma ve değer atama
Şimdi, bir map oluşturma, anahtar/değer ikililerinden oluşan elemanlar ekleme ve bu ikili değerleri ekrana yazma işlemlerini bir örnek üzerinde incelemeye çalışalım:
Örnek
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
#include <iostream>
#include <map>
using namespace std;
int main(void)
{
// int anahtar ve string değerlerden oluşan ikililer içeren map oluşturma
map<int, string> Personel;
// insert() fonksiyonu ile map'e anahtar/değer ikilileri ekleme
Personel.insert(pair<int, string>(1, "Ahmet Sakin"));
Personel.insert(pair<int, string>(2, "Ayşe Saygılı"));
Personel.insert(pair<int, string>(3, "Mehmet Efendi"));
Personel.insert(pair<int, string>(4, "Kadir Mütevazi"));
Personel.insert(pair<int, string>(5, "Ekrem Vefalı"));
cout << "Map eleman sayısı: " << Personel.size() << "\n";
// [ ] işlemcisi ile map'e anahtar/değer ikilileri ekleme
Personel[Personel.size()+1] = "Murat Yardımcı";
Personel[Personel.size()+1] = "Esra Sadıker";
Personel[Personel.size()+1] = "Öner Erdemli";
cout << "Map eleman sayısı: " << Personel.size() << "\n\n";
// Map elemanlarını ekrana yazma
cout << "Map elemanları:" << "\n";
cout << "---------------" << "\n";
map<int, string>::iterator mp;
for(mp=Personel.begin(); mp!=Personel.end(); mp++) {
cout << (*mp).first << ": " << (*mp).second << "\n";
}
return 0;
}
Yukarıdaki programı derleyip çalıştırdığımızda, aşağıdaki ifadeleri ekrana yazar:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
Map eleman sayısı: 5
Map eleman sayısı: 8
Map elemanları:
---------------
1: Ahmet Sakin
2: Ayşe Saygılı
3: Mehmet Efendi
4: Kadir Mütevazi
5: Ekrem Vefalı
6: Murat Yardımcı
7: Esra Sadıker
8: Öner Erdemli
Program, int veri türünden anahtar ve string veri türünden değer içeren ikililerden oluşan Personel adlı bir map bildirimi yapar. insert() fonksiyonunu kullanarak, map’e beş eleman ekler. size() fonksiyonu ile map eleman sayısını ekrana yazar. [ ] işlemcisini kullanarak, map’e üç eleman daha ekler ve map eleman sayısını tekrar ekrana yazar. Bir for döngüsü içinde, Personel map elemanlarını sırasıyla bir tekrarlayıcıya atayarak, anahtar ve değer ikilisini ekrana yazar.
İlk değer atayarak map oluşturma
Bir map oluştururken, anahtar ve değer ikililerinden oluşan ilk değerler vererek eleman ekleyebiliriz.
Şimdi, ilk değer vererek bir map oluşturma işlemini bir örnek üzerinde incelemeye çalışalım:
Örnek
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
#include <iostream>
#include <map>
using namespace std;
int main(void)
{
// İlk değer verilerek int anahtar ve string değerlerden oluşan ikililer içeren map oluşturma
// C++11
map<int, string> Personel = {
{1, "Ahmet Sakin"},
{2, "Ayşe Saygılı"},
{3, "Mehmet Efendi"}
};
// Map elemanlarını ekrana yazma
cout << "Map elemanları:" << "\n";
cout << "---------------" << "\n";
map<int, string>::iterator mp;
for(mp=Personel.begin(); mp!=Personel.end(); mp++) {
cout << (*mp).first << ": " << (*mp).second << "\n";
}
return 0;
}
Yukarıdaki programı derleyip çalıştırdığımızda, aşağıdaki ifadeleri ekrana yazar:
1
2
3
4
5
6
7
Map elemanları:
---------------
1: Ahmet Sakin
2: Ayşe Saygılı
3: Mehmet Efendi
Program, int veri türünden anahtar ve string veri türünden değer içeren ikililerden oluşan Personel adlı bir map bildirimi yapar. Map oluştururken ilk değer atama yöntemiyle, map’e beş eleman ekler. Bir for döngüsü içinde, Personel map elemanlarını sırasıyla bir tekrarlayıcıya atayarak, anahtar ve değer ikilisini ekrana yazar.
Map içinde değer arama
Şimdi, oluşturulan bir map içinde, anahtar değerini kullanarak, arama yapma işlemlerini bir örnek üzerinde incelemeye çalışalım:
Örnek
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
#include <iostream>
#include <map>
using namespace std;
int main(void)
{
// int anahtar ve string değerlerden oluşan ikililer içeren map oluşturma
map<int, string> Personel;
// insert() fonksiyonu ile map'e anahtar/değer ikilileri ekleme
Personel.insert(pair<int, string>(1, "Ahmet Sakin"));
Personel.insert(pair<int, string>(2, "Ayşe Saygılı"));
Personel.insert(pair<int, string>(3, "Mehmet Efendi"));
Personel.insert(pair<int, string>(4, "Kadir Mütevazi"));
Personel.insert(pair<int, string>(5, "Ekrem Vefalı"));
// Map elemanlarını ekrana yazma
cout << "Map elemanları:" << "\n";
cout << "---------------" << "\n";
map<int, string>::iterator mp;
for(mp=Personel.begin(); mp!=Personel.end(); mp++) {
cout << (*mp).first << ": " << (*mp).second << "\n";
}
cout << "\n";
// 3 anahtar değerine karşılık gelen ismi bulma ve karşılığını ekrana yazma
mp = Personel.find(3);
if (mp!=Personel.end()){
cout << "3 anahtarına karşılık gelen değer: " << mp->second << "\n";
}
// 5 anahtar değerine karşılık gelen ismi bulma ve karşılığını ekrana yazma
mp = Personel.find(5);
if (mp!=Personel.end()){
cout << "5 anahtarına karşılık gelen değer: " << mp->second << "\n";
}
return 0;
}
Yukarıdaki programı derleyip çalıştırdığımızda, aşağıdaki ifadeleri ekrana yazar:
1
2
3
4
5
6
7
8
9
10
11
12
Map elemanları:
---------------
1: Ahmet Sakin
2: Ayşe Saygılı
3: Mehmet Efendi
4: Kadir Mütevazi
5: Ekrem Vefalı
3 anahtarına karşılık gelen değer: Mehmet Efendi
5 anahtarına karşılık gelen değer: Ekrem Vefalı
Program, int veri türünden anahtar ve string veri türünden değer içeren ikililerden oluşan Personel adlı bir map bildirimi yapar. insert() fonksiyonunu kullanarak, map’e beş eleman ekler. Bir for döngüsü içinde, Personel map elemanlarını sırasıyla bir tekrarlayıcıya atayarak, anahtar ve değer ikilisini ekrana yazar. Sonra, find() fonksiyonu ile 3. ve 5. sırada yer alan anahtarları arar. Bulduğu anahtara karşılık gelen değeri ekrana yazar.
Map içinde anahtar değerine karşılık gelen değeri değiştirme
Map içindeki anahtar değerlerinden herhangi birine karşılık gelen değeri değiştirmek için, find() fonksiyonuyla bir anahtar/değer ikilisinin adresini bir tekrarlayıcıya atadıktan sonra second değerini veya [ ] işlemcisi içinde anahtar değerini kullanabiliriz.
Şimdi, oluşturulan bir map içinde, anahtar değerini kullanarak, arama yapma işlemlerini bir örnek üzerinde incelemeye çalışalım:
Örnek
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
#include <iostream>
#include <map>
using namespace std;
int main(void)
{
// int anahtar ve string değerlerden oluşan ikililer içeren map oluşturma
map<int, string> Personel;
// insert() fonksiyonu ile map'e anahtar/değer ikilileri ekleme
Personel.insert(pair<int, string>(1, "Ahmet Sakin"));
Personel.insert(pair<int, string>(2, "Ayşe Saygılı"));
Personel.insert(pair<int, string>(3, "Mehmet Efendi"));
Personel.insert(pair<int, string>(4, "Kadir Mütevazi"));
Personel.insert(pair<int, string>(5, "Ekrem Vefalı"));
// Map elemanlarını ekrana yazma
cout << "Map elemanları:" << "\n";
cout << "---------------" << "\n";
map<int, string>::iterator mp;
for(mp=Personel.begin(); mp!=Personel.end(); mp++) {
cout << (*mp).first << ": " << (*mp).second << "\n";
}
cout << "\n";
// 3 anahtar değerine karşılık gelen ismi bulma ve karşılık gelen değeri değiştirme
mp = Personel.find(3);
if (mp!=Personel.end()){
mp->second = "Serdar Değerli";
}
// [ ] işlemcisi ile 5 anahtar değerine karşılık gelen değeri değiştirme
Personel[5] = "Nedime Fedakar";
// Map elemanlarını ekrana yazma
cout << "Map elemanları:" << "\n";
cout << "---------------" << "\n";
for(mp=Personel.begin(); mp!=Personel.end(); mp++) {
cout << (*mp).first << ": " << (*mp).second << "\n";
}
return 0;
}
Yukarıdaki programı derleyip çalıştırdığımızda, aşağıdaki ifadeleri ekrana yazar:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
Map elemanları:
---------------
1: Ahmet Sakin
2: Ayşe Saygılı
3: Mehmet Efendi
4: Kadir Mütevazi
5: Ekrem Vefalı
Map elemanları:
---------------
1: Ahmet Sakin
2: Ayşe Saygılı
3: Serdar Değerli
4: Kadir Mütevazi
5: Nedime Fedakar
Program, int veri türünden anahtar ve string veri türünden değer içeren ikililerden oluşan Personel adlı bir map bildirimi yapar. insert() fonksiyonunu kullanarak, map’e beş eleman ekler. Bir for döngüsü içinde, Personel map elemanlarını sırasıyla bir tekrarlayıcıya atayarak, anahtar ve değer ikililerini ekrana yazar. Sonra, find() fonksiyonu ile map içinde 3. sırada yer alan anahtarı bulur ve tekrarlayıcıya atar. Tekrarlayıcı yoluyla, second değerine yeni bir değer atayarak, anahtara karşılık gelen değeri değiştirir. Sonra, map adı ile [ ] işlemcisini kullanarak, map içinde 5. sırada yer alan anahtara karşılık gelen değeri değiştirir. Daha sonra, bir for döngüsü içinde, Personel map elemanlarını sırasıyla bir tekrarlayıcıya atayarak, anahtar ve değer ikililerini tekrar ekrana yazar.
Map’lerle sınıf nesneleri kullanma
Bir map konteynerine herhangi bir veri türünden oluşturulan nesneleri kaydedebiliriz.
Şimdi, bir map üzerinde sınıf ile ilgili işlemlerin yapılmasını bir örnek üzerinde incelemeye çalışalım:
Örnek
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
#include <iostream>
#include <map>
using namespace std;
class sinif {
private:
string adi;
string soyadi;
int yasi;
public:
sinif(string padi, string psoyadi, int pyasi)
{
adi = padi;
soyadi = psoyadi;
yasi = pyasi;
}
sinif() { };
void deger_ata(string padi, string psoyadi, int pyasi)
{
adi = padi;
soyadi = psoyadi;
yasi = pyasi;
}
void deger_goster()
{
cout << adi << " " << soyadi << " " << yasi << endl;
}
};
int main(void)
{
map<int, sinif> Personel; // int ve sinif veri türleri ile map bildirimi
// insert() fonksiyonu ile map'e anahtar/değer ikilileri ekleme
Personel.insert(pair<int, sinif>(1, sinif("Ahmet", "Sakin", 25)));
Personel.insert(pair<int, sinif>(2, sinif("Ayşe", "Saygılı", 36)));
Personel.insert(pair<int, sinif>(3, sinif("Mehmet", "Efendi", 19)));
Personel.insert(pair<int, sinif>(4, sinif("Kadir", "Mütevazi", 47)));
Personel.insert(pair<int, sinif>(5, sinif("Ekrem", "Vefalı", 32)));
// Map elemanlarını ekrana yazma
cout << "Map elemanları:" << "\n";
cout << "---------------" << "\n";
map<int, sinif>::iterator mp;
for(mp=Personel.begin(); mp!=Personel.end(); mp++) {
cout << (*mp).first << ": ";
(*mp).second.deger_goster();
}
cout << endl;
// Kayıt arama
mp = Personel.find(3);
if (mp!=Personel.end()){
cout << "3 anahtarına karşılık gelen kayıt: ";
(*mp).second.deger_goster();
}
// Kayıt değiştirme
mp = Personel.find(4);
if (mp!=Personel.end()){
(*mp).second.deger_ata("Erson", "Özverili", 39);
}
// [ ] işlemcisi ile eleman oluşturma
Personel[6] = sinif ("Murat", "Çağlayan", 57);
cout << "\nMap elemanları:" << "\n";
cout << "---------------" << "\n";
for(mp=Personel.begin(); mp!=Personel.end(); mp++) {
cout << (*mp).first << ": ";
(*mp).second.deger_goster();
}
return 0;
}
Yukarıdaki programı derleyip çalıştırdığımızda, aşağıdaki ifadeleri ekrana yazar:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
Map elemanları:
---------------
1: Ahmet Sakin 25
2: Ayşe Saygılı 36
3: Mehmet Efendi 19
4: Kadir Mütevazi 47
5: Ekrem Vefalı 32
3 anahtarına karşılık gelen kayıt: Mehmet Efendi 19
Map elemanları:
---------------
1: Ahmet Sakin 25
2: Ayşe Saygılı 36
3: Mehmet Efendi 19
4: Erson Özverili 39
5: Ekrem Vefalı 32
6: Murat Çağlayan 57
Program, içinde private olarak adi ve soyadi adlı iki adet string ve yasi adlı bir adet int değişken ve parametreli ve parametresiz olmak üzere, iki adet constructor fonksiyonu ile değişkenlere değer atayan ve ekranda gösteren iki adet fonksiyon tanımladığı sinif adlı bir sınıf oluşturur.
Program, int veri türünden anahtar ve sinif veri türünden değer içeren ikililerden oluşan Personel adlı bir map bildirimi yapar. insert() fonksiyonunu kullanarak, map’e beş eleman ekler. Bir for döngüsü içinde, Personel map elemanlarını sırasıyla bir tekrarlayıcıya atayarak, anahtar ve değer ikililerini ekrana yazar. Sonra, find() fonksiyonu ile map içinde 3. sırada yer alan anahtarı bulur ve tekrarlayıcıya atar. Tekrarlayıcı yoluyla, second değeri ile deger_goster() fonksiyonunu kullanarak, sınıf kopyası içindeki değerleri ekrana yazar. Daha sonra, yine find() fonksiyonu ile map içinde 4. sırada yer alan anahtarı bulur ve tekrarlayıcıya atar. Tekrarlayıcı yoluyla, second değeri ile deger_ata() fonksiyonunu kullanarak, sınıf kopyası içindeki değerleri değiştirir. [ ] işlemcisini kullanarak, map’e yeni bir kayıt ekledikten sonra eleman değerlerini tekrar ekrana yazar.