c++ - sort - ¿Por qué no hay std:: borrar?

stl c++ queue

Question

Mientras leía el STL, me di cuenta de que no se proporciona std::erase . No estoy realmente seguro de por qué no está allí. Un caso de uso válido está siguiendo

std::vector<int> odd { 1, 3, 5, 3, 9, 11, 5, 17 };
std::sort(odd.begin(), odd.end());
std::erase(std::unique(odd.begin(), odd.end()), odd.end());

Sin embargo, está incrustado en cada contenedor. Si el rendimiento es la razón, de una manera que si los objetos son contiguos, se podrían eliminar de una sola vez. Pero supongo que eso es factible con la especialización de plantillas de ayuda.

Answer 1

¿Cómo funcionaría? Sólo acepta un par de iteradores. Los iteradores no tienen que mantener una referencia a su contenedor (los iteradores de un vector pueden ser simples alias para los punteros).

Entonces, ¿cómo modificaría el algoritmo el contenedor? Necesita ese acceso.

Debe ser una función miembro.

Answer 2

El pegamento entre secuencias y algoritmos son iteradores (gracias a @Pete Becker por indicarme el término correcto aquí). Se reducen a la funcionalidad mínima necesaria para algoritmos potentes que pueden aplicarse a múltiples tipos de secuencia (contenedor). Un ejemplo es tal fragmento:

std::vector<int> vec{1, 2, 3, 4};
std::list<int> lst;

std::copy(vec.cbegin(), vec.cend(), std::back_inserter(lst));
std::copy(lst.cbegin(), lst.cend(), std::ostream_iterator<int>(std::cout, " "));

Aquí, std::copy se puede implementar independientemente del tipo de secuencia específico en el que opera, ya que funciona con iteradores que tienen la intención de hacer dos cosas: atravesar una secuencia y proporcionar acceso a sus elementos.

Sin embargo, esto se envía con una limitación cuando los elementos se eliminarán de un contenedor.

La necesidad de hacerlo mientras se aprovecha un algoritmo ( std -) es lo suficientemente común como para dar lugar a que el borrado elimine el idioma, ya que se trata de un conocido patrón o bibliotecas de rango que aprovechan los contenedores completos que se pasan a los algoritmos:

#include <boost/range/algorithm_ext.hpp>

std::vector<int> vec{1, 2, 3, 4};

boost::remove_erase(vec, 3);

La última invocación de la función puede realmente eliminar el elemento con el valor 3 del contenedor, porque no se ha ocultado ninguna información en esa llamada a la función. En contraste, la familia de funciones *begin / *end (miembro) hace exactamente eso: ocultar información detrás de una abstracción.

Answer 3

La eliminación uniforme de los contenedores se agregó a std / experimental int the Library Fundamentals 2 TS a finales de 2014. Esto se aprobó recientemente en la norma para C ++ - 2a, pero incluso el borrador de github no lo muestra todavía. Sé que gcc, clang y Visual Studio soportan soporte experimental.

Así que en lugar de tu contenedor habitual incluye una de estas versiones:

<experimental/deque>
<experimental/forward_list>
<experimental/list>
<experimental/map>
<experimental/set>
<experimental/string>
<experimental/unordered_map>
<experimental/unordered_set>
<experimental/vector>

Estas son las firmas de un artículo más reciente :

  // <experimental/string>
  template <class charT, class traits, class A, class Predicate>
    void erase_if(basic_string<charT, traits, A>& c, Predicate pred);
  template <class charT, class traits, class A, class U>
    void erase(basic_string<charT, traits, A>& c, const U& value);

  // <experimental/deque>
  template <class T, class A, class Predicate>
    void erase_if(deque<T, A>& c, Predicate pred);
  template <class T, class A, class U>
    void erase(deque<T, A>& c, const U& value);

  // <experimental/vector>
  template <class T, class A, class Predicate>
    void erase_if(vector<T, A>& c, Predicate pred);
  template <class T, class A, class U>
    void erase(vector<T, A>& c, const U& value);

  // <experimental/forward_list>
  template <class T, class A, class Predicate>
    void erase_if(forward_list<T, A>& c, Predicate pred);
  template <class T, class A, class U>
    void erase(forward_list<T, A>& c, const U& value);

  // <experimental/list>
  template <class T, class A, class Predicate>
    void erase_if(list<T, A>& c, Predicate pred);
  template <class T, class A, class U>
    void erase(list<T, A>& c, const U& value);

  // <experimental/map>
  template <class K, class T, class C, class A, class Predicate>
    void erase_if(map<K, T, C, A>& c, Predicate pred);
  template <class K, class T, class C, class A, class Predicate>
    void erase_if(multimap<K, T, C, A>& c, Predicate pred);

  // <experimental/set>
  template <class K, class C, class A, class Predicate>
    void erase_if(set<K, C, A>& c, Predicate pred);
  template <class K, class C, class A, class Predicate>
    void erase_if(multiset<K, C, A>& c, Predicate pred);

  // <experimental/unordered_map>
  template <class K, class T, class H, class P, class A, class Predicate>
    void erase_if(unordered_map<K, T, H, P, A>& c, Predicate pred);
  template <class K, class T, class H, class P, class A, class Predicate>
    void erase_if(unordered_multimap<K, T, H, P, A>& c, Predicate pred);

  // <experimental/unordered_set>
  template <class K, class H, class P, class A, class Predicate>
    void erase_if(unordered_set<K, H, P, A>& c, Predicate pred);
  template <class K, class H, class P, class A, class Predicate>
    void erase_if(unordered_multiset<K, H, P, A>& c, Predicate pred);