30 C++ Vektör Örnekleri

30 C Vektor Ornekleri



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:

  1. Matematiksel vektörlerin bilimsel ve mühendislik uygulamalarında temsil edilmesi
  2. 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:

  1. Bir Vektöre Öğe Ekleme
  2. Bir Vektöre Birden Çok Öğe Ekleme
  3. Bir Vektörden Öğelere Erişme
  4. Bir Vektördeki Öğeyi Güncelleme
  5. Bir Vektörden Belirli Bir Öğeyi Kaldırma
  6. Bir Vektörden Tüm Öğeleri Kaldırma
  7. Vektörlerin Birliği
  8. Vektörlerin Kesişimi
  9. Vektörün Boş Olup Olmadığını Kontrol Edin
  10. Const_Iterator Kullanarak Bir Vektörü Geçme
  11. Reverse_Iterator Kullanarak Bir Vektörü Geçme
  12. Öğeleri Vektörün İçine İtin
  13. Vektörden Öğeleri Aç
  14. Vektörleri Değiştirin
  15. Vektörden İlk Elemanı Getir
  16. Vektörden Son Öğeyi Getir
  17. Bir Vektöre Yeni Değerler Atama
  18. Emplace() Kullanarak Vektörü Genişletme
  19. Emplace_Back() Kullanarak Vektörü Genişletme
  20. Bir Vektörün Maksimum Elemanı
  21. Bir Vektörün Minimum Elemanı
  22. Bir Vektördeki Öğelerin Toplamı
  23. İki Vektörün Element Bilge Çarpımı
  24. İki Vektörün Nokta Çarpımı
  25. Bir Kümeyi Vektöre Dönüştürme
  26. Yinelenen Öğeleri Kaldır
  27. Bir Vektörü Kümeye Dönüştürme
  28. Boş Dizeleri Kaldır
  29. Metin Dosyasına Vektör Yazma
  30. 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.

#include

kullanarak 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:

  1. Konum parametresi eklenecek öğe konumunu belirtir. Boyut 1'den büyükse başlangıç ​​konumu dizini konum olacaktır.
  2. Size parametresi, bir öğenin kaç kez ekleneceğini belirtir.
  3. 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.

#include

kullanarak 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:

  1. Konum parametresi eklenecek öğe konumunu belirtir.
  2. '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).
  3. '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.

#include

kullanarak 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.

#include

kullanarak 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.

#include

kullanarak 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 ] = Öğe

Beş 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 ) = Öğe

Beş öğeli “ürünler” vektörünü düşünün. Vektörde bulunan tüm öğeleri diğer öğelerle güncelleyin.

#include

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 ;

//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.

  1. 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.
  2. end() yineleyicisini belirterek son öğeyi kaldırın. End() vektördeki son öğeyi işaret eder.
#include

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.

#include

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 ;



// İ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.

#include

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 ;



// Ü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:

  1. “İlk1”, ilk yineleyicinin (vektör) ilk elemanını işaret eder.
  2. “Last1” ilk yineleyicinin (vektör) son elemanını işaret eder.
  3. “İlk2” ikinci yineleyicinin (vektör) ilk elemanını işaret eder.
  4. “Last2” ikinci yineleyicinin (vektör) son elemanını işaret eder.

Tamsayı türünde iki vektör – “konu1” ve “konu2” – oluşturun.

  1. Yineleyicileri geçirerek sort() işlevini kullanarak iki vektörü sıralayın.
  2. Bir çıktı vektörü (yineleyici) oluşturun.
  3. 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.
  4. İşlev tarafından döndürülen öğeleri görüntülemek için çıktı vektörünü yineleyin.
#include

#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.

  1. Yineleyicileri geçirerek sort() işlevini kullanarak iki vektörü sıralayın.
  2. Bir çıktı vektörü (yineleyici) oluşturun.
  3. 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.
  4. İşlev tarafından döndürülen öğeleri görüntülemek için çıktı vektörünü yineleyin.
#include

#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.

  1. Beş dizeden oluşan “departmanlar” adında bir vektör oluşturalım.
  2. türünde bir const_iterator – ctr bildirin.
  3. “For” döngüsünü kullanarak önceki yineleyiciyi kullanarak bölümler üzerinde yineleme yapın ve onu görüntüleyin.
#include

