iterador "genérica" ​​en C++

Question

tengo:

void add_all_msgs(std::deque<Message>::iterator &iter); 

¿Cómo puedo hacer que la función "genérico", por lo que puede tomar cualquier tipo de inputiterators? Realmente no me importa si está iterando un deque, un vector u otra cosa, siempre y cuando el iterador itere Mensaje. - ¿Es esto lo más sencillo posible en C++?

Answer 1

template<class InputIterator> 
void add_all_msgs(InputIterator iter); 

Uso:

std::deque<Message> deq; 
add_all_msgs(deq.begin()); 

Answer 2

#include <deque> 
#include <vector> 
#include <list> 
#include <string> 
using namespace std; 

template<typename T> 
void add_all_msgs(T &iter) 
{ 

} 

int _tmain(int argc, _TCHAR* argv[]) 
{ 
    std::deque<string>::iterator it1; 
    std::vector<string>::iterator it2; 
    std::list<string>::iterator it3; 

    add_all_msgs(it1); 
    add_all_msgs(it2); 
    add_all_msgs(it3); 


    return 0; 
} 

Answer 3

template <typename Iterator> 
void add_all_messages(Iterator first, Iterator last) 

uso:

vector<message> v; 
add_all_messages(v.begin(), v.end()); 

Es necesario especificar el final, de lo contrario no saber cuándo parar! También le da la flexibilidad de agregar solo un subrango de un contenedor.

Answer 4

Si desea que el compilador compruebe si el iterador realmente se refiere a los objetos Message, puede utilizar una técnica como la siguiente.

template <typename InputIterator, typename ValueType> 
struct AddAllMessages { }; 

template <typename InputIterator> 
struct AddAllMessages<InputIterator, Message> { 
    static void execute(const InputIterator &it) { 
    // ... 
    } 
}; 

template <typename InputIterator> 
void add_all_msgs(const InputIterator &it) { 
    AddAllMessages<InputIterator, 
       typename std::iterator_traits<InputIterator>::value_type>::execute(it); 
} 

Answer 5

un poco más sencillo que el anterior (en la que aprovecha las bibliotecas existentes):

#include <boost/static_assert.hpp> // or use C++0x static_assert 
#include <boost/type_traits/is_same.hpp> 

template <typename InputIterator> 
void add_all_msgs(InputIterator it) { 
    BOOST_STATIC_ASSERT((boost::is_same< 
     typename std::iterator_traits<InputIterator>::value_type, 
     Message>::value)); 
    // ... 

Answer 6

Si no desea crear plantillas de su función add_all_msgs, se pueden utilizar adobe::any_iterator:

typedef adobe::any_iterator<Message, std::input_iterator_tag> any_message_iterator; 
void add_all_msgs(any_message_iterator begin, any_message_iterator end); 

Answer 7

Es difícil tener un polimorfismo dinámico con iteradores de estilo C++. operator++(int) devuelve por valor, lo que afaik es intratable: no puede tener una función de miembro virtual que devuelve *this por valor sin que se corte.

Si es posible, recomiendo usar plantillas como todo el mundo dice.

Sin embargo, si usted no necesita el polimorfismo dinámico, por ejemplo, porque no se puede exponer a la implementación de add_all_msgs como plantilla haría, entonces yo creo que se podría pretender ser Java, así:

struct MessageIterator { 
    virtual Message &get() = 0; 
    virtual void next() = 0; 
    // add more functions if you need more than a Forward Iterator. 
    virtual ~MessageIterator() { }; // Not currently needed, but best be safe 
}; 

// implementation elsewhere. Uses get() and next() instead of * and ++ 
void add_all_msgs(MessageIterator &it); 

template <typename T> 
struct Adaptor : public MessageIterator { 
    typename T::iterator wrapped; 
    Adaptor(typename T::iterator w) : wrapped(w) { } 
    virtual Message &get() { 
     return *wrapped; 
    } 
    virtual void next() { 
     ++wrapped; 
    } 
}; 

int main() { 
    std::deque<Message> v; 
    Adaptor<std::deque<Message> > a(v.begin()); 
    add_all_msgs(a); 
} 

He comprobado que esto compila, pero no lo he probado y nunca he usado este diseño. Tampoco me he molestado con la estupidez. En la práctica, es probable que desee un const Message &get() const. Y, por el momento, el adaptador no tiene forma de saber cuándo detenerse, pero tampoco el código con el que comenzó, así que ignoré eso también. Básicamente necesitaría una función hasNext que compare wrapped con un iterador final proporcionado al constructor.

Es posible que pueda hacer algo con una función de plantilla y const references, para que el cliente no tenga que saber o declarar ese desagradable tipo de adaptador.

[Editar: pensándolo bien, es probable que sea mejor tener una plantilla de función stub add_all_msgs, que envuelve su parámetro en un adaptador y luego llama al real_add_all_msgs. Esto oculta completamente el adaptador del cliente.]