Pourquoi est-ce que je peux passer la clé de std :: map à une fonction qui attend non-const?

Question

Selon std::mapdocumentation, il stocke les paires clé-valeur dans std::pair<const Key, Value>, de sorte que les clés de la carte sont const.

Maintenant, imaginez que j'ai un std::map où les touches sont les pointeurs vers certains objets.

struct S {}; 
struct Data {}; 
using MyMap = std::map<S*, Data>; 

Supposons aussi qu'il existe une fonction foo qui accepte le paramètre S*.

void foo(S* ptr) { /* modify the object (*ptr) */ } 

Maintenant, la question est: quand j'itérer sur MyMap avec gamme basée à boucle, je suis en mesure de passer l'élément de carte clé foo:

MyMap m = getMyMapSomehow(); 
for (auto elem : m) 
{ 
    static_assert(std::is_const<decltype(elem.first)>::value, "Supposed to be `const S*`"); 
    foo(elem.first); // why does it compile? 
} 

Ainsi, même si mon static_assert réussit (donc je suppose que le type de elem.first est const S*), l'appel à foo se compile bien, et donc il semble que je suis capable de modifier l'objet derrière pointeur-à-const. Pourquoi suis-je capable de faire cela?

P.S. Voici un live example at Coliru qui illustre mon point. Par souci de concision, j'utilise int au lieu de S et Data.

Answer 1

donc je suppose que le type de elem.first est const S*

Non, la clé stockée dans mapconst, std::map<S*, Data>, la clé sera). Donc, il est bon de le passer à foo(S* ptr), le pointeur const lui-même sera copié dans le paramètre.

Answer 2

Voici un exemple plus simple, voir si vous pouvez travailler dehors:

void f(int);   // takes a non-const int 

int main() { 
    std::set<int> s; // elements are const ints 
    for (auto n : s) { 
     f(n);   // OK!? 
    } 
} 

Answer 3

std::map<K, V>::value_type est std::pair<const K, V>, comme vous l'avez mentionné. Alors qu'est-ce que const K quand S* est substitué K? La réponse, qui pourrait vous surprendre, n'est pas const S*. mais plutôt S* const.