Kontener typu list

Stronę tą wyświetlono już: 22 razy

Wstęp

Klasa list jest dostępna w pliku nagłówkowym list i umożliwia przechowywanie obiektów określonego typu lub typów prostych z łatwym dostępem do elementu końcowego, początkowego oraz wewnętrznych elementów. Implementacja klasy list różni się od implementacji klasy vector metodami jakie te dwie klasy udostępniają. Jeżeli potrzebujesz łatwej możliwości zdejmowania ostatniego lub pierwszego elementu to właśnie klasa list jest tym czego szukasz. Oczywiście nie oznacza to, że klasa vector nie umożliwia takiego działania, a jedynie to, że klasa ta nie ma metody realizującej to zadanie.

Konstruktory klasy list

Standardowo klasa list ma zdefiniowany konstruktor bezparametrowy oraz konstruktor kopiujący:

Listing 1
  1. std::list<int> firstList;
  2. std::list<int> secondList(firstList);

Możliwe jest również zainicjalizowanie obiektu klasy list wartościami już na etapie konstruktora:

Listing 2
  1. std::list<int> myList(5, 20);

Powyższy kod doda 5 elementów o wartości równej 20.

Możliwe jest skopiowanie zakresu wartości z innej listy tego samego typu:

Listing 3
  1. std::list<int> firstList(5, 20);
  2. std::list<int> secondList(firstList.begin(), firstList.end());

Można również skopiować zawartość tablicy statycznej w następujący sposób:

Listing 4
  1. int values[] = {0, 1, 2, 3, 4, 5};
  2. std::list<int> myList(values, values + sizeof(values) / sizeof(int) );

Iterowanie po elementach obiektu klasy list

Jak większość kontenerów klasa list pozwala na iterowanie po jej elementach w następujący sposób:

Listing 5
  1. int values[] = {0, 1, 2, 3, 4, 5};
  2. std::list<int> myList(values, values + sizeof(values) / sizeof(int) );
  3. for(std::list<int>::iterator element = myList.begin(); element != myList.end(); element++){
  4. std::cout << *element << std::endl;
  5. }

Dodawanie elementów do obiektu klasy list

Do obiektu klasy list można dodać element na jej początku za pomocą metody push_front:

Listing 6
  1. int values[] = {0, 1, 2, 3, 4, 5};
  2. std::list<int> myList(values, values + sizeof(values) / sizeof(int) );
  3. myList.push_front(100);
  4. for(std::list<int>::iterator element = myList.begin(); element != myList.end(); element++){
  5. std::cout << *element << std::endl;
  6. }

Powyższy kod spowoduje wyświetlenie:

100
0
1
2
3
4
5

Z kolei metoda push_back (jak nie trudno się domyślić) pozwala na dodawanie elementów na końcu listy.

Możliwe jest również dodanie elementu lub elementów na określonym miejscu w obiekcie klasy list za pomocą metody insert:

Listing 7
  1. int values[] = {0, 1, 2, 3, 4, 5};
  2. std::list<int> myList(values, values + sizeof(values) / sizeof(int) );
  3. myList.insert(++myList.begin(), 100);
  4. for(std::list<int>::iterator element = myList.begin(); element != myList.end(); element++){
  5. std::cout << *element << std::endl;
  6. }

Niestety wskaźnik na element listy nie obsługuje operatora + więc umieszczanie elementów wewnątrz listy jest dość utrudnione. Wynik powyższego kodu:

0
100
1
2
3
4
5

Można dodawać również zakres wartości:

Listing 8
  1. int values[] = {0, 1, 2, 3, 4, 5};
  2. std::list<int> firstList(values, values + sizeof(values) / sizeof(int) );
  3. std::list<int> secondList(2, 5);
  4. secondList.insert(secondList.begin(), firstList.begin(), firstList.end());
  5. for(std::list<int>::iterator element = secondList.begin(); element != secondList.end(); element++){
  6. std::cout << *element << std::endl;
  7. }

Wynik działania powyższego kodu:

0
1
2
3
4
5
5
5

Można to samo zrobić z tablicą statyczną:

Listing 9
  1. int values[] = {0, 1, 2, 3, 4, 5};
  2. std::list<int> myList(2, 5);
  3. myList.insert(secondList.begin(), values, values + sizeof(values) / sizeof(int));
  4. for(std::list<int>::iterator element = myList.begin(); element != myList.end(); element++){
  5. std::cout << *element << std::endl;
  6. }

Zdejmowanie elementów klasy list

Z obiektu klasy list można zdjąć element początkowy metodą pop_front lub końcowy metodą pop_back. Metody te nie zwracają wartości zdejmowanych elementów.

Dostęp do początkowej i końcowej wartości zawartej w obiekcie klasy list

Klasa list umożliwia łatwy dostęp tylko do początkowego i ostatniego jej elementu za pośrednictwem metod: front i back.

Usuwanie elementów z obiektu klasy list

Do usuwania elementów z obiektu klasy list służy metoda erase:

Listing 10
  1. int values[] = {0, 1, 2, 3, 4, 5};
  2. std::list<int> myList(values, values + sizeof(values) / sizeof(int) );
  3. myList.erase(++myList.begin());
  4. for(std::list<int>::iterator element = myList.begin(); element != myList.end(); element++){
  5. std::cout << *element << std::endl;
  6. }

Powyższy kod spowoduje wyświetlenie:

0
2
3
4
5

Możliwe jest również usuwanie zakresu elementów, np tak:

Listing 11
  1. myList.erase(++myList.begin(), myList.end());

Można również opróżnić obiekt klasy list metodą clear.

Dostępna jest również metoda remove umożliwiająca usunięcie elementów o takiej samej wartości jak podany jako argument tejże metody:

Listing 12
  1. int values[] = {0, 1, 2, 3, 4, 5};
  2. std::list<int> myList(values, values + sizeof(values) / sizeof(int) );
  3. myList.remove(2);
  4. for(std::list<int>::iterator element = myList.begin(); element != myList.end(); element++){
  5. std::cout << *element << std::endl;
  6. }

Wynik działania powyższego kodu:

0
1
3
4
5

Liczba elementów obiektu klasy list

Liczbę elementów zawartych w obiekcie klasy list można pozyskać za pomocą metody size.

Sprawdzanie, czy obiekt klasy list jest pusty

Metoda empty zwraca true, gdy obiekt klasy list jest pusty.

Sortowanie elementów obiektu klasy list

Klasa list ma wbudowaną metodę sort umożliwiającą sortowanie jej elementów:

Listing 13
  1. int values[] = {5, 1, 2, 3, 4, 0};
  2. std::list<int> myList(values, values + sizeof(values) / sizeof(int) );
  3. myList.sort();
  4. for(std::list<int>::iterator element = myList.begin(); element != myList.end(); element++){
  5. std::cout << *element << std::endl;
  6. }

Wynik działania powyższego kodu:

0
1
2
3
4
5

Odwracanie kolejności elementów zawartych w obiekcie klasy list

Metoda reverse umożliwia odwrócenie kolejności elementów zawartych w obiekcie klasy list.

Listing 14
  1. int values[] = {0, 1, 2, 3, 4, 5};
  2. std::list<int> myList(values, values + sizeof(values) / sizeof(int) );
  3. myList.sort();
  4. for(std::list<int>::iterator element = myList.begin(); element != myList.end(); element++){
  5. std::cout << *element << std::endl;
  6. }

Wynik działania powyższego kodu:

5
4
3
2
1
0
Strony powiązane
strony powiązane
  1. cplusplus.com/reference/list/list/ - opis klasy list

Komentarze