Taşıyıcılar (Containers) kitaplığı - cppreference.com

NOT: Bu başlığın çevirisi devam etmektedir. Siz de bir kısmını çevirerek katkıda bulunabilirsiniz.

C++ Taşıyıcılar (Containers) Kitaplığı programcılara kuyruklar, listeler ve yığınlar gibi standart veri yapılarını kolayca geliştirme olanağı sağlayan, genel amaçlı bir sınıf şablonları ve algoritmaları bütünüdür. Her biri farklı işlemler için tasarlanan üç tür taşıyıcı vardır: dizi taşıyıcıları, ilişkili taşıyıcılar ve sırasız ilişkili taşıyıcılar.

Taşıyıcı, öğeleri için ayrılan depolama alanını yönetir ve doğrudan veya iterator denen işaretçi (pointer) benzeri yapılar yoluyla bunlara erişmek için bazı üye fonksiyonlar (member functions) sağlar.

Çoğu taşıyıcı birbirlerininkine benzer en az birkaç üye fonksiyona ve benzer bazı işlevselliğe sahiptir. Belirli bir uygulama için hangi taşıyıcının iyi olduğu sadece sunulan işleve değil, aynı zamanda farklı iş yükleri için verimliliğine de bağlıdır.

Dizi (Sequence) taşıyıcıları

Dizi taşıyıcıları öğelerine ardışık şekilde erişilebilen veri yapılarıdır.

	statik (sabit boyuylu) bitişik dizi (sınıf şablonu) [edit]
	dinamik (değişken boyutlu) bitişik dizi (sınıf şablonu) [edit]
	çift uçlu kuyruk (sınıf şablonu) [edit]
	tek bağlantılı liste (sınıf şablonu) [edit]
	çift bağlantılı liste (sınıf şablonu) [edit]

İlişkili (Associative) taşıyıcılar

İlişkili taşıyıcılar hızlıca aranabilen (O(log n) karmaşıklıkta) otomatik olarak sıralanmış veri yapılarıdır. Genellikle kırmızı-siyah ağaç (red-black tree) şeklindedirler.

	benzersiz anahtarlar koleksiyonu, anahtarlarına göre sıralanır (sınıf şablonu) [edit]
	anahtar/değer çiftleri koleksiyonu, anahtarlarına göre sıralanır, anahtarları benzersizdir (sınıf şablonu) [edit]
	benzersiz olmayan anahtarlar koleksiyonu, anahtarlarına göre sıralanır (sınıf şablonu) [edit]
	anahtar/değer çiftleri koleksiyonu, anahtarlarına göre sıralanır, anahtarları benzersiz değildir (sınıf şablonu) [edit]

Sırasız ilişkili (Unordered Associative) taşıyıcılar

Sırasız ilişkili taşıyıcılar hızlıca aranabilen (O(1) genel, O(n) en kötü durum zaman karmaşıklığı) ve bunun için içindeki öğelerin hash değerini alan veri yapılarıdır.

	benzersiz anahtarlar koleksiyonu, anahtarları hash değeri alınarak saklanır (sınıf şablonu) [edit]
	anahtar/değer çiftleri koleksiyonu, anahtarları hash değeri alınarak saklanır, anahtarları benzersizdir (sınıf şablonu) [edit]
	benzersiz olmayan anahtarlar koleksiyonu, anahtarları hash değeri alınarak saklanır (sınıf şablonu) [edit]
	benzersiz olmayan anahtarlar koleksiyonu, anahtarları hash değeri alınarak saklanır, anahtarları benzersiz olmayabilir (sınıf şablonu) [edit]

Taşıyıcı uyarlayıcıları

Taşıyıcı uyarlayıcıları (Container adaptors) dizi taşıyıcıları için farklı bir arayüz sağlar.

	bir taşıyıcıyı yığın (LIFO: Son giren ilk çıkar) veri yapısına uyarlar (sınıf şablonu) [edit]
	bir taşıyıcıyı kuyruk (FIFO: İlk giren ilk çıkar) veri yapısına uyarlar (sınıf şablonu) [edit]
	bir taşıyıcıyı öncelik kuyruğu (priority queue) veri yapısına uyarlar (sınıf şablonu) [edit]

`span`

A span is a non-owning view over a contiguous sequence of objects, the storage of which is owned by some other object.

a non-owning view over a contiguous sequence of objects
(sınıf şablonu) [edit]

Yineleyici geçersizleşmesi

Salt-okunur fonksiyonlar hiçbir zaman yineleyicileri veya referansları geçersiz yapmaz. Taşıyıcının içeriğini değiştiren fonksiyonlar ise aşağıdaki tabloda görüldüğü gibi bazen yineleyicileri ve/veya referansları geçersiz hale getirebilir.

