std::map<Key,T,Compare,Allocator>::end, std::map<Key,T,Compare,Allocator>::cend
De cppreference.com
<tbody>
</tbody>
<tbody class="t-dcl-rev ">
</tbody><tbody>
</tbody>
<tbody class="t-dcl-rev ">
</tbody><tbody>
</tbody>
iterator end(); |
(hasta C++11) | |
iterator end() noexcept; |
(desde C++11) | |
const_iterator end() const; |
(hasta C++11) | |
const_iterator end() const noexcept; |
(desde C++11) | |
const_iterator cend() const noexcept; |
(desde C++11) | |
Devuelve un iterador al elemento que sigue después del último elemento del map.
Este elemento actúa como un marcador de posición; intentar accederlo resulta en comportamiento no definido.
Parámetros
(Ninguno)
Valor de retorno
Iterador al elemento que sigue después del último 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 principio. (función miembro pública) |