C++'da Vector, ihtiyaca göre kendisini dinamik olarak artıran tek boyutlu bir veri yapısıdır. Bu veri yapısında veri organizasyonu (ekleme/değiştirme/silme) verimli bir şekilde yapılabilmektedir. Uygulamaları aşağıdakileri içerir:
- Matematiksel vektörlerin bilimsel ve mühendislik uygulamalarında temsil edilmesi
- Kuyruklar, yığınlar bu veri yapısı vb. kullanılarak uygulanabilir.
Bu veri yapısına ilişkin yaygın CRUD işlemlerinin ve işlevlerinin çoğu, sözdizimi ve kod parçacıklarıyla birlikte senaryo bazında ayrıntılı olarak tartışılmaktadır.
İçeriğin Konusu:
- Bir Vektöre Öğe Ekleme
- Bir Vektöre Birden Çok Öğe Ekleme
- Bir Vektörden Öğelere Erişme
- Bir Vektördeki Öğeyi Güncelleme
- Bir Vektörden Belirli Bir Öğeyi Kaldırma
- Bir Vektörden Tüm Öğeleri Kaldırma
- Vektörlerin Birliği
- Vektörlerin Kesişimi
- Vektörün Boş Olup Olmadığını Kontrol Edin
- Const_Iterator Kullanarak Bir Vektörü Geçme
- Reverse_Iterator Kullanarak Bir Vektörü Geçme
- Öğeleri Vektörün İçine İtin
- Vektörden Öğeleri Aç
- Vektörleri Değiştirin
- Vektörden İlk Elemanı Getir
- Vektörden Son Öğeyi Getir
- Bir Vektöre Yeni Değerler Atama
- Emplace() Kullanarak Vektörü Genişletme
- Emplace_Back() Kullanarak Vektörü Genişletme
- Bir Vektörün Maksimum Elemanı
- Bir Vektörün Minimum Elemanı
- Bir Vektördeki Öğelerin Toplamı
- İki Vektörün Element Bilge Çarpımı
- İki Vektörün Nokta Çarpımı
- Bir Kümeyi Vektöre Dönüştürme
- Yinelenen Öğeleri Kaldır
- Bir Vektörü Kümeye Dönüştürme
- Boş Dizeleri Kaldır
- Metin Dosyasına Vektör Yazma
- Metin Dosyasından Vektör Oluşturma
Bir Vektöre Öğe Ekleme
std::vector::insert() C++ STL'deki işlev, öğeleri belirtilen konuma eklemek için kullanılır.
Sözdizimi:
vektör. sokmak ( pozisyon, eleman ) ;Bu fonksiyonu kullanalım ve ilk konumu, elemanın eklenmesi gereken konumu belirten bir parametre olarak iletelim ve ikinci parametre olarak da elemanı sağlayalım.
Burada begin() işlevi, giriş vektörünün ilk elemanına işaret eden bir yineleyiciyi döndürmek için kullanılabilir. Bu fonksiyona konum eklendiğinde eleman o konuma eklenir.
String türünde “öğrenci_isimleri” vektörünü oluşturalım ve insert() fonksiyonunu kullanarak birinci ve ikinci konumlara iki dizeyi arka arkaya ekleyelim.
#includekullanarak ad alanı std ;
ana ( )
{
// Vektörün başlatılması - öğrenci_isimleri
vektör < sicim > öğrenci_isimleri ;
cout << 'Mevcut vektör: \N ' ;
için ( Oto Ben : öğrenci_isimleri ) cout << Ben << sonunda ;
// İlk konuma 'Sravan Kumar'ı ekleyin
öğrenci_isimleri. sokmak ( öğrenci_isimleri. başlamak ( ) + 0 , 'Shravan Kumar' ) ;
// 'Sravan Kumar'ı ikinci konuma ekleyin
öğrenci_isimleri. sokmak ( öğrenci_isimleri. başlamak ( ) + 1 , 'Lalita' ) ;
cout << 'Son vektör: \N ' ;
için ( Oto J : öğrenci_isimleri ) cout << J << sonunda ;
}
Çıktı:
Daha önce 'öğrenci_isimleri' vektörü boştu. Eklemeden sonra vektör iki öğeyi tutar.
Bir Vektöre Birden Çok Öğe Ekleme
Bu senaryoda std::vector::insert() ile aynı işlevi kullanıyoruz. Ancak bir vektöre birden fazla öğe eklemek için ekstra/farklı parametreleri aynı fonksiyona aktarmamız gerekir.
Senaryo 1: Tek Bir Öğeyi Birden Çok Kez Ekleme
Bu senaryoda aynı öğeyi birden çok kez ekliyoruz.
Sözdizimi:
vektör. sokmak ( konum, boyut, öğe ) ;Bunu yapmak için boyutu ikinci parametre olarak insert() fonksiyonuna aktarmamız gerekiyor. Bu fonksiyona iletilen toplam parametreler üçtür.
Burada:
- Konum parametresi eklenecek öğe konumunu belirtir. Boyut 1'den büyükse başlangıç konumu dizini konum olacaktır.
- Size parametresi, bir öğenin kaç kez ekleneceğini belirtir.
- Element parametresi bir vektöre eklenecek öğeyi alır.
İki dizeli “öğrenci_isimleri” vektörünü düşünün. “Lavanya” dizelerini ikinci konuma beş kez yerleştirin.
#includekullanarak ad alanı std ;
ana ( )
{
// Vektörün başlatılması - öğrenci_isimleri
vektör < sicim > öğrenci_isimleri { 'Shravan Kumar' , 'Lalita' } ;
cout << 'Mevcut vektör: \N ' ;
için ( Oto Ben : öğrenci_isimleri ) cout << Ben << sonunda ;
// 'Lavanya'yı ikinci konuma 5 kez ekleyin
öğrenci_isimleri. sokmak ( öğrenci_isimleri. başlamak ( ) + 1 , 5 , 'Lavanya' ) ;
cout << ' \N Son vektör: \N ' ;
için ( Oto J : öğrenci_isimleri ) cout << J << sonunda ;
}
Çıktı:
Mevcut vektörde 'Sravan Kumar' birinci konumda ve 'Lalitha' ikinci konumdadır. “Lavanya”yı beş kez ekledikten sonra (ikinci sıradan altıncı sıraya), “Lalitha” yedinci sıraya (sonuncuya) geçti.
Senaryo 2: Birden Çok Öğe Ekleme
Bu senaryoda, başka bir vektörden farklı öğeleri aynı anda ekliyoruz. Burada da aynı fonksiyonu kullanıyoruz ancak sözdizimi ve parametreler değişecek.
Sözdizimi:
vektör. sokmak ( konum, birinci_iteratör, ikinci_iteratör ) ;Bunu yapmak için boyutu ikinci parametre olarak insert() fonksiyonuna aktarmamız gerekiyor. Bu fonksiyona iletilen toplam parametreler üçtür.
Burada:
- Konum parametresi eklenecek öğe konumunu belirtir.
- 'First_iterator', elemanların ekleneceği başlangıç konumunu belirtir (temel olarak, begin() işlevini kullanarak, kapta bulunan ilk elemana işaret eden bir yineleyici döndürülür).
- 'second_iterator', elemanların eklenebileceği bitiş konumunu belirtir (temel olarak, end() işlevi kullanılarak, kapta mevcut olan son noktanın yanına işaret eden bir yineleyici döndürülür).
Tamsayı tipinde 'marks1' ve 'marks2' olmak üzere iki vektör oluşturun. 'marks2' vektöründe bulunan tüm elemanları 'marks1' vektörünün ilk konumuna ekleyin.
#includekullanarak ad alanı std ;
ana ( )
{
// Vektörün başlatılması - marks1
vektör < int > işaretler1 { 100 , 89 , 90 , 78 , 98 } ;
cout << 'İlk vektör: \N ' ;
için ( Oto Ben : işaretler1 ) cout << Ben << sonunda ;
// Vektörün başlatılması - marks2
vektör < int > işaretler2 { 56 , Dört beş , 65 } ;
cout << 'İkinci vektör: \N ' ;
için ( Oto J : işaretler2 ) cout << J << sonunda ;
işaretler1. sokmak ( başlamak ( işaretler1 ) , başlamak ( işaretler2 ) , son ( işaretler2 ) ) ;
// Son vektör
cout << 'İlk-Son vektör: \N ' ;
için ( Oto X : işaretler1 )
cout << X << ' ' ;
}
Çıktı:
İlk vektör (marks1) beş elementi, ikinci vektör (marks2) ise üç elementi tutar. begin (marks1), begin(marks2), end(marks2) parametrelerini “insert” fonksiyonuna öyle bir aktardık ki, ikinci vektörde bulunan tüm elemanlar yinelenip başlangıçtaki birinci vektöre ekleniyor. Yani ilk vektör sekiz element içeriyor.
Bir Vektörden Öğelere Erişme
1. [] Operatörünü Kullanma
Bazı senaryolarda vektörden yalnızca belirli öğeleri döndürmeniz gerekebilir. Tüm öğelerin döndürülmesine gerek yoktur. Bu nedenle, dizine dayalı olarak yalnızca belirli öğeleri döndürmek için dizin operatörü ve at() işlevleri kullanılır.
Sözdizimi:
vektör [ dizin_konumu ]C++'da indeksleme herhangi bir veri yapısı için 0'dan başlar. Eleman mevcut değilse boş döndürür (Hata yok veya bir uyarı verilmedi).
Beş öğeli “ürünler” vektörünü düşünün. Dizin konumunu kullanarak tüm öğelere tek tek erişin.
#includekullanarak ad alanı std ;
ana ( )
{
// Vektör oluştur - 5 dizeli ürünler
vektör < sicim > ürünler { 'sabun' , 'şampuan' , 'yağ' , 'meyveler' , 'sebzeler' } ;
//Ürünlerden elementlere erişim
cout << 'İlk Unsur:' << ürünler [ 0 ] << sonunda ;
cout << 'İkinci Unsur:' << ürünler [ 1 ] << sonunda ;
cout << 'Üçüncü Unsur:' << ürünler [ 2 ] << sonunda ;
cout << 'Dördüncü Unsur:' << ürünler [ 3 ] << sonunda ;
cout << 'Beşinci Element:' << ürünler [ 4 ] << sonunda ;
// 9. elemente erişmeyi deneyin
cout << 'Dokuzuncu Element:' << ürünler [ 8 ] << sonunda ;
}
Çıktı:
Dizin 8'de hiçbir öğe mevcut değildir. Dolayısıyla boş döndürülür.
2. At() Fonksiyonunu Kullanmak
At(), önceki kullanım durumuna benzer bir üye işlevidir ancak kendisine aralık dışı dizin sağlandığında 'std::out_of_range' istisnasını döndürür.
Sözdizimi:
vektör. en ( dizin_konumu )Bu fonksiyona indeks pozisyonunu aktarmamız gerekiyor.
Beş öğeli “ürünler” vektörünü düşünün. İndeks konumunu kullanarak tüm öğelere tek tek erişin ve 9. konumda bulunan öğeye erişmeye çalışın.
#includekullanarak ad alanı std ;
ana ( )
{
// Vektör oluştur - 5 dizeli ürünler
vektör < sicim > ürünler { 'sabun' , 'şampuan' , 'yağ' , 'meyveler' , 'sebzeler' } ;
//Ürünlerden elementlere erişim
cout << 'İlk Unsur:' << ürünler. en ( 0 ) << sonunda ;
cout << 'İkinci Unsur:' << ürünler. en ( 1 ) << sonunda ;
cout << 'Üçüncü Unsur:' << ürünler. en ( 2 ) << sonunda ;
cout << 'Dördüncü Unsur:' << ürünler. en ( 3 ) << sonunda ;
cout << 'Beşinci Element:' << ürünler. en ( 4 ) << sonunda ;
//Vektörde olmayan elemanlara erişim
cout << 'Dokuzuncu Element:' << ürünler. en ( 8 ) << sonunda ;
}
Çıktı:
9. öğeye erişimde bir hata oluşuyor:
bir örneğini attıktan sonra çağrılan sonlandırma 'std::aralığın_dışında'Ne ( ) : vektör :: _M_range_check : __N ( hangisi 8 ) >= Bu - > boyut ( ) ( hangisi 5 )
Bir Vektördeki Bir Öğeyi Güncelleme
1. [] Operatörünü Kullanma
İndeks konumunu kullanarak vektördeki öğeyi güncelleyebiliriz. [] operatörü, güncellenmesi gereken öğenin dizin konumunu alır. Yeni öğe bu operatöre atanacaktır.
Sözdizimi:
Vektör [ dizin_konumu ] = ÖğeBeş değere sahip “öğrenci_işaretleri” vektörünü düşünün. 1 ve 3 numaralı indekslerde bulunan unsurları güncelleyin.
#include#include
kullanarak ad alanı std ;
ana ( )
{
// Vektör oluştur - öğrenci_işaretleri
vektör < int > öğrenci_işaretleri { 98 , 78 , 90 , 67 , 89 } ;
cout << 'Mevcut işaretler: ' << sonunda ;
için ( int itr : öğrenci_işaretleri )
cout << itr << sonunda ;
// Dizin-3'teki öğeyi 100 ile güncelle
öğrenci_işaretleri [ 3 ] = 100 ;
// Dizin-1'deki öğeyi 60 ile güncelle
öğrenci_işaretleri [ 1 ] = 60 ;
cout << 'Son notlar: ' << sonunda ;
için ( int itr : öğrenci_işaretleri )
cout << itr << sonunda ;
}
Çıktı:
Son vektörün güncelleme elemanlarını 1 ve 3 endekslerinde tuttuğunu görebiliriz.
2. At() Fonksiyonunu Kullanmak
İndeks operatörüne benzer şekilde, at() temel olarak değeri bir yineleyicideki indekse göre güncelleyen bir üye fonksiyondur. Bu işlevin içinde belirtilen dizin mevcut değilse 'std::out_of_range' istisnası oluşturulur.
vektör. en ( dizin_konumu ) = ÖğeBeş öğeli “ürünler” vektörünü düşünün. Vektörde bulunan tüm öğeleri diğer öğelerle güncelleyin.
#includekullanarak ad alanı std ;
ana ( )
{
// Vektör oluştur - 5 dizeli ürünler
vektör < sicim > ürünler { 'sabun' , 'şampuan' , 'yağ' , 'meyveler' , 'sebzeler' } ;
cout << 'Varolan ürünler: ' << sonunda ;
için ( dize onu : ürünler )
cout << itr << sonunda ;
//Tüm stringler güncelleniyor
ürünler. en ( 0 ) = 'Kek' ;
ürünler. en ( 1 ) = 'Çikolata' ;
ürünler. en ( 2 ) = 'Meyveler' ;
ürünler. en ( 3 ) = 'Soğanlar' ;
ürünler. en ( 4 ) = 'Alkolsüz içecekler' ;
cout << ' \N Nihai Ürünler: ' << sonunda ;
için ( dize onu : ürünler )
cout << itr << sonunda ;
}
Çıktı:
Bir Vektörden Belirli Bir Öğeyi Kaldırma
C++'da, std::vector::erase() işlev, bir vektörden belirli bir öğeyi/öğe aralığını kaldırmak için kullanılır. Öğeler yineleyici konumlarına göre kaldırılır.
Sözdizimi:
vektör. silmek ( yineleyici konumu )Belirli bir öğeyi bir vektörden kaldırmak için kullanılan sözdizimini görelim. Kaldırılacak vektörde mevcut olan öğenin konumunu elde etmek için begin() veya end() işlevlerini kullanabiliriz.
Beş öğeli “ürünler” vektörünü düşünün.
- begin() yineleyicisini belirterek üçüncü öğeyi kaldırın. Begin() vektördeki ilk öğeyi işaret eder. Bu fonksiyona iki tane eklersek üçüncü elemana işaret eder.
- end() yineleyicisini belirterek son öğeyi kaldırın. End() vektördeki son öğeyi işaret eder.
kullanarak ad alanı std ;
ana ( )
{
// Vektör oluştur - 5 dizeli ürünler
vektör < sicim > ürünler { 'sabun' , 'şampuan' , 'yağ' , 'meyveler' , 'sebzeler' } ;
cout << 'Varolan ürünler: ' << sonunda ;
için ( dize onu : ürünler )
cout << itr << sonunda ;
// 3. elemanı kaldır
ürünler. silmek ( ürünler. başlamak ( ) + 2 ) ;
cout << ' \N 3. elemanı çıkardıktan sonra: \N ' ;
için ( dize onu : ürünler )
cout << itr << sonunda ;
// Son elemanı kaldır
ürünler. silmek ( ürünler. son ( ) ) ;
cout << ' \N Son elemanı çıkardıktan sonra: \N ' ;
için ( dize onu : ürünler )
cout << itr << sonunda ;
}
Çıktı:
Artık “ürünler” vektöründe yalnızca üç öğe (“sabun”, “şampuan”, “meyveler”) bulunmaktadır.
Bir Vektörden Tüm Öğeleri Kaldırma
Senaryo 1: Bir Vektörden Belirli Bir Öğe Aralığını Kaldırma
Bir aralıktaki birden fazla öğeyi kaldırmak için std::vector::erase() işlevini kullanalım.
Sözdizimi:
vektör. silmek ( ilk yineleyici, son yineleyici )Aralığı belirtmek için iki yineleyici (begin() ilk öğeye işaret eder ve end() son öğe işlevlerine işaret eder) kullanılır.
Beş öğeli 'ürünler' vektörünü düşünün ve ikinci konumdaki tüm öğeleri kaldırın. Bunu başarmak için, ilk yineleyici ikinci öğeye işaret eden begin (products)+1 ve ikinci yineleyici end (products) olur.
#includekullanarak ad alanı std ;
ana ( )
{
// Vektör oluştur - 5 dizeli ürünler
vektör < sicim > ürünler { 'sabun' , 'şampuan' , 'yağ' , 'meyveler' , 'sebzeler' } ;
cout << 'Varolan ürünler: ' << sonunda ;
için ( dize onu : ürünler )
cout << itr << sonunda ;
// İkinci konumdaki tüm elemanları kaldır
ürünler. silmek ( başlamak ( ürünler ) + 1 ,son ( ürünler ) ) ;
cout << ' \N Nihai Ürünler: \N ' ;
için ( dize onu : ürünler )
cout << itr << sonunda ;
}
Çıktı:
Artık “ürünler” vektöründe mevcut olan tek bir element (“sabun”) vardır.
Senaryo 2: Vektörden Tüm Öğeleri Kaldır
Hadi kullanalım std::vector::clear() vektörden tüm öğeleri kaldırma işlevi.
Sözdizimi:
vektör. temizlemek ( )Bu fonksiyona herhangi bir parametre aktarılmaz.
İlk senaryoda kullanılan vektörün aynısını düşünün ve clear() işlevini kullanarak tüm öğeleri kaldırın.
#includekullanarak ad alanı std ;
ana ( )
{
// Vektör oluştur - 5 dizeli ürünler
vektör < sicim > ürünler { 'sabun' , 'şampuan' , 'yağ' , 'meyveler' , 'sebzeler' } ;
cout << 'Varolan ürünler: ' << sonunda ;
için ( dize onu : ürünler )
cout << itr << sonunda ;
// Ürünlerdeki tüm öğeleri kaldırın
ürünler. temizlemek ( ) ;
cout << ' \N Nihai Ürünler: \N ' ;
için ( dize onu : ürünler )
cout << itr << sonunda ;
}
Çıktı:
“Ürünler” vektöründe hiçbir öğenin olmadığını görebiliriz.
Vektörlerin Birliği
STd::set_union() fonksiyonunu kullanarak vektörler üzerinde UNION işlemini gerçekleştirmek mümkündür. Union, yinelenen öğeleri göz ardı ederek vektörlerdeki benzersiz öğeleri döndürür. Her iki yineleyiciyi de bu fonksiyona geçirmemiz gerekiyor. Bununla birlikte, her iki yineleyici tarafından döndürülen sonucu saklayan bir çıktı yineleyicisinin de geçirilmesi gerekir.
Sözdizimi:
set_union ( GirişYineleyici1 ilk1, GirişYineleyici1 son1, GirişYineleyici2 ilk2, GirişYineleyici2 son2, OutputIterator res ) ;Burada:
- “İlk1”, ilk yineleyicinin (vektör) ilk elemanını işaret eder.
- “Last1” ilk yineleyicinin (vektör) son elemanını işaret eder.
- “İlk2” ikinci yineleyicinin (vektör) ilk elemanını işaret eder.
- “Last2” ikinci yineleyicinin (vektör) son elemanını işaret eder.
Tamsayı türünde iki vektör – “konu1” ve “konu2” – oluşturun.
- Yineleyicileri geçirerek sort() işlevini kullanarak iki vektörü sıralayın.
- Bir çıktı vektörü (yineleyici) oluşturun.
- std::set_union() işlevini kullanarak bu iki vektörün birleşimini bulun. İlk yineleyici olarak begin() işlevini ve son yineleyici olarak end() öğesini kullanın.
- İşlev tarafından döndürülen öğeleri görüntülemek için çıktı vektörünü yineleyin.
#include
#include
kullanarak ad alanı std ;
ana ( )
{
// Vektör oluştur - marks1
vektör < int > işaretler1 = { 100 , 90 , 80 , 70 , 60 } ;
// Vektör oluştur - marks2
vektör < int > işaretler2 = { 80 , 90 , 60 , 70 , 100 } ;
// Her iki vektörü de sıralayın
düzenlemek ( işaretler1. başlamak ( ) , işaretler1. son ( ) ) ;
düzenlemek ( işaretler2. başlamak ( ) , işaretler2. son ( ) ) ;
vektör < int > çıktıVektörü ( işaretler1. boyut ( ) + işaretler2. boyut ( ) ) ;
vektör < int > :: yineleyici dır-dir ;
Ben = set_union ( işaretler1. başlamak ( ) , işaretler1. son ( ) ,
işaretler2. başlamak ( ) ,işaretler2. son ( ) ,
çıktıVektörü. başlamak ( ) ) ;
cout << ' \N işaretleri1 U işaretleri2: \N ' ;
için ( S = çıktıVektörü. başlamak ( ) ; S ! = Ben ; ++ S )
cout << * S << ' ' << ' \N ' ;
}
Çıktı:
Her iki vektörde de (konu1 ve konu2) yalnızca beş benzersiz öğe vardır.
Vektörlerin Kesişimi
İki vektörün kesişimini bulmak std::set_intersection() işlevi kullanılarak mümkün olabilir. Kesişme her iki vektörde de bulunan öğeleri döndürür.
Sözdizimi:
set_intersection ( GirişYineleyici1 ilk1, GirişYineleyici1 son1, GirişYineleyici2 ilk2, GirişYineleyici2 son2, OutputIterator res ) ;set_union() işlevine iletilen parametreler bu set_intersection() işlevine de aktarılabilir.
Tamsayı türünde iki vektör – “konu1” ve “konu2” – oluşturun.
- Yineleyicileri geçirerek sort() işlevini kullanarak iki vektörü sıralayın.
- Bir çıktı vektörü (yineleyici) oluşturun.
- std::set_intersection() fonksiyonunu kullanarak bu iki vektörün kesişimini bulun. İlk yineleyici olarak begin() işlevini ve son yineleyici olarak end() öğesini kullanın.
- İşlev tarafından döndürülen öğeleri görüntülemek için çıktı vektörünü yineleyin.
#include
#include
kullanarak ad alanı std ;
ana ( )
{
// Vektör oluştur - marks1
vektör < int > işaretler1 = { 100 , 10 , 80 , 40 , 60 } ;
// Vektör oluştur - marks2
vektör < int > işaretler2 = { elli , 90 , 60 , 10 , 100 } ;
// Her iki vektörü de sıralayın
düzenlemek ( işaretler1. başlamak ( ) , işaretler1. son ( ) ) ;
düzenlemek ( işaretler2. başlamak ( ) , işaretler2. son ( ) ) ;
vektör < int > çıktıVektörü ( işaretler1. boyut ( ) + işaretler2. boyut ( ) ) ;
vektör < int > :: yineleyici dır-dir ;
Ben = set_intersection ( işaretler1. başlamak ( ) , işaretler1. son ( ) ,
işaretler2. başlamak ( ) ,işaretler2. son ( ) ,
çıktıVektörü. başlamak ( ) ) ;
cout << ' \N işaret1 ∩ işaret2: \N ' ;
için ( S = çıktıVektörü. başlamak ( ) ; S ! = Ben ; ++ S )
cout << * S << ' ' << ' \N ' ;
}
Çıktı:
Her iki vektörde de yalnızca üç öğe mevcuttur (konu1 ve konu2).
Vektörün Boş Olup Olmadığını Kontrol Edin
Vektörler üzerinde çalışmaya başlamadan önce vektörün boş olup olmadığını kontrol etmek önemlidir. Yazılım projelerinde CRUD işlemleri vb. işlemleri yapmadan önce vektörün boş olup olmadığını kontrol etmek de iyi bir uygulamadır.
1. Std::vector::empty() işlevinin kullanılması
Bu işlev, vektör boşsa (herhangi bir öğe içermiyorsa) 1 değerini döndürür. Aksi takdirde 0 döndürülür. Bu fonksiyona herhangi bir parametre aktarılmaz.
2. Kullanımı Std::vector::size()
std::vector::size() işlevi, vektörde bulunan öğelerin toplam sayısını temsil eden tamsayıyı döndürür.
İki vektör oluşturun – “üniversite1” ve “üniversite2”. “College1” beş öğeyi barındırıyor ve “college2” boş. Her iki fonksiyonu da her iki vektöre uygulayın ve çıktıyı kontrol edin.
#include#include
#include
kullanarak ad alanı std ;
ana ( )
{
// Vektör oluştur - kolej1
vektör < sicim > üniversite1 = { 'kolej-A' , 'kolej-B' , 'üniversite-C' , 'üniversite-D' , 'üniversite-E' } ;
// Vektör oluştur - kolej2
vektör < sicim > üniversite2 ;
// boş()
cout << üniversite1. boş ( ) << sonunda ;
cout << kolej2. boş ( ) << sonunda ;
// boyut()
cout << üniversite1. boyut ( ) << sonunda ;
cout << kolej2. boyut ( ) << sonunda ;
}
Çıktı:
Empty() işlevi “üniversite1” için 0 ve “üniversite2” için 1 değerini döndürür. size() işlevi “üniversite1” için beş, “üniversite2” için 0 değerini döndürür.
Const_Iterator'ı Kullanarak Bir Vektörü Geçme
Kümeler, vektörler vb. gibi C++ kapsayıcıları üzerinde çalışırken, kapta bulunan tüm öğeleri değiştirmeden yinelemek mümkündür. const_iterator bu senaryoyu gerçekleştiren yineleyicilerden biridir. cbegin() (vektördeki ilk öğeye işaret eder) ve cend() (vektördeki son öğeye işaret eder), sabit yineleyiciyi başlangıç ve bitiş noktasına döndürmek için kullanılan her kap tarafından sağlanan iki işlevdir. konteyner. Vektörü yinelerken bu iki fonksiyondan yararlanabiliriz.
- Beş dizeden oluşan “departmanlar” adında bir vektör oluşturalım.
-
türünde bir const_iterator – ctr bildirin. - “For” döngüsünü kullanarak önceki yineleyiciyi kullanarak bölümler üzerinde yineleme yapın ve onu görüntüleyin.
#include
kullanarak ad alanı std ;
ana ( )
{
// Vektör - departmanlar oluştur
vektör < sicim > bölümler = { 'Satış' , 'Hizmet' ,
'İK' , 'BT' , 'Diğerleri' } ;
vektör < sicim > :: const_iterator ton ;
// const_iterator - ctr kullanarak departmanlar üzerinde yineleme yapın.
için ( ton = departmanlar. cbaşla ( ) ; ton ! = departmanlar. bir kaç ( ) ; ton ++ ) {
cout << * ton << sonunda ;
}
}
Çıktı:
Reverse_Iterator'ı Kullanarak Bir Vektörü Geçme
ters_iteratör aynı zamanda const_iterator'a benzer bir yineleyicidir ancak öğeleri tersten döndürür. rbegin() (vektördeki son öğeye işaret eder) ve rend() (vektördeki ilk öğeye işaret eder), sabit yineleyiciyi başlangıç ve bitiş noktasına döndürmek için kullanılan her kap tarafından sağlanan iki işlevdir. konteyner.
- Beş dizeden oluşan “departmanlar” adında bir vektör oluşturalım.
-
tipinde bir revers_iterator – rtr bildirin. - “For” döngüsünü kullanarak önceki yineleyiciyi kullanarak bölümler üzerinde yineleme yapın ve onu görüntüleyin.
#include
kullanarak ad alanı std ;
ana ( )
{
// Vektör - departmanlar oluştur
vektör < sicim > bölümler = { 'Satış' , 'Hizmet' ,
'İK' , 'BT' , 'Diğerleri' } ;
vektör < sicim > :: ters_iteratör rtr ;
// Reverse_iterator - rtr'yi kullanarak bölümler üzerinde yineleme yapın.
için ( rtr = departmanlar. yeniden başla ( ) ; rtr ! = departmanlar. yapar ( ) ; rtr ++ ) {
cout << * rtr << sonunda ;
}
}
Çıktı:
Öğeleri Vektörün İçine İtin
Öğeleri bir vektöre itmek veya eklemek, aşağıdaki komut kullanılarak yapılabilecek tek yönlü bir eklemedir: vektör::Push_back() işlev.
Sözdizimi:
vektör. Geri itmek ( eleman )Parametre olarak vektöre itilecek bir öğe gerekir.
Beş dizeden oluşan “departments” adında boş bir vektör oluşturalım ve Push_back() fonksiyonunu kullanarak iki dizeyi arka arkaya itelim.
#include#include
kullanarak ad alanı std ;
ana ( )
{
// Vektör - departmanları başlat
vektör < sicim > bölümler ;
cout << 'Gerçek Departmanlar:' << sonunda ;
için ( Oto itr = departmanlar. başlamak ( ) ; itr ! = departmanlar. son ( ) ; ++ itr )
cout << * itr << sonunda ;
// 'Satış'a basın
departmanlar. Geri itmek ( 'Satış' ) ;
// 'BT'ye basın
departmanlar. Geri itmek ( 'BT' ) ;
cout << ' \N Son Bölümler:' << sonunda ;
için ( Oto itr = departmanlar. başlamak ( ) ; itr ! = departmanlar. son ( ) ; ++ itr )
cout << * itr << sonunda ;
}
Çıktı:
İlk önce “Satışlar”a basıyoruz. Bundan sonra “IT” vektöre itilir. Artık “departmanlar” vektörü iki öğeyi barındırıyor.
Vektörden Öğeleri Aç
Vektörde bulunan son öğeyi silmek isterseniz, vektör::pop_back() işlevi en iyi yaklaşımdır. Vektörde bulunan son öğeyi siler.
Sözdizimi:
vektör. pop_back ( )Bu fonksiyon için herhangi bir parametreye gerek yoktur. Boş bir vektörden son öğeyi silmeye çalıştığımızda tanımsız davranışı gösterir.
Beş dizeden oluşan “departments” adında boş bir vektör oluşturalım ve önceki fonksiyonu kullanarak son elemanı silelim. Her iki durumda da vektörü görüntüleyin.
#include#include
kullanarak ad alanı std ;
ana ( )
{
// Vektör - departmanları başlat
vektör < sicim > bölümler = { 'Satış' , 'BT' , 'Hizmet' , 'Pazarlama' , 'İK' } ;
cout << 'Gerçek Departmanlar:' << sonunda ;
için ( Oto itr = departmanlar. başlamak ( ) ; itr ! = departmanlar. son ( ) ; ++ itr )
cout << * itr << sonunda ;
// Son elemanı sil
departmanlar. pop_back ( ) ;
cout << ' \N Son Bölümler:' << sonunda ;
için ( Oto itr = departmanlar. başlamak ( ) ; itr ! = departmanlar. son ( ) ; ++ itr )
cout << * itr << sonunda ;
}
Çıktı:
“İK”, “departmanlar” vektöründe bulunan son öğedir. Böylece vektörden çıkarılır ve son vektörde 'Satış', 'BT', 'Hizmet' ve 'Pazarlama' yer alır.
Vektörleri Değiştirin
vektör::takas() C++ STL'deki işlev, iki vektörde bulunan tüm öğeleri değiştirmek için kullanılır.
Sözdizimi:
ilk_vektör. takas ( ikinci_vektör )Vektörlerin boyutu dikkate alınmaz ancak vektörler aynı türde olmalıdır (vektör türleri farklıysa hata oluşur).
Farklı boyutlarda dize türünde iki vektör – “meyveler” ve “sebzeler” oluşturalım. Her birini değiştirin ve her iki durumda da vektörleri görüntüleyin.
#include#include
kullanarak ad alanı std ;
ana ( )
{
// Vektörü başlat - meyveler
vektör < sicim > meyveler = { 'Elma' , 'Mango' } ;
cout << 'Gerçek Meyveler:' << sonunda ;
için ( Oto itr = meyveler. başlamak ( ) ; itr ! = meyveler. son ( ) ; ++ itr )
cout << * itr << sonunda ;
// Vektörü başlat - sebzeler
vektör < sicim > sebzeler = { 'Patates' , 'Domates' , 'Brinjal' } ;
cout << ' \N Gerçek Sebzeler:' << sonunda ;
için ( Oto itr = sebzeler. başlamak ( ) ; itr ! = sebzeler. son ( ) ; ++ itr )
cout << * itr << sonunda ;
// Her iki vektördeki elemanların yerini değiştir
meyveler. takas ( sebzeler ) ;
cout << ' \N Meyveleri değiştirdikten sonra:' << sonunda ;
için ( Oto itr = meyveler. başlamak ( ) ; itr ! = meyveler. son ( ) ; ++ itr )
cout << * itr << sonunda ;
cout << ' \N Sebzeleri değiştirdikten sonra:' << sonunda ;
için ( Oto itr = sebzeler. başlamak ( ) ; itr ! = sebzeler. son ( ) ; ++ itr )
cout << * itr << sonunda ;
}
Çıktı:
Daha önce, 'meyveler' vektörü iki öğeyi, 'sebzeler' vektörü ise üç öğeyi barındırıyordu. Değiştirme sonrasında, 'meyveler' vektörü üç öğeyi, 'sebzeler' vektörü ise iki öğeyi tutar.
Vektörden İlk Elemanı Getir
Bazı durumlarda gereksinim, vektörden yalnızca ilk öğenin döndürülmesidir. C++ STL'deki vektör::front() işlevi, vektörden yalnızca ilk öğeyi getirir.
Sözdizimi:
vektör. ön ( )Bu fonksiyon herhangi bir parametre almayacaktır. Vektör boşsa bir hata oluşturulur.
String türünde iki vektör – “meyveler” ve “sebzeler” oluşturalım ve ilk elemanı iki vektörden ayrı olarak almaya çalışalım.
#include#include
kullanarak ad alanı std ;
ana ( )
{
// Vektör oluştur - 2 elementli meyveler
vektör < sicim > meyveler = { 'Elma' , 'Mango' } ;
// İlk elemanı döndür
cout << meyveler. ön ( ) << sonunda ;
// Vektörü başlat - sebzeler
vektör < sicim > sebzeler ;
// İlk elemanı döndürmeye çalışın
cout << sebzeler. ön ( ) ;
}
Çıktı:
“Elma”, “meyveler” vektöründe bulunan ilk elementtir. Yani iade edilir. Ancak 'sebze' vektörünün ilk elemanını almaya çalıştığımızda boş olduğu için hata veriliyor.
Vektörden Son Öğeyi Getir
C++ STL'deki vektör::end() işlevi, vektörden yalnızca son öğeyi getirir.
Sözdizimi:
vektör. geri ( )Bu fonksiyon herhangi bir parametre almayacaktır. Vektör boşsa bir hata oluşturulur.
String tipinde iki vektör – “meyveler” ve “sebzeler” oluşturalım ve son elemanı iki vektörden ayrı olarak almaya çalışalım.
#include#include
kullanarak ad alanı std ;
ana ( )
{
// Vektör oluştur - 2 elementli meyveler
vektör < sicim > meyveler = { 'Elma' , 'Mango' } ;
// Son elemanı getir
cout << meyveler. geri ( ) << sonunda ;
// Vektörü başlat - sebzeler
vektör < sicim > sebzeler ;
// Son elemanı getirmeye çalış
cout << sebzeler. geri ( ) ;
}
Çıktı:
“Mango”, “meyveler” vektöründe bulunan son elementtir. Yani iade edilir. Ancak “sebze” vektörünün son elemanını almaya çalıştığımızda boş olduğu için hata atılıyor.
Bir Vektöre Yeni Değerler Atama
Bazı senaryolarda, tüm değerleri yeni değerle güncellemek veya aynı değerlere sahip bir vektör oluşturmak istiyorsanız, vektör::sign() işlevini kullanmak en iyi yaklaşımdır. Bu işlevi kullanarak şunları yapabiliriz:
- Tüm benzer öğelerle vektörü oluşturun
- Mevcut vektörü aynı öğeyle değiştirin
Sözdizimi:
vektör. atamak ( boyut, değer )Bu fonksiyon için iki parametre gereklidir.
Burada:
- Boyut, atanacak öğe sayısını belirtir.
- Değer atanacak öğeyi belirtir.
Beş değerli “marks1” adında bir vektör oluşturalım ve bu vektörü, güncellenen vektörün tüm elemanları 20’ye eşit olacak şekilde dört elemanla güncelleyelim.
#include#include
#include
kullanarak ad alanı std ;
ana ( )
{
// Vektör oluştur - marks1
vektör < int > işaretler1 = { 100 , 90 , 80 , 70 , 60 } ;
cout << 'Gerçek Vektör:' << sonunda ;
için ( int Ben = 0 ; Ben < işaretler1. boyut ( ) ; Ben ++ )
cout << işaretler1 [ Ben ] << sonunda ;
işaretler1. atamak ( 4 , yirmi ) ;
cout << ' \N Güncellenmiş Vektör:' << sonunda ;
için ( int Ben = 0 ; Ben < işaretler1. boyut ( ) ; Ben ++ )
cout << işaretler1 [ Ben ] << sonunda ;
}
Çıktı:
Daha önce vektör beş farklı öğeyi barındırıyordu. Şimdi sadece dört elementi var ve hepsi 20'ye eşit.
Emplace() Kullanarak Vektörü Genişletme
Yeni öğelerin bir vektörün herhangi bir konumuna dinamik olarak eklendiğini zaten biliyoruz. Vector::emplace() işlevini kullanmak mümkündür. Bu fonksiyonun kabul ettiği sözdizimine ve parametrelere hızlıca bakalım.
Sözdizimi:
vektör. konum ( const_iterator konumu, öğe )Bu fonksiyona iki zorunlu parametre iletilir.
Burada:
- İlk parametre, öğeyi herhangi bir konuma yerleştirebilmemiz için konumu alır. Begin() veya end() yineleyici işlevini kullanarak konumu elde edebiliriz.
- İkinci parametre vektöre eklenecek öğedir.
İki elementli “kimyasallar” vektörünü düşünün.
- İlk konuma “Manganez” ekleyin – başlayın(kimyasallar)
- Son pozisyona “Bakır”ı ekleyin – son(kimyasallar)
- 'Kükürt'ü üçüncü konuma ekleyin – begin(chemicals)+2
#include
#include
kullanarak ad alanı std ;
ana ( )
{
// Vektör - kimyasallar oluştur
vektör < sicim > kimyasallar = { 'Oksijen' , 'CO' } ;
cout << 'Gerçek Kimyasallar:' << sonunda ;
için ( int Ben = 0 ; Ben < kimyasallar. boyut ( ) ; Ben ++ )
cout << kimyasallar [ Ben ] << sonunda ;
// Elemanı ilk konuma ekle
kimyasallar. konum ( başlamak ( kimyasallar ) , 'Manganez' ) ;
// Elemanı son konuma ekle
kimyasallar. konum ( son ( kimyasallar ) , 'Bakır' ) ;
// Elemanı üçüncü konuma ekle
kimyasallar. konum ( başlamak ( kimyasallar ) + 2 , 'Kükürt' ) ;
cout << ' \N Nihai Kimyasallar:' << sonunda ;
için ( int Ben = 0 ; Ben < kimyasallar. boyut ( ) ; Ben ++ )
cout << kimyasallar [ Ben ] << sonunda ;
}
Çıktı:
Artık son vektör beş öğeyi barındırıyor (aşağıdaki ekran görüntüsünde verilmiştir).
Emplace_Back() Kullanarak Vektörü Genişletme
kullanılarak yapılabilecek bir öğe eklenebilir (vektörün sonuna ekleme). vektör::emplace_back() işlev.
Sözdizimi:
vektör. emplace_back ( eleman )Vektöre eklenecek elemanın parametre olarak iletilmesi zorunludur.
emplace_back() fonksiyonunu kullanarak iki elemanı arka arkaya ekleyelim.
#include#include
#include
kullanarak ad alanı std ;
ana ( )
{
// Vektör - kimyasallar oluştur
vektör < sicim > kimyasallar = { 'Oksijen' , 'CO' } ;
cout << 'Gerçek Kimyasallar:' << sonunda ;
için ( int Ben = 0 ; Ben < kimyasallar. boyut ( ) ; Ben ++ )
cout << kimyasallar [ Ben ] << sonunda ;
// Manganezi vektörün sonuna ekle
kimyasallar. emplace_back ( 'Manganez' ) ;
// Manganezi vektörün sonuna ekle
kimyasallar. emplace_back ( 'Bakır' ) ;
cout << ' \N Nihai Kimyasallar:' << sonunda ;
için ( int Ben = 0 ; Ben < kimyasallar. boyut ( ) ; Ben ++ )
cout << kimyasallar [ Ben ] << sonunda ;
}
Çıktı:
Artık son vektör, “Manganez” ve “Bakır” eklendikten sonra dört elementi içeriyor.
Bir Vektörün Maksimum Elemanı
- Bazı öğeler içeren bir vektör oluşturun.
- Vektörde mevcut olan maksimum öğeyi bulmak için, iki yineleyiciyi bağımsız değişken olarak kabul eden *max_element() işlevini kullanın. Bu iki parametre aralık görevi görür ve maksimum öğe, sağlanan aralık içinde döndürülür. Başlangıç konumu begin() ve son konum end()'dur.
Beş tamsayı türü değerini tutan ve maksimum öğeyi döndüren “item_costs” adında bir vektör düşünelim.
#include#include
#include
kullanarak ad alanı std ;
ana ( )
{
// Vektör oluştur - item_costs
vektör < int > item_costs = { 8900 , 5677 , 200 , 1000 , 2300 } ;
cout << 'Ürünlerin Maliyeti: \N ' ;
için ( int Ben = 0 ; Ben < item_costs. boyut ( ) ; Ben ++ )
cout << item_costs [ Ben ] << sonunda ;
// Yukarıdaki vektörden maksimum öğeyi döndür - item_costs
cout << ' \N Maksimum Maliyet: ' << * maksimum_element ( başlamak ( item_costs ) ,son ( item_costs ) ) ;
}
Çıktı:
Burada 8900, “item_costs” vektöründe bulunan tüm unsurlar arasında maksimum elemandır.
Bir Vektörün Minimum Elemanı
- Bazı öğeler içeren bir vektör oluşturun.
- Vektörde mevcut olan minimum öğeyi bulmak için, iki yineleyiciyi bağımsız değişken olarak kabul eden *min_element() işlevini kullanın. Bu iki parametre aralık görevi görür ve minimum öğe (diğer tüm öğelerden daha az) sağlanan aralık içinde döndürülür. Başlangıç konumu begin() ve son konum end()'dur.
Maksimum öğeyi bulmak için oluşturulan vektörün aynısını kullanın ve *min_element() işlevini kullanarak minimum öğeyi bulun.
#include#include
#include
kullanarak ad alanı std ;
ana ( )
{
// Vektör oluştur - item_costs
vektör < int > item_costs = { 8900 , 5677 , 200 , 1000 , 2300 } ;
cout << 'Ürünlerin Maliyeti: \N ' ;
için ( int Ben = 0 ; Ben < item_costs. boyut ( ) ; Ben ++ )
cout << item_costs [ Ben ] << sonunda ;
// Yukarıdaki vektörden minimum öğeyi döndür - item_costs
cout << ' \N Minimum Maliyet: ' << * min_element ( başlamak ( item_costs ) ,son ( item_costs ) ) ;
}
Çıktı:
Burada 200, “item_costs” vektöründe yer alan tüm öğeler arasında minimum öğedir.
Bir Vektördeki Öğelerin Toplamı
Vektörde bulunan tüm elemanların toplamını döndürmek için, biriktirmek() C++ STL'deki fonksiyon kullanılır. Üç parametre kabul eder. İlk parametre, aralıktaki başlangıç öğesini temsil eden ilk dizini alır (begin() yineleyicisini belirtin) ve ikinci parametre, aralıktaki bitiş öğesini temsil eden son dizini alır (end() yineleyicisini belirtin). Son olarak toplamın başlangıç değerini (bizim durumumuzda 0) aktarmamız gerekiyor.
biriktirmek ( ilk_index, son_index, başlangıç_değeri ) ;Beş tamsayı tipi öğeye sahip “item_costs” adında bir vektör oluşturun ve toplamı hesaplayın.
#includekullanarak ad alanı std ;
ana ( )
{
// Vektör oluştur - item_costs
vektör < int > item_costs = { 8900 , 5677 , 200 , 1000 , 2300 } ;
cout << 'Ürünlerin Maliyeti: \N ' ;
için ( int Ben = 0 ; Ben < item_costs. boyut ( ) ; Ben ++ )
cout << item_costs [ Ben ] << sonunda ;
// Yukarıdaki vektördeki tüm öğelerin toplamını döndür - item_costs
cout << ' \N Toplam tutar: ' << biriktirmek ( başlamak ( item_costs ) ,son ( item_costs ) , 0 ) ;
}
Çıktı:
8900, 5677, 200, 1000, 2300'ün toplamı 18077'dir.
İki Vektörün Element Bilge Çarpımı
- Sayısal türünde iki vektör oluşturun ve iki vektör aynı boyutta olmalıdır (ilk vektörde bulunan öğelerin toplam sayısı = ikinci vektörde bulunan öğelerin toplam sayısı).
- Yeni bir vektör bildirin ve şunu kullanın: döngü için , her yinelemede iki öğe üzerinde çarpma işlemini gerçekleştirin ve Push_back() işlevini kullanarak değeri oluşturulan vektöre kaydedin. için ( int itr = 0 ; Ben < ilk_vec. boyut ( ) ; itr ++ )
- Sonuç vektöründe bulunan elemanları yineleyerek görüntüleyin.
{
sonuç_vektörü. Geri itmek ( ilk_vec [ itr ] * saniye_şey [ itr ] ) ;
}
Beş tamsayı tipi öğeye sahip “item_costs” adında bir vektör oluşturun ve toplamı hesaplayın.
#includekullanarak ad alanı std ;
ana ( )
{
// Her birinde 5 öğe bulunan ürünler1 ve ürünler2 olmak üzere iki vektör oluşturun
vektör < int > ürünler1 = { 10 , yirmi , 30 , 40 , elli } ;
vektör < int > ürünler2 = { elli , 40 , 30 , 70 , 60 } ;
vektör < int > sonuç_ürünleri ;
// Eleman bazında çarpma işlemi gerçekleştirin
için ( int Ben = 0 ; Ben < ürünler1. boyut ( ) ; Ben ++ ) {
sonuç_ürünleri. Geri itmek ( ürünler1 [ Ben ] * ürünler2 [ Ben ] ) ;
}
// Sonuç vektörünü göster
cout << 'Vektör Çarpımı: \N ' ;
için ( int res : sonuç_ürünleri )
cout << res << sonunda ;
}
Çıktı:
Yineleme - 1 : 10 * elli => 500Yineleme - 2 : yirmi * 40 => 800
Yineleme - 3 : 30 * 30 => 900
Yineleme - 4 : 40 * 70 => 2800
Yineleme - 5 : elli * 60 => 3000
İki Vektörün Nokta Çarpımı
C++ vektörleri durumunda nokta çarpım, 'iki vektör dizisinin karşılık gelen girdilerinin çarpımlarının toplamı' olarak tanımlanır.
Sözdizimi:
iç ürün ( Önce Vektör1, son olarak Vektör1, ilk olarak Vektör2, İlk_Val )Nokta çarpımı döndürmek için inner_product() işlevini kullanın. Bu fonksiyon dört gerekli parametreyi alır.
Burada:
- İlk parametre, ilk vektörün başlangıcına işaret eden bir yineleyiciyi ifade eder (begin() işlevini kullanarak belirtin).
- İkinci parametre, birinci vektörün sonunu işaret eden bir yineleyiciyi ifade eder (end() işlevini kullanarak belirtin).
- Üçüncü parametre, ikinci vektörün başlangıcına işaret eden bir yineleyiciyi ifade eder (begin() işlevini kullanarak belirtin).
- Nokta çarpımın birikimi için bir tam sayı olan son parametre olarak başlangıç değerinin iletilmesi gerekir.
İki vektörün çarpımı için oluşturulan programın aynısını kullanın ve iki vektörün nokta çarpımını bulmak için innsr_product() işlevini kullanın.
#includekullanarak ad alanı std ;
ana ( )
{
// Her birinde 5 öğe bulunan ürünler1 ve ürünler2 olmak üzere iki vektör oluşturun
vektör < int > ürünler1 = { 10 , yirmi , 30 , 40 , elli } ;
vektör < int > ürünler2 = { elli , 40 , 30 , 70 , 60 } ;
// Sonuç vektörünü göster
cout << 'Ürünler1 ve ürünler2'nin Nokta Çarpımı: ' ;
cout << iç ürün ( başlamak ( ürünler1 ) ,son ( ürünler1 ) ,başlamak ( ürünler2 ) , 0 ) ;
}
Çıktı:
( 10 * elli ) + ( yirmi * 40 ) + ( 30 * 30 ) + ( 40 * 70 ) + ( elli * 60 )=> 500 + 800 + 900 + 2800 + 3000
=> 8000
Bir Kümeyi Vektöre Dönüştürme
Bir kümede yükseltilmiş tüm elemanları bir vektöre geçirerek bir kümeyi vektöre dönüştürmenin birçok yolu vardır. En iyi ve en basit yol std::copy() fonksiyonunu kullanmaktır.
Sözdizimi
std :: kopyala ( İlk olarak sourceIterator, son olarak sourceIterator, ilk olarak hedefIterator )Kullan std::kopya() Bir kümenin elemanlarını vektöre ekleyen fonksiyon. Üç parametre alır.
Burada:
- İlk parametre, yineleyicideki ilk öğeye işaret eden kaynak yineleyiciyi ifade eder. Burada set, begin() işlevi kullanılarak belirtilen kaynak yineleyicidir.
- Benzer şekilde ikinci parametre de son öğeye (end() işlevi) işaret eder.
- Üçüncü parametre, yineleyicideki ilk öğeye (begin() işlevi kullanılarak belirtilir) işaret eden hedef yineleyiciyi ifade eder.
Beş öğrenciden oluşan bir küme oluşturalım ve önceki fonksiyonu kullanarak tüm elemanları bir vektöre kopyalayalım.
#includekullanarak ad alanı std ;
ana ( )
{
// Bir set oluşturun - 5 elementli öğrenciler
ayarlamak < sicim > öğrenciler = { 'Sravan' , 'Bobby' , 'Madhu' , 'Megana' , 'Lavanya' } ;
cout << 'Ayarlamak: \N ' ;
için ( dize ben : öğrenciler )
cout << Ben << sonunda ;
// Vektör oluştur - student_vcof boyutu kümenin boyutuna eşit
vektör < sicim > öğrenci_vc ( öğrenciler. boyut ( ) ) ;
// Öğrenciler Kümesinden öğeleri Vektör - öğrenci_vc'ye ekleyin.
kopyala ( öğrenciler. başlamak ( ) , öğrenciler. son ( ) , öğrenci_vc. başlamak ( ) ) ;
cout << ' \N Vektör: \N ' ;
için ( dize ben : öğrenci_vc )
cout << Ben << sonunda ;
}
Çıktı:
Artık “Öğrenciler” kümesinde bulunan tüm öğeler “öğrenciler_vc” vektörüne kopyalanmıştır.
Yinelenen Öğeleri Kaldır
- İlk olarak, vektördeki elemanları, tüm yinelenen elemanların birbirine bitişik olacağı şekilde sıralamamız gerekir. std::sort() işlev. std :: düzenlemek ( Önce vektör, son olarak vektör ) ;
- Yinelenen öğelerin seçilebilmesi için std::unique() işlevini kullanın. Aynı zamanda, std::unique() işlevi tarafından döndürülen kopyaları kaldırmak için delete() işlevini kullanın. Son vektörde elemanların sırası değişebilir. vektör. silmek ( std :: eşsiz ( Önce vektör, son olarak vektör ) , Vektör son ) )
10 öğeli 'öğrenciler' vektörünü oluşturun ve kopyaları kaldırarak vektörü döndürün.
#includekullanarak ad alanı std ;
ana ( )
{
// Bir vektör oluşturun - 10 elementli öğrenciler
vektör < sicim > öğrenciler = { 'Sravan' , 'Bobby' , 'Madhu' , 'Megana' , 'Lavanya' ,
'Sravan' , 'Bobby' , 'Madhu' , 'Megana' , 'Lavanya' } ;
cout << 'Öğrenciler: \N ' ;
için ( dize ben : öğrenciler )
cout << Ben << ' ' ;
// Öğrenci vektöründeki tüm öğeleri sıralayın.
düzenlemek ( başlamak ( öğrenciler ) , son ( öğrenciler ) ) ;
// Yinelenenleri delete() işleviyle kaldırmak için benzersiz() işlevini kullanın
öğrenciler. silmek ( eşsiz ( başlamak ( öğrenciler ) , son ( öğrenciler ) ) , son ( öğrenciler ) ) ;
cout << ' \N \N Benzersiz Öğrenciler: \N ' ;
için ( Oto itr = cbaşla ( öğrenciler ) ; itr ! = bir kaç ( öğrenciler ) ; ++ itr ) {
cout << * itr << ' ' ;
}
}
Çıktı:
Artık vektördeki tüm öğeler benzersizdir.
Bir Vektörü Kümeye Dönüştürme
Set yinelenen öğelere izin vermez. Tekrarları olan bir kümeye bir vektör eklemek için yazıyorsanız bunlar göz ardı edilecektir. Kümeyi bir vektöre dönüştüren önceki senaryoda kullanılan std::copy() işlevinin aynısını kullanıyoruz.
Bu senaryoda:
- İlk parametre, begin() işlevi kullanılarak belirtilen kaynak yineleyici olarak vektörü alır.
- İkinci parametre, vektörü end() işlevi kullanılarak belirtilen kaynak yineleyici olarak alır.
- Kümenin sonunu işaret eden kümeyi ve yineleyiciyi parametre olarak sağlayarak, kümedeki belirli bir konumdaki öğelerin üzerine otomatik olarak yazmak/kopyalamak için kullanılan std::inserter() işlevini iletin.
10 tamsayıdan oluşan bir vektör oluşturalım ve elemanlarını bir kümeye kopyalayalım.
#includekullanarak ad alanı std ;
ana ( )
{
// 10 değerli işaretlerden oluşan bir set oluşturun
vektör < int > işaretler = { 12 , 3. 4 , 56 , 78 , 65 , 78 , 90 , 90 , 78 , 3. 4 } ;
cout << 'Vektör: \N ' ;
için ( int Ben : işaretler )
cout << Ben << ' ' ;
// Küme Oluştur - vektörün boyutuna eşit boyutta işaretler_kümesi
ayarlamak < int > marks_set ;
// Öğrenciler Kümesinden öğeleri Vektör - öğrenci_vc'ye ekleyin.
kopyala ( başlamak ( işaretler ) ,son ( işaretler ) , yerleştirici ( marks_set,son ( işaretler_set ) ) ) ;
cout << ' \N \N Ayarlamak: \N ' ;
için ( int Ben : işaretler_set )
cout << Ben << ' ' ;
}
Çıktı:
Mevcut “marks” isimli vektörün 10 değeri bulunmaktadır. “marks_set” kümesine kopyaladıktan sonra, diğer dört öğe kopyalandığı için yalnızca altı öğe tutar.
Boş Dizeleri Kaldır
Bir vektörde bulunan boş dizelerin kullanımı yoktur. Vektörde bulunan boş dizelerin kaldırılması iyi bir uygulamadır. Boş dizelerin C++ vektöründen nasıl kaldırılacağını görelim:
- “For” döngüsünü kullanarak vektörü yineleyin.
- Her yinelemede, öğenin boş (“”) olup olmadığını veya at() üye işleviyle “==” operatörünü kullanarak kontrol edin.
- std::erase() işlevini kullanarak, önceki koşulu kontrol ettikten sonra boş dizeleri kaldırın.
- Vektörün sonuna kadar adım 2 ve adım 3'ü tekrarlayın.
10 dizeden oluşan “şirketler” vektörünü oluşturalım. Bunlardan beşi boş ve önceki yaklaşımı uygulayarak onları kaldırıyoruz.
#include#include
kullanarak ad alanı std ;
ana ( ) {
vektör < sicim > şirketler { 'Şirket-A' , '' , 'Şirket-B' ,
'' , 'Şirket-C' , '' , 'Şirket-D' , '' , '' , '' } ;
// Şirketler üzerinde yineleme
// ve delete() işlevini kullanarak boş öğeleri kaldırın
için ( int itr = 1 ; itr < şirketler. boyut ( ) ; ++ itr ) {
eğer ( şirketler. en ( itr ) == '' ) {
şirketler. silmek ( şirketler. başlamak ( ) + itr ) ;
-- itr ;
}
}
// Vektörü göster
için ( Oto & Ben : şirketler ) {
cout << Ben << sonunda ;
}
}
Çıktı:
Artık “şirketler” vektörü boş olmayan dizeleri tutuyor.
Metin Dosyasına Vektör Yazma
Bir vektörde bulunan tüm elemanların vektör indekslerini kullanarak bir dosyaya nasıl yazılacağını tartışalım. f akışı .
- Vektörü başlattıktan sonra Push_back işlevini kullanarak bazı öğeleri içine itin.
- “fstream” kütüphanesindeki open() fonksiyonunu mod out olarak kullanın.
- Bir 'for' döngüsündeki indeksleri kullanarak vektörde bulunan her bir öğeyi çaprazlayın ve her bir öğeyi sağlanan dosyaya yazın.
- Son olarak dosyayı kapatın.
Bir C++ kodu çalıştırarak önceki yaklaşımı uygulayalım.
#include#include
#include
#include
kullanarak ad alanı std ;
ana ( )
{
// Bir Vektör Oluştur - v_data
// ve içine iki öğe itin.
vektör < sicim > v_data ;
v_data. Geri itmek ( 'Hoş geldin' ) ;
v_data. Geri itmek ( 'LinuxHint'e' ) ;
akış f ;
// Dosyayı aç
F. açık ( 'yazılı_dosya.txt' ,ios_base :: dışarı ) ;
// Vektörün her elemanını yineleyin ve dosyaya tek tek yazın.
için ( int Ben = 0 ; Ben < v_data. boyut ( ) ; Ben ++ )
{
F << v_data [ Ben ] << sonunda ;
}
// Dosyayı kapat
F. kapalı ( ) ;
}
Çıktı:
“v_data” vektörü iki öğeyi tutar ve vektörde bulunan öğelerle programın yürütüldüğü yolda bir dosya oluşturulur.
Metin Dosyasından Vektör Oluşturma
Vektörde bulunan elemanların bir metin dosyasına nasıl yazılacağını öğrendik. Burada metin dosyasında bulunan içerikten bir vektör oluşturalım.
- Oluşturduğunuz bir ' ifstream” dosyadan vektör oluşturduğumuz metin dosyasındaki bilgileri okumak için kullanılan değişken.
- Dosya içeriğini depolamak için boş bir vektör oluşturun ve dosyanın sonunu kontrol etmek için boş bir dize değişkenini bayrak olarak kullanın.
- Dosyadaki bir sonraki satırı sonuna ulaşana kadar okuyun (temel olarak “while” döngüsünü kullanarak). Sonraki satırı okumak ve vektöre itmek için Push_back() işlevini kullanın.
- Konsolda vektörde bulunan elemanları görmek için satırda bulunan çizgiyi ayrı ayrı görüntüleyin.
Önceki yaklaşımı C++ kodunu çalıştırarak uygulayalım. Aşağıdaki içeriğe sahip “data.txt” dosyasını ele alalım. Burada vektörün adı “v_data”dır.
#include
kullanarak ad alanı std ;
ana ( )
{
// Metin dosyasını aç - veri
ifstream dosyası ( 'veri.txt' ) ;
// Vektör - v_data tipi - string oluştur
vektör < sicim > v_data ;
tanga vardı ;
// data.txt dosyasındaki sonraki satırı oku
// sonuna ulaşana kadar.
sırasında ( dosya >> öyleydi ) {
// Sonraki satırı okuyun ve v_data'ya aktarın
v_data. Geri itmek ( öyleydi ) ;
}
// Satırda bulunan satırı ayrı ayrı göster.
kopyala ( v_data. başlamak ( ) , v_data. son ( ) , ostream_iterator < sicim > ( cout , ' \N ' ) ) ;
}
Çıktı:
“v_data”nın dosyadan gelen beş öğeyi barındırdığını görebiliriz.
Çözüm
Bu uzun makalede, C++ programlama dilindeki vektörlerle ilgili gerçek zamanlı uygulamalarda kullanılan tüm olası örnekleri araştırdık. Her örnek sözdizimi, parametreler ve çıktılı örnekle açıklanmaktadır. Kodun net bir şekilde anlaşılmasını sağlamak için her koda yorumlar eklenir.