Llamar a la función miembro.begin() destd::vector ystd::begin() en los valores de los resultados en diferentes salidas, como muestra la siguiente prueba:

vector<int> a{ 1, 2, 3 };

vector<int>::iterator it1 = move(a).begin(); // OK
vector<int>::const_iterator it2 = move(a).begin(); // OK

vector<int>::iterator it3 = begin(move(a)); // Error!
vector<int>::const_iterator it4 = begin(move(a)); // OK

Aquí está mi entendimiento:std::begin() llamadasconst& sobrecarga (ya que falta&& sobrecarga), y por lo tanto, devuelve unconst_iterator objeto. Entonces, el valor devuelto se puede asignar aconst_iterator pero noiterator.

¿Es correcto mi entendimiento?Por questd::begin() no tiene una sobrecarga de valor?

Solo una nota que usémove(a) para demostrar vocación.begin() ystd::begin() en valores. Por supuesto, puede ser reemplazado por cualquier objeto rvalue para el cual.begin() ystd::begin() Están bien definidos.

Editar: Aquí está el ejemplo real que muestra dónde encontré este problema. He simplificado mucho solo para transmitir la idea de dóndestd::begin() se llama en un rvalue. Entonces, desderow_matrix es una clase proxy, no debería haber ningún problema al llamarbegin yend en valores ya que el objeto subyacente es idéntico.

class matrix_row;
class row_iterator;

class matrix {
public:
    matrix_row row(int i);
    // other members
};  

class matrix_row { // <- proxy class representing a row of matrix
public:
    row_iterator begin();
    row_iterator end();
    // other members
private:
    int row_;
    matrix& matrix_;
};

class row_iterator {
    // defined everything needed to qualify as a valid iterator 
};

matrix m(3,4);

for(auto x = m.row(1).begin(); x != m.row(1).end(); ++x) {
    *x /=2; // OK
}

for(auto x = begin(m.row(1)); x != end(m.row(1)); ++x) {
    *x /= 2; // Error
}