Kategori	Taşıyıcı	Bir öğe eklendikten sonra...		Bir öğe silindikten sonra...		Eğer
Kategori	Taşıyıcı	yineleyiciler geçerli mi?	referanslar geçerli mi?	yineleyiciler geçerli mi?	referanslar geçerli mi?	Eğer
Dizi taşıyıcıları	`array`	N/A		N/A
	`vector`	Hayır		N/A		Öğe eklemek kapasiteyi değiştirirse
		Evet		Evet		Öğe(ler)i değiştirmeden önce ise
		Hayır		Hayır		Öğe(ler)i değiştirme anında veya sonra ise
	`deque`	Hayır	Evet	Evet, silinen öğe(ler) hariç		İlk veya son öğe değiştirildiyse
	`deque`	Hayır	Hayır	Hayır		Sadece ortadan değiştirme yapıldıysa
	`list`	Evet		Evet, silinen öğe(ler) hariç
	`forward_list`	Evet		Evet, silinen öğe(ler) hariç
İlişkili taşıyıcılar	`set` `multiset` `map` `multimap`	Evet		Evet, silinen öğe(ler) hariç
Sırasız ilişkili taşıyıcılar	`unordered_set` `unordered_multiset` `unordered_map` `unordered_multimap`	Hayır	Evet	N/A		Öğe eklemek yeniden hash almaya neden olursa
Sırasız ilişkili taşıyıcılar		Evet	Evet	Evet, silinen öğe(ler) hariç		Yeniden hash alınmazsa

Burada öğe ekleme ile taşıyıcıya bir ya da birden fazla öğe ekleyen foksiyonlardan, öğe silme ile de taşıyıcıdan bir veya birden fazla öğe silen fonksiyonlardan bahsedilir.

Öğe ekleyen fonksiyonlara std::set::insert, std::map::emplace, std::vector::push_back, ve std::deque::push_front örnek verilebilir.
- Note that std::unordered_map::operator[] also counts, as it may insert an element into the map.
- std::unordered_map::operator[]
Examples of erasure methods are std::set::erase, std::vector::pop_back, std::deque::pop_front, and std::map::clear.
- clear invalidates all iterators and references. Because it erases all elements, this technically complies with the rules above.

The past-the-end iterator deserves particular mention. In general this iterator is invalidated as though it were a normal iterator to a non-erased element. So std::set::end is never invalidated, std::unordered_set::end is invalidated only on rehash, std::vector::end is always invalidated (since it is always after the modified elements), and so on.

There is one exception: an erasure which deletes the last element of a std::deque does invalidate the past-the-end iterator, even though it is not an erased element of the container (or an element at all). Combined with the general rules for std::deque iterators, the net result is that the only modifying operation which does not invalidate std::deque::end is an erasure which deletes the first element, but not the last.

İş parçacığı güvenliği

Bütün taşıyıcı fonksiyonları farklı taşıyıcılar üzerinde ve farklı iş parçacıkları tarafından eşzamanlı olarak çağrılabilir. Daha genel olarak, C++ standart kitaplığı fonksiyonları, nesneler doğrudan ya da dolaylı olarak fonksiyon argümanları vasıtasıyla (this işaretçisi dahil) erişilebilir olmadığı sürece, başka iş parçacıkları tarafından erişilebilir olan nesneleri okumazlar.
Bütün const üye fonksiyonları aynı taşıyıcı üzerinde ve farklı iş parçacıkları tarafından eşzamanlı olarak çağrılabilir. Bununla beraber, begin(), end(), rbegin(), rend(), front(), back(), data(), find(), lower_bound(), upper_bound(), equal_range(), at(), ve ilişkili taşıyıcılar hariç operator[], iş parçacığı güvenliği amacıyla const gibi davranır. (yani, onlar da aynı taşıyıcı üzerinde ve farklı iş parçacıkları tarafından eşzamanlı olarak çağrılabilir.) Daha genel olarak, C++ standart kitaplığı fonksiyonları, nesneler doğrudan ya da dolaylı olarak const-olmayan fonksiyon argümanları vasıtasıyla (this işaretçisi dahil) erişilebilir olmadığı sürece, başka iş parçacıkları tarafından erişilebilir olan nesneler üzerinde değişiklik yapmazlar.
Aynı taşıyıcı üzerindeki farklı öğeler üzerinde, farkli iş parçacıkları tarafından eşzamanlı olarak değişiklik yapılabilir(std::vector<bool> hariç). Örneğin, std::future nesnelerini taşıyan bir std::vector birden fazla iş parçacığından veri alıyor olabilir.
Iterator operations (e.g. incrementing an iterator) read, but do not modify the underlying container, and may be executed concurrently with operations on other iterators on the same container, with the const member functions, or reads from the elements. Container operations that invalidate any iterators modify the container and cannot be executed concurrently with any operations on existing iterators even if those iterators are not invalidated.
Elements of the same container can be modified concurrently with those member functions that are not specified to access these elements. More generally, the C++ standard library functions do not read objects indirectly accessible through their arguments (including other elements of a container) except when required by its specification.
In any case, container operations (as well as algorithms, or any other C++ standard library functions) may be parallelized internally as long as this does not change the user-visible results (e.g. std::transform may be parallelized, but not std::for_each which is specified to visit each element of a sequence in order)

(C++11'den beri)

Üye fonksiyon tablosu

	- C++03'ten beri mevcut olan fonksiyonlar
	- C++11'den beri mevcut olan fonksiyonlar
	- C++17'den beri mevcut olan fonksiyonlar
	- C++20'den beri mevcut olan fonksiyonlar