Come leggere un numero arbitrario di valori usando std :: copy?

Question

Sto cercando di codificare l'azione opposta a questa:

std::ostream outs; // properly initialized of course
std::set<int> my_set; // ditto

outs << my_set.size();
std::copy( my_set.begin(), my_set.end(), std::ostream_iterator<int>( outs ) );

dovrebbe essere qualcosa del genere:

std::istream ins;

std::set<int>::size_type size;
ins >> size;

std::copy( std::istream_iterator<int>( ins ), std::istream_iterator<int>( ins ) ???, std::inserter( my_set, my_set.end() ) );

Ma sono bloccato con l'iteratore 'end' - gli interatori di input non possono usare std :: anticipo e nemmeno io posso usare due stream con la stessa sorgente ...

Esiste un modo elegante per risolverlo? Certo che posso usare per loop, ma forse c'è qualcosa di più bello :)

Answer 1

Potresti derivare da istream_iterator < T > ;.
Anche se l'utilizzo di Metodo generatore daem è un'altra opzione , anche se genererei direttamente nel set anziché utilizzare un vettore intermedio.

#include <set>
#include <iterator>
#include <algorithm>
#include <iostream>


template<typename T>
struct CountIter: public std::istream_iterator<T>
{
    CountIter(size_t c)
        :std::istream_iterator<T>()
        ,count(c)
    {}
    CountIter(std::istream& str)
        :std::istream_iterator<T>(str)
        ,count(0)
    {}

    bool operator!=(CountIter const& rhs) const
    {
        return (count != rhs.count) && (dynamic_cast<std::istream_iterator<T> const&>(*this) != rhs);
    }
    T operator*()
    {
        ++count;
        return std::istream_iterator<T>::operator*();
    }

    private:
        size_t  count;
};

int main()
{
    std::set<int>       x;

    //std::copy(std::istream_iterator<int>(std::cin),std::istream_iterator<int>(),std::inserter(x,x.end()));
    std::copy(
                CountIter<int>(std::cin),
                CountIter<int>(5),
                std::inserter(x,x.end())
            );
}

Answer 2

Usa:

std::copy( std::istream_iterator<int>(ins),
           std::istream_iterator<int>(),
           std::inserter(my_set, my_set.end())
         );

Nota il parametro vuoto:

std::istream_iterator<int>();

Answer 3

Errr ... copy_n () algoritmo?

Answer 4

Esaminando un po 'questo, non penso che leggere direttamente in un set funzionerà, poiché devi chiamare insert su di esso per aggiungere effettivamente gli elementi (potrei sbagliarmi, è piuttosto presto la mattina qui). Anche se esaminando brevemente la documentazione STL in VS2005, penso che qualcosa che utilizza la funzione generate_n dovrebbe funzionare, ad esempio:

std::istream ins;
std::set<int> my_set;
std::vector<int> my_vec;

struct read_functor
{
    read_functor(std::istream& stream) :
        m_stream(stream)
    {
    }

    int operator()
    {
        int temp;
        m_stream >> temp;
        return temp;
    }
private:
    std::istream& m_stream;
};

std::set<int>::size_type size;
ins >> size;
my_vec.reserve(size);

std::generate_n(my_vec.begin(), size, read_functor(ins));
my_set.insert(my_vec.begin(), my_vec.end());

Spero che questo abbia risolto il tuo problema o ti abbia convinto che il circuito non è poi così male nel grande schema delle cose.

Answer 5

Che ne dici di usare un iteratore alternativo per fare l'attraversamento e quindi usare un oggetto funzione (o lambda) per riempire il contenitore?

istream ins;
set<int>::size_type size;
set<int> new_set;
ins >> size;
ostream_iterator<int> ins_iter(ins);

for_each(counting_iterator<int>(0), counting_iterator<int>(size),
  [&new_set, &ins_iter](int n) { new_set.insert(*ins_iter++); }
);

Naturalmente questo presuppone che tu abbia un compilatore conforme a C ++ 0x.

A proposito, 'counting_iterator < >' fa parte di Boost.Iterator .

Answer 6

O potresti farlo:

my_set.insert(std::istream_iterator<int>(ins), std::istream_iterator<int>());

Answer 7

Sì, ma quando voglio usare un'altra struttura di dati in quel file / flusso? Probabilmente dovrei scrivere esplicitamente qui, voglio conservare un'altra roba dopo questo set, questo è il motivo per cui sto memorizzando anche le dimensioni.

Answer 8

(Modificato: avrei dovuto leggere la domanda più da vicino ...)

Anche se in qualche modo sospetto, puoi ottenere approssimativamente il comportamento giusto avendo una voce nel file che " fallirà " il primo ciclo, quindi cancella il bit di errore sullo stream e inizia a leggere di più.

Dati, senza dimensioni esplicite, ma come questo

1 1 2 3 5 8 Fibb

Fed al codice qui sotto sembra fare quello che intendevo, almeno su VS2005 con STLPort.

typedef std::istream_iterator < int, char, std::char_traits ,ptrdiff_t> is_iter;
std::copy( is_iter(cin), is_iter(), inserter(my_set,my_set.end()));
cin.clear();
std::cin >> instr;