std::map<Key,T,Compare,Allocator>::end, std::map<Key,T,Compare,Allocator>::cend

#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';
  }
}

#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
    }
}