Listeler hakkında
List sınıfı, çift yönlü ve doğrusal bir liste sağlar. Bir listedeki elemanlara sadece sıralı olarak erişim sağlanabilir. Elemanlara rastgele erişim yapılamaz. Çift yönlü olduğu için baştan sona veya sondan başa doğru erişim sağlanabilir.
Bir list sınıfı için şablon bildiriminin genel yapısı aşağıda gösterilmektedir:
template <class T, class Allocator = allocator<T>> class list
T: Listeye kaydedilen veri türünü gösterir.
allocator: Tahsis ediciyi ifade eder.
List konteynerleri aşağıdaki constructor fonksiyonlarını içerir:
1
2
3
4
5
6
7
explicit list(const Allocator &a = Allocator());
explicit list(size_type num, const T &val = T(), const Allocator &a = Allocator());
list(const list &nes);
template list(InIter start, InIter end, const Allocator &a = Allocator());
İlk yapı boş bir liste oluşturur. İkinci yapı, val değerine sahip num kadar elemanlı bir liste oluşturur. Üçüncü yapı, nes nesnesi ile aynı elemanları içeren bir liste oluşturur. Dördüncü yapı, start ve end tekrarlayıcıları ile gösterilen aralıktaki elemanları içeren bir liste oluşturur.
Aşağıdaki işlemciler listelerle birlikte kullanılabilir:
==, <, <=, !=, >, >=
Azami esneklik ve taşınabilirlik amacıyla, bir listeye depolanacak herhangi bir nesne, varsayılan bir constructor fonksiyonu tanımlamalıdır.
List sınıfı içinde tanımlanan bazı üye fonksiyonlar aşağıdaki tabloda yer almaktadır:
| Üye fonksiyon | Açıklama |
|---|---|
| reference back();const_reference back() const; | Listedeki son elemanın referansını geri döndürür. |
| iterator begin();const_iterator begin() const; | Listedeki ilk elemanı gösteren bir tekrarlayıcı geri döndürür. |
| void clear(); | Listedeki tüm elemanları siler. |
| bool empty() const; | Eğer çağıran liste boş ise doğru, aksi takdirde yanlış bir değer geri döndürür. |
| iterator end();const_iterator end() const; | Listenin sonunu gösteren bir tekrarlayıcı geri döndürür. |
| iterator erase(iterator i); | i ile gösterilen elemanı siler.Silinen elemandan sonraki elemanı gösteren bir tekrarlayıcı geri döndürür. |
| iterator erase(iterator start, iterator end); | start ile end arasındaki elemanları siler.Silinen en son elemandan sonraki elemanı gösteren bir tekrarlayıcı geri döndürür. |
| reference front();const_reference front() const; | Listedeki ilk elemanı gösteren bir referans geri döndürür. |
| iterator insert(iterator i, const T &val); | i ile gösterilen elemandan hemen önce val değerini ekler.Elemanı gösteren bir tekrarlayıcı geri döndürür. |
| void insert(iterator i, size_type num, const T &val) | i ile gösterilen elemandan hemen önce num değeri kadar val değerini ekler. |
| template void insert(iterator i, InIter start, InIter end); | i ile gösterilen elemandan önce start ve end ile gösterilen sırayı ekler. |
void merge(list<T, Allocator> &ob);template <class Comp> void merge(list<T, Allocator> &ob, Comp cmpfn); | ob nesnesinde yer alan sıralı listeyi sıralı çağırma listesiyle birleştirir. Elde edilen liste sıralı olur. Birleştirmeden sonra ob nesnesi içinde bulunan liste boştur. İkinci yapıda, bir elemanın diğerinden ne zaman küçük olduğunu belirleyen bir karşılaştırma fonksiyonu tanımlanabilir. |
| void pop_back(); | Listedeki son elemanı siler. |
| void pop_front(); | Listedeki ilk elemanı siler. |
| void push_back(const T &val); | val ile gösterilen değeri listenin sonuna ekler. |
| void push_front(const T &val); | val ile gösterilen değeri listenin başına ekler. |
| void remove(const T &val); | val ile gösterilen elemanları listeden siler. |
| void reverse(); | Çağıran listeyi ters çevirir. |
| size_type size() const; | Listede yer alan eleman sayısını geri döndürür. |
void sort();template <class Comp> void sort(Comp cmpfn); | Listeyi sıralar.İkinci yapıda, bir elemanın diğerinden ne zaman küçük olduğunu belirleyen bir karşılaştırma fonksiyonu tanımlanabilir. |
void splice(iterator i, list<T, Allocator> &ob); | ob içeriği çağıran listede i ile gösterilen yere eklenir. İşlemden sonra ob boş olur. |
void splice(iterator i, list<T, Allocator> &ob, iterator el); | el ile gösterilen eleman ob listesinden çıkarılır ve i ile gösterilen konumda çağırma listesine eklenir. |
void splice(iterator i, list<T, Allocator> &ob, iterator start, iterator end); | start ve end ile tanımlanan aralık ob ile gösterilen listeden silinir ve i ile gösterilen konumdan başlayan çağırma listesine eklenir. |
Liste oluşturma ve değer atama
Listeleri oluştururken, boş veya belirli bir sayıda elemana sahip olacak şekilde tanımlayabiliriz. Listeyi boş olarak tanımlarsak, eleman eklemek için push_back() fonksiyonunu kullanabiliriz. Listeyi eleman içerecek şekilde tanımlarsak, elemanlara değer atamak için, tekrarlayıcıları kullanabiliriz. Bu durumda, önce begin() fonksiyonuyla listedeki ilk elemanın bellek adresi bir tekrarlayıcıya atanır. Tekrarlayıcının değeri her artırıldığında, listedeki bir sonraki elemana erişim sağlanarak değer atanır.
Şimdi, elemanlı bir liste oluşturma, liste elemanlarına değer atama ve eleman değerlerini ekran yazma işlemlerinin gerçekleştirildiği bir örneği 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
#include <iostream>
#include <list>
using namespace std;
int main(void)
{
list<int> il(10); // 10 elemanlı bir int liste bildirimi yapar.
list<int>::iterator ipl; // Tekrarlayıcı bildirimi yapar.
int id;
// il listesinin eleman sayısını yazar.
cout << "il liste eleman sayısı: " << il.size() << endl;
// Listeye değer atama işlemi
for (ipl=il.begin(), id=1; ipl!=il.end(); ) {
*ipl++ = id++;
}
// Liste içeriğini ekrana yazma
cout << "Liste içeriği: ";
for (ipl=il.begin(); ipl!=il.end(); ) {
cout << *ipl++ << " ";
}
return 0;
}
Yukarıdaki programı derleyip çalıştırdığımızda, aşağıdaki ifadeleri ekrana yazar:
1
2
3
4
il liste eleman sayısı: 10
Liste içeriği: 1 2 3 4 5 6 7 8 9 10
Program, 10 elemanlı bir int liste ve bir int tekrarlayıcı bildirimi yapar. Listenin eleman sayısını size() fonksiyonu ile ekrana yazar. Bir for döngüsü içinde, begin() fonksiyonu ile listedeki ilk eleman bellek adresini tekrarlayıcıya atar. Tekrarlayıcı end() fonksiyonu ile elde edilen değerden farklı olduğu sürece, liste sonuna gelene kadar, her bir elemana sırasıyla 1-10 arasındaki sayıları atar. Aynı yöntemle liste eleman değerlerini bir for döngüsü kullanarak ekrana yazar.
Çalışma zamanında eleman ekleyerek liste boyutunu değiştirme
Eleman içeren bir liste oluşturduktan sonra, listeye eleman eklemek için push_back() fonksiyonunu kullanabiliriz. Bu durumda, liste boyutu otomatik olarak artar.
Şimdi, bir liste oluşturma, liste elemanlarına değer atama ve listeye eleman ekleyerek liste boyutunu artırma işlemlerinin gerçekleştirildiği bir örneği 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
#include <iostream>
#include <list>
using namespace std;
int main(void)
{
list<int> il(10); // 10 elemanlı bir int liste bildirimi yapar.
list<int>::iterator ipl; // Tekrarlayıcı bildirimi yapar.
int id;
// il listesinin eleman sayısını yazar.
cout << "il liste eleman sayısı: " << il.size() << endl;
// Listeye değer atama işlemi
for (ipl=il.begin(), id=1; ipl!=il.end(); ) {
*ipl++ = id++;
}
// Liste içeriğini ekrana yazma
cout << "Liste içeriği: ";
for (ipl=il.begin(); ipl!=il.end(); ) {
cout << *ipl++ << " ";
}
cout << endl;
// Listeye yeni değerlerler atayarak eleman sayısını artırma
for(id=il.size(); id<20; id++) il.push_back(id+1);
// il listesinin eleman sayısını yazar.
cout << "il liste eleman sayısı: " << il.size() << endl;
// Liste içeriğini ekrana yazma
cout << "Liste içeriği: ";
for (ipl = il.begin(); ipl!=il.end(); ) {
cout << *ipl++ << " ";
}
return 0;
}
Yukarıdaki programı derleyip çalıştırdığımızda, aşağıdaki ifadeleri ekrana yazar:
1
2
3
4
5
6
il liste eleman sayısı: 10
Liste içeriği: 1 2 3 4 5 6 7 8 9 10
il liste eleman sayısı: 20
Liste içeriği: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
Program, 10 elemanlı bir int liste ve bir int tekrarlayıcı bildirimi yapar. Listenin eleman sayısını size() fonksiyonu ile ekrana yazar. Bir for döngüsü içinde, begin() fonksiyonu ile listedeki ilk eleman bellek adresini tekrarlayıcıya atar. Tekrarlayıcı end() fonksiyonu ile elde edilen değerden farklı olduğu sürece, liste sonuna gelene kadar, her bir elemana sırasıyla 1-10 arasındaki sayıları atar. Aynı yöntemle liste eleman değerlerini bir for döngüsü kullanarak ekrana yazar. Sonra, push_back() fonksiyonu ile 11-12 arasındaki sayıları bir for döngüsü ile listenin sonuna ekler. Liste eleman sayısını ve içeriğini tekrar ekrana yazar.
Listelere değer atama yöntemleri
Liste bildirimlerini yaparken, farklı yöntemler kullanarak boş, değer atanmamış elemanlara sahip veya ilk değer verilmiş elemanlara sahip olarak tanımlama yapabiliriz.
Aşağıda farklı yöntemlerle yapılan liste bildirimleri gösterilmektedir:
- Sonradan push_back() fonksiyonu ile elemanları oluşturulan boş liste bildirimi
- Sonradan [ ] işlemcisi veya tekrarlayıcı ile elemanlarına değer atanan, ilk değer atanmamış elemanlı liste bildirimi
- Her elemanı aynı değere sahip ilk değer atanan elemanlı liste bildirimi
- Her elemanına farklı ilk değer atanan elemanlı liste bildirimi
- Farklı bir liste elemanları ile ilk değer atanan liste bildirimi
- Sonradan fill() fonksiyonu ile elemanlarına aynı değer atanan, elemanlı liste bildirimi
Şimdi, farklı yöntemlerle liste bildirimi 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
#include <iostream>
#include <list>
using namespace std;
int main(void)
{
list<int> ilst1; // Boş bir liste bildirimi
list<int> ilst2(10); // 10 elemanlı bir liste bildirimi
list<int> ilst3(10, 21); // Bütün eleman değerleri 21 olan 10 elemanlı bir liste bildirimi
list<int> ilst4 = { 1, 2, 3, 4 , 5, 6, 7, 8, 9, 10 }; // C++11 1-10 arasında değerlerin atandığı 10 elemanlı bir liste bildirimi
list<int> ilst5(ilst4);
list<int> ilst6(10); // 10 elemanlı bir liste bildirimi
list<int>::iterator ipv; // Tekrarlayıcı bildirimi yapar.
int id;
// ilst1 listesine 1-10 arasındaki sayıları eleman olarak atama
for(id=1; id<=10; id++) ilst1.push_back(id);
// ilst2 listesine değer atama işlemi
for (ipv=ilst2.begin(), id=1; ipv!=ilst2.end(); ) *ipv++ = id++;
// ilst6 listesinin tüm elemanlarına 7 sayısını atama
fill(ilst6.begin(), ilst6.end(), 7);
cout << "Liste boyutları: " << ilst1.size() << " " << ilst2.size() << " " << ilst3.size() << " ";
cout << ilst4.size() << " " << ilst5.size() << " " << ilst6.size();
// liste içeriklerini ekrana yazma
cout << "\nListe içerikleri:\n";
cout << "------------------\n";
cout << "ilst1: ";
for (ipv=ilst1.begin(); ipv!=ilst1.end(); ) cout << *ipv++ << " ";
cout << "\nilst2: ";
for (ipv=ilst2.begin(); ipv!=ilst2.end(); ) cout << *ipv++ << " ";
cout << "\nilst3: ";
for (ipv=ilst3.begin(); ipv!=ilst3.end(); ) cout << *ipv++ << " ";
cout << "\nilst4: ";
for (ipv=ilst4.begin(); ipv!=ilst4.end(); ) cout << *ipv++ << " ";
cout << "\nilst5: ";
for (ipv=ilst5.begin(); ipv!=ilst5.end(); ) cout << *ipv++ << " ";
cout << "\nilst6: ";
for (ipv=ilst6.begin(); ipv!=ilst6.end(); ) cout << *ipv++ << " ";
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
Liste boyutları: 10 10 10 10 10 10
Liste içerikleri:
------------------
ilst1: 1 2 3 4 5 6 7 8 9 10
ilst2: 1 2 3 4 5 6 7 8 9 10
ilst3: 21 21 21 21 21 21 21 21 21 21
ilst4: 1 2 3 4 5 6 7 8 9 10
ilst5: 1 2 3 4 5 6 7 8 9 10
ilst6: 7 7 7 7 7 7 7 7 7 7
Program, 6 adet liste bildirimi yapar. İlk listeyi boş olarak, ikinci listeyi 10 elemanlı olarak, üçüncü listeyi herbirinin değeri 21 olan 10 elemanlı olarak, dördüncü listeyi 1-10 arasındaki sayılar ilk değer atama yöntemiyle atanmış 10 elemanlı olarak, beşinci listeyi dördüncü vektörden oluşturarak, altıncı listeyi 10 elemanlı olarak tanımlar.
Önce boş olan iv1 listesine push_back() fonksiyonu ile 1-10 arasındaki sayıları atar. iv2 liste elemanlarına ipv tekrarlayıcısını kullanarak 1-10 arasındaki sayıları atar. iv6 liste elemanlarına find() fonksiyonunu kullanarak 7 değerini atar.
Tüm listelerin eleman sayısını size() fonksiyonu ile eleman değerlerini de tekrarlayıcı yoluyla ekrana yazar.
Liste elemanlarının değerini değiştirme
Listelere eklenen elemanlara sadece tekrarlayıcı kullanarak erişim sağlayabiliriz. Listede yer alan eleman değerlerini okumak veya değiştirmek istediğimizde, tekrarlayıcının begin() fonksiyonu ile aldığı ilk değeri, her defasında bir artırarak listenin tüm elemanlarına sıra ile erşim sağlayabiliriz. Sadece tek bir elemana veya belirli sayıda elemana erişim sağlamak istediğimizde ise, advance() fonksiyonunu kullanabiliriz.
Şimdi, bir listedeki tüm elemanların değerlerinin değiştirilmesini 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
#include <iostream>
#include <list>
using namespace std;
int main(void)
{
list<int> il(10); // 10 elemanlı bir int liste bildirimi yapar.
list<int>::iterator ipl; // Tekrarlayıcı bildirimi yapar.
int id;
// il listesinin eleman sayısını yazar.
cout << "il liste eleman sayısı: " << il.size() << endl;
// Listeye değer atama işlemi
for (ipl=il.begin(), id=1; ipl!=il.end(); ) {
*ipl++ = id++;
}
// Liste içeriğini ekrana yazma
cout << "Liste içeriği: ";
for (ipl=il.begin(); ipl!=il.end(); ) {
cout << *ipl++ << " ";
}
cout << endl;
// Liste eleman değerlerini değiştirme
for (ipl=il.begin(); ipl!=il.end(); ipl++) {
*ipl = (*ipl) * (*ipl);
}
// Liste içeriğini ekrana yazma
cout << "Liste içeriği: ";
for (ipl = il.begin(); ipl!=il.end(); ) {
cout << *ipl++ << " ";
}
return 0;
}
Yukarıdaki programı derleyip çalıştırdığımızda, aşağıdaki ifadeleri ekrana yazar:
1
2
3
4
5
il liste eleman sayısı: 10
Liste içeriği: 1 2 3 4 5 6 7 8 9 10
Liste içeriği: 1 4 9 16 25 36 49 64 81 100
Program, 10 elemanlı bir int liste ve bir int tekrarlayıcı bildirimi yapar. Listenin eleman sayısını size() fonksiyonu ile ekrana yazar. Önce, begin() fonksiyonu ile listenin ilk elemanının bellek adresini ipl adlı tekrarlayıcıya atar. Bir for döngüsü kullanarak, ipl tekrarlayıcısı end() fonksiyonu ile geri döndürülen bellek adresinden farklı olana kadar, id değişken değerini ipl tekrarlayıcısının bellek adresine atar. Döngünün her tekrarında ipl ve id değerleri bir kez artırılır. Aynı yöntemle liste eleman değerlerini ekrana yazar. Yine aynı yöntemle, liste içindeki her bir elemanın karesini yine kendisine atar ve eleman değerlerini ekrana yazar.
Şimdi, bir listedeki tek bir elemanın değerinin değiştirilmesini 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
#include <iostream>
#include <list>
#include <iterator>
using namespace std;
int main(void)
{
list<int> il(10); // 10 elemanlı bir int liste bildirimi yapar.
list<int>::iterator ipl; // Tekrarlayıcı bildirimi yapar.
int id;
// il listesinin eleman sayısını yazar.
cout << "il liste eleman sayısı: " << il.size() << endl;
// Listeye değer atama işlemi
for (ipl=il.begin(), id=1; ipl!=il.end(); ) {
*ipl++ = id++;
}
// Liste içeriğini ekrana yazma
cout << "Liste içeriği: ";
for (ipl=il.begin(); ipl!=il.end(); ) {
cout << *ipl++ << " ";
}
cout << endl;
ipl=il.begin();
advance(ipl, 4);
*ipl = 121;
// Liste içeriğini ekrana yazma
cout << "Liste içeriği: ";
for (ipl = il.begin(); ipl!=il.end(); ) {
cout << *ipl++ << " ";
}
return 0;
}
Yukarıdaki programı derleyip çalıştırdığımızda, aşağıdaki ifadeleri ekrana yazar:
1
2
3
4
5
il liste eleman sayısı: 10
Liste içeriği: 1 2 3 4 5 6 7 8 9 10
Liste içeriği: 1 2 3 4 121 6 7 8 9 10
Program, 10 elemanlı bir int liste ve bir int tekrarlayıcı bildirimi yapar. Listenin eleman sayısını size() fonksiyonu ile ekrana yazar. Önce, begin() fonksiyonu ile listeninin ilk elemanının bellek adresini ipl adlı tekrarlayıcıya atar. Bir for döngüsü kullanarak, ipl tekrarlayıcısı end() fonksiyonu ile geri döndürülen bellek adresinden farklı olana kadar, id değişken değerini ipl tekrarlayıcısının bellek adresine atar. Döngünün her tekrarında ipl ve id değerleri bir kez artırılır. Aynı yöntemle liste eleman değerlerini ekrana yazar. Sonra, begin() fonksiyonu ile listenin ilk elemanının bellek adresini tekrar ipl adlı tekrarlayıcıya atar. advance() fonksiyonu ile listedeki tekrarlayıcı değerini 4 ileri alarak listenin 5.elemanını gösterecek duruma getirir. Tekrarlayıcı kullanarak 5.elemana 121 değeri atar ve tüm liste eleman değerlerini tekrarlayıcı kullanarak tekrar ekran yazar.
Listeleri sıralama
Bir listede yer alan elemanları sort() fonksiyonunu kullanarak sıralayabiliriz. Fonksiyonu parametresiz olarak kullandığımızda, elemanlar küçükten büyüğe doğru sıralanır. Sıralamada istediğimiz yöntemi kullanmak istediğimizde bir fonksiyon tanımlayarak, bu fonksiyonu parametre olarak geçirerek sort() fonksiyonuna çağırabiliriz.
Şimdi, bir listedeki elemanların, sort() fonksiyonunun parametreli ve parametresiz olarak kullanılarak, sıralanması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
#include <iostream>
#include <list>
using namespace std;
bool comp(int id1, int id2) {
return (id1 > id2);
}
int main(void)
{
list<int> il = { 75, 21, 17, 84, 8, 35, 93, 46, 52 }; // C++11
list<int>::iterator ipl; // Tekrarlayıcı bildirimi yapar.
// Liste içeriğini ekrana yazma
cout << "Liste içeriği: ";
for (ipl=il.begin(); ipl!=il.end(); ) {
cout << *ipl++ << " ";
}
cout << endl;
// Küçükten büyüğe sıralama (fonksiyonsuz)
il.sort();
// Liste içeriğini ekrana yazma
cout << "Liste içeriği: ";
for (ipl=il.begin(); ipl!=il.end(); ) {
cout << *ipl++ << " ";
}
cout << endl;
// Büyükten küçüğe sıralama (fonksiyonlu)
il.sort(comp);
// Liste içeriğini ekrana yazma
cout << "Liste içeriği: ";
for (ipl=il.begin(); ipl!=il.end(); ) {
cout << *ipl++ << " ";
}
return 0;
}
Yukarıdaki programı derleyip çalıştırdığımızda, aşağıdaki ifadeleri ekrana yazar:
1
2
3
4
5
Liste içeriği: 75 21 17 84 8 35 93 46 52
Liste içeriği: 8 17 21 35 46 52 75 84 93
Liste içeriği: 93 84 75 52 46 35 21 17 8
Program, 10 elemanlı bir int liste ve bir int tekrarlayıcı bildirimi yapar. Liste eleman değerlerini ekrana yazar. Önce, sort() fonksiyonunu parametresiz olarak kullanarak, listedeki elemanları küçükten büyüğe doğru sıralar ve değerleri ekrana yazar. Sonra, sort() fonksiyonuna comp() fonksiyonunu parametre olarak geçirerek, listedeki elemanları büyükten küçüğe doğru sıralar ve değerleri ekrana yazar.
İki listeyi birleştirme
İki adet sıralanmış listeyi merge() fonksiyonunu kullanarak birleştirebiliriz. Listelerin birleştirilmiş hali yine küçükten büyüğe sıralı olarak merge() fonksiyonunu çağıran listenin yerini alır, parametre olarak işlem gören liste ise boş kalır.
Birleştirmek istediğimiz listelerin merge() fonksiyonu ile kullanılması için mutlaka sıralanmış olması gerekir.
Şimdi, iki sıralı listenin merge() fonksiyonu ile birleştirilmesini 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
#include <iostream>
#include <list>
using namespace std;
int main(void)
{
list<int> il1 = { 75, 21, 17, 84, 8, 35, 93, 46, 52 }; // C++11
list<int> il2 = { 43, 36, 54, 95, 5, 23, 86, 71, 18 }; // C++11
list<int>::iterator ipl; // Tekrarlayıcı bildirimi yapar.
// merge() fonksiyonu ile kullanılması için listelerin sıralanması
il1.sort(); // 8 17 21 35 46 52 75 84 93
il2.sort(); // 5 18 23 36 43 54 71 86 95
// il1 liste içeriğini ekrana yazma
cout << "il1 liste içeriği: ";
for (ipl=il1.begin(); ipl!=il1.end(); ) {
cout << *ipl++ << " ";
}
cout << endl;
// il2 liste içeriğini ekrana yazma
cout << "il2 liste içeriği: ";
for (ipl=il2.begin(); ipl!=il2.end(); ) {
cout << *ipl++ << " ";
}
cout << endl;
// Listeleri birleştirme
il1.merge(il2); // 5 8 17 18 21 23 35 36 43 46 52 54 71 75 84 86 93 95
// il1 liste içeriğini ekrana yazma
cout << "il1 liste içeriği: ";
for (ipl=il1.begin(); ipl!=il1.end(); ) {
cout << *ipl++ << " ";
}
cout << endl;
// il2 liste içeriğini ekrana yazma
cout << "il2 liste içeriği: ";
for (ipl=il2.begin(); ipl!=il2.end(); ) {
cout << *ipl++ << " ";
}
cout << endl;
return 0;
}
Yukarıdaki programı derleyip çalıştırdığımızda, aşağıdaki ifadeleri ekrana yazar:
1
2
3
4
5
6
il1 liste içeriği: 8 17 21 35 46 52 75 84 93
il2 liste içeriği: 5 18 23 36 43 54 71 86 95
il1 liste içeriği: 5 8 17 18 21 23 35 36 43 46 52 54 71 75 84 86 93 95
il2 liste içeriği:
Program, 10 elemanlı iki adet int liste ve bir int tekrarlayıcı bildirimi yapar. Her iki listeyi sort() fonksiyonu ile sıraladıktan sonra, listelerin eleman değerlerini ekrana yazar. Listeleri merge() fonksiyonu ile birleştirdikten sonra, listelerin eleman değerlerini tekrar ekrana yazar. İşlem sonrasında, listelerin birleşmiş ve sıralı halinin il1 listesine aktarıldığı, il2 listesinin ise boş olduğu görülür.
Şimdi, iki sıralı listenin merge() fonksiyonu ile, karşılaştırma fonksiyonu kullanarak, birleştirilmesini 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
#include <iostream>
#include <list>
using namespace std;
bool comp(int id1, int id2) {
return (id1 > id2);
}
int main(void)
{
list<int> il1 = { 75, 21, 17, 84, 8, 35, 93, 46, 52 }; // C++11
list<int> il2 = { 43, 36, 54, 95, 5, 23, 86, 71, 18 }; // C++11
list<int>::iterator ipl; // Tekrarlayıcı bildirimi yapar.
// merge() fonksiyonu ile kullanılması için listelerin sıralanması
il1.sort(comp); // 93 84 75 52 46 35 21 17 8
il2.sort(comp); // 95 86 71 54 43 36 23 18 5
// il1 liste içeriğini ekrana yazma
cout << "il1 liste içeriği: ";
for (ipl=il1.begin(); ipl!=il1.end(); ) {
cout << *ipl++ << " ";
}
cout << endl;
// il2 liste içeriğini ekrana yazma
cout << "il2 liste içeriği: ";
for (ipl=il2.begin(); ipl!=il2.end(); ) {
cout << *ipl++ << " ";
}
cout << endl;
// Büyükten küçüğe sıralama (fonksiyonlu)
il1.merge(il2, comp); // 95 93 86 84 75 71 54 52 46 43 36 35 23 21 18 17 8 5
// il1 liste içeriğini ekrana yazma
cout << "il1 liste içeriği: ";
for (ipl=il1.begin(); ipl!=il1.end(); ) {
cout << *ipl++ << " ";
}
cout << endl;
// il2 liste içeriğini ekrana yazma
cout << "il2 liste içeriği: ";
for (ipl=il2.begin(); ipl!=il2.end(); ) {
cout << *ipl++ << " ";
}
cout << endl;
return 0;
}
Yukarıdaki programı derleyip çalıştırdığımızda, aşağıdaki ifadeleri ekrana yazar:
1
2
3
4
5
6
il1 liste içeriği: 93 84 75 52 46 35 21 17 8
il2 liste içeriği: 95 86 71 54 43 36 23 18 5
il1 liste içeriği: 95 93 86 84 75 71 54 52 46 43 36 35 23 21 18 17 8 5
il2 liste içeriği:
Program, 10 elemanlı iki adet int liste ve bir int tekrarlayıcı bildirimi yapar. Her iki listeyi, comp() fonksiyonunu parametre olarak geçirerek, sort() fonksiyonu ile büyükten küçüğe doğru sıraladıktan sonra, listelerin eleman değerlerini ekrana yazar. Listeleri, comp() fonksiyonunu parametre olarak geçirerek, merge() fonksiyonu ile birleştirdikten sonra, listelerin eleman değerlerini tekrar ekrana yazar. İşlem sonrasında, listelerin birleşmiş ve sıralı halinin il1 listesine aktarıldığı, il2 listesinin ise boş olduğu görülür.
Listelerle sınıf nesneleri kullanma
Bir listeye herhangi bir veri türünden oluşturulan nesneleri kaydedebiliriz.
Şimdi, bir liste ü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
#include <iostream>
#include <list>
using namespace std;
class sinif {
private:
int priid;
protected:
int proid;
public:
int pubid;
sinif(int pid1, int pid2, int pid3)
{
priid = pid1; proid = pid2; pubid = pid3;
}
sinif() { };
void deger_ata(int pid1, int pid2, int pid3)
{
priid = pid1; proid = pid2; pubid = pid3;
}
void deger_goster()
{
cout << "priid=" << priid << " proid=" << proid << " pubid=" << pubid << endl;
}
};
int main(void)
{
list<sinif> cl(5); // 5 elemanlı bir sinif liste bildirimi yapar.
list<sinif>::iterator clv; // Tekrarlayıcı bildirimi yapar.
int id;
// Liste içindeki nesnelere değer atama işlemi
for (clv=cl.begin(), id=1; clv!=cl.end(); id++) {
clv++->deger_ata(id, id*id, id*id*id);
}
// Liste içindeki nesne değişken değerlerini ekrana yazma
for (clv=cl.begin(); clv!=cl.end(); ) {
clv++->deger_goster();
}
cout << endl;
// Listeye nesne ekleme
for(id=cl.size()+1; id<=10; id++) cl.push_back(sinif(id, id*id, id*id*id));
// Liste içindeki nesne değişken değerlerini ekrana yazma
for (clv=cl.begin(); clv!=cl.end(); ) {
clv++->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
priid=1 proid=1 pubid=1
priid=2 proid=4 pubid=8
priid=3 proid=9 pubid=27
priid=4 proid=16 pubid=64
priid=5 proid=25 pubid=125
priid=1 proid=1 pubid=1
priid=2 proid=4 pubid=8
priid=3 proid=9 pubid=27
priid=4 proid=16 pubid=64
priid=5 proid=25 pubid=125
priid=6 proid=36 pubid=216
priid=7 proid=49 pubid=343
priid=8 proid=64 pubid=512
priid=9 proid=81 pubid=729
priid=10 proid=100 pubid=1000
Program, içinde private, protected ve public olmak üzere üç adet 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.
sinif türünden 5 elemanlı bir liste ve bir tekrarlayıcı bildirimi yapar. Liste içindeki her bir nesneyi gösteren tekrarlayıcıyı sıra ile kullanarak deger_ata() fonksiyonu yoluyla sınıf içindeki değişkenlere 1-5 arasındaki sayıların sırasıyla kendisini, karesini ve küpünü atar. Sonra, deger_goster() fonksiyonu yoluyla, liste içindeki nesnelerin temsil ettiği sınıf kopyasının değişken değerlerini tekrarlayıcı kullanarak ekrana yazar.
Önce, push_back() fonksiyonunu kullanarak, liste sonuna 5 yeni nesne ekler. Bu fonksiyona geçirilen parametre değeri parametreli constructor fonksiyonudur. Sonra, deger_goster() fonksiyonu yoluyla, liste içindeki nesnelerin temsil ettiği sınıf kopyasının değişken değerlerini tekrarlayıcı kullanarak tekrar ekrana yazar.