Pourquoi "std :: begin()" renvoie-t-il toujours "const_iterator" dans un tel cas?

Question

#include <vector> 
#include <iostream> 

using namespace std; 

int main() 
{ 
    vector<int> coll; 

    decltype(std::begin(std::declval<vector<int>>())) 
     pos_1 = coll.begin(); 
    auto pos_2 = coll.begin(); 

    cout << typeid(decltype(pos_1)).name() << endl; 
    cout << typeid(decltype(pos_2)).name() << endl; 
} 

Mon compilateur est clang 4.0. La sortie est:

class std::_Vector_const_iterator<class std::_Vector_val<struct std::_Simple_types<int> > > 
class std::_Vector_iterator<class std::_Vector_val<struct std::_Simple_types<int> > > 

Cela signifie: pos_1 = pos_2; est ok, alors que pos_2 = pos_1; n'est pas correct.

Pourquoi est-ce que std::begin() renvoie toujours const_iterator plutôt que iterator dans un tel cas?

Answer 1

non-const L'appel de fonction:

std::declval<std::vector<int>>() 

se traduit par une expression rvalue qui peut être désigné par:

std::vector<int>&& 

Le compilateur a deux surcharges (générique) de std::begin à choisir ([iterator.range]):

template <class C> 
auto begin(C& c) -> decltype(c.begin());  // #1 

template <class C> 
auto begin(const C& c) -> decltype(c.begin()); // #2 

Pour une expression rvalue, seule la seconde surcharge (# 2) est viable - un rvalue ne peut pas être lié par un référence de lvalue non-const. La qualification const du type référencé implique que le compilateur utilisera la surcharge admissible const de la fonction membre begin:

const_iterator begin() const noexcept; 
//      ~~~~^ 

qui renvoie une instance de type const_iterator.

Vous pouvez modifier ce comportement en demandant une expression lvalue de std::vector<int> de l'appel std::declval:

decltype(std::begin(std::declval<std::vector<int>&>())) pos_1 = coll.begin(); 
//            ~~^~~  

Answer 2

si vous avez Type&& (temporaire), puis la surcharge résolution préférera const Type& sur Type&, puisque une liaison coutume temporaire à un lvalue référence