Por favor explique este código que usa std :: ignore

Estoy leyendo la documentación en std::ignore from cppreference. Me resulta bastante difícil comprender el verdadero propósito de este objeto, y el código de ejemplo no le hace mucha justicia. Por ejemplo, en el siguiente código, ¿cómo y por qué se inserted conjunto en verdadero? No tiene mucho sentido para mí.

 #include  #include  #include  #include  int main() { std::set set_of_str; bool inserted; std::tie(std::ignore, inserted) = set_of_str.insert("Test"); if (inserted) { std::cout << "Value was inserted sucessfully\n"; } } 

Si alguien me puede explicar el código, se lo agradecería. Gracias.

set::insert devuelve un par donde el primero es el iterador del elemento insertado y el segundo es un bool que dice si el elemento fue insertado.

std::tie crea una tupla de referencias de valores. Cuando se asigna al resultado de la insert le permite establecer las variables en el tie con los resultados de la inserción en el first y second miembro del pair retorno.

std::ignore es un valor que se puede asignar sin ningún efecto.

Básicamente, este código ignora el iterador del elemento donde se insertó "Test" y las asigna el second miembro del par devuelto por set::insert que indica si se insertó un elemento.

Creo que la respuesta de Dave es bastante buena, pero me gustaría explicar un poco por qué usar este enfoque.

En otros idiomas como Scala, Haskell o Python, usualmente tienes la presencia de tuplas (al ser una tupla de dos elementos) y tienen esta forma idiomática de asignarlas a las variables:

 (var1,...,varN) = func_returning_tuple() 

Esto tiene el propósito de expandir el valor semántico de su código y mejorar su legibilidad, donde de lo contrario tendría una sola variable sin semántica para sus elementos (como t.first, etc.), y en C ++ para acceder a los valores de las tuplas tendría que utilizar:

 varN = std::get(my_tuple); 

Por lo tanto, si solo utiliza el enlace, puede hacer que su código de ejemplo sea más fácil de leer de la siguiente manera:

 std::tie( element_iterator, inserted ) = set_of_str.insert("test"); 

Y luego use sus variables aisladas a voluntad, esto mejora la forma en que otros (e incluso usted mismo) leen las siguientes declaraciones de su código.

std::ignore se usa cuando no te importa lo que se devuelve, en otros idiomas también tienes este recurso, en Scala, por ejemplo, este es el subrayado. Por ejemplo, si uso la función de inserción en un mapa y el valor ya existe, simplemente devolvió el par que contiene (iterator,false) así que si quiero el iterador para alguna clave, incluso si no me importa si ya existe en El mapa, lo puedo hacer con esta línea:

 std::tie( element_iterator, std::ignore ) = set_of_str.insert("test"); 

Así es como C ++ resuelve este problema de legibilidad de las tuplas y los pares.