Programowanie w C++ oferuje szeroki wachlarz typów danych, które mogą być wykorzystane w różnych sytuacjach w celu optymalizacji wydajności, zwiększenia czytelności kodu lub lepszego zarządzania pamięcią. Oprócz standardowych typów danych, takich jak int, double, czy char, C++ udostępnia również bardziej zaawansowane i specjalistyczne typy danych, które mogą znacznie ułatwić pracę programistom. W tej lekcji omówimy takie typy jak std::string, std::vector, std::array, std::map, std::set oraz inne kontenery z biblioteki STL (Standard Template Library). Zrozumienie i efektywne wykorzystanie tych typów danych jest kluczowe dla pisania wydajnych i dobrze zorganizowanych aplikacji.

1. Typ std::string

Jednym z najczęściej używanych typów danych w C++ do pracy z tekstem jest std::string. Jest to klasa zdefiniowana w bibliotece standardowej, która pozwala na wygodne manipulowanie ciągami znaków bez potrzeby zarządzania pamięcią w sposób ręczny, jak to jest konieczne w przypadku tablic znakowych char*.

Podstawowe operacje na std::string

#include <iostream>
#include <string>

int main() {
    std::string tekst = "Witaj, świecie!";
    std::cout << "Długość tekstu: " << tekst.length() << std::endl;
    tekst += " Jak się masz?";
    std::cout << "Po dodaniu tekstu: " << tekst << std::endl;
    return 0;
}

W powyższym przykładzie używamy klasy std::string do przechowywania i manipulowania tekstem. Metody takie jak length() i operator += ułatwiają operacje na ciągach znaków.

Główne funkcje i metody std::string

• length(): Zwraca długość ciągu znaków.
• substr(): Zwraca podciąg znaków.
• find(): Szuka podciągu w ciągu znaków.
• replace(): Zamienia część ciągu znaków na inny ciąg.

2. Kontenery sekwencyjne: std::vector i std::array

Kiedy musimy przechowywać kolekcję elementów o tym samym typie, możemy skorzystać z kontenerów sekwencyjnych. Najczęściej używane kontenery tego typu to std::vector i std::array.

std::vector

std::vector to dynamiczna tablica, która automatycznie zmienia swój rozmiar w miarę dodawania lub usuwania elementów. Dzięki temu jest znacznie bardziej elastyczna niż zwykła tablica.

Przykład użycia std::vector

#include <iostream>
#include <vector>

int main() {
    std::vector<int> liczby = {1, 2, 3, 4, 5};
    liczby.push_back(6); // Dodaj element na końcu
    for (int liczba : liczby) {
        std::cout << liczba << " ";
    }
    std::cout << std::endl;
    return 0;
}

W powyższym przykładzie używamy std::vector do przechowywania i iteracji po elementach. Metoda push_back() umożliwia dodanie nowego elementu na końcu wektora.

std::array

std::array to kontener wprowadzony w C++11, który reprezentuje statyczną tablicę o stałym rozmiarze. Jest bezpieczniejszy i bardziej elastyczny niż tradycyjna tablica C.

Przykład użycia std::array

#include <iostream>
#include <array>

int main() {
    std::array<int, 5> liczby = {1, 2, 3, 4, 5};
    for (int liczba : liczby) {
        std::cout << liczba << " ";
    }
    std::cout << std::endl;
    return 0;
}

std::array zapewnia wszystkie funkcje standardowej tablicy, ale z dodatkowymi metodami, takimi jak size(), które zwiększają bezpieczeństwo i wygodę programisty.

3. Kontenery asocjacyjne: std::map i std::set

Kontenery asocjacyjne są przeznaczone do przechowywania elementów w uporządkowany sposób, umożliwiając szybkie wyszukiwanie, dodawanie i usuwanie. Najpopularniejsze kontenery asocjacyjne to std::map i std::set.

std::map

std::map to kontener, który przechowuje pary klucz-wartość, umożliwiając szybki dostęp do wartości na podstawie klucza.

Przykład użycia std::map

#include <iostream>
#include <map>

int main() {
    std::map<std::string, int> wiek;
    wiek["Jan"] = 25;
    wiek["Anna"] = 30;
    wiek["Piotr"] = 22;

    for (const auto& para : wiek) {
        std::cout << para.first << ": " << para.second << " lat" << std::endl;
    }
    return 0;
}

W tym przykładzie std::map przechowuje wiek osób na podstawie ich imienia. Klucze w std::map są unikalne, a elementy są automatycznie sortowane.

std::set

std::set to kontener, który przechowuje unikalne elementy w uporządkowany sposób. Jest użyteczny, gdy musimy przechowywać zbiór elementów bez duplikatów.

Przykład użycia std::set

#include <iostream>
#include <set>

int main() {
    std::set<int> liczby = {5, 3, 1, 4, 2};
    liczby.insert(6); // Dodaj nowy element

    for (int liczba : liczby) {
        std::cout << liczba << " ";
    }
    std::cout << std::endl;
    return 0;
}

W powyższym przykładzie std::set przechowuje liczby w uporządkowany sposób, a metoda insert() dodaje nowy element do zbioru.

4. Inne przydatne typy danych

Oprócz wyżej wymienionych kontenerów, C++ oferuje również inne przydatne typy danych, takie jak std::deque, std::stack, std::queue, std::unordered_map i std::unordered_set. Każdy z tych typów ma swoje specyficzne zastosowania i zalety.

std::deque

std::deque (dwukierunkowa kolejka) to kontener, który umożliwia szybkie dodawanie i usuwanie elementów zarówno na początku, jak i na końcu.

Przykład użycia std::deque

#include <iostream>
#include <deque>

int main() {
    std::deque<int> liczby = {1, 2, 3};
    liczby.push_front(0); // Dodaj na początek
    liczby.push_back(4);  // Dodaj na koniec

    for (int liczba : liczby) {
        std::cout << liczba << " ";
    }
    std::cout << std::endl;
    return 0;
}

std::deque jest szczególnie przydatny, gdy często musimy modyfikować oba końce kontenera.

Podsumowanie

W tej lekcji zapoznałeś się z różnymi przydatnymi typami danych w C++, takimi jak std::string, std::vector, std::array, std::map, std::set oraz innymi kontenerami. Każdy z tych typów ma swoje unikalne cechy i zastosowania, które mogą znacznie ułatwić pisanie bardziej efektywnego i czytelnego kodu. Wybór odpowiedniego typu danych zależy od specyficznych wymagań projektu i operacji, które chcemy wykonać na danych. Dzięki zrozumieniu tych typów będziesz w stanie projektować bardziej zaawansowane i skalowalne aplikacje.

Następna lekcja ==> Wskaźniki i pamięć dynamiczna