Dyrektywy preprocesora
Typy proste arytmetyczne
Typ prosty wyliczeniowy
Operatory
Dev C++ - tworzenie projektu
Strumienie we/wy cin i cout
Funkcje obsługi we/wy printf i scanf
Kolory w konsoli
Instrukcja warunkowa if, else if oraz else
Instrukcja switch, case, default
Pętla for
Pętla for iterująca po zakresie dostępna w standardzie C++11
Pętla while i do while
Tablice statyczne i dynamiczne
Funkcje
Szablony funkcji
Argumenty funkcji main
Modyfikatory dostępu do wartości const i static
Obszary dostępu do zmiennych
Funkcje i stałe matematyczne
Generowanie liczb pseudo losowych za pomocą funkcji srand oraz rand
Struktury
Tworzenie własnej listy dwukierunkowej
Klasy
Szablony klas na przykładzie własnej kolejki LIFO (stosu)
Metody wirtualne, czysto wirtualne oraz klasy abstrakcyjne
Obsługa i przeciążanie operatorów klas
Rzutowanie typów kompatybilnych za pomocą static_cast
Rzutowanie w dół i rzutowanie w górę za pomocą funkcji dynamic_cast
Rzutowanie za pomocą funkcji reinterpret_cast
Kontener typu stack - stos
Kontener typu list
Kontener typu vector
Kontener typu map - tablica asocjacyjna
Kontener typu unordered_map - tablica asocjacyjna
Kontener typu set - zbiór
Kontener typu unordered_set - zbiór niesortowany
Sortowanie elementów kontenera vector
Klasa string
Funkcje związane z operacjami na łańcuchach znaków
Konwersja tekst - liczba
Operacje we/wy na plikach
Przeszukiwanie ścieżki w poszukiwaniu plików za pomocą funkcji _findfirst i _findnext
Własne pliki nagłówkowe .h
Polskie znaki w konsoli
Menu konsolowe z wykorzystaniem funkcji getch
Zmiana rozmiarów okna i bufora konsoli
Ta strona należy do działu:
poddziału
Autor podstrony: Krzysztof Zajączkowski
Stronę tą wyświetlono już: 4018 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:
std::list<int> firstList;
std::list<int> secondList(firstList);
Możliwe jest również zainicjalizowanie obiektu klasy list wartościami już na etapie konstruktora:
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:
std::list<int> firstList(5, 20);
std::list<int> secondList(firstList.begin(), firstList.end());
Można również skopiować zawartość tablicy statycznej w następujący sposób:
int values[] = {0, 1, 2, 3, 4, 5};
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:
int values[] = {0, 1, 2, 3, 4, 5};
std::list<int> myList(values, values + sizeof(values) / sizeof(int) );
for(std::list<int>::iterator element = myList.begin(); element != myList.end(); element++){
std::cout << *element << std::endl;
}
Dodawanie elementów do obiektu klasy list
Do obiektu klasy list można dodać element na jej początku za pomocą metody push_front :
int values[] = {0, 1, 2, 3, 4, 5};
std::list<int> myList(values, values + sizeof(values) / sizeof(int) );
myList.push_front(100);
for(std::list<int>::iterator element = myList.begin(); element != myList.end(); element++){
std::cout << *element << std::endl;
}
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 :
int values[] = {0, 1, 2, 3, 4, 5};
std::list<int> myList(values, values + sizeof(values) / sizeof(int) );
myList.insert(++myList.begin(), 100);
for(std::list<int>::iterator element = myList.begin(); element != myList.end(); element++){
std::cout << *element << std::endl;
}
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:
int values[] = {0, 1, 2, 3, 4, 5};
std::list<int> firstList(values, values + sizeof(values) / sizeof(int) );
std::list<int> secondList(2, 5);
secondList.insert(secondList.begin(), firstList.begin(), firstList.end());
for(std::list<int>::iterator element = secondList.begin(); element != secondList.end(); element++){
std::cout << *element << std::endl;
}
Wynik działania powyższego kodu:
0
1
2
3
4
5
5
5
Można to samo zrobić z tablicą statyczną:
int values[] = {0, 1, 2, 3, 4, 5};
std::list<int> myList(2, 5);
myList.insert(secondList.begin(), values, values + sizeof(values) / sizeof(int));
for(std::list<int>::iterator element = myList.begin(); element != myList.end(); element++){
std::cout << *element << std::endl;
}
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 :
int values[] = {0, 1, 2, 3, 4, 5};
std::list<int> myList(values, values + sizeof(values) / sizeof(int) );
myList.erase(++myList.begin());
for(std::list<int>::iterator element = myList.begin(); element != myList.end(); element++){
std::cout << *element << std::endl;
}
Powyższy kod spowoduje wyświetlenie:
0
2
3
4
5
Możliwe jest również usuwanie zakresu elementów, np tak:
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:
int values[] = {0, 1, 2, 3, 4, 5};
std::list<int> myList(values, values + sizeof(values) / sizeof(int) );
myList.remove(2);
for(std::list<int>::iterator element = myList.begin(); element != myList.end(); element++){
std::cout << *element << std::endl;
}
Wynik działania powyższego kodu:
0
1
3
4
5
W przypadku, gdy lista przechowuje obiekty jakiejś klasy aby metoda remove mogła zostać wykorzystana do usunięcia elementu z listy konieczne jest obsłużenie operatorów == i != .
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:
int values[] = {5, 1, 2, 3, 4, 0};
std::list<int> myList(values, values + sizeof(values) / sizeof(int) );
myList.sort();
for(std::list<int>::iterator element = myList.begin(); element != myList.end(); element++){
std::cout << *element << std::endl;
}
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 .
int values[] = {0, 1, 2, 3, 4, 5};
std::list<int> myList(values, values + sizeof(values) / sizeof(int) );
myList.sort();
for(std::list<int>::iterator element = myList.begin(); element != myList.end(); element++){
std::cout << *element << std::endl;
}
Wynik działania powyższego kodu:
5
4
3
2
1
0
Strony powiązane Tematy powiązane
