Los punteros aquí son una forma conveniente de evitar copiar y pegar. Suponga que tiene el siguiente código:
set xs, ys;
// ...
if (operation == 'X') {
xs.erase(value_to_remove);
xs.insert(value_to_insert);
cout << *xs.begin() << endl;
} else if (operation == 'Y') {
ys.erase(value_to_remove);
ys.insert(value_to_insert);
cout << *ys.begin() << endl;
}
Y ahora quieres deshacerte de esa repetición. Los punteros le ofrecen una buena solución: creemos una variable de puntero (digamos, current_set ) y hagamos que apunte a xs o ys dependiendo de la operation . Luego, hacemos todo a través de esta variable de puntero y las operaciones se realizarán con nuestros conjuntos originales:
- ¿Dónde puedo encontrar un algoritmo de relevancia marginal máxima en Python para la eliminación de redundancia en dos documentos?
- ¿Podemos hacerlo mejor en complejidad de tiempo que el siguiente código para calcular la suma de los primeros 10 primos?
- ¿Qué ventajas tiene una ordenación por inserción sobre una ordenación por burbujas en la programación y por qué se ha propuesto?
- ¿Cuál sería un algoritmo eficiente para ordenar millones de líneas de cadenas / enteros en un archivo?
- ¿Por qué algún algoritmo tiene la misma salida?
set xs, ys;
// ...
set *current_set;
if (operation == 'X') {
current_set = &xs; // '&' is 'reference operator', means 'take address of'
} else if (operation == 'Y') {
current_set = &ys;
}
// same as xs.erase(value_to_remove), if operation == 'X'
(*current_set).erase(value_to_remove); // '*' is 'dereference operator'
current_set->insert(value_to_insert); // 'a->b' is pretty same as (*a).b
cout <begin() <' has higher priority than '*'
No dude en comentar si no he respondido su pregunta; la actualizaré si es necesario.
