std::map<Key,T,Compare,Allocator>::begin, std::map<Key,T,Compare,Allocator>::cbegin
De cppreference.com
iterator begin(); |
(hasta C++11) | |
iterator begin() noexcept; |
(desde C++11) | |
const_iterator begin() const; |
(hasta C++11) | |
const_iterator begin() const noexcept; |
(desde C++11) | |
const_iterator cbegin() const noexcept; |
(desde C++11) | |
Devuelve un iterador al primer elemento del map.
Si el map está vacío, el iterador devuelto será igual a end().
Parámetros
(Ninguno)
Valor de retorno
Iterador al primer elemento.
Complejidad
Constante.
Ejemplo
Ejecuta este código
#include <iostream>
#include <map>
int main() {
std::map<int, float> map_num; // mapa de números
map_num[4] = 4.13;
map_num[9] = 9.24;
map_num[1] = 1.09;
// llama a map.begin() y a map.end()
for (auto it = map_num.begin(); it != map_num.end(); ++it) {
std::cout << it->first << ", " << it->second << '\n';
}
}
Salida:
1, 1.09
4, 4.13
9, 9.24
Ejemplo usando una función de comparación personalizada
Ejecuta este código
#include <cmath>
#include <iostream>
#include <map>
struct Punto { double x, y; };
// Compara las coordenadas x de dos punteros a Punto
struct CompDePuntos {
bool operator()(const Punto *lhs, const Punto *rhs) const {
return lhs->x < rhs->x;
}
};
int main() {
// Observa que aunque las coordenadas x no están en orden,
// el map se iterará a través de coordenadas x que se incrementan
Punto puntos[3] = { {2, 0}, {1, 0}, {3, 0} };
// mag es un map que manda la dirección de un nodo a su magnitud en el plano x-y
// Aunque las claves son punteros a Punto, queremos ordenar el map por las
// coordenadas x de los puntos y NO por las direcciones de los Puntos. Esto
// se hace usando la función miembro de comparación de la clase CompDePuntos.
std::map<Punto*, double, CompDePuntos> mag({
{ puntos, 2 },
{ puntos + 1, 1 },
{ puntos + 2, 3 }
});
// Cambiar cada coordenada y de 0 a la magnitud
for (auto iter = mag.begin(); iter != mag.end(); ++iter){
auto actual = iter->first; // puntero a Node
actual->y = mag[actual]; // could also have used actual->y = iter->second;
}
// Actualizar e imprimir la magnitud de cada nodo
for (auto iter = mag.begin(); iter != mag.end(); ++iter){
auto actual = iter->first;
mag[actual] = std::hypot(actual->x, actual->y);
std::cout << "La magnitud de (" << actual->x << ", " << actual->y << ") es ";
std::cout << iter->second << '\n';
}
// Repetir lo de arriba con el bucle for basado en rango
for (auto i : mag) {
auto actual = i.first;
actual->y = i.second;
mag[actual] = std::hypot(actual->x, actual->y);
std::cout << "La magnitud de (" << actual->x << ", " << actual->y << ") es ";
std::cout << mag[actual] << '\n';
// Observa que a diferencia de std::cout << iter->second << '\n'; arriba,
// std::cout << i.second << '\n'; NO imprimirá la magnitud actualizada.
// Si se usara auto &i: mag, imprimiría la magnitud actualizada
}
}
Salida:
La magnitud de (1, 1) es 1.41421
La magnitud de (2, 2) es 2.82843
La magnitud de (3, 3) es 4.24264
La magnitud de (1, 1.41421) es 1.73205
La magnitud de (2, 2.82843) es 3.4641
La magnitud de (3, 4.24264) es 5.19615
Véase también
(C++11) |
Devuelve un iterador al final. (función miembro pública) |