Quelle est la raison de cbegin/cend ?

Question

Je me demande pourquoi cbegin y cend ont été introduites dans C++11 ?

Quels sont les cas où l'appel de ces méthodes fait une différence par rapport aux surcharges constantes de begin y end ?

Answer 1

iterator y const_iterator ont une relation d'héritage et une conversion implicite se produit lorsqu'ils sont comparés ou affectés à l'autre type.

class T {} MyT1, MyT2, MyT3;
std::vector<T> MyVector = {MyT1, MyT2, MyT3};
for (std::vector<T>::const_iterator it=MyVector.begin(); it!=MyVector.end(); ++it)
{
    // ...
}

Utilisation de cbegin() y cend() augmentera les performances dans ce cas.

for (std::vector<T>::const_iterator it=MyVector.cbegin(); it!=MyVector.cend(); ++it)
{
    // ...
}

Answer 2

C'est simple, cbegin renvoie un itérateur constant alors que begin ne renvoie qu'un itérateur.

Pour mieux comprendre, prenons deux scénarios

scénario - 1 :

#include <iostream>
using namespace std;
#include <vector>
int main(int argc, char const *argv[])
{
std::vector<int> v;

for (int i = 1; i < 6; ++i)
{
    /* code */
    v.push_back(i);
}

for(auto i = v.begin();i< v.end();i++){
    *i = *i + 5;
}

for (auto i = v.begin();i < v.end();i++){
    cout<<*i<<" ";
}

return 0;
}

cela fonctionnera parce qu'ici l'itérateur i n'est pas constant et peut être incrémenté par 5

utilisons maintenant cbegin et cend en les désignant comme des itérateurs constants scénario - 2 :

#include <iostream>
using namespace std;
#include <vector>
int main(int argc, char const *argv[])
{
std::vector<int> v;

for (int i = 1; i < 6; ++i)
{
    /* code */
    v.push_back(i);
}

for(auto i = v.cbegin();i< v.cend();i++){
    *i = *i + 5;
}

for (auto i = v.begin();i < v.end();i++){
    cout<<*i<<" ";
}

return 0;
}

cela ne va pas fonctionner, car vous ne pouvez pas mettre à jour la valeur en utilisant cbegin et cend qui renvoient l'itérateur constant.