Yineleyicileri kullanarak bir vektörde nasıl gezinilir? (C ++)

Amaç, [] operatörü veya "at" yöntemi yerine bir dizge vektörünün "n'inci" öğesine erişmektir. Anladığım kadarıyla yineleyiciler konteynerler arasında gezinmek için kullanılabilir, ancak daha önce hiç yineleyici kullanmadım ve okuduğum şey kafa karıştırıcı.

Biri bana bunu nasıl başaracağıma dair biraz bilgi verebilirse, minnettar olurum. Teşekkür ederim.

Sırasıyla birinci ve son öğeye atıfta bulunan yineleyiciyi döndüren sınıfın beginve endyöntemini kullanmanız gerekir vector.

using namespace std;  

vector<string> myvector;  // a vector of stings.


// push some strings in the vector.
myvector.push_back("a");
myvector.push_back("b");
myvector.push_back("c");
myvector.push_back("d");


vector<string>::iterator it;  // declare an iterator to a vector of strings
int n = 3;  // nth element to be found.
int i = 0;  // counter.

// now start at from the beginning
// and keep iterating over the element till you find
// nth element...or reach the end of vector.
for(it = myvector.begin(); it != myvector.end(); it++,i++ )    {
    // found nth element..print and break.
    if(i == n) {
        cout<< *it << endl;  // prints d.
        break;
    }
}

// other easier ways of doing the same.
// using operator[]
cout<<myvector[n]<<endl;  // prints d.

// using the at method
cout << myvector.at(n) << endl;  // prints d.

Tipik olarak yineleyiciler, bir kabın öğelerine doğrusal biçimde erişmek için kullanılır; ancak "rastgele erişim yineleyiciler" ile herhangi bir öğeye aynı şekilde erişmek mümkündür operator[].

To bir vektör erişim keyfi elemanları vec , aşağıdakileri kullanabilirsiniz:

vec.begin()                  // 1st
vec.begin()+1                // 2nd
// ...
vec.begin()+(i-1)            // ith
// ...
vec.begin()+(vec.size()-1)   // last

Aşağıda, tipik bir erişim modelinin bir örneği verilmiştir (C ++ 'ın önceki sürümleri):

int sum = 0;
using Iter = std::vector<int>::const_iterator;
for (Iter it = vec.begin(); it!=vec.end(); ++it) {
    sum += *it;
}

Yineleyici kullanmanın avantajı, aynı kalıbı diğer kaplarla uygulayabilmenizdir :

sum = 0;
for (Iter it = lst.begin(); it!=lst.end(); ++it) {
    sum += *it;
}

Bu nedenle, konteyner türü ne olursa olsun aynı şekilde çalışacak şablon kodu oluşturmak gerçekten çok kolay . Yineleyicilerin diğer bir avantajı, verilerin bellekte yerleşik olduğunu varsaymamasıdır; örneğin, bir girdi akışından veri okuyabilen veya anında veri üreten bir ileri yineleyici yaratılabilir (örneğin, bir aralık veya rasgele sayı üreteci).

std::for_eachLambdas kullanan başka bir seçenek :

sum = 0;
std::for_each(vec.begin(), vec.end(), [&sum](int i) { sum += i; });

C ++ 11'den autoberi, daha önce görüldüğü gibi (veya daha karmaşık) yineleyicinin çok uzun, karmaşık bir tür adını belirtmekten kaçınmak için kullanabilirsiniz :

sum = 0;
for (auto it = vec.begin(); it!=vec.end(); ++it) {
    sum += *it;
}

Ayrıca, her varyant için daha basit bir yöntem vardır:

sum = 0;
for (auto value : vec) {
    sum += value;
}

Ve son olarak, std::accumulatetamsayı veya kayan nokta sayıları eklerken dikkatli olmanız gereken yerler de vardır .

C ++ - 11'de şunları yapabilirsiniz:

std::vector<int> v = {0, 1, 2, 3, 4, 5};
for (auto i : v)
{
   // access by value, the type of i is int
   std::cout << i << ' ';
}
std::cout << '\n';

Varyasyonlar için buraya bakın: https://en.cppreference.com/w/cpp/language/range-for

Vector'un yineleyicileri rastgele erişimli yineleyicilerdir, bu da düz işaretçiler gibi göründükleri ve hissettikleri anlamına gelir.

Kapsayıcının begin()yönteminden döndürülen yineleyiciye n ekleyerek n'inci öğeye erişebilir veya operatörü kullanabilirsiniz [].

std::vector<int> vec(10);
std::vector<int>::iterator it = vec.begin();

int sixth = *(it + 5);
int third = *(2 + it);
int second = it[1];

Alternatif olarak , her tür yineleyici ile çalışan gelişmiş işlevini kullanabilirsiniz . (Rastgele erişimli olmayan yineleyicilerle gerçekten "rasgele erişim" gerçekleştirmek isteyip istemediğinizi düşünmeniz gerekir, çünkü bu yapılması pahalı bir şey olabilir.)

std::vector<int> vec(10);
std::vector<int>::iterator it = vec.begin();

std::advance(it, 5);
int sixth = *it;

İki yineleyicinin artırılmasını gerektirmeyen bir döngü içinde bir kullanarak a'nın ithdizinine erişmenin bir örneği aşağıda verilmiştir .std::vectorstd::iterator

std::vector<std::string> strs = {"sigma" "alpha", "beta", "rho", "nova"};
int nth = 2;
std::vector<std::string>::iterator it;
for(it = strs.begin(); it != strs.end(); it++) {
    int ith = it - strs.begin();
    if(ith == nth) {
        printf("Iterator within  a for-loop: strs[%d] = %s\n", ith, (*it).c_str());
    }
}

Döngü olmadan

it = strs.begin() + nth;
printf("Iterator without a for-loop: strs[%d] = %s\n", nth, (*it).c_str());

ve atyöntemi kullanma :

printf("Using at position: strs[%d] = %s\n", nth, strs.at(nth).c_str());