¿Por qué no hay ningún algoritmo std :: copy_if?

Question

¿Hay alguna razón específica para no tener el algoritmo std :: copy_if en C++? Sé que puedo usar std :: remove_copy_if para lograr el comportamiento requerido. Creo que viene en C++ 0x, pero un simple copy_if que toma un rango, un iterador de salida y un functor habría sido bueno. ¿Simplemente lo perdieron o hay alguna otra razón detrás de esto?

Answer 1

De acuerdo con "El lenguaje de programación C++" de Stroustrup, era solo una visión excesiva.

(como una cita, la misma pregunta contestada en impulsar las listas de correo-: copy_if)

Answer 2

Multiplesourcesindicate que se dejó fuera de STL por accidente.

Sin embargo, no estoy seguro de si eso es un hecho o un mito que se autoperpetúa. Agradecería que alguien señalara una fuente más creíble que un enlace a una publicación aleatoria en Internet.

Answer 3

BS dice que se olvidaron. Está en C++ 11. Sin embargo, puede usar remove_copy_if (que realmente se debería llamar copy_if_not) junto con not1 en su lugar.

Answer 4

Está muerto fácil de escribir su propio:

template <class InputIterator, class OutputIterator, class Predicate> 
OutputIterator copy_if(InputIterator first, InputIterator last, 
         OutputIterator result, Predicate pred) 
{ 
    return std::remove_copy_if(first,last,result,std::not1(pred)); 
} 

Editar: Esta versión funciona con todos los predicados:

template <class InputIterator, class OutputIterator, class Predicate> 
OutputIterator copy_if(InputIterator first, InputIterator last, 
         OutputIterator result, Predicate pred) 
{ 
    while(first!=last) 
    { 
    if(pred(*first)) 
     *result++ = *first; 
    ++first; 
    } 
    return result; 
} 

Answer 5

simplemente para la corrección, en caso de que alguien googles su/su manera de esta pregunta, se debe mencionar que ahora (después de C + + 11) hay un algoritmo copy if. Se comporta como se esperaba (copia los elementos en un rango, para los cuales algún predicado devuelve verdadero, a otro rango).

Un caso de uso típico sería

std::vector<int> foo{ 25, 15, 5, -5, -15 }; 
std::vector<int> bar; 

// copy only positive numbers: 
auto it = std::copy_if (foo.begin(), foo.end(), std::back_inserter(bar), 
      [](int i){return !(i<0); 
      }); 

Answer 6

simplemente para la corrección voy a añadir ese impulso tiene boost::algorithm::copy_if para aquellos de ustedes que no pueden utilizar C++ versión de 11 (como yo) en boost/algorithm/cxx11/copy_if.hpp que utilizará std::copy_if cuando :

#if __cplusplus >= 201103L 
// Use the C++11 versions of copy_if if it is available 
using std::copy_if;   // Section 25.3.1 
#else 

Ejemplo:

#include <boost/algorithm/cxx11/copy_if.hpp> 
#include <boost/assign/list_of.hpp> // for 'list_of()' 
#include <boost/foreach.hpp> 

#include <iostream> 
#include <vector> 
#include <iterator> 

struct Odd 
{ 
    bool operator()(int n) 
    { 
    return n & 1; 
    } 
}; 

int main() 
{ 
    std::vector<int> v = boost::assign::list_of(0)(1)(2)(3)(4); 
    BOOST_FOREACH(int i, v) 
    std::cout << i << ' ' ; 

    std::vector<int> out; 
    boost::algorithm::copy_if(v.begin(), v.end(), std::back_inserter(out), Odd()); 

    std::cout << std::endl; 

    BOOST_FOREACH(int i, out) 
    std::cout << i << ' ' ; 

} 

Salida:

0 1 2 3 4 
1 3