#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.

  1. Beş dizeden oluşan “departmanlar” adında bir vektör oluşturalım.
  2. tipinde bir revers_iterator – rtr bildirin.
  3. “For” döngüsünü kullanarak önceki yineleyiciyi kullanarak bölümler üzerinde yineleme yapın ve onu görüntüleyin.
#include

#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:

  1. Tüm benzer öğelerle vektörü oluşturun
  2. Mevcut vektörü aynı öğeyle değiştirin

Sözdizimi:

vektör. atamak ( boyut, değer )

Bu fonksiyon için iki parametre gereklidir.

Burada:

  1. Boyut, atanacak öğe sayısını belirtir.
  2. 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:

  1. İlk parametre, öğeyi herhangi bir konuma yerleştirebilmemiz için konumu alır. Begin() veya end() yineleyici işlevini kullanarak konumu elde edebiliriz.
  2. İkinci parametre vektöre eklenecek öğedir.

İki elementli “kimyasallar” vektörünü düşünün.

  1. İlk konuma “Manganez” ekleyin – başlayın(kimyasallar)
  2. Son pozisyona “Bakır”ı ekleyin – son(kimyasallar)
  3. 'Kükürt'ü üçüncü konuma ekleyin – begin(chemicals)+2
#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 ;



// 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ı

  1. Bazı öğeler içeren bir vektör oluşturun.
  2. 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.
* maksimum_element ( ilk_Index,last_Index )

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ı

  1. Bazı öğeler içeren bir vektör oluşturun.
  2. 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.
* min_element ( ilk_Index,last_Index )

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.

#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ö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ı

  1. 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ı).
  2. 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.
  3. için ( int itr = 0 ; Ben < ilk_vec. boyut ( ) ; itr ++ )

    {

    sonuç_vektörü. Geri itmek ( ilk_vec [ itr ] * saniye_şey [ itr ] ) ;

    }
  4. Sonuç vektöründe bulunan elemanları yineleyerek görüntüleyin.

Beş tamsayı tipi öğeye sahip “item_costs” adında bir vektör oluşturun ve toplamı hesaplayın.

#include

kullanarak 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 => 500

Yineleme - 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:

  1. İlk parametre, ilk vektörün başlangıcına işaret eden bir yineleyiciyi ifade eder (begin() işlevini kullanarak belirtin).
  2. İkinci parametre, birinci vektörün sonunu işaret eden bir yineleyiciyi ifade eder (end() işlevini kullanarak belirtin).
  3. Üçüncü parametre, ikinci vektörün başlangıcına işaret eden bir yineleyiciyi ifade eder (begin() işlevini kullanarak belirtin).
  4. 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.

#include

kullanarak 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:

  1. İlk parametre, yineleyicideki ilk öğeye işaret eden kaynak yineleyiciyi ifade eder. Burada set, begin() işlevi kullanılarak belirtilen kaynak yineleyicidir.
  2. Benzer şekilde ikinci parametre de son öğeye (end() işlevi) işaret eder.
  3. Üçü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.

#include

kullanarak 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

  1. İlk olarak, vektördeki elemanları, tüm yinelenen elemanların birbirine bitişik olacağı şekilde sıralamamız gerekir. std::sort() işlev.
  2. std :: düzenlemek ( Önce vektör, son olarak vektör ) ;
  3. 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.
  4. 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.

#include

kullanarak 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:

  1. İlk parametre, begin() işlevi kullanılarak belirtilen kaynak yineleyici olarak vektörü alır.
  2. İkinci parametre, vektörü end() işlevi kullanılarak belirtilen kaynak yineleyici olarak alır.
  3. 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.

#include

kullanarak 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:

  1. “For” döngüsünü kullanarak vektörü yineleyin.
  2. Her yinelemede, öğenin boş (“”) olup olmadığını veya at() üye işleviyle “==” operatörünü kullanarak kontrol edin.
  3. std::erase() işlevini kullanarak, önceki koşulu kontrol ettikten sonra boş dizeleri kaldırın.
  4. 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ışı .

  1. Vektörü başlattıktan sonra Push_back işlevini kullanarak bazı öğeleri içine itin.
  2. “fstream” kütüphanesindeki open() fonksiyonunu mod out olarak kullanın.
  3. 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.
  4. 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.

  1. Oluşturduğunuz bir ' ifstream” dosyadan vektör oluşturduğumuz metin dosyasındaki bilgileri okumak için kullanılan değişken.
  2. 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.
  3. 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.
  4. 